wehub-resource-sync
1587 lines
54 KiB
PowerShell
1587 lines
54 KiB
PowerShell
#requires -Version 5.1
|
|
param(
|
|
[Parameter(Position = 0)]
|
|
[string]$Action = "menu"
|
|
)
|
|
|
|
Set-StrictMode -Version 2.0
|
|
$ErrorActionPreference = "Stop"
|
|
|
|
if ([System.Environment]::OSVersion.Platform -ne [System.PlatformID]::Win32NT) {
|
|
throw "scripts/god.ps1 is for native Windows PowerShell. Use ./scripts/god.sh on macOS/Linux."
|
|
}
|
|
|
|
function Join-PathMany {
|
|
param([Parameter(ValueFromRemainingArguments = $true)][string[]]$Parts)
|
|
if ($Parts.Count -eq 0) {
|
|
return ""
|
|
}
|
|
$path = $Parts[0]
|
|
for ($i = 1; $i -lt $Parts.Count; $i++) {
|
|
$path = Join-Path $path $Parts[$i]
|
|
}
|
|
return $path
|
|
}
|
|
|
|
function Write-GodLog {
|
|
param([string]$Message)
|
|
Write-Host "[GOD] $Message"
|
|
}
|
|
|
|
function Write-GodDiagnostic {
|
|
param([AllowNull()][string]$Message)
|
|
[Console]::Error.WriteLine($Message)
|
|
}
|
|
|
|
function Stop-God {
|
|
param([string]$Message)
|
|
throw "[GOD] error: $Message"
|
|
}
|
|
|
|
function Test-CommandExists {
|
|
param([string]$Name)
|
|
return [bool](Get-Command $Name -ErrorAction SilentlyContinue)
|
|
}
|
|
|
|
function Get-ToolPath {
|
|
param([string[]]$Names)
|
|
foreach ($name in $Names) {
|
|
$cmd = Get-Command $name -ErrorAction SilentlyContinue
|
|
if ($cmd) {
|
|
return $cmd.Source
|
|
}
|
|
}
|
|
return $Names[0]
|
|
}
|
|
|
|
function Quote-PSLiteral {
|
|
param([AllowNull()][string]$Value)
|
|
if ($null -eq $Value) {
|
|
return "''"
|
|
}
|
|
return "'" + $Value.Replace("'", "''") + "'"
|
|
}
|
|
|
|
function Write-TextUtf8NoBom {
|
|
param(
|
|
[string]$Path,
|
|
[string]$Content
|
|
)
|
|
$parent = Split-Path -Parent $Path
|
|
if ($parent) {
|
|
[System.IO.Directory]::CreateDirectory($parent) | Out-Null
|
|
}
|
|
$encoding = New-Object System.Text.UTF8Encoding($false)
|
|
[System.IO.File]::WriteAllText($Path, $Content, $encoding)
|
|
}
|
|
|
|
$script:RootDir = (Resolve-Path (Join-Path $PSScriptRoot "..")).Path
|
|
$script:EnvFile = if ($env:GOD_ENV_FILE) { $env:GOD_ENV_FILE } else { Join-Path $script:RootDir ".env" }
|
|
|
|
$script:InitialEnv = @{
|
|
GOD_EXPERIMENT = $env:GOD_EXPERIMENT
|
|
GOD_EXPERIMENT_RUN = $env:GOD_EXPERIMENT_RUN
|
|
GOD_HYPOTHESIS_ID = $env:GOD_HYPOTHESIS_ID
|
|
GOD_EXPERIMENT_ID = $env:GOD_EXPERIMENT_ID
|
|
LIVE_WORKSPACE_PATH = $env:LIVE_WORKSPACE_PATH
|
|
GOD_MAP_ID = $env:GOD_MAP_ID
|
|
}
|
|
|
|
$script:StateDir = Join-Path $script:RootDir ".god"
|
|
$script:LogDir = Join-Path $script:StateDir "logs"
|
|
$script:PidDir = Join-Path $script:StateDir "pids"
|
|
$script:RunDir = Join-Path $script:StateDir "run"
|
|
New-Item -ItemType Directory -Force -Path $script:LogDir, $script:PidDir, $script:RunDir | Out-Null
|
|
|
|
$script:BackendPidFile = Join-Path $script:PidDir "backend.pid"
|
|
$script:FrontendPidFile = Join-Path $script:PidDir "frontend.pid"
|
|
$script:RuntimePidFile = Join-Path $script:PidDir "runtime.pid"
|
|
$script:CurrentExperimentFile = Join-Path $script:StateDir "current_experiment.json"
|
|
$script:StartRequestFile = Join-Path $script:RunDir "start-request.json"
|
|
|
|
$script:BackendLog = Join-Path $script:LogDir "backend.log"
|
|
$script:FrontendLog = Join-Path $script:LogDir "frontend.log"
|
|
$script:RuntimeLog = Join-Path $script:LogDir "runtime.log"
|
|
$script:RuntimeInitLog = Join-Path $script:LogDir "runtime-init.log"
|
|
|
|
function Get-EnvValue {
|
|
param(
|
|
[string]$Name,
|
|
[string]$Default = ""
|
|
)
|
|
$value = [System.Environment]::GetEnvironmentVariable($Name, "Process")
|
|
if ([string]::IsNullOrEmpty($value)) {
|
|
return $Default
|
|
}
|
|
return $value
|
|
}
|
|
|
|
function Set-ProcessEnv {
|
|
param(
|
|
[string]$Name,
|
|
[AllowNull()][string]$Value
|
|
)
|
|
[System.Environment]::SetEnvironmentVariable($Name, $Value, "Process")
|
|
}
|
|
|
|
function Remove-ProcessEnv {
|
|
param([string]$Name)
|
|
[System.Environment]::SetEnvironmentVariable($Name, $null, "Process")
|
|
}
|
|
|
|
function Refresh-ConfigFromEnv {
|
|
$script:BackendRoot = Get-EnvValue "BACKEND_ROOT" (Join-Path $script:RootDir "agentsociety")
|
|
$script:RuntimeRoot = Get-EnvValue "RUNTIME_ROOT" (Join-Path $script:RootDir "jiuwenclaw")
|
|
$script:LiveWorkspacePath = Get-EnvValue "LIVE_WORKSPACE_PATH" (Join-Path $script:BackendRoot "quick_experiments")
|
|
|
|
$script:RuntimeInstance = Get-EnvValue "RUNTIME_INSTANCE" "god-town"
|
|
$script:RuntimeMode = Get-EnvValue "RUNTIME_MODE" "dev"
|
|
$script:RuntimeLanguage = Get-EnvValue "RUNTIME_LANGUAGE" "zh"
|
|
$script:RuntimeLegacyInstances = (Get-EnvValue "RUNTIME_LEGACY_INSTANCES" "jiuwenclaw-town jiuwenclaw-town-native-skill").Split(" ", [System.StringSplitOptions]::RemoveEmptyEntries)
|
|
$script:RuntimeAgentPort = [int](Get-EnvValue "RUNTIME_AGENT_PORT" "19092")
|
|
$script:RuntimeWebPort = [int](Get-EnvValue "RUNTIME_WEB_PORT" "20000")
|
|
$script:RuntimeGatewayPort = [int](Get-EnvValue "RUNTIME_GATEWAY_PORT" "20001")
|
|
$script:RuntimeUiPort = [int](Get-EnvValue "RUNTIME_UI_PORT" "6173")
|
|
$script:GodExtraStopPorts = (Get-EnvValue "GOD_EXTRA_STOP_PORTS" "20092 21000 21001 7173").Split(" ", [System.StringSplitOptions]::RemoveEmptyEntries) | ForEach-Object { [int]$_ }
|
|
|
|
$script:GodExperiment = Get-EnvValue "GOD_EXPERIMENT" (Get-EnvValue "GOD_HYPOTHESIS_ID" "god_town")
|
|
$script:GodExperimentRun = Get-EnvValue "GOD_EXPERIMENT_RUN" (Get-EnvValue "GOD_EXPERIMENT_ID" "1")
|
|
$script:GodBackendHost = Get-EnvValue "GOD_BACKEND_HOST" (Get-EnvValue "BACKEND_HOST" "127.0.0.1")
|
|
$script:GodBackendPort = [int](Get-EnvValue "GOD_BACKEND_PORT" (Get-EnvValue "BACKEND_PORT" "8001"))
|
|
$script:GodFrontendPort = [int](Get-EnvValue "GOD_FRONTEND_PORT" (Get-EnvValue "AGENTSOCIETY_FRONTEND_PORT" "5174"))
|
|
$script:GodLiveStepTimeout = Get-EnvValue "GOD_LIVE_STEP_TIMEOUT" (Get-EnvValue "AGENTSOCIETY_LIVE_STEP_TIMEOUT" "900")
|
|
|
|
$script:BackendUrl = "http://$($script:GodBackendHost):$($script:GodBackendPort)"
|
|
$script:FrontendUrl = "http://127.0.0.1:$($script:GodFrontendPort)"
|
|
$script:RuntimeUiUrl = "http://localhost:$($script:RuntimeUiPort)"
|
|
}
|
|
|
|
Refresh-ConfigFromEnv
|
|
|
|
function Show-Usage {
|
|
@"
|
|
Usage: .\scripts\god.ps1 [menu|setup|configure|start|restart|new-run|stop|status|tail|open]
|
|
|
|
menu Interactive menu.
|
|
setup Install or check Python and Node dependencies only.
|
|
configure Open the experiment setup wizard and wait for a new experiment request.
|
|
start Start GOD (idempotent; reuses running services) and open frontend pages.
|
|
restart Stop everything cleanly, then start.
|
|
new-run Stop, wipe the current run, then start a fresh session.
|
|
stop Stop GOD and release its ports.
|
|
status Print URLs, ports, and model status.
|
|
tail Follow GOD service logs.
|
|
open Open the GOD frontend pages in the default browser.
|
|
"@ | Write-Host
|
|
}
|
|
|
|
function Update-ProcessPath {
|
|
$currentPath = $env:Path
|
|
$machinePath = [System.Environment]::GetEnvironmentVariable("Path", "Machine")
|
|
$userPath = [System.Environment]::GetEnvironmentVariable("Path", "User")
|
|
$localBin = Join-Path $HOME ".local\bin"
|
|
$parts = @($currentPath, $machinePath, $userPath, $localBin) | Where-Object { -not [string]::IsNullOrWhiteSpace($_) }
|
|
$env:Path = ($parts -join [System.IO.Path]::PathSeparator)
|
|
}
|
|
|
|
function Require-Winget {
|
|
if (-not (Test-CommandExists "winget")) {
|
|
Stop-God "winget is required to auto-install Git and Node.js on Windows. Install App Installer from Microsoft Store, then rerun this command."
|
|
}
|
|
}
|
|
|
|
function Install-WingetPackage {
|
|
param(
|
|
[string]$Id,
|
|
[string]$Name
|
|
)
|
|
Require-Winget
|
|
Write-GodLog "Installing $Name with winget"
|
|
& winget install --id $Id -e --accept-package-agreements --accept-source-agreements
|
|
if ($LASTEXITCODE -ne 0) {
|
|
Stop-God "winget failed to install $Name ($Id)"
|
|
}
|
|
Update-ProcessPath
|
|
}
|
|
|
|
function Install-Uv {
|
|
Write-GodLog "Installing uv"
|
|
Invoke-RestMethod https://astral.sh/uv/install.ps1 | Invoke-Expression
|
|
Update-ProcessPath
|
|
if (-not (Test-CommandExists "uv")) {
|
|
Stop-God "uv was installed but is not available on PATH. Open a new PowerShell window and rerun this command."
|
|
}
|
|
}
|
|
|
|
function Test-NpmAvailable {
|
|
return (Test-CommandExists "npm.cmd") -or (Test-CommandExists "npm")
|
|
}
|
|
|
|
function Ensure-Prerequisites {
|
|
if (-not (Test-CommandExists "uv")) {
|
|
Install-Uv
|
|
}
|
|
if (-not (Test-CommandExists "git")) {
|
|
Install-WingetPackage "Git.Git" "Git"
|
|
}
|
|
if (-not (Test-NpmAvailable)) {
|
|
Install-WingetPackage "OpenJS.NodeJS.LTS" "Node.js LTS"
|
|
}
|
|
|
|
Update-ProcessPath
|
|
foreach ($tool in @("uv", "git")) {
|
|
if (-not (Test-CommandExists $tool)) {
|
|
Stop-God "$tool is not available after installation. Open a new PowerShell window and rerun this command."
|
|
}
|
|
}
|
|
if (-not (Test-NpmAvailable)) {
|
|
Stop-God "npm is not available after Node.js installation. Open a new PowerShell window and rerun this command."
|
|
}
|
|
}
|
|
|
|
function Read-DotEnv {
|
|
if (-not (Test-Path $script:EnvFile)) {
|
|
return
|
|
}
|
|
foreach ($line in [System.IO.File]::ReadAllLines($script:EnvFile)) {
|
|
if ($line -match '^\s*#' -or $line -notmatch '^\s*([A-Za-z_][A-Za-z0-9_]*)=(.*)$') {
|
|
continue
|
|
}
|
|
$key = $Matches[1]
|
|
$value = $Matches[2].Trim()
|
|
if (($value.StartsWith('"') -and $value.EndsWith('"')) -or ($value.StartsWith("'") -and $value.EndsWith("'"))) {
|
|
if ($value.Length -ge 2) {
|
|
$value = $value.Substring(1, $value.Length - 2)
|
|
}
|
|
}
|
|
Set-ProcessEnv $key $value
|
|
}
|
|
}
|
|
|
|
function Set-EnvValue {
|
|
param(
|
|
[string]$Key,
|
|
[string]$Value
|
|
)
|
|
$lines = @()
|
|
if (Test-Path $script:EnvFile) {
|
|
$lines = [System.IO.File]::ReadAllLines($script:EnvFile)
|
|
}
|
|
$out = New-Object System.Collections.Generic.List[string]
|
|
$seen = $false
|
|
foreach ($line in $lines) {
|
|
if ($line -like "$Key=*") {
|
|
$out.Add("$Key=$Value")
|
|
$seen = $true
|
|
} else {
|
|
$out.Add($line)
|
|
}
|
|
}
|
|
if (-not $seen) {
|
|
if ($out.Count -gt 0 -and $out[$out.Count - 1] -ne "") {
|
|
$out.Add("")
|
|
}
|
|
$out.Add("$Key=$Value")
|
|
}
|
|
Write-TextUtf8NoBom $script:EnvFile (($out -join "`n").TrimEnd() + "`n")
|
|
Set-ProcessEnv $Key $Value
|
|
Refresh-ConfigFromEnv
|
|
}
|
|
|
|
function Set-EnvValuesInFile {
|
|
param(
|
|
[string]$Path,
|
|
[hashtable]$Values
|
|
)
|
|
$lines = @()
|
|
if (Test-Path $Path) {
|
|
$lines = [System.IO.File]::ReadAllLines($Path)
|
|
}
|
|
$out = New-Object System.Collections.Generic.List[string]
|
|
$seen = @{}
|
|
foreach ($line in $lines) {
|
|
$replaced = $false
|
|
foreach ($key in $Values.Keys) {
|
|
if ($line -like "$key=*") {
|
|
$out.Add("$key=$($Values[$key])")
|
|
$seen[$key] = $true
|
|
$replaced = $true
|
|
break
|
|
}
|
|
}
|
|
if (-not $replaced) {
|
|
$out.Add($line)
|
|
}
|
|
}
|
|
foreach ($key in $Values.Keys) {
|
|
if (-not $seen.ContainsKey($key)) {
|
|
if ($out.Count -gt 0 -and $out[$out.Count - 1] -ne "") {
|
|
$out.Add("")
|
|
}
|
|
$out.Add("$key=$($Values[$key])")
|
|
}
|
|
}
|
|
Write-TextUtf8NoBom $Path (($out -join "`n").TrimEnd() + "`n")
|
|
}
|
|
|
|
function Set-ObjectProperty {
|
|
param(
|
|
[object]$Object,
|
|
[string]$Name,
|
|
[object]$Value
|
|
)
|
|
if ($Object.PSObject.Properties[$Name]) {
|
|
$Object.$Name = $Value
|
|
} else {
|
|
$Object | Add-Member -NotePropertyName $Name -NotePropertyValue $Value
|
|
}
|
|
}
|
|
|
|
function Get-ObjectPropertyValue {
|
|
param(
|
|
[AllowNull()][object]$Object,
|
|
[string]$Name,
|
|
[AllowNull()][object]$Default = $null
|
|
)
|
|
if ($null -ne $Object -and $Object.PSObject.Properties[$Name]) {
|
|
return $Object.$Name
|
|
}
|
|
return $Default
|
|
}
|
|
|
|
function Export-InternalEnv {
|
|
$godLlmKey = Get-EnvValue "GOD_LLM_API_KEY" (Get-EnvValue "AGENTSOCIETY_LLM_API_KEY" (Get-EnvValue "JIUWENCLAW_API_KEY" ""))
|
|
$godLlmBase = Get-EnvValue "GOD_LLM_API_BASE" (Get-EnvValue "AGENTSOCIETY_LLM_API_BASE" (Get-EnvValue "JIUWENCLAW_API_BASE" ""))
|
|
$godLlmModel = Get-EnvValue "GOD_LLM_MODEL" (Get-EnvValue "AGENTSOCIETY_LLM_MODEL" (Get-EnvValue "JIUWENCLAW_MODEL" ""))
|
|
$godEmbeddingKey = Get-EnvValue "GOD_EMBEDDING_API_KEY" (Get-EnvValue "AGENTSOCIETY_EMBEDDING_API_KEY" (Get-EnvValue "JIUWENCLAW_EMBED_API_KEY" ""))
|
|
$godEmbeddingBase = Get-EnvValue "GOD_EMBEDDING_API_BASE" (Get-EnvValue "AGENTSOCIETY_EMBEDDING_API_BASE" (Get-EnvValue "JIUWENCLAW_EMBED_API_BASE" ""))
|
|
$godEmbeddingModel = Get-EnvValue "GOD_EMBEDDING_MODEL" (Get-EnvValue "AGENTSOCIETY_EMBEDDING_MODEL" (Get-EnvValue "JIUWENCLAW_EMBED_MODEL" ""))
|
|
|
|
if ([string]::IsNullOrEmpty($godLlmBase)) { $godLlmBase = "https://api.openai.com/v1" }
|
|
if ([string]::IsNullOrEmpty($godLlmModel)) { $godLlmModel = "gpt-5.4" }
|
|
$nanoModel = Get-EnvValue "GOD_LLM_NANO_MODEL" ""
|
|
if ([string]::IsNullOrEmpty($nanoModel)) {
|
|
if ($godLlmModel -eq "gpt-5.4") {
|
|
$nanoModel = "gpt-5.4-nano"
|
|
} else {
|
|
$nanoModel = ($godLlmModel -replace '\.[^.]*$', '') + ".*-nano"
|
|
}
|
|
}
|
|
if ([string]::IsNullOrEmpty($godEmbeddingKey)) { $godEmbeddingKey = $godLlmKey }
|
|
if ([string]::IsNullOrEmpty($godEmbeddingBase)) { $godEmbeddingBase = $godLlmBase }
|
|
if ([string]::IsNullOrEmpty($godEmbeddingModel)) { $godEmbeddingModel = "text-embedding-3-large" }
|
|
|
|
Set-ProcessEnv "GOD_LLM_API_KEY" $godLlmKey
|
|
Set-ProcessEnv "GOD_LLM_API_BASE" $godLlmBase
|
|
Set-ProcessEnv "GOD_LLM_MODEL" $godLlmModel
|
|
Set-ProcessEnv "GOD_EMBEDDING_API_KEY" $godEmbeddingKey
|
|
Set-ProcessEnv "GOD_EMBEDDING_API_BASE" $godEmbeddingBase
|
|
Set-ProcessEnv "GOD_EMBEDDING_MODEL" $godEmbeddingModel
|
|
|
|
Set-ProcessEnv "AGENTSOCIETY_LLM_API_KEY" $godLlmKey
|
|
Set-ProcessEnv "AGENTSOCIETY_LLM_API_BASE" $godLlmBase
|
|
Set-ProcessEnv "AGENTSOCIETY_LLM_MODEL" $godLlmModel
|
|
Set-ProcessEnv "AGENTSOCIETY_NANO_LLM_MODEL" $nanoModel
|
|
Set-ProcessEnv "AGENTSOCIETY_EMBEDDING_API_KEY" $godEmbeddingKey
|
|
Set-ProcessEnv "AGENTSOCIETY_EMBEDDING_API_BASE" $godEmbeddingBase
|
|
Set-ProcessEnv "AGENTSOCIETY_EMBEDDING_MODEL" $godEmbeddingModel
|
|
|
|
Set-ProcessEnv "JIUWENCLAW_API_KEY" $godLlmKey
|
|
Set-ProcessEnv "JIUWENCLAW_API_BASE" $godLlmBase
|
|
Set-ProcessEnv "JIUWENCLAW_MODEL" $godLlmModel
|
|
Set-ProcessEnv "JIUWENCLAW_MODEL_PROVIDER" (Get-EnvValue "JIUWENCLAW_MODEL_PROVIDER" "OpenAI")
|
|
Set-ProcessEnv "JIUWENCLAW_EMBED_API_KEY" $godEmbeddingKey
|
|
Set-ProcessEnv "JIUWENCLAW_EMBED_API_BASE" $godEmbeddingBase
|
|
Set-ProcessEnv "JIUWENCLAW_EMBED_MODEL" $godEmbeddingModel
|
|
|
|
Set-ProcessEnv "BACKEND_HOST" $script:GodBackendHost
|
|
Set-ProcessEnv "BACKEND_PORT" ([string]$script:GodBackendPort)
|
|
Set-ProcessEnv "AGENTSOCIETY_FRONTEND_PORT" ([string]$script:GodFrontendPort)
|
|
Set-ProcessEnv "GOD_HYPOTHESIS_ID" $script:GodExperiment
|
|
Set-ProcessEnv "GOD_EXPERIMENT_ID" $script:GodExperimentRun
|
|
}
|
|
|
|
function Load-CurrentExperiment {
|
|
if (-not (Test-Path $script:CurrentExperimentFile)) {
|
|
return
|
|
}
|
|
try {
|
|
$data = Get-Content $script:CurrentExperimentFile -Raw | ConvertFrom-Json
|
|
} catch {
|
|
return
|
|
}
|
|
$hypothesisId = Get-ObjectPropertyValue $data "hypothesis_id" ""
|
|
$experimentId = Get-ObjectPropertyValue $data "experiment_id" ""
|
|
$workspacePath = Get-ObjectPropertyValue $data "workspace_path" ""
|
|
if (($script:InitialEnv.GOD_EXPERIMENT -eq $null) -and ($script:InitialEnv.GOD_HYPOTHESIS_ID -eq $null) -and $hypothesisId) {
|
|
Set-ProcessEnv "GOD_EXPERIMENT" ([string]$hypothesisId)
|
|
}
|
|
if (($script:InitialEnv.GOD_EXPERIMENT_RUN -eq $null) -and ($script:InitialEnv.GOD_EXPERIMENT_ID -eq $null) -and $experimentId) {
|
|
Set-ProcessEnv "GOD_EXPERIMENT_RUN" ([string]$experimentId)
|
|
}
|
|
if (($script:InitialEnv.LIVE_WORKSPACE_PATH -eq $null) -and $workspacePath) {
|
|
Set-ProcessEnv "LIVE_WORKSPACE_PATH" ([string]$workspacePath)
|
|
}
|
|
}
|
|
|
|
function Load-Env {
|
|
Read-DotEnv
|
|
|
|
if ($script:InitialEnv.GOD_EXPERIMENT -ne $null) {
|
|
Set-ProcessEnv "GOD_EXPERIMENT" $script:InitialEnv.GOD_EXPERIMENT
|
|
} elseif ($script:InitialEnv.GOD_HYPOTHESIS_ID -ne $null) {
|
|
Set-ProcessEnv "GOD_EXPERIMENT" $script:InitialEnv.GOD_HYPOTHESIS_ID
|
|
} else {
|
|
Remove-ProcessEnv "GOD_EXPERIMENT"
|
|
Remove-ProcessEnv "GOD_HYPOTHESIS_ID"
|
|
}
|
|
|
|
if ($script:InitialEnv.GOD_EXPERIMENT_RUN -ne $null) {
|
|
Set-ProcessEnv "GOD_EXPERIMENT_RUN" $script:InitialEnv.GOD_EXPERIMENT_RUN
|
|
} elseif ($script:InitialEnv.GOD_EXPERIMENT_ID -ne $null) {
|
|
Set-ProcessEnv "GOD_EXPERIMENT_RUN" $script:InitialEnv.GOD_EXPERIMENT_ID
|
|
} else {
|
|
Remove-ProcessEnv "GOD_EXPERIMENT_RUN"
|
|
Remove-ProcessEnv "GOD_EXPERIMENT_ID"
|
|
}
|
|
|
|
if ($script:InitialEnv.LIVE_WORKSPACE_PATH -ne $null) {
|
|
Set-ProcessEnv "LIVE_WORKSPACE_PATH" $script:InitialEnv.LIVE_WORKSPACE_PATH
|
|
}
|
|
if ($script:InitialEnv.GOD_MAP_ID -ne $null) {
|
|
Set-ProcessEnv "GOD_MAP_ID" $script:InitialEnv.GOD_MAP_ID
|
|
} else {
|
|
Remove-ProcessEnv "GOD_MAP_ID"
|
|
}
|
|
|
|
Refresh-ConfigFromEnv
|
|
Export-InternalEnv
|
|
Load-CurrentExperiment
|
|
Refresh-ConfigFromEnv
|
|
Export-InternalEnv
|
|
Refresh-ConfigFromEnv
|
|
}
|
|
|
|
function Get-ConfiguredState {
|
|
param([string]$Value)
|
|
if ([string]::IsNullOrEmpty($Value)) {
|
|
return "missing"
|
|
}
|
|
return "configured"
|
|
}
|
|
|
|
function Get-RuntimeWorkspace {
|
|
return Join-PathMany $HOME ".jiuwenclaw-instances" $script:RuntimeInstance
|
|
}
|
|
|
|
function Ensure-EnvFile {
|
|
$envWasCreated = $false
|
|
if (-not (Test-Path $script:EnvFile)) {
|
|
Copy-Item (Join-Path $script:RootDir ".env.example") $script:EnvFile
|
|
$envWasCreated = $true
|
|
Write-GodLog "Created .env from .env.example"
|
|
}
|
|
|
|
Load-Env
|
|
|
|
if ((Get-EnvValue "GOD_SETUP_MODE" "0") -eq "1") {
|
|
Set-EnvValue "GOD_LLM_API_BASE" (Get-EnvValue "GOD_LLM_API_BASE" "https://api.openai.com/v1")
|
|
Set-EnvValue "GOD_LLM_MODEL" (Get-EnvValue "GOD_LLM_MODEL" "gpt-5.4")
|
|
Set-EnvValue "GOD_EMBEDDING_MODEL" (Get-EnvValue "GOD_EMBEDDING_MODEL" "text-embedding-3-large")
|
|
Load-Env
|
|
return
|
|
}
|
|
|
|
if ([string]::IsNullOrEmpty((Get-EnvValue "GOD_LLM_API_KEY" ""))) {
|
|
if ([Environment]::UserInteractive) {
|
|
$secureKey = Read-Host "[GOD] LLM API key is required. Paste it now" -AsSecureString
|
|
$bstr = [Runtime.InteropServices.Marshal]::SecureStringToBSTR($secureKey)
|
|
try {
|
|
$apiKey = [Runtime.InteropServices.Marshal]::PtrToStringBSTR($bstr)
|
|
} finally {
|
|
[Runtime.InteropServices.Marshal]::ZeroFreeBSTR($bstr)
|
|
}
|
|
if ([string]::IsNullOrEmpty($apiKey)) {
|
|
Stop-God "LLM API key is empty"
|
|
}
|
|
Set-EnvValue "GOD_LLM_API_KEY" $apiKey
|
|
} else {
|
|
Stop-God "GOD_LLM_API_KEY is empty. Fill $($script:EnvFile) first."
|
|
}
|
|
}
|
|
|
|
if ($envWasCreated -and [Environment]::UserInteractive) {
|
|
$defaultApiBase = Get-EnvValue "GOD_LLM_API_BASE" "https://api.openai.com/v1"
|
|
$defaultModel = Get-EnvValue "GOD_LLM_MODEL" "gpt-5.4"
|
|
$apiBaseInput = Read-Host "[GOD] LLM API base URL [$defaultApiBase]"
|
|
$modelInput = Read-Host "[GOD] LLM model [$defaultModel]"
|
|
if ([string]::IsNullOrEmpty($apiBaseInput)) { $apiBaseInput = $defaultApiBase }
|
|
if ([string]::IsNullOrEmpty($modelInput)) { $modelInput = $defaultModel }
|
|
Set-EnvValue "GOD_LLM_API_BASE" $apiBaseInput
|
|
Set-EnvValue "GOD_LLM_MODEL" $modelInput
|
|
}
|
|
|
|
Set-EnvValue "GOD_LLM_API_BASE" (Get-EnvValue "GOD_LLM_API_BASE" "https://api.openai.com/v1")
|
|
Set-EnvValue "GOD_LLM_MODEL" (Get-EnvValue "GOD_LLM_MODEL" "gpt-5.4")
|
|
Set-EnvValue "GOD_EMBEDDING_MODEL" (Get-EnvValue "GOD_EMBEDDING_MODEL" "text-embedding-3-large")
|
|
Load-Env
|
|
}
|
|
|
|
function Test-PortOpen {
|
|
param([int]$Port)
|
|
foreach ($connectHost in @("127.0.0.1", "::1", "localhost")) {
|
|
$client = New-Object System.Net.Sockets.TcpClient
|
|
try {
|
|
$async = $client.BeginConnect($connectHost, $Port, $null, $null)
|
|
if ($async.AsyncWaitHandle.WaitOne(350)) {
|
|
$client.EndConnect($async)
|
|
return $true
|
|
}
|
|
} catch {
|
|
} finally {
|
|
$client.Close()
|
|
}
|
|
}
|
|
return $false
|
|
}
|
|
|
|
function Wait-ForPort {
|
|
param(
|
|
[int]$Port,
|
|
[string]$Label,
|
|
[int]$TimeoutSeconds = 90
|
|
)
|
|
$deadline = (Get-Date).AddSeconds($TimeoutSeconds)
|
|
while ((Get-Date) -lt $deadline) {
|
|
if (Test-PortOpen $Port) {
|
|
Write-GodLog "$Label ready on port $Port"
|
|
return
|
|
}
|
|
Start-Sleep -Seconds 1
|
|
}
|
|
Write-WaitTimeoutContext $Label $Port
|
|
Stop-God "Timed out waiting for $Label on port $Port"
|
|
}
|
|
|
|
function Write-WaitTimeoutContext {
|
|
param(
|
|
[string]$Label,
|
|
[int]$Port
|
|
)
|
|
Write-GodDiagnostic "[GOD] timeout diagnostics for $Label on port $Port"
|
|
try {
|
|
Get-NetTCPConnection -State Listen -LocalPort $Port -ErrorAction SilentlyContinue |
|
|
Format-Table -AutoSize |
|
|
Out-String |
|
|
ForEach-Object { Write-GodDiagnostic $_ }
|
|
} catch {
|
|
}
|
|
if ($Label -like "Agent runtime*" -and (Test-Path $script:RuntimeLog)) {
|
|
Write-GodDiagnostic "[GOD] recent runtime log:"
|
|
Get-Content $script:RuntimeLog -Tail 80 | ForEach-Object { Write-GodDiagnostic $_ }
|
|
}
|
|
if ($Label -eq "Backend" -and (Test-Path $script:BackendLog)) {
|
|
Write-GodDiagnostic "[GOD] recent backend log:"
|
|
Get-Content $script:BackendLog -Tail 80 | ForEach-Object { Write-GodDiagnostic $_ }
|
|
}
|
|
}
|
|
|
|
function ConvertTo-UrlEncoded {
|
|
param([string]$Value)
|
|
return [System.Uri]::EscapeDataString($Value)
|
|
}
|
|
|
|
function Get-ReplayUrl {
|
|
return "$($script:FrontendUrl)/pixel-replay/$($script:GodExperiment)/$($script:GodExperimentRun)"
|
|
}
|
|
|
|
function Get-SessionUrl {
|
|
$workspace = ConvertTo-UrlEncoded $script:LiveWorkspacePath
|
|
return "$($script:BackendUrl)/api/v1/live-experiments/$($script:GodExperiment)/$($script:GodExperimentRun)/sessions?workspace_path=$workspace"
|
|
}
|
|
|
|
function Get-RunStepUrl {
|
|
$workspace = ConvertTo-UrlEncoded $script:LiveWorkspacePath
|
|
return "$($script:BackendUrl)/api/v1/live-experiments/$($script:GodExperiment)/$($script:GodExperimentRun)/run-step?workspace_path=$workspace"
|
|
}
|
|
|
|
function Get-StopLiveUrl {
|
|
$workspace = ConvertTo-UrlEncoded $script:LiveWorkspacePath
|
|
return "$($script:BackendUrl)/api/v1/live-experiments/$($script:GodExperiment)/$($script:GodExperimentRun)/stop?workspace_path=$workspace"
|
|
}
|
|
|
|
function Get-SetupUrl {
|
|
return "$($script:FrontendUrl)/setup"
|
|
}
|
|
|
|
function Show-FrontendLinks {
|
|
Write-Host ("Control room: {0}" -f (Get-ReplayUrl))
|
|
Write-Host ("Agent runtime UI: {0}" -f $script:RuntimeUiUrl)
|
|
}
|
|
|
|
function Open-BrowserWindow {
|
|
param([string]$Url)
|
|
if ((Get-EnvValue "GOD_OPEN_BROWSER" "1") -ne "1") {
|
|
return
|
|
}
|
|
Start-Process $Url | Out-Null
|
|
}
|
|
|
|
function Open-FrontendPages {
|
|
Write-GodLog "Opening frontend pages"
|
|
Open-BrowserWindow (Get-ReplayUrl)
|
|
Open-BrowserWindow $script:RuntimeUiUrl
|
|
}
|
|
|
|
function Open-SetupPage {
|
|
Write-GodLog "Opening setup wizard"
|
|
Open-BrowserWindow (Get-SetupUrl)
|
|
Write-Host ("Setup wizard: {0}" -f (Get-SetupUrl))
|
|
}
|
|
|
|
function Get-CurrentExperimentConfigPath {
|
|
if (-not (Test-Path $script:CurrentExperimentFile)) {
|
|
return $null
|
|
}
|
|
try {
|
|
$data = Get-Content $script:CurrentExperimentFile -Raw | ConvertFrom-Json
|
|
} catch {
|
|
return $null
|
|
}
|
|
$hypothesisId = [string](Get-ObjectPropertyValue $data "hypothesis_id" "")
|
|
$rawExperimentId = Get-ObjectPropertyValue $data "experiment_id" ""
|
|
$experimentId = if ($rawExperimentId) { [string]$rawExperimentId } else { "1" }
|
|
if ([string]::IsNullOrWhiteSpace($hypothesisId) -or [string]::IsNullOrWhiteSpace($experimentId)) {
|
|
return $null
|
|
}
|
|
$rawWorkspace = Get-ObjectPropertyValue $data "workspace_path" ""
|
|
$workspace = if ($rawWorkspace) { [string]$rawWorkspace } else { $script:LiveWorkspacePath }
|
|
return Join-PathMany $workspace "hypothesis_$hypothesisId" "experiment_$experimentId" "init" "init_config.json"
|
|
}
|
|
|
|
function Test-CurrentExperimentConfig {
|
|
$configPath = Get-CurrentExperimentConfigPath
|
|
return (-not [string]::IsNullOrEmpty($configPath)) -and (Test-Path $configPath)
|
|
}
|
|
|
|
function Test-PendingStartRequest {
|
|
if (-not (Test-Path $script:StartRequestFile)) {
|
|
return $false
|
|
}
|
|
if ((Test-Path $script:CurrentExperimentFile) -and ((Get-Item $script:StartRequestFile).LastWriteTime -lt (Get-Item $script:CurrentExperimentFile).LastWriteTime)) {
|
|
$stalePath = "$($script:StartRequestFile).stale.$((Get-Date).ToString('yyyyMMdd_HHmmss'))"
|
|
Write-GodLog "Ignoring stale setup startup request: $($script:StartRequestFile)"
|
|
try {
|
|
Move-Item $script:StartRequestFile $stalePath -Force
|
|
} catch {
|
|
Remove-Item $script:StartRequestFile -Force -ErrorAction SilentlyContinue
|
|
}
|
|
return $false
|
|
}
|
|
return $true
|
|
}
|
|
|
|
function Test-ReadyStartConfig {
|
|
Load-Env
|
|
return (-not [string]::IsNullOrEmpty((Get-EnvValue "GOD_LLM_API_KEY" ""))) -and (Test-CurrentExperimentConfig)
|
|
}
|
|
|
|
function Require-CurrentExperimentConfig {
|
|
if (-not (Test-CurrentExperimentConfig)) {
|
|
Stop-God "No current experiment is configured. Run .\scripts\god.ps1 start and choose an experiment in setup."
|
|
}
|
|
}
|
|
|
|
function Stop-ProcessTree {
|
|
param([int]$ProcessId)
|
|
if ($ProcessId -le 0) {
|
|
return
|
|
}
|
|
try {
|
|
$children = Get-CimInstance Win32_Process -Filter "ParentProcessId = $ProcessId" -ErrorAction SilentlyContinue
|
|
foreach ($child in $children) {
|
|
Stop-ProcessTree -ProcessId ([int]$child.ProcessId)
|
|
}
|
|
} catch {
|
|
}
|
|
try {
|
|
$proc = Get-Process -Id $ProcessId -ErrorAction SilentlyContinue
|
|
if ($proc) {
|
|
Stop-Process -Id $ProcessId -Force -ErrorAction SilentlyContinue
|
|
}
|
|
} catch {
|
|
}
|
|
}
|
|
|
|
function Stop-PidFile {
|
|
param(
|
|
[string]$Path,
|
|
[string]$Label
|
|
)
|
|
if (-not (Test-Path $Path)) {
|
|
return
|
|
}
|
|
$processIdText = (Get-Content $Path -ErrorAction SilentlyContinue | Select-Object -First 1)
|
|
$processId = 0
|
|
[int]::TryParse($processIdText, [ref]$processId) | Out-Null
|
|
if ($processId -gt 0 -and (Get-Process -Id $processId -ErrorAction SilentlyContinue)) {
|
|
Write-GodLog "Stopping $Label pid=$processId"
|
|
Stop-ProcessTree -ProcessId $processId
|
|
}
|
|
Remove-Item $Path -Force -ErrorAction SilentlyContinue
|
|
}
|
|
|
|
function Stop-ListenersOnPort {
|
|
param([int]$Port)
|
|
$processIds = @()
|
|
try {
|
|
$processIds = @(Get-NetTCPConnection -State Listen -LocalPort $Port -ErrorAction SilentlyContinue |
|
|
Select-Object -ExpandProperty OwningProcess -Unique)
|
|
} catch {
|
|
$processIds = @()
|
|
}
|
|
|
|
if ($processIds.Count -eq 0) {
|
|
try {
|
|
$processIds = @(netstat -ano -p tcp |
|
|
Select-String "LISTENING" |
|
|
Where-Object { $_.Line -match "[:.]$Port\s" } |
|
|
ForEach-Object { ($_ -split '\s+')[-1] } |
|
|
Select-Object -Unique)
|
|
} catch {
|
|
$processIds = @()
|
|
}
|
|
}
|
|
|
|
$processIds = @($processIds | Where-Object { $_ -and ([int]$_) -gt 0 } | Select-Object -Unique)
|
|
if ($processIds.Count -eq 0) {
|
|
return
|
|
}
|
|
Write-GodLog "Clearing port $Port"
|
|
foreach ($processId in $processIds) {
|
|
Stop-ProcessTree -ProcessId ([int]$processId)
|
|
}
|
|
}
|
|
|
|
function Stop-ControlServices {
|
|
Stop-PidFile $script:FrontendPidFile "control room"
|
|
Stop-PidFile $script:BackendPidFile "backend"
|
|
Stop-ListenersOnPort $script:GodFrontendPort
|
|
Stop-ListenersOnPort $script:GodBackendPort
|
|
}
|
|
|
|
function Stop-LivePorts {
|
|
$ports = @(
|
|
$script:GodBackendPort,
|
|
$script:GodFrontendPort,
|
|
$script:RuntimeAgentPort,
|
|
$script:RuntimeWebPort,
|
|
$script:RuntimeGatewayPort,
|
|
$script:RuntimeUiPort
|
|
) + $script:GodExtraStopPorts
|
|
foreach ($port in $ports) {
|
|
Stop-ListenersOnPort ([int]$port)
|
|
}
|
|
}
|
|
|
|
function Start-DetachedService {
|
|
param(
|
|
[string]$SessionName,
|
|
[string]$PidFile,
|
|
[string]$Command,
|
|
[string]$LogPath = ""
|
|
)
|
|
$psExe = (Get-Process -Id $PID).Path
|
|
if ([string]::IsNullOrEmpty($psExe)) {
|
|
$psExe = "powershell.exe"
|
|
}
|
|
if (-not [string]::IsNullOrEmpty($LogPath)) {
|
|
$Command = @(
|
|
"`$ErrorActionPreference = 'Stop'",
|
|
"try {",
|
|
$Command,
|
|
"} catch {",
|
|
" '[GOD] service startup error' | Out-File -FilePath $(Quote-PSLiteral $LogPath) -Append -Encoding utf8",
|
|
" `$_.Exception.Message | Out-File -FilePath $(Quote-PSLiteral $LogPath) -Append -Encoding utf8",
|
|
" `$_.ScriptStackTrace | Out-File -FilePath $(Quote-PSLiteral $LogPath) -Append -Encoding utf8",
|
|
" exit 1",
|
|
"}"
|
|
) -join "`n"
|
|
}
|
|
$encoded = [Convert]::ToBase64String([System.Text.Encoding]::Unicode.GetBytes($Command))
|
|
$process = Start-Process -FilePath $psExe `
|
|
-ArgumentList @("-NoProfile", "-ExecutionPolicy", "Bypass", "-EncodedCommand", $encoded) `
|
|
-PassThru `
|
|
-WindowStyle Hidden
|
|
Write-TextUtf8NoBom $PidFile ("$($process.Id)`n")
|
|
Start-Sleep -Seconds 2
|
|
if (-not (Get-Process -Id $process.Id -ErrorAction SilentlyContinue)) {
|
|
if (-not [string]::IsNullOrEmpty($LogPath) -and (Test-Path $LogPath)) {
|
|
Write-GodDiagnostic "[GOD] recent $SessionName log ($LogPath):"
|
|
Get-Content $LogPath -Tail 80 -ErrorAction SilentlyContinue | ForEach-Object { Write-GodDiagnostic $_ }
|
|
}
|
|
Stop-God "$SessionName exited during startup. See $LogPath"
|
|
}
|
|
}
|
|
|
|
function Stop-RuntimeInstance {
|
|
param([string]$Name)
|
|
if (-not (Test-Path $script:RuntimeRoot)) {
|
|
return
|
|
}
|
|
if (-not (Test-CommandExists "uv")) {
|
|
return
|
|
}
|
|
Push-Location $script:RuntimeRoot
|
|
try {
|
|
Invoke-NativeCommand -FilePath (Get-ToolPath @("uv")) -ArgumentList @("run", "jiuwenclaw-start", "--stop", $Name) *> $null
|
|
} catch {
|
|
} finally {
|
|
Pop-Location
|
|
}
|
|
}
|
|
|
|
function Stop-All {
|
|
Write-GodLog "Stopping GOD services"
|
|
if (Test-PortOpen $script:GodBackendPort) {
|
|
try {
|
|
Invoke-RestMethod -Method Post -Uri (Get-StopLiveUrl) | Out-Null
|
|
} catch {
|
|
}
|
|
}
|
|
Stop-PidFile $script:FrontendPidFile "control room"
|
|
Stop-PidFile $script:BackendPidFile "backend"
|
|
Stop-PidFile $script:RuntimePidFile "agent runtime"
|
|
Stop-RuntimeInstance $script:RuntimeInstance
|
|
foreach ($name in $script:RuntimeLegacyInstances) {
|
|
Stop-RuntimeInstance $name
|
|
}
|
|
Stop-LivePorts
|
|
}
|
|
|
|
function Remove-PathSafe {
|
|
param(
|
|
[string]$Path,
|
|
[string]$Label
|
|
)
|
|
if (Test-Path $Path) {
|
|
Write-GodLog "Removing $Label"
|
|
Remove-Item $Path -Recurse -Force -ErrorAction SilentlyContinue
|
|
}
|
|
}
|
|
|
|
function Remove-ExperimentRuns {
|
|
if (-not (Test-Path $script:LiveWorkspacePath)) {
|
|
return
|
|
}
|
|
Write-GodLog "Removing experiment run directories"
|
|
Get-ChildItem -Path $script:LiveWorkspacePath -Directory -Recurse -ErrorAction SilentlyContinue |
|
|
Where-Object { $_.Name -eq "run" -or $_.Name -like "run_*" } |
|
|
ForEach-Object { Remove-Item $_.FullName -Recurse -Force -ErrorAction SilentlyContinue }
|
|
}
|
|
|
|
function Remove-RuntimeRegistryEntries {
|
|
if (-not (Test-Path $script:RuntimeRoot) -or -not (Test-CommandExists "uv")) {
|
|
return
|
|
}
|
|
$names = @($script:RuntimeInstance) + $script:RuntimeLegacyInstances
|
|
$nameArgs = ($names | ForEach-Object { Quote-PSLiteral $_ }) -join ", "
|
|
$code = @"
|
|
from pathlib import Path
|
|
from ruamel.yaml import YAML
|
|
|
|
names = {$nameArgs}
|
|
path = Path.home() / ".jiuwenclaw" / "instances.yaml"
|
|
if not path.exists():
|
|
raise SystemExit(0)
|
|
yaml = YAML()
|
|
data = yaml.load(path.read_text(encoding="utf-8")) or {}
|
|
instances = data.get("instances")
|
|
if not isinstance(instances, dict):
|
|
raise SystemExit(0)
|
|
for name in names:
|
|
instances.pop(name, None)
|
|
if instances:
|
|
with path.open("w", encoding="utf-8") as f:
|
|
yaml.dump(data, f)
|
|
else:
|
|
path.unlink()
|
|
"@
|
|
Push-Location $script:RuntimeRoot
|
|
try {
|
|
$code | & (Get-ToolPath @("uv")) run python -
|
|
} catch {
|
|
Write-GodLog "Could not update runtime registry; continuing reset"
|
|
} finally {
|
|
Pop-Location
|
|
}
|
|
}
|
|
|
|
function Reset-Factory {
|
|
Ensure-Prerequisites
|
|
Write-GodLog "Factory reset"
|
|
Stop-All
|
|
Remove-ExperimentRuns
|
|
Remove-RuntimeRegistryEntries
|
|
foreach ($name in @($script:RuntimeInstance) + $script:RuntimeLegacyInstances) {
|
|
Remove-PathSafe (Join-PathMany $HOME ".jiuwenclaw-instances" $name) "runtime instance state"
|
|
}
|
|
Remove-PathSafe $script:EnvFile ".env"
|
|
Remove-PathSafe $script:StateDir "state and logs"
|
|
Remove-PathSafe (Join-Path $script:BackendRoot ".venv") "backend virtualenv"
|
|
Remove-PathSafe (Join-Path $script:RuntimeRoot ".venv") "runtime virtualenv"
|
|
Remove-PathSafe (Join-PathMany $script:BackendRoot "frontend" "node_modules") "frontend dependencies"
|
|
Remove-PathSafe (Join-PathMany $script:RuntimeRoot "jiuwenclaw" "channels" "web" "frontend" "node_modules") "runtime UI dependencies"
|
|
Write-GodLog "Factory reset complete."
|
|
}
|
|
|
|
function Invoke-NativeCommand {
|
|
param(
|
|
[Parameter(ValueFromPipeline = $true)]
|
|
[AllowNull()][object]$InputObject,
|
|
[string]$FilePath,
|
|
[object[]]$ArgumentList,
|
|
[string]$LogPath = ""
|
|
)
|
|
begin {
|
|
$previousEap = $ErrorActionPreference
|
|
$ErrorActionPreference = "Continue"
|
|
$pipelineInput = New-Object System.Collections.Generic.List[object]
|
|
}
|
|
process {
|
|
if ($null -ne $InputObject) {
|
|
$pipelineInput.Add($InputObject)
|
|
}
|
|
}
|
|
end {
|
|
try {
|
|
$hasInput = $pipelineInput.Count -gt 0
|
|
$inputText = if ($hasInput) { ($pipelineInput | ForEach-Object { [string]$_ }) -join [Environment]::NewLine } else { $null }
|
|
if ($LogPath) {
|
|
if ($hasInput) {
|
|
$inputText | & $FilePath @ArgumentList 2>&1 | Out-File -FilePath $LogPath -Append -Encoding utf8
|
|
} else {
|
|
& $FilePath @ArgumentList 2>&1 | Out-File -FilePath $LogPath -Append -Encoding utf8
|
|
}
|
|
} else {
|
|
if ($hasInput) {
|
|
$inputText | & $FilePath @ArgumentList
|
|
} else {
|
|
& $FilePath @ArgumentList
|
|
}
|
|
}
|
|
} finally {
|
|
$ErrorActionPreference = $previousEap
|
|
}
|
|
}
|
|
}
|
|
|
|
function Get-DetachedNativeExecLine {
|
|
param(
|
|
[string]$FilePath,
|
|
[string]$ArgumentExpression,
|
|
[string]$LogPath = ""
|
|
)
|
|
$redirect = if ($LogPath) {
|
|
" 2>&1 | Out-File -FilePath $(Quote-PSLiteral $LogPath) -Append -Encoding utf8"
|
|
} else {
|
|
""
|
|
}
|
|
return "`$ErrorActionPreference = 'Continue'; & $(Quote-PSLiteral $FilePath) $ArgumentExpression$redirect; if (`$LASTEXITCODE -ne 0) { exit `$LASTEXITCODE }"
|
|
}
|
|
|
|
function Invoke-CheckedCommand {
|
|
param(
|
|
[string]$FilePath,
|
|
[string[]]$Arguments,
|
|
[string]$WorkingDirectory
|
|
)
|
|
Push-Location $WorkingDirectory
|
|
try {
|
|
Invoke-NativeCommand -FilePath $FilePath -ArgumentList $Arguments
|
|
if ($LASTEXITCODE -ne 0) {
|
|
Stop-God "Command failed: $FilePath $($Arguments -join ' ')"
|
|
}
|
|
} finally {
|
|
Pop-Location
|
|
}
|
|
}
|
|
|
|
function Ensure-BackendDependencies {
|
|
if ((Get-EnvValue "GOD_SKIP_SETUP" "0") -eq "1") {
|
|
return
|
|
}
|
|
$uv = Get-ToolPath @("uv")
|
|
Write-GodLog "Ensuring backend Python dependencies (first run may take several minutes)"
|
|
Invoke-CheckedCommand -FilePath $uv -Arguments @("sync", "--managed-python") -WorkingDirectory $script:BackendRoot
|
|
}
|
|
|
|
function Setup-Dependencies {
|
|
Ensure-Prerequisites
|
|
if ((Get-EnvValue "GOD_SKIP_SETUP" "0") -eq "1") {
|
|
Write-GodLog "Skipping dependency setup (GOD_SKIP_SETUP=1)"
|
|
return
|
|
}
|
|
|
|
$uv = Get-ToolPath @("uv")
|
|
$npm = Get-ToolPath @("npm.cmd", "npm")
|
|
|
|
Write-GodLog "Syncing backend Python dependencies"
|
|
Invoke-CheckedCommand -FilePath $uv -Arguments @("sync", "--managed-python") -WorkingDirectory $script:BackendRoot
|
|
|
|
Write-GodLog "Syncing agent runtime Python dependencies"
|
|
Invoke-CheckedCommand -FilePath $uv -Arguments @("sync", "--managed-python") -WorkingDirectory $script:RuntimeRoot
|
|
|
|
$backendFrontend = Join-Path $script:BackendRoot "frontend"
|
|
if ((-not (Test-Path (Join-Path $backendFrontend "node_modules"))) -or (Get-EnvValue "GOD_FORCE_SETUP" "0") -eq "1") {
|
|
Write-GodLog "Installing control-room dependencies"
|
|
Invoke-CheckedCommand -FilePath $npm -Arguments @("install", "--no-audit", "--no-fund", "--loglevel=error") -WorkingDirectory $backendFrontend
|
|
}
|
|
|
|
$runtimeFrontend = Join-PathMany $script:RuntimeRoot "jiuwenclaw" "channels" "web" "frontend"
|
|
if ((-not (Test-Path (Join-Path $runtimeFrontend "node_modules"))) -or (Get-EnvValue "GOD_FORCE_SETUP" "0") -eq "1") {
|
|
Write-GodLog "Installing runtime UI dependencies"
|
|
Invoke-CheckedCommand -FilePath $npm -Arguments @("install", "--no-audit", "--no-fund", "--loglevel=error") -WorkingDirectory $runtimeFrontend
|
|
}
|
|
}
|
|
|
|
function Sync-RuntimeModelEnv {
|
|
$workspace = Get-RuntimeWorkspace
|
|
if (-not (Test-Path $workspace)) {
|
|
return
|
|
}
|
|
$apiKey = Get-EnvValue "GOD_LLM_API_KEY" ""
|
|
$apiBase = Get-EnvValue "GOD_LLM_API_BASE" ""
|
|
$model = Get-EnvValue "GOD_LLM_MODEL" ""
|
|
if ([string]::IsNullOrEmpty($apiKey) -or [string]::IsNullOrEmpty($apiBase) -or [string]::IsNullOrEmpty($model)) {
|
|
return
|
|
}
|
|
Write-GodLog "Syncing runtime model config"
|
|
$configEnv = Join-PathMany $workspace "config" ".env"
|
|
Set-EnvValuesInFile $configEnv @{
|
|
API_KEY = $apiKey
|
|
API_BASE = $apiBase
|
|
MODEL_NAME = $model
|
|
MODEL_PROVIDER = Get-EnvValue "JIUWENCLAW_MODEL_PROVIDER" "OpenAI"
|
|
EMBED_API_KEY = Get-EnvValue "GOD_EMBEDDING_API_KEY" $apiKey
|
|
EMBED_API_BASE = Get-EnvValue "GOD_EMBEDDING_API_BASE" $apiBase
|
|
EMBED_MODEL = Get-EnvValue "GOD_EMBEDDING_MODEL" ""
|
|
}
|
|
}
|
|
|
|
function Ensure-RuntimeInstance {
|
|
Setup-Dependencies
|
|
$uv = Get-ToolPath @("uv")
|
|
$existing = $false
|
|
Push-Location $script:RuntimeRoot
|
|
try {
|
|
Invoke-NativeCommand -FilePath $uv -ArgumentList @("run", "jiuwenclaw-start", "--status", $script:RuntimeInstance) *> $null
|
|
$existing = ($LASTEXITCODE -eq 0)
|
|
} finally {
|
|
Pop-Location
|
|
}
|
|
|
|
if (-not $existing) {
|
|
Write-GodLog "Initializing agent runtime instance (default language: $($script:RuntimeLanguage))"
|
|
Write-TextUtf8NoBom $script:RuntimeInitLog ""
|
|
$workspace = Get-RuntimeWorkspace
|
|
$initInput = if (Test-Path $workspace) { "yes`n$($script:RuntimeLanguage)`n" } else { "$($script:RuntimeLanguage)`n" }
|
|
Push-Location $script:RuntimeRoot
|
|
try {
|
|
$initInput | Invoke-NativeCommand -FilePath $uv -ArgumentList @("run", "jiuwenclaw-init", "--name", $script:RuntimeInstance) -LogPath $script:RuntimeInitLog
|
|
if ($LASTEXITCODE -ne 0) {
|
|
Get-Content $script:RuntimeInitLog -Tail 80 -ErrorAction SilentlyContinue | ForEach-Object { Write-GodDiagnostic $_ }
|
|
Stop-God "Failed to initialize agent runtime instance"
|
|
}
|
|
} finally {
|
|
Pop-Location
|
|
}
|
|
}
|
|
|
|
$code = @'
|
|
import os
|
|
from pathlib import Path
|
|
from ruamel.yaml import YAML
|
|
|
|
name = os.environ["RUNTIME_INSTANCE"]
|
|
path = Path.home() / ".jiuwenclaw" / "instances.yaml"
|
|
path.parent.mkdir(parents=True, exist_ok=True)
|
|
yaml = YAML()
|
|
data = yaml.load(path.read_text(encoding="utf-8")) if path.exists() else None
|
|
if not isinstance(data, dict):
|
|
data = {"instances": {}}
|
|
instances = data.setdefault("instances", {})
|
|
entry = instances.setdefault(name, {})
|
|
workspace = entry.get("workspace") or str(Path.home() / ".jiuwenclaw-instances" / name)
|
|
entry["workspace"] = workspace
|
|
entry["ports"] = {
|
|
"agent_server": int(os.environ["RUNTIME_AGENT_PORT"]),
|
|
"web": int(os.environ["RUNTIME_WEB_PORT"]),
|
|
"gateway": int(os.environ["RUNTIME_GATEWAY_PORT"]),
|
|
"frontend": int(os.environ["RUNTIME_UI_PORT"]),
|
|
}
|
|
with path.open("w", encoding="utf-8") as f:
|
|
yaml.dump(data, f)
|
|
|
|
workspace_path = Path(workspace).expanduser()
|
|
workspace_path.mkdir(parents=True, exist_ok=True)
|
|
bootstrap_env = workspace_path / ".env"
|
|
bootstrap_env.write_text(
|
|
"\n".join(
|
|
[
|
|
f"# Bootstrap .env for runtime instance: {name}",
|
|
f"JIUWENCLAW_DATA_DIR={workspace_path}",
|
|
f"JIUWENCLAW_INSTANCE={name}",
|
|
f"AGENT_SERVER_PORT={os.environ['RUNTIME_AGENT_PORT']}",
|
|
f"WEB_PORT={os.environ['RUNTIME_WEB_PORT']}",
|
|
f"GATEWAY_PORT={os.environ['RUNTIME_GATEWAY_PORT']}",
|
|
f"FRONTEND_PORT={os.environ['RUNTIME_UI_PORT']}",
|
|
"",
|
|
]
|
|
),
|
|
encoding="utf-8",
|
|
)
|
|
'@
|
|
Set-ProcessEnv "RUNTIME_INSTANCE" $script:RuntimeInstance
|
|
Set-ProcessEnv "RUNTIME_AGENT_PORT" ([string]$script:RuntimeAgentPort)
|
|
Set-ProcessEnv "RUNTIME_WEB_PORT" ([string]$script:RuntimeWebPort)
|
|
Set-ProcessEnv "RUNTIME_GATEWAY_PORT" ([string]$script:RuntimeGatewayPort)
|
|
Set-ProcessEnv "RUNTIME_UI_PORT" ([string]$script:RuntimeUiPort)
|
|
Push-Location $script:RuntimeRoot
|
|
try {
|
|
$code | Invoke-NativeCommand -FilePath $uv -ArgumentList @("run", "python", "-")
|
|
if ($LASTEXITCODE -ne 0) {
|
|
Stop-God "Failed to update runtime instance registry"
|
|
}
|
|
} finally {
|
|
Pop-Location
|
|
}
|
|
Sync-RuntimeModelEnv
|
|
}
|
|
|
|
function Prepare-Experiment {
|
|
$experimentPath = Join-PathMany $script:LiveWorkspacePath "hypothesis_$($script:GodExperiment)" "experiment_$($script:GodExperimentRun)"
|
|
$configPath = Join-PathMany $experimentPath "init" "init_config.json"
|
|
if (-not (Test-Path $configPath)) {
|
|
Stop-God "Experiment config not found: $configPath"
|
|
}
|
|
|
|
$sessionPrefix = Get-EnvValue "GOD_SESSION_PREFIX" "$($script:GodExperiment)_run_$($script:GodExperimentRun)"
|
|
Write-GodLog "Preparing experiment: $($script:GodExperiment) (run $($script:GodExperimentRun))"
|
|
$config = Get-Content $configPath -Raw | ConvertFrom-Json
|
|
$agentRoot = (Resolve-Path $script:BackendRoot).Path
|
|
$wsUrl = "ws://127.0.0.1:$($script:RuntimeAgentPort)"
|
|
$requestedMapId = if ($script:InitialEnv.GOD_MAP_ID -ne $null) { Get-EnvValue "GOD_MAP_ID" "" } else { "" }
|
|
|
|
foreach ($module in @(Get-ObjectPropertyValue -Object $config -Name "env_modules" -Default @())) {
|
|
if ($null -eq $module) {
|
|
continue
|
|
}
|
|
if ((Get-ObjectPropertyValue $module "module_type" "") -ne "PixelTownSocialEnv") {
|
|
continue
|
|
}
|
|
if (-not $module.PSObject.Properties["kwargs"] -or $null -eq $module.kwargs) {
|
|
Set-ObjectProperty $module "kwargs" ([pscustomobject]@{})
|
|
}
|
|
$kwargs = $module.kwargs
|
|
if (-not [string]::IsNullOrWhiteSpace($requestedMapId)) {
|
|
Set-ObjectProperty $kwargs "map_id" $requestedMapId
|
|
Set-ObjectProperty $kwargs "map_manifest_path" "custom/maps/$requestedMapId/map.yaml"
|
|
} else {
|
|
$mapId = if ($kwargs.PSObject.Properties["map_id"]) { [string]$kwargs.map_id } else { "" }
|
|
$manifestPath = if ($kwargs.PSObject.Properties["map_manifest_path"]) { [string]$kwargs.map_manifest_path } else { "" }
|
|
if ([string]::IsNullOrWhiteSpace($manifestPath)) {
|
|
if ([string]::IsNullOrWhiteSpace($mapId)) {
|
|
$mapId = "the_ville"
|
|
Set-ObjectProperty $kwargs "map_id" $mapId
|
|
}
|
|
Set-ObjectProperty $kwargs "map_manifest_path" "custom/maps/$mapId/map.yaml"
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach ($agent in @(Get-ObjectPropertyValue -Object $config -Name "agents" -Default @())) {
|
|
if ($null -eq $agent) {
|
|
continue
|
|
}
|
|
if (-not $agent.PSObject.Properties["kwargs"] -or $null -eq $agent.kwargs) {
|
|
Set-ObjectProperty $agent "kwargs" ([pscustomobject]@{})
|
|
}
|
|
$kwargs = $agent.kwargs
|
|
$agentId = 0
|
|
$rawAgentId = Get-ObjectPropertyValue $agent "agent_id" $null
|
|
$rawKwargsId = Get-ObjectPropertyValue $kwargs "id" $null
|
|
if ($rawAgentId) {
|
|
$agentId = [int]$rawAgentId
|
|
} elseif ($rawKwargsId) {
|
|
$agentId = [int]$rawKwargsId
|
|
}
|
|
Set-ObjectProperty $kwargs "jiuwenclaw_ws_url" $wsUrl
|
|
Set-ObjectProperty $kwargs "session_id" "$sessionPrefix`_agent_$agentId"
|
|
Set-ObjectProperty $kwargs "trusted_dirs" @($agentRoot)
|
|
}
|
|
|
|
Write-TextUtf8NoBom $configPath (($config | ConvertTo-Json -Depth 100) + "`n")
|
|
}
|
|
|
|
function Start-Runtime {
|
|
Ensure-RuntimeInstance
|
|
if ((Test-PortOpen $script:RuntimeAgentPort) -and (Test-PortOpen $script:RuntimeWebPort) -and (Test-PortOpen $script:RuntimeGatewayPort) -and (Test-PortOpen $script:RuntimeUiPort)) {
|
|
Write-GodLog "Agent runtime already up"
|
|
return
|
|
}
|
|
|
|
Write-GodLog "Starting agent runtime"
|
|
Write-TextUtf8NoBom $script:RuntimeLog ""
|
|
$uv = Get-ToolPath @("uv")
|
|
$runtimeDataDir = Get-RuntimeWorkspace
|
|
$runtimeCmd = @(
|
|
"`$ErrorActionPreference = 'Stop'",
|
|
"Set-Location $(Quote-PSLiteral $script:RuntimeRoot)",
|
|
"`$env:JIUWENCLAW_DATA_DIR = $(Quote-PSLiteral $runtimeDataDir)",
|
|
"`$env:JIUWENCLAW_ROOT = $(Quote-PSLiteral $script:RuntimeRoot)",
|
|
"`$env:JIUWENCLAW_PROJECT_ROOT = $(Quote-PSLiteral $script:RuntimeRoot)",
|
|
"`$env:AGENT_SERVER_PORT = $(Quote-PSLiteral ([string]$script:RuntimeAgentPort))",
|
|
"`$env:WEB_PORT = $(Quote-PSLiteral ([string]$script:RuntimeWebPort))",
|
|
"`$env:GATEWAY_PORT = $(Quote-PSLiteral ([string]$script:RuntimeGatewayPort))",
|
|
"`$env:FRONTEND_PORT = $(Quote-PSLiteral ([string]$script:RuntimeUiPort))",
|
|
(Get-DetachedNativeExecLine -FilePath $uv -ArgumentExpression "run jiuwenclaw-start $(Quote-PSLiteral $script:RuntimeMode) --name $(Quote-PSLiteral $script:RuntimeInstance)" -LogPath $script:RuntimeLog)
|
|
) -join "; "
|
|
Start-DetachedService -SessionName $script:RuntimeInstance -PidFile $script:RuntimePidFile -Command $runtimeCmd -LogPath $script:RuntimeLog
|
|
|
|
Wait-ForPort $script:RuntimeAgentPort "Agent runtime" 180
|
|
Wait-ForPort $script:RuntimeWebPort "Agent runtime web" 120
|
|
Wait-ForPort $script:RuntimeGatewayPort "Agent runtime gateway" 120
|
|
Wait-ForPort $script:RuntimeUiPort "Agent runtime UI" 120
|
|
}
|
|
|
|
function Test-BackendHealthy {
|
|
if (-not (Test-PortOpen $script:GodBackendPort)) {
|
|
return $false
|
|
}
|
|
try {
|
|
Invoke-RestMethod -Uri "$($script:BackendUrl)/health" -TimeoutSec 5 | Out-Null
|
|
return $true
|
|
} catch {
|
|
return $false
|
|
}
|
|
}
|
|
|
|
function Start-Backend {
|
|
Ensure-EnvFile
|
|
if (Test-BackendHealthy) {
|
|
Write-GodLog "Backend already up"
|
|
return
|
|
}
|
|
|
|
Ensure-BackendDependencies
|
|
Write-GodLog "Starting backend"
|
|
Write-TextUtf8NoBom $script:BackendLog ""
|
|
$uv = Get-ToolPath @("uv")
|
|
$backendLogLevel = Get-EnvValue "BACKEND_LOG_LEVEL" "info"
|
|
$backendCmd = @(
|
|
"`$ErrorActionPreference = 'Stop'",
|
|
"Set-Location $(Quote-PSLiteral $script:BackendRoot)",
|
|
"`$env:GOD_ROOT = $(Quote-PSLiteral $script:RootDir)",
|
|
"`$env:GOD_ENV_FILE = $(Quote-PSLiteral $script:EnvFile)",
|
|
"`$env:LIVE_WORKSPACE_PATH = $(Quote-PSLiteral $script:LiveWorkspacePath)",
|
|
"`$env:AGENTSOCIETY_LLM_API_KEY = $(Quote-PSLiteral (Get-EnvValue 'AGENTSOCIETY_LLM_API_KEY' ''))",
|
|
"`$env:AGENTSOCIETY_LLM_API_BASE = $(Quote-PSLiteral (Get-EnvValue 'AGENTSOCIETY_LLM_API_BASE' 'https://api.openai.com/v1'))",
|
|
"`$env:AGENTSOCIETY_LLM_MODEL = $(Quote-PSLiteral (Get-EnvValue 'AGENTSOCIETY_LLM_MODEL' 'gpt-5.4'))",
|
|
"`$env:AGENTSOCIETY_NANO_LLM_MODEL = $(Quote-PSLiteral (Get-EnvValue 'AGENTSOCIETY_NANO_LLM_MODEL' 'gpt-5.4-nano'))",
|
|
"`$env:AGENTSOCIETY_EMBEDDING_API_KEY = $(Quote-PSLiteral (Get-EnvValue 'AGENTSOCIETY_EMBEDDING_API_KEY' (Get-EnvValue 'AGENTSOCIETY_LLM_API_KEY' '')))",
|
|
"`$env:AGENTSOCIETY_EMBEDDING_API_BASE = $(Quote-PSLiteral (Get-EnvValue 'AGENTSOCIETY_EMBEDDING_API_BASE' (Get-EnvValue 'AGENTSOCIETY_LLM_API_BASE' 'https://api.openai.com/v1')))",
|
|
"`$env:AGENTSOCIETY_EMBEDDING_MODEL = $(Quote-PSLiteral (Get-EnvValue 'AGENTSOCIETY_EMBEDDING_MODEL' 'text-embedding-3-large'))",
|
|
"`$env:BACKEND_HOST = $(Quote-PSLiteral $script:GodBackendHost)",
|
|
"`$env:BACKEND_PORT = $(Quote-PSLiteral ([string]$script:GodBackendPort))",
|
|
"`$env:AGENTSOCIETY_LIVE_STEP_TIMEOUT = $(Quote-PSLiteral $script:GodLiveStepTimeout)",
|
|
"`$env:BACKEND_LOG_LEVEL = $(Quote-PSLiteral $backendLogLevel)",
|
|
(Get-DetachedNativeExecLine -FilePath $uv -ArgumentExpression "run python -m agentsociety2.backend.run --log-level $(Quote-PSLiteral $backendLogLevel)" -LogPath $script:BackendLog)
|
|
) -join "; "
|
|
Start-DetachedService -SessionName "god-backend" -PidFile $script:BackendPidFile -Command $backendCmd -LogPath $script:BackendLog
|
|
|
|
$backendStartTimeout = [int](Get-EnvValue "GOD_BACKEND_START_TIMEOUT" "180")
|
|
Wait-ForPort $script:GodBackendPort "Backend" $backendStartTimeout
|
|
$deadline = (Get-Date).AddSeconds(30)
|
|
while ((Get-Date) -lt $deadline) {
|
|
if (Test-BackendHealthy) {
|
|
return
|
|
}
|
|
Start-Sleep -Seconds 1
|
|
}
|
|
Stop-God "Backend port is open but /health did not respond"
|
|
}
|
|
|
|
function Start-Frontend {
|
|
if (Test-PortOpen $script:GodFrontendPort) {
|
|
Write-GodLog "Control room already up"
|
|
return
|
|
}
|
|
|
|
Write-GodLog "Starting control room"
|
|
Write-TextUtf8NoBom $script:FrontendLog ""
|
|
$npm = Get-ToolPath @("npm.cmd", "npm")
|
|
$frontendRoot = Join-Path $script:BackendRoot "frontend"
|
|
$frontendCmd = @(
|
|
"`$ErrorActionPreference = 'Stop'",
|
|
"Set-Location $(Quote-PSLiteral $frontendRoot)",
|
|
"`$env:VITE_REPLAY_WORKSPACE_PATH = $(Quote-PSLiteral $script:LiveWorkspacePath)",
|
|
"`$env:VITE_DEFAULT_REPLAY_HYPOTHESIS_ID = $(Quote-PSLiteral $script:GodExperiment)",
|
|
"`$env:VITE_DEFAULT_REPLAY_EXPERIMENT_ID = $(Quote-PSLiteral $script:GodExperimentRun)",
|
|
(Get-DetachedNativeExecLine -FilePath $npm -ArgumentExpression "run dev -- --host 127.0.0.1 --port $(Quote-PSLiteral ([string]$script:GodFrontendPort))" -LogPath $script:FrontendLog)
|
|
) -join "; "
|
|
Start-DetachedService -SessionName "god-frontend" -PidFile $script:FrontendPidFile -Command $frontendCmd -LogPath $script:FrontendLog
|
|
Wait-ForPort $script:GodFrontendPort "Control room" 120
|
|
}
|
|
|
|
function Start-SetupServices {
|
|
Setup-Dependencies
|
|
Set-ProcessEnv "GOD_SETUP_MODE" "1"
|
|
Ensure-EnvFile
|
|
Remove-Item $script:StartRequestFile -Force -ErrorAction SilentlyContinue
|
|
Stop-All
|
|
Start-Backend
|
|
Start-Frontend
|
|
Open-SetupPage
|
|
}
|
|
|
|
function Receive-StartRequest {
|
|
try {
|
|
$data = Get-Content $script:StartRequestFile -Raw | ConvertFrom-Json
|
|
} catch {
|
|
Stop-God "Could not read setup start request"
|
|
}
|
|
$hypothesisId = [string](Get-ObjectPropertyValue $data "hypothesis_id" "")
|
|
$rawExperimentId = Get-ObjectPropertyValue $data "experiment_id" ""
|
|
$experimentId = if ($rawExperimentId) { [string]$rawExperimentId } else { "1" }
|
|
$rawWorkspacePath = Get-ObjectPropertyValue $data "workspace_path" ""
|
|
$workspacePath = if ($rawWorkspacePath) { [string]$rawWorkspacePath } else { "" }
|
|
if ([string]::IsNullOrWhiteSpace($hypothesisId)) {
|
|
Stop-God "Setup start request is missing hypothesis_id"
|
|
}
|
|
try {
|
|
Move-Item $script:StartRequestFile "$($script:StartRequestFile).consumed" -Force
|
|
} catch {
|
|
Remove-Item $script:StartRequestFile -Force -ErrorAction SilentlyContinue
|
|
}
|
|
Set-ProcessEnv "GOD_EXPERIMENT" $hypothesisId
|
|
Set-ProcessEnv "GOD_EXPERIMENT_RUN" $experimentId
|
|
if (-not [string]::IsNullOrWhiteSpace($workspacePath)) {
|
|
Set-ProcessEnv "LIVE_WORKSPACE_PATH" $workspacePath
|
|
}
|
|
Load-Env
|
|
Write-GodLog "Received start request: $($script:GodExperiment) / experiment_$($script:GodExperimentRun)"
|
|
}
|
|
|
|
function Wait-ForStartRequest {
|
|
Write-GodLog "Waiting for setup wizard to save and request startup"
|
|
$nextNotice = (Get-Date).AddSeconds(30)
|
|
while (-not (Test-Path $script:StartRequestFile)) {
|
|
Start-Sleep -Seconds 2
|
|
if ((Get-Date) -ge $nextNotice) {
|
|
Write-GodLog "Still waiting on $(Get-SetupUrl)"
|
|
$nextNotice = (Get-Date).AddSeconds(30)
|
|
}
|
|
}
|
|
Receive-StartRequest
|
|
}
|
|
|
|
function Start-WithSetupIfNeeded {
|
|
Ensure-Prerequisites
|
|
Load-Env
|
|
if (Test-PendingStartRequest) {
|
|
Write-GodLog "Applying pending setup startup request"
|
|
Receive-StartRequest
|
|
Remove-ProcessEnv "GOD_SETUP_MODE"
|
|
Stop-All
|
|
Start-All
|
|
return
|
|
}
|
|
if (Test-ReadyStartConfig) {
|
|
Start-All
|
|
return
|
|
}
|
|
|
|
Write-GodLog "No complete experiment configuration found; starting setup wizard first"
|
|
Start-SetupServices
|
|
Wait-ForStartRequest
|
|
Remove-ProcessEnv "GOD_SETUP_MODE"
|
|
Stop-ControlServices
|
|
Start-All
|
|
}
|
|
|
|
function Configure-Experiment {
|
|
Ensure-Prerequisites
|
|
Write-GodLog "Starting new experiment setup wizard"
|
|
Start-SetupServices
|
|
Wait-ForStartRequest
|
|
Remove-ProcessEnv "GOD_SETUP_MODE"
|
|
Stop-ControlServices
|
|
Start-All
|
|
}
|
|
|
|
function New-LiveSession {
|
|
if (-not (Test-BackendHealthy)) {
|
|
Start-Backend
|
|
}
|
|
Write-GodLog "Creating live session"
|
|
try {
|
|
$statusJson = Invoke-RestMethod -Method Post -Uri (Get-SessionUrl) -ContentType "application/json" -Body "{}"
|
|
} catch {
|
|
Stop-God "Failed to create live session"
|
|
}
|
|
$stepCount = if ($statusJson.PSObject.Properties["step_count"]) { [int]$statusJson.step_count } else { 0 }
|
|
if ((Get-EnvValue "GOD_PRIME_FIRST_STEP" "1") -ne "0" -and $stepCount -eq 0) {
|
|
Write-GodLog "Priming live session (step 1)"
|
|
try {
|
|
Invoke-RestMethod -Method Post -Uri (Get-RunStepUrl) -ContentType "application/json" -Body "{}" | Out-Null
|
|
} catch {
|
|
Stop-God "Failed to run the first live step"
|
|
}
|
|
}
|
|
}
|
|
|
|
function Start-All {
|
|
Load-Env
|
|
Require-CurrentExperimentConfig
|
|
Setup-Dependencies
|
|
Ensure-EnvFile
|
|
Prepare-Experiment
|
|
Start-Runtime
|
|
Start-Backend
|
|
Start-Frontend
|
|
New-LiveSession
|
|
Show-Status
|
|
}
|
|
|
|
function Restart-All {
|
|
Ensure-Prerequisites
|
|
Stop-All
|
|
Start-WithSetupIfNeeded
|
|
}
|
|
|
|
function Start-NewRun {
|
|
Ensure-Prerequisites
|
|
Load-Env
|
|
Require-CurrentExperimentConfig
|
|
Set-ProcessEnv "GOD_SESSION_PREFIX" "$($script:GodExperiment)_fresh_$((Get-Date).ToString('yyyyMMdd_HHmmss'))"
|
|
Stop-All
|
|
$runDir = Join-PathMany $script:LiveWorkspacePath "hypothesis_$($script:GodExperiment)" "experiment_$($script:GodExperimentRun)" "run"
|
|
Write-GodLog "New run will clear: $runDir"
|
|
Remove-Item $runDir -Recurse -Force -ErrorAction SilentlyContinue
|
|
Write-GodLog "Cleared previous run"
|
|
Start-All
|
|
}
|
|
|
|
function Show-PortStatus {
|
|
param(
|
|
[string]$Label,
|
|
[int]$Port
|
|
)
|
|
if (Test-PortOpen $Port) {
|
|
"{0,-24} {1} up" -f $Label, $Port | Write-Host
|
|
} else {
|
|
"{0,-24} {1} down" -f $Label, $Port | Write-Host
|
|
}
|
|
}
|
|
|
|
function Show-Status {
|
|
Load-Env
|
|
Write-Host ""
|
|
Write-Host "GOD status"
|
|
Write-Host "----------"
|
|
Show-PortStatus "Backend" $script:GodBackendPort
|
|
Show-PortStatus "Control room" $script:GodFrontendPort
|
|
Show-PortStatus "Agent runtime" $script:RuntimeAgentPort
|
|
Show-PortStatus "Agent runtime web" $script:RuntimeWebPort
|
|
Show-PortStatus "Agent runtime gateway" $script:RuntimeGatewayPort
|
|
Show-PortStatus "Agent runtime UI" $script:RuntimeUiPort
|
|
Write-Host ""
|
|
Write-Host "URLs"
|
|
Show-FrontendLinks
|
|
Write-Host ("Backend: {0}/health" -f $script:BackendUrl)
|
|
Write-Host ""
|
|
Write-Host "Current experiment"
|
|
if (Test-CurrentExperimentConfig) {
|
|
Write-Host ("Experiment: {0} / experiment_{1}" -f $script:GodExperiment, $script:GodExperimentRun)
|
|
Write-Host ("Workspace: {0}" -f $script:LiveWorkspacePath)
|
|
} else {
|
|
Write-Host "Experiment: <not configured>"
|
|
}
|
|
Write-Host ""
|
|
Write-Host "Model"
|
|
Write-Host ("API key: {0}" -f (Get-ConfiguredState (Get-EnvValue "GOD_LLM_API_KEY" "")))
|
|
Write-Host ("API base: {0}" -f (Get-EnvValue "GOD_LLM_API_BASE" "<unset>"))
|
|
Write-Host ("Model: {0}" -f (Get-EnvValue "GOD_LLM_MODEL" "<unset>"))
|
|
}
|
|
|
|
function Watch-Logs {
|
|
foreach ($logPath in @($script:RuntimeLog, $script:BackendLog, $script:FrontendLog)) {
|
|
if (-not (Test-Path $logPath)) {
|
|
Write-TextUtf8NoBom $logPath ""
|
|
}
|
|
}
|
|
Get-Content $script:RuntimeLog, $script:BackendLog, $script:FrontendLog -Wait
|
|
}
|
|
|
|
function Open-Replay {
|
|
Load-Env
|
|
if (-not (Test-CurrentExperimentConfig)) {
|
|
Open-SetupPage
|
|
return
|
|
}
|
|
Open-FrontendPages
|
|
}
|
|
|
|
function Show-InteractiveMenu {
|
|
@"
|
|
|
|
GOD - Govern, Observe, Direct
|
|
|
|
1. Start
|
|
2. Restart
|
|
3. New run (reset replay and start fresh)
|
|
4. Configure new experiment
|
|
5. Status
|
|
6. Stop
|
|
7. Tail logs
|
|
8. Setup dependencies only
|
|
|
|
"@ | Write-Host
|
|
$choice = Read-Host "Choose"
|
|
switch ($choice) {
|
|
"1" { Start-WithSetupIfNeeded }
|
|
"" { Start-WithSetupIfNeeded }
|
|
"2" { Restart-All }
|
|
"3" { Start-NewRun }
|
|
"4" { Configure-Experiment; Open-FrontendPages }
|
|
"5" { Show-Status }
|
|
"6" { Stop-All }
|
|
"7" { Watch-Logs }
|
|
"8" { Setup-Dependencies; Set-ProcessEnv "GOD_SETUP_MODE" "1"; Ensure-EnvFile }
|
|
default { Show-Usage; exit 2 }
|
|
}
|
|
}
|
|
|
|
Load-Env
|
|
|
|
switch ($Action) {
|
|
"menu" { Show-InteractiveMenu }
|
|
"setup" { Setup-Dependencies; Set-ProcessEnv "GOD_SETUP_MODE" "1"; Ensure-EnvFile }
|
|
"configure" { Configure-Experiment; Open-FrontendPages }
|
|
"start" { Start-WithSetupIfNeeded; Open-FrontendPages }
|
|
"restart" { Restart-All; Open-FrontendPages }
|
|
"new-run" { Start-NewRun; Open-FrontendPages }
|
|
"factory-reset" { Reset-Factory }
|
|
"reset" { Reset-Factory }
|
|
"session" { Ensure-Prerequisites; Prepare-Experiment; New-LiveSession }
|
|
"stop" { Stop-All }
|
|
"status" { Show-Status }
|
|
"tail" { Watch-Logs }
|
|
"open" { Open-Replay }
|
|
"-h" { Show-Usage }
|
|
"--help" { Show-Usage }
|
|
"help" { Show-Usage }
|
|
default { Show-Usage; exit 2 }
|
|
}
|