diff --git a/cmd/agentflow/main.go b/cmd/agentflow/main.go index 88f6f0a31..b53879734 100644 --- a/cmd/agentflow/main.go +++ b/cmd/agentflow/main.go @@ -92,7 +92,7 @@ func main() { mysqlDSN := flag.String("mysql-dsn", "", "MySQL DSN; overrides AGENTFLOW_MYSQL_DSN. MySQL is the only data source.") roleFlag := flag.String("role", "", "process role: api, worker, or all (default all)") cliAction := flag.String("cli-action", "", "local managed CLI administration: status, update, or rollback; exits without starting services") - cliProvider := flag.String("cli-provider", "", "provider for CLI rollback: codex, codebuddy, or claude-code") + cliProvider := flag.String("cli-provider", "", "managed CLI provider to roll back") cliTimeout := flag.Duration("cli-timeout", 80*time.Minute, "total managed CLI operation timeout") browserImage := flag.Bool("browser-image", false, "build or pull the agent browser sidecar image, print its name and exit") flag.Parse() diff --git a/docs/deployment.md b/docs/deployment.md index ed1819455..85a09442d 100644 --- a/docs/deployment.md +++ b/docs/deployment.md @@ -15,6 +15,12 @@ npm install --global @openai/codex@0.162.1 @anthropic-ai/claude-code@2.1.326 Ensure the service can find `codebuddy` and Node.js on its PATH, or set `AGENTFLOW_CODEBUDDY_BIN` to the installed executable. Configure the model key and its network environment in personal settings. The no-key script demo does not need the CLI. The production Docker image includes CodeBuddy, Codex and DeepSeek Harness (`dsh`). Claude Code and the other agent CLIs are not bundled. When a conversation fails because one is missing, the error says it is not installed and offers an install button. That downloads the pinned `@anthropic-ai/claude-code` release, or the public package for OpenCode, Kimi Code and Pi, into `$LOOPFORGE_DATA_DIR/cli`; an installation outside the image gets the pinned `@deepseek-ai/dsh` release the same way. Cursor CLI and Antigravity use their providers' installers and land in the service user's `~/.local/bin`. Closing or reloading the browser does not stop an install that has already started, and the button stays on “自动安装” until it finishes. A finished install replaces the earlier generation failure with a prompt to send the message again. The next message reuses the installation. An SOP sandbox of the published image that selects Claude Code, OpenCode, Kimi Code or Pi installs the same package on first use and shares it with conversations. Cursor CLI and Antigravity are not installed into SOP sandboxes. Connected runners keep their own CLI requirements. +Set `AGENTFLOW_MANAGED_CLI_ROOT` to a persistent absolute directory to enable the daily CLI updater on platform processes that execute runs (`worker` or `all`). The updater uses npm for Claude Code, CodeBuddy, Codex, DeepSeek Harness, Kimi Code, OpenCode, and Pi. Cursor and Antigravity use their official release archives. All candidates pass a 24-hour observation window and a version and CLI argument check before activation. The previous installation remains available for rollback. After a rollback, automatic updates wait for a release newer than the rejected version. + +For native execution, the platform prefers explicit binary overrides, then the managed inventory. Platform-owned native workflows pin the inventory within their managed root. A worker that adopts a run can reuse its pin when it accesses the same persistent managed directory at the same absolute path with compatible binaries. Workers with separate roots resolve the CLI from their own inventory. + +The updater keeps observations of Cursor and Antigravity releases across daily checks so each release can age even while the vendor keeps publishing. Docker sandboxes use the CLI supplied by their image or sandbox installer. ZCode uses the executable supplied by the deployment. + A conversation workspace on a custom Dockerfile without Node.js, npm or Python 3 uses the platform's own copies. On first use the platform copies its Node.js, npm and a relocatable Python into `$LOOPFORGE_DATA_DIR/cli/toolchain//`, plus each bundled CLI (CodeBuddy, Codex, DeepSeek Harness) the first time a sandbox needs it, and mounts the directory read-only at the end of the sandbox `PATH`. Tools the image ships take precedence. Only glibc images of the platform's architecture use it; Alpine (musl) images need their own Node.js, npm and Python 3. A new platform build creates a new directory and leaves the previous ones in place: after an upgrade, delete the other `cli/toolchain//` directories (about 200 MB each plus the CLIs copied into them). Stop the foreground service with Ctrl-C. Start it again with the same command. MySQL data stays in its Compose volume. `docker compose stop mysql` stops the database without deleting it. diff --git a/internal/httpapi/assistant_agentcli_bin_test.go b/internal/httpapi/assistant_agentcli_bin_test.go index 7ecee3407..ac6ed82e5 100644 --- a/internal/httpapi/assistant_agentcli_bin_test.go +++ b/internal/httpapi/assistant_agentcli_bin_test.go @@ -16,32 +16,36 @@ import ( "agentflow/internal/managedcli" ) -func TestResolveUnmanagedCLIPreservesPathAndInstallerFallback(t *testing.T) { +func TestResolveManagedPiBeforePATHAndPreserveOverrides(t *testing.T) { root, host, home := t.TempDir(), t.TempDir(), t.TempDir() t.Setenv("HOME", home) t.Setenv("PATH", host) t.Setenv("AGENTFLOW_MANAGED_CLI_ROOT", root) - t.Setenv("AGENTFLOW_DSH_BIN", "") + t.Setenv("AGENTFLOW_PI_BIN", "") t.Setenv("AGENTFLOW_CURSOR_BIN", "") - hostDSH := filepath.Join(host, "dsh") - if err := os.WriteFile(hostDSH, []byte("#!/bin/sh\n"), 0700); err != nil { + hostPi := filepath.Join(host, "pi") + if err := os.WriteFile(hostPi, []byte("#!/bin/sh\n"), 0700); err != nil { t.Fatal(err) } - managed := filepath.Join(root, "providers", "dsh", "0.2.2-rc.1", "node_modules", ".bin", "dsh") + managed := filepath.Join(root, "providers", "pi", "1.5.2", "node_modules", ".bin", "pi") if err := os.MkdirAll(filepath.Dir(managed), 0700); err != nil { t.Fatal(err) } if err := os.WriteFile(managed, []byte("#!/bin/sh\n"), 0700); err != nil { t.Fatal(err) } - data, _ := json.Marshal(managedcli.State{Current: managedcli.Inventory{"dsh": {Version: "0.2.2-rc.1", Binary: managed}}}) + data, _ := json.Marshal(managedcli.State{Current: managedcli.Inventory{"pi": {Version: "1.5.2", Binary: managed}}}) if err := os.WriteFile(filepath.Join(root, "state.json"), data, 0600); err != nil { t.Fatal(err) } - if got, err := resolveAssistantEngineBin("dsh"); err != nil || got != hostDSH { - t.Fatalf("unmanaged dsh did not use PATH: %q %v", got, err) + if got, err := resolveAssistantEngineBin("pi"); err != nil || got != managed { + t.Fatalf("managed Pi did not supersede the host binary: %q %v", got, err) } - // Cursor has no npm package: the managed root never hides ~/.local/bin. + t.Setenv("AGENTFLOW_PI_BIN", hostPi) + if got, err := resolveAssistantEngineBin("pi"); err != nil || got != hostPi { + t.Fatalf("explicit Pi override was ignored: %q %v", got, err) + } + // An empty Cursor inventory still falls back to its installer location. found, err := resolveAssistantEngineBin("cursor") // The integration image also installs Cursor globally. PATH and HOME // isolation deliberately do not disable the supported global fallback. diff --git a/internal/httpapi/assistant_engine_cli.go b/internal/httpapi/assistant_engine_cli.go index 39f2223e6..44bd4e82b 100644 --- a/internal/httpapi/assistant_engine_cli.go +++ b/internal/httpapi/assistant_engine_cli.go @@ -70,12 +70,12 @@ func resolveAssistantEngineBin(engine string) (string, error) { if engine == assistantEngineClaude { binary, override, managed = "claude", "AGENTFLOW_CLAUDE_BIN", "claude-code" } else if runtime.IsAgentCLI(engine) { - binary, override, managed = runtime.AgentCLIBinary(engine), "AGENTFLOW_"+strings.ToUpper(strings.ReplaceAll(engine, "-", "_"))+"_BIN", "" + binary, override, managed = runtime.AgentCLIBinary(engine), "AGENTFLOW_"+strings.ToUpper(strings.ReplaceAll(engine, "-", "_"))+"_BIN", engine } if path := strings.TrimSpace(os.Getenv(override)); path != "" && fileExecutable(path) { return path, nil } - if root := strings.TrimSpace(os.Getenv("AGENTFLOW_MANAGED_CLI_ROOT")); root != "" && managed != "" { + if root := strings.TrimSpace(os.Getenv("AGENTFLOW_MANAGED_CLI_ROOT")); root != "" && managedcli.Supports(managed) { if inventory, err := managedcli.ReadInventory(root); err == nil { if path, ok := inventory.BinaryFor(managed); ok { return path, nil diff --git a/internal/managedcli/coordinator_process_test.go b/internal/managedcli/coordinator_process_test.go index 73224f118..987216466 100644 --- a/internal/managedcli/coordinator_process_test.go +++ b/internal/managedcli/coordinator_process_test.go @@ -10,6 +10,7 @@ import ( "os" "os/exec" "path/filepath" + "strings" "testing" "time" ) @@ -156,7 +157,7 @@ func TestDailyClaimAcrossProcessesAndCrash(t *testing.T) { } data, err := os.ReadFile(filepath.Join(root, "attempts")) must(t, err) - want := "attempt\nattempt\nattempt\n" // One check visits all three providers. + want := strings.Repeat("attempt\n", len(providerNames())) // One check visits every provider. if crash { want = "attempt\n" // The first request was interrupted after the claim. } diff --git a/internal/managedcli/manifest.go b/internal/managedcli/manifest.go index f5eec08b7..fe71667fd 100644 --- a/internal/managedcli/manifest.go +++ b/internal/managedcli/manifest.go @@ -18,13 +18,14 @@ import ( var releaseVersion = regexp.MustCompile(`^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)$`) -// Installation points at one immutable, version-specific npm installation. +// Installation points at an immutable version-specific CLI installation. // Authentication/configuration homes are deliberately not part of this record. type Installation struct { - Version string `json:"version"` - Binary string `json:"binary"` - Integrity string `json:"integrity,omitempty"` - InstalledAt time.Time `json:"installedAt,omitempty"` + Version string `json:"version"` + Binary string `json:"binary"` + Integrity string `json:"integrity,omitempty"` + PublishedAt *time.Time `json:"publishedAt,omitempty"` + InstalledAt time.Time `json:"installedAt,omitempty"` } type Inventory map[string]Installation @@ -35,12 +36,13 @@ func (i Inventory) BinaryFor(provider string) (string, bool) { } type State struct { - LastCheck time.Time `json:"lastCheck"` - Candidates Inventory `json:"candidates"` - Current Inventory `json:"current"` - Previous Inventory `json:"previous"` - Rejected map[string]string `json:"rejected,omitempty"` - UpdatedAt time.Time `json:"updatedAt,omitempty"` + LastCheck time.Time `json:"lastCheck"` + Candidates Inventory `json:"candidates"` + Current Inventory `json:"current"` + Previous Inventory `json:"previous"` + Rejected map[string]string `json:"rejected,omitempty"` + VendorObservations map[string][]vendorObservation `json:"vendorObservations,omitempty"` + UpdatedAt time.Time `json:"updatedAt,omitempty"` } // State and its rollback pointers are committed in one atomic rename. @@ -63,6 +65,9 @@ func ReadState(root string) (State, error) { if state.Rejected == nil { state.Rejected = map[string]string{} } + if state.VendorObservations == nil { + state.VendorObservations = map[string][]vendorObservation{} + } if err := validateInventory(root, state.Current); err != nil { return State{}, fmt.Errorf("current inventory: %w", err) } @@ -74,8 +79,8 @@ func ReadInventory(root string) (Inventory, error) { return state.Current, err } -// PinInventory fixes the complete inventory for a run, including an empty one -// before initial provisioning. Pins live outside agent-controlled workspaces. +// PinInventory fixes the complete inventory for a run in this root, including +// an empty one before provisioning. Pins live outside agent-controlled workspaces. // Publishing via link makes concurrent first claims observe a complete file. // Old versions and pins are not automatically deleted: suspended/resumable runs // may still reference them after the runner or updater restarts. @@ -161,10 +166,10 @@ func validateInventory(root string, inventory Inventory) error { return errors.New("managed CLI inventory must be a JSON object") } for provider, installed := range inventory { - if _, ok := providerSpecs[provider]; !ok { + if !Supports(provider) { return fmt.Errorf("unknown managed CLI provider %q", provider) } - if !releaseVersion.MatchString(installed.Version) { + if !validProviderVersion(provider, installed.Version) { return fmt.Errorf("invalid release version for %s", provider) } base := filepath.Join(root, "providers", provider) diff --git a/internal/managedcli/npm.go b/internal/managedcli/npm.go index 3206a8d78..cd48407ef 100644 --- a/internal/managedcli/npm.go +++ b/internal/managedcli/npm.go @@ -54,7 +54,7 @@ func (m *Manager) commandEnvironment() []string { ) } -func (m *Manager) prepareTools(ctx context.Context) error { +func (m *Manager) prepareCommandDirectories() error { for _, rel := range []string{"updater-home", "tmp", "npm-cache", "providers"} { if err := prepareDirectory(m.Root, rel); err != nil { return err @@ -65,6 +65,13 @@ func (m *Manager) prepareTools(ctx context.Context) error { return err } } + return nil +} + +func (m *Manager) prepareTools(ctx context.Context) error { + if err := m.prepareCommandDirectories(); err != nil { + return err + } for name, target := range map[string]*string{"node": &m.nodeBinary, "npm": &m.npmBinary} { if *target == "" { path, err := exec.LookPath(name) @@ -112,33 +119,23 @@ func (m *Manager) install(ctx context.Context, provider string, candidate releas } } }() - if err := os.WriteFile(filepath.Join(stage, "package.json"), []byte("{\"private\":true}\n"), 0o600); err != nil { - return Installation{}, err - } - args := []string{"install", "--prefix", stage, "--registry", npmRegistry, "--no-audit", "--no-fund", "--engine-strict", "--ignore-scripts", "--include=optional", "--save-exact", spec.Package + "@" + candidate.Version} - if _, err := m.command(ctx, m.npmBinary, args, stage); err != nil { - return Installation{}, fmt.Errorf("install %s: %w", provider, err) - } - if err := verifyPackageLock(stage, spec.Package, candidate); err != nil { - return Installation{}, err - } - // Some native optional dependencies need lifecycle hooks. Defer them until - // npm has fetched the exact candidate and its SRI has been checked. Commands - // use the updater's isolated home and credential-free environment; they run - // with the worker's OS permissions, not in a separate security sandbox. - rebuild := []string{"rebuild", "--prefix", stage, "--registry", npmRegistry, "--no-audit", "--no-fund"} - if _, err := m.command(ctx, m.npmBinary, rebuild, stage); err != nil { - return Installation{}, fmt.Errorf("build verified CLI dependencies: %w", err) + var executable string + if candidate.Artifact != nil { + executable = spec.Binary + err = m.installVendorArtifact(ctx, provider, candidate, stage) + } else { + executable = filepath.Join("node_modules", ".bin", spec.Binary) + err = m.installPackage(ctx, provider, spec, candidate, stage) } - if err := verifyPackageLock(stage, spec.Package, candidate); err != nil { + if err != nil { return Installation{}, err } - staged := Installation{Version: candidate.Version, Binary: filepath.Join(stage, "node_modules", ".bin", spec.Binary)} + staged := Installation{Version: candidate.Version, Binary: filepath.Join(stage, executable)} if err := validateInventory(m.Root, Inventory{provider: staged}); err != nil { return Installation{}, err } // Rename a unique complete directory, never an existing installation. - // npm's .bin links are relative and remain valid after this rename. + // Executable links and launchers are relative to the installation. final := filepath.Join(base, candidate.Version+"-"+strings.TrimPrefix(filepath.Base(stage), ".staging-")) if _, err := os.Lstat(final); err == nil || !os.IsNotExist(err) { return Installation{}, errors.New("candidate installation target already exists or is inaccessible") @@ -146,13 +143,48 @@ func (m *Manager) install(ctx context.Context, provider string, candidate releas if err := os.Rename(stage, final); err != nil { return Installation{}, err } - installed := Installation{Version: candidate.Version, Binary: filepath.Join(final, "node_modules", ".bin", spec.Binary), Integrity: candidate.Dist.Integrity, InstalledAt: m.Now().UTC()} + installed := Installation{ + Version: candidate.Version, Binary: filepath.Join(final, executable), + Integrity: candidate.identity(), InstalledAt: m.Now().UTC(), + } + if provider == "cursor" { + installed.PublishedAt = &candidate.Published + } if err := validateInventory(m.Root, Inventory{provider: installed}); err != nil { return Installation{}, err } return installed, nil } +func (m *Manager) installPackage(ctx context.Context, provider string, spec providerSpec, candidate release, stage string) error { + if err := os.WriteFile(filepath.Join(stage, "package.json"), []byte("{\"private\":true}\n"), 0o600); err != nil { + return err + } + engines := "--engine-strict" + if spec.RelaxEngines { + engines = "--engine-strict=false" + } + args := []string{"install", "--prefix", stage, "--registry", npmRegistry, "--no-audit", "--no-fund", engines, "--ignore-scripts", "--include=optional", "--save-exact", spec.Package + "@" + candidate.Version} + if _, err := m.command(ctx, m.npmBinary, args, stage); err != nil { + return fmt.Errorf("install %s: %w", provider, err) + } + if err := verifyPackageLock(stage, spec.Package, candidate); err != nil { + return err + } + // Some native optional dependencies need lifecycle hooks. Defer them until + // npm has fetched the exact candidate and its SRI has been checked. Commands + // use the updater's isolated home and credential-free environment; they run + // with the worker's OS permissions, not in a separate security sandbox. + rebuild := []string{"rebuild", "--prefix", stage, "--registry", npmRegistry, "--no-audit", "--no-fund"} + if _, err := m.command(ctx, m.npmBinary, rebuild, stage); err != nil { + return fmt.Errorf("build verified CLI dependencies: %w", err) + } + if err := verifyPackageLock(stage, spec.Package, candidate); err != nil { + return err + } + return nil +} + func verifyPackageLock(dir, packageName string, candidate release) error { var lock struct { Packages map[string]struct { @@ -180,7 +212,7 @@ func verifyPackageLock(dir, packageName string, candidate release) error { return nil } -var outputVersion = regexp.MustCompile(`(?:^|[^0-9.])([0-9]+\.[0-9]+\.[0-9]+)(?:$|[^0-9.A-Za-z+-])`) +var outputVersion = regexp.MustCompile(`(?:^|[^0-9.])([0-9]+\.[0-9]+\.[0-9]+(?:-(?:rc\.[0-9]+|[a-f0-9]{7,40}))?)(?:$|[^0-9.A-Za-z+-])`) func (m *Manager) validate(ctx context.Context, provider string, installed Installation) error { if err := validateInventory(m.Root, Inventory{provider: installed}); err != nil { diff --git a/internal/managedcli/providers.go b/internal/managedcli/providers.go index 95f895909..8ac81d5ba 100644 --- a/internal/managedcli/providers.go +++ b/internal/managedcli/providers.go @@ -1,7 +1,9 @@ package managedcli import ( + "regexp" "sort" + "strings" "time" ) @@ -15,13 +17,41 @@ const ( ) type providerSpec struct { - Package string - Binary string - Help []string - Flags []string + Package string + Binary string + Help []string + Flags []string + RelaxEngines bool } var providerSpecs = map[string]providerSpec{ + "agy": { + Binary: "agy", Help: []string{"--help"}, + Flags: []string{"--output-format", "--model", "--settings", "--conversation", "--disable-slash-commands"}, + }, + "cursor": { + Binary: "cursor-agent", Help: []string{"--help"}, + Flags: []string{"--output-format", "--stream-partial-output", "--model", "--resume"}, + }, + "dsh": { + Package: "@deepseek-ai/dsh", Binary: "dsh", Help: []string{"--profile", "headless", "--help"}, + Flags: []string{"--json", "--permission-mode", "--approval-policy", "--session-id"}, + // The runtime already uses DSH on Node 22. Probe the actual binary + // on this worker before activating a release that declares Node 24. + RelaxEngines: true, + }, + "kimi": { + Package: "@moonshot-ai/kimi-code", Binary: "kimi", Help: []string{"--help"}, + Flags: []string{"--output-format", "--agent-file", "--session"}, + }, + "opencode": { + Package: "opencode-ai", Binary: "opencode", Help: []string{"run", "--help"}, + Flags: []string{"--format", "--thinking", "--model", "--session"}, + }, + "pi": { + Package: "@earendil-works/pi-coding-agent", Binary: "pi", Help: []string{"--help"}, + Flags: []string{"--mode", "--session-id", "--model", "--tools", "--exclude-tools", "--append-system-prompt"}, + }, "codex": { Package: "@openai/codex", Binary: "codex", Help: []string{"exec", "--help"}, Flags: []string{"--json", "--sandbox", "--skip-git-repo-check", "--model"}, @@ -44,3 +74,28 @@ func providerNames() []string { sort.Strings(names) return names } + +var cursorBuild = regexp.MustCompile(`^[0-9]{4}\.[0-9]{2}\.[0-9]{2}-[a-f0-9]{7,40}$`) +var releaseCandidateNumber = regexp.MustCompile("^(0|[1-9][0-9]*)$") + +func validProviderVersion(provider, version string) bool { + if provider == "cursor" { + if !cursorBuild.MatchString(version) { + return false + } + _, err := time.Parse("2006.01.02", version[:10]) + return err == nil + } + if provider == "dsh" { + if core, candidate, ok := strings.Cut(version, "-rc."); ok { + return releaseVersion.MatchString(core) && releaseCandidateNumber.MatchString(candidate) + } + } + return releaseVersion.MatchString(version) +} + +// Supports reports whether the platform updater owns this provider. +func Supports(provider string) bool { + _, ok := providerSpecs[provider] + return ok +} diff --git a/internal/managedcli/providers_test.go b/internal/managedcli/providers_test.go index bd6995d8d..d4f3436bf 100644 --- a/internal/managedcli/providers_test.go +++ b/internal/managedcli/providers_test.go @@ -29,7 +29,7 @@ func TestDefaultProvidersIgnoreLegacyConfiguration(t *testing.T) { report, err = f.manager.Update(context.Background()) } must(t, err) - if len(report.Results) != 3 || len(f.state(t).Current) != 3 || len(f.installs) != 3 { + if len(report.Results) != len(providerNames()) || len(f.state(t).Current) != len(providerNames()) || len(f.installs) != len(providerNames()) { t.Fatalf("default providers missing: %+v", report) } for _, result := range report.Results { @@ -70,8 +70,14 @@ func TestFixedProvidersAndSafetyBounds(t *testing.T) { Flags: []string{"--print", "--output-format", "--verbose", "--permission-mode", "--setting-sources", "--system-prompt-file", "--mcp-config", "--settings", "--resume", "--plugin-dir"}, }, } - if !reflect.DeepEqual(providerSpecs, want) || !reflect.DeepEqual(providerNames(), []string{"claude-code", "codebuddy", "codex"}) { - t.Fatal("official packages or required compatibility arguments changed") + for provider, spec := range want { + if !reflect.DeepEqual(providerSpecs[provider], spec) { + t.Fatalf("official package or compatibility arguments changed for %s", provider) + } + } + all := []string{"agy", "claude-code", "codebuddy", "codex", "cursor", "dsh", "kimi", "opencode", "pi"} + if !reflect.DeepEqual(providerNames(), all) || Supports("zcode") { + t.Fatal("managed CLI scope changed") } for _, root := range []string{"", "/", "relative", "/tmp/../tmp/cli"} { if _, err := NewManager(root); err == nil { diff --git a/internal/managedcli/registry.go b/internal/managedcli/registry.go index c91846062..8bc5d071b 100644 --- a/internal/managedcli/registry.go +++ b/internal/managedcli/registry.go @@ -20,7 +20,8 @@ type release struct { Dist struct { Integrity string `json:"integrity"` } `json:"dist"` - Published time.Time `json:"-"` + Artifact *vendorArtifact `json:"-"` + Published time.Time `json:"-"` } type packageMetadata struct { @@ -32,15 +33,18 @@ type packageMetadata struct { func (m *Manager) candidate(ctx context.Context, provider string) (release, error) { spec := providerSpecs[provider] + if spec.Package == "" { + return m.vendorCandidate(ctx, provider) + } metadata, err := m.fetchPackageMetadata(ctx, spec.Package) if err != nil { return release{}, err } version := metadata.Tags["latest"] - if metadata.Name != spec.Package || !releaseVersion.MatchString(version) { - return release{}, errors.New("registry did not provide the expected package and a stable release version") + if metadata.Name != spec.Package || !validProviderVersion(provider, version) { + return release{}, errors.New("registry did not provide the expected package and a supported release version") } - if mature := matureVersion(metadata, version, m.Now().Add(-observationWindow)); mature != "" { + if mature := matureVersion(provider, metadata, version, m.Now().Add(-observationWindow)); mature != "" { version = mature } candidate, ok := metadata.Versions[version] @@ -93,18 +97,21 @@ func (m *Manager) fetchPackageMetadata(ctx context.Context, pkg string) (package return metadata, nil } -// matureVersion returns the newest stable, non-deprecated release no newer -// than upper that was published before cutoff, or "" when none qualifies. +// matureVersion returns the newest supported, non-deprecated release no +// newer than upper that was published before cutoff. // // Fast-moving CLIs may publish several times a day. Merely rejecting an // immature latest tag would then postpone updates forever. Selecting the -// newest mature stable release, bounded by the official latest tag, keeps -// updates flowing while versions published only to another channel cannot -// leak in. -func matureVersion(metadata packageMetadata, upper string, cutoff time.Time) string { +// newest mature release, bounded by the official latest tag, keeps updates +// flowing. DSH release candidates are eligible only while latest is an RC. +func matureVersion(provider string, metadata packageMetadata, upper string, cutoff time.Time) string { mature := "" + allowRC := strings.Contains(upper, "-rc.") for v, entry := range metadata.Versions { - if !releaseVersion.MatchString(v) || compareVersions(v, upper) > 0 || entry.Deprecated != "" { + if !allowRC && strings.Contains(v, "-rc.") { + continue + } + if !validProviderVersion(provider, v) || compareVersions(v, upper) > 0 || entry.Deprecated != "" { continue } var published time.Time @@ -127,17 +134,29 @@ func validIntegrity(value string) bool { } func compareVersions(a, b string) int { - left, right := strings.Split(a, "."), strings.Split(b, ".") + aCore, aRC, _ := strings.Cut(a, "-rc.") + bCore, bRC, _ := strings.Cut(b, "-rc.") + left, right := strings.Split(aCore, "."), strings.Split(bCore, ".") for i := 0; i < 3; i++ { - if len(left[i]) < len(right[i]) { - return -1 - } - if len(left[i]) > len(right[i]) { - return 1 - } - if cmp := strings.Compare(left[i], right[i]); cmp != 0 { + if cmp := compareVersionNumber(left[i], right[i]); cmp != 0 { return cmp } } - return 0 + switch { + case aRC == bRC: + return 0 + case aRC == "": + return 1 + case bRC == "": + return -1 + default: + return compareVersionNumber(aRC, bRC) + } +} + +func compareVersionNumber(a, b string) int { + if len(a) != len(b) { + return len(a) - len(b) + } + return strings.Compare(a, b) } diff --git a/internal/managedcli/registry_mature_test.go b/internal/managedcli/registry_mature_test.go index 89848ebb0..803a030df 100644 --- a/internal/managedcli/registry_mature_test.go +++ b/internal/managedcli/registry_mature_test.go @@ -1,11 +1,38 @@ package managedcli import ( + "context" "encoding/json" "testing" "time" ) +func TestManagedDSHReleaseCandidates(t *testing.T) { + f := newUpdaterFixture(t) + f.versions["dsh"] = "0.2.2-rc.9" + _, err := f.manager.UpdateProvider(context.Background(), "dsh") + must(t, err) + f.versions["dsh"] = "0.2.2-rc.10" + _, err = f.manager.UpdateProvider(context.Background(), "dsh") + must(t, err) + current := f.state(t).Current + if current["dsh"].Version != "0.2.2-rc.10" { + t.Fatalf("DSH release ordering lost the new RC: %+v", current) + } + if validProviderVersion("pi", "1.5.2-rc.1") || validProviderVersion("dsh", "0.2.2-alpha.1") { + t.Fatal("unsupported release channel was accepted") + } + published, err := json.Marshal(f.published) + must(t, err) + metadata := packageMetadata{ + Versions: map[string]release{"0.2.1": {}, "0.2.2-rc.10": {}, "0.2.2": {}}, + Times: map[string]json.RawMessage{"0.2.1": published, "0.2.2-rc.10": published}, + } + if got := matureVersion("dsh", metadata, "0.2.2", f.manager.Now()); got != "0.2.1" { + t.Fatalf("stable channel selected %q", got) + } +} + func TestMatureVersionSelectsNewestEligibleRelease(t *testing.T) { now := time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC) cutoff := now.Add(-observationWindow) @@ -37,7 +64,7 @@ func TestMatureVersionSelectsNewestEligibleRelease(t *testing.T) { } for _, tc := range cases { t.Run(tc.name, func(t *testing.T) { - if got := matureVersion(tc.metadata, tc.upper, cutoff); got != tc.want { + if got := matureVersion("codex", tc.metadata, tc.upper, cutoff); got != tc.want { t.Fatalf("matureVersion = %q, want %q", got, tc.want) } }) @@ -50,7 +77,7 @@ func TestMatureVersionIgnoresMissingOrInvalidPublishTime(t *testing.T) { Versions: map[string]release{"1.0.0": {Version: "1.0.0"}, "1.1.0": {Version: "1.1.0"}, "1.2.0": {Version: "1.2.0"}}, Times: map[string]json.RawMessage{"1.1.0": json.RawMessage(`"not-a-time"`), "1.2.0": json.RawMessage(`"0001-01-01T00:00:00Z"`)}, } - if got := matureVersion(metadata, "1.2.0", cutoff); got != "" { + if got := matureVersion("codex", metadata, "1.2.0", cutoff); got != "" { t.Fatalf("matureVersion = %q, want empty", got) } } diff --git a/internal/managedcli/scheduler_test.go b/internal/managedcli/scheduler_test.go index 5cc41544a..43eaeb988 100644 --- a/internal/managedcli/scheduler_test.go +++ b/internal/managedcli/scheduler_test.go @@ -178,9 +178,9 @@ func TestLoopStartupCrossingWindowDoesNotSkipToday(t *testing.T) { } stop := start(context.Background(), func() (*Manager, error) { return f.manager, nil }) defer stop() - waitUntil(t, func() bool { return len(f.state(t).Current) == 3 }) + waitUntil(t, func() bool { return len(f.state(t).Current) == len(providerNames()) }) stop() - if !f.state(t).LastCheck.Equal(at.Add(time.Nanosecond)) || len(f.installs) != 3 { + if !f.state(t).LastCheck.Equal(at.Add(time.Nanosecond)) || len(f.installs) != len(providerNames()) { t.Fatal("crossing startup window deferred today's check until tomorrow") } } @@ -192,10 +192,10 @@ func TestLoopTimerStartsNextCheck(t *testing.T) { f.manager.Now = func() time.Time { return at.Add(-50 * time.Millisecond).Add(time.Since(started)) } stop := start(context.Background(), func() (*Manager, error) { return f.manager, nil }) defer stop() - waitUntil(t, func() bool { return len(f.state(t).Current) == 3 }) + waitUntil(t, func() bool { return len(f.state(t).Current) == len(providerNames()) }) stop() state := f.state(t) - if state.LastCheck.Before(at) || len(f.installs) != 3 { + if state.LastCheck.Before(at) || len(f.installs) != len(providerNames()) { t.Fatal("timer failed to run the next daily check") } } @@ -205,9 +205,9 @@ func TestLoopStartupCheckUsesFixtureAndIgnoresLegacyConfig(t *testing.T) { writeTestFile(t, filepath.Join(f.manager.Root, "config.json"), `{"enabled":false}`) stop := start(context.Background(), func() (*Manager, error) { return f.manager, nil }) defer stop() - waitUntil(t, func() bool { return len(f.state(t).Current) == 3 }) + waitUntil(t, func() bool { return len(f.state(t).Current) == len(providerNames()) }) stop() - if len(f.installs) != 3 { + if len(f.installs) != len(providerNames()) { t.Fatal("startup did not check all providers") } } diff --git a/internal/managedcli/updater.go b/internal/managedcli/updater.go index 11e236c52..24575ea78 100644 --- a/internal/managedcli/updater.go +++ b/internal/managedcli/updater.go @@ -64,7 +64,7 @@ func (m *Manager) Update(ctx context.Context) (Report, error) { // UpdateProvider updates a single CLI already selected by the runner. func (m *Manager) UpdateProvider(ctx context.Context, provider string) (Report, error) { - if _, ok := providerSpecs[provider]; !ok { + if !Supports(provider) { return Report{}, fmt.Errorf("unsupported managed CLI %q", provider) } return m.run(ctx, "update", provider) @@ -125,12 +125,17 @@ func (m *Manager) updateProvidersLocked(ctx context.Context, state *State, repor for _, provider := range providers { result := ProviderResult{Provider: provider, From: state.Current[provider].Version} candidate, err := m.candidate(ctx, provider) + if err == nil && candidate.Artifact != nil { + candidate, err = m.observeVendorReleases(state, provider, candidate) + } if err == nil { result.To = candidate.Version result.Status, result.Message = m.releaseGate(state, provider, result.From, candidate) } if err == nil && result.Status == "" { - if !toolsReady { + if candidate.Artifact != nil { + err = m.prepareCommandDirectories() + } else if !toolsReady { err = m.prepareTools(ctx) toolsReady = err == nil } @@ -181,21 +186,57 @@ func (m *Manager) releaseGate(state *State, provider, from string, candidate rel switch { case candidate.Version == from: return "unchanged", "" - case from != "" && compareVersions(candidate.Version, from) < 0: + case from != "" && !newerRelease(provider, candidate, from, state.Current[provider].PublishedAt): return "skipped", "automatic downgrade refused" - case state.Rejected[provider] == candidate.Version: - return "skipped", "this release was rolled back; waiting for a newer release" + case blockedByRollback(state, provider, candidate): + if state.Rejected[provider] == candidate.Version { + return "skipped", "this release was rolled back; waiting for a newer release" + } + return "skipped", "waiting for a release newer than the rolled-back version" case m.Now().Before(candidate.Published.Add(observationWindow)): return "skipped", "release is still in the observation window" } return "", "" } +func blockedByRollback(state *State, provider string, candidate release) bool { + rejected := state.Rejected[provider] + if rejected == "" { + return false + } + // An intermediate release could otherwise activate and clear the + // rejection, allowing the rolled-back version to return later. + if !validProviderVersion(provider, rejected) { + return true + } + var published *time.Time + if previous := state.Previous[provider]; previous.Version == rejected { + published = previous.PublishedAt + } + return !newerRelease(provider, candidate, rejected, published) +} + +func newerRelease(provider string, candidate release, from string, published *time.Time) bool { + if candidate.Version == from { + return false + } + if provider == "cursor" { + // Build hashes have no ordering within a day. The artifact's + // timestamp must establish a strictly newer same-day release. + candidateDate, currentDate := candidate.Version[:10], from[:10] + if candidateDate != currentDate { + return candidateDate > currentDate + } + return published != nil && candidate.Published.After(*published) + } + return compareVersions(candidate.Version, from) > 0 +} + // stageCandidate reuses the cached candidate installation when it still matches // the release, otherwise installs it, then smoke-validates the result. func (m *Manager) stageCandidate(ctx context.Context, state *State, provider string, candidate release) (Installation, error) { installed := state.Candidates[provider] - if installed.Version != candidate.Version || installed.Integrity != candidate.Dist.Integrity || validateInventory(m.Root, Inventory{provider: installed}) != nil { + if installed.Version != candidate.Version || installed.Integrity != candidate.identity() || validateInventory(m.Root, Inventory{provider: installed}) != nil { var err error if installed, err = m.install(ctx, provider, candidate); err != nil { return Installation{}, err @@ -214,7 +255,7 @@ func (m *Manager) stageCandidate(ctx context.Context, state *State, provider str } func (m *Manager) rollbackLocked(ctx context.Context, provider string, state *State, report *Report) error { - if _, ok := providerSpecs[provider]; !ok { + if !Supports(provider) { return errors.New("rollback requires a known provider") } previous, ok := state.Previous[provider] @@ -222,7 +263,13 @@ func (m *Manager) rollbackLocked(ctx context.Context, provider string, state *St return errors.New("no previous managed version available; global installations were not modified") } report.Results = append(report.Results, ProviderResult{Provider: provider, From: state.Current[provider].Version, To: previous.Version, Status: "failed"}) - if err := m.prepareTools(ctx); err != nil { + var err error + if providerSpecs[provider].Package == "" { + err = m.prepareCommandDirectories() + } else { + err = m.prepareTools(ctx) + } + if err != nil { return err } if err := m.validate(ctx, provider, previous); err != nil { diff --git a/internal/managedcli/updater_gate_test.go b/internal/managedcli/updater_gate_test.go index f68236aac..1ad4f6275 100644 --- a/internal/managedcli/updater_gate_test.go +++ b/internal/managedcli/updater_gate_test.go @@ -18,11 +18,12 @@ func TestReleaseGate(t *testing.T) { {"same version", "codex", "2.0.0", "2.0.0", old, "unchanged", ""}, {"downgrade", "codex", "2.0.0", "1.9.0", old, "skipped", "automatic downgrade refused"}, {"rolled back", "codex", "2.0.0", "3.0.0", old, "skipped", "this release was rolled back; waiting for a newer release"}, - {"rejected only for its provider", "claude", "2.0.0", "3.0.0", old, "", ""}, - {"observation window", "codex", "2.0.0", "2.1.0", now.Add(-time.Hour), "skipped", "release is still in the observation window"}, - {"eligible upgrade", "codex", "2.0.0", "2.1.0", old, "", ""}, - {"first install", "codex", "", "2.1.0", old, "", ""}, - {"first install in observation window", "codex", "", "2.1.0", now, "skipped", "release is still in the observation window"}, + {"intermediate release after rollback", "codex", "2.0.0", "2.1.0", old, "skipped", "waiting for a release newer than the rolled-back version"}, + {"rejected only for its provider", "claude-code", "2.0.0", "3.0.0", old, "", ""}, + {"observation window", "codex", "2.0.0", "3.1.0", now.Add(-time.Hour), "skipped", "release is still in the observation window"}, + {"eligible upgrade", "codex", "2.0.0", "3.1.0", old, "", ""}, + {"first install", "claude-code", "", "2.1.0", old, "", ""}, + {"first install in observation window", "claude-code", "", "2.1.0", now, "skipped", "release is still in the observation window"}, } { t.Run(tc.name, func(t *testing.T) { status, message := m.releaseGate(state, tc.provider, tc.from, release{Version: tc.version, Published: tc.published}) diff --git a/internal/managedcli/updater_test.go b/internal/managedcli/updater_test.go index 3089e39e6..0813025a9 100644 --- a/internal/managedcli/updater_test.go +++ b/internal/managedcli/updater_test.go @@ -20,16 +20,17 @@ import ( ) type updaterFixture struct { - manager *Manager - mu sync.Mutex - versions map[string]string - published time.Time - installs map[string]int - failHelp string - badIntegrity bool - tamperLock bool - environments [][]string - rebuildCalls int + manager *Manager + mu sync.Mutex + versions map[string]string + published time.Time + installs map[string]int + failHelp string + badIntegrity bool + tamperLock bool + environments [][]string + rebuildCalls int + missingVendorVersion string } func newUpdaterFixture(t *testing.T) *updaterFixture { @@ -38,11 +39,15 @@ func newUpdaterFixture(t *testing.T) *updaterFixture { for _, provider := range providerNames() { f.versions[provider] = "1.0.0" } + f.versions["cursor"] = cursorFixtureVersion("1.0.0") server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { f.mu.Lock() defer f.mu.Unlock() + if f.serveVendorRelease(t, w, r) { + return + } for provider, spec := range providerSpecs { - if r.URL.Path != "/"+spec.Package { + if spec.Package == "" || r.URL.Path != "/"+spec.Package { continue } version := f.versions[provider] @@ -104,14 +109,21 @@ func (f *updaterFixture) run(ctx context.Context, name string, args []string, di } specArg := args[len(args)-1] for provider, spec := range providerSpecs { + if spec.Package == "" { + continue + } prefix := spec.Package + "@" if !strings.HasPrefix(specArg, prefix) { continue } version := strings.TrimPrefix(specArg, prefix) - want := []string{"install", "--prefix", dir, "--registry", "https://registry.npmjs.org", "--no-audit", "--no-fund", "--engine-strict", "--ignore-scripts", "--include=optional", "--save-exact", spec.Package + "@" + version} - if !reflect.DeepEqual(args, want) || !releaseVersion.MatchString(version) { - return nil, errors.New("install bypassed exact stable version, fixed registry or safety arguments") + engines := "--engine-strict" + if provider == "dsh" { + engines = "--engine-strict=false" + } + want := []string{"install", "--prefix", dir, "--registry", "https://registry.npmjs.org", "--no-audit", "--no-fund", engines, "--ignore-scripts", "--include=optional", "--save-exact", spec.Package + "@" + version} + if !reflect.DeepEqual(args, want) || !validProviderVersion(provider, version) { + return nil, errors.New("install bypassed exact version, fixed registry or safety arguments") } f.installs[provider]++ binDir := filepath.Join(dir, "node_modules", ".bin") @@ -135,6 +147,9 @@ func (f *updaterFixture) run(ctx context.Context, name string, args []string, di if !strings.Contains(name, string(filepath.Separator)+provider+string(filepath.Separator)) { continue } + if spec.Package == "" { + return executeCommand(ctx, name, args, dir, env) + } if len(args) == 1 && args[0] == "--version" { data, err := os.ReadFile(name) if err != nil { @@ -156,6 +171,7 @@ func (f *updaterFixture) setVersion(version string) { for provider := range f.versions { f.versions[provider] = version } + f.versions["cursor"] = cursorFixtureVersion(version) } func (f *updaterFixture) state(t *testing.T) State { @@ -226,6 +242,35 @@ func TestUpdatePinsRollbackAndIdempotence(t *testing.T) { must(t, err) } +func TestNPMWaitsPastRollbackWhenRegistryTagRetreats(t *testing.T) { + f := newUpdaterFixture(t) + ctx := context.Background() + update := func(version, status string) { + t.Helper() + f.setVersion(version) + report, err := f.manager.UpdateProvider(ctx, "pi") + must(t, err) + if len(report.Results) != 1 || report.Results[0].To != version || report.Results[0].Status != status { + t.Fatalf("update %s got %+v, want %s", version, report.Results, status) + } + } + update("1.0.0", "updated") + update("3.0.0", "updated") + _, err := f.manager.Rollback(ctx, "pi") + must(t, err) + + update("2.0.0", "skipped") + update("3.0.0", "skipped") + state := f.state(t) + if state.Current["pi"].Version != "1.0.0" || state.Rejected["pi"] != "3.0.0" { + t.Fatalf("the registry tag retreat undid the rollback: %+v", state) + } + update("4.0.0", "updated") + if f.state(t).Rejected["pi"] != "" { + t.Fatal("a newer release did not clear the rollback marker") + } +} + func TestUpdateFailuresAndCandidateReuse(t *testing.T) { for _, mode := range []string{"help", "integrity-before-hook", "integrity-after-hook", "offline", "maintenance"} { t.Run(mode, func(t *testing.T) { @@ -278,7 +323,7 @@ func TestUpdateFailuresAndCandidateReuse(t *testing.T) { t.Fatal("complete candidate was downloaded again") } } - if mode == "integrity-before-hook" && f.rebuildCalls != 3 { + if mode == "integrity-before-hook" && f.rebuildCalls != 7 { t.Fatal("hooks executed before integrity check") } }) @@ -295,7 +340,7 @@ func TestActivationCancellationBeforePublication(t *testing.T) { err := WithUpdateLock(ctx, f.manager.Root, func() error { return f.manager.activate(ctx, State{Current: Inventory{}}) }) - if !errors.Is(err, context.Canceled) || len(f.state(t).Current) != 3 { + if !errors.Is(err, context.Canceled) || len(f.state(t).Current) != len(providerNames()) { t.Fatalf("canceled activation published state: %v", err) } } @@ -368,10 +413,17 @@ func fixtureClient(t *testing.T, server *httptest.Server) *http.Client { client := server.Client() transport := client.Transport client.Transport = roundTripFunc(func(req *http.Request) (*http.Response, error) { - if req.URL.Scheme != "https" || req.URL.Host != "registry.npmjs.org" { + if req.URL.Scheme != "https" { + return nil, fmt.Errorf("unexpected production registry URL: %s", req.URL) + } + switch req.URL.Host { + case "registry.npmjs.org", "cursor.com", "downloads.cursor.com", "storage.googleapis.com", + "antigravity-cli-auto-updater-974169037036.us-central1.run.app": + default: return nil, fmt.Errorf("unexpected production registry URL: %s", req.URL) } local := req.Clone(req.Context()) + local.Host = req.URL.Host local.URL.Scheme, local.URL.Host = endpoint.Scheme, endpoint.Host return transport.RoundTrip(local) }) diff --git a/internal/managedcli/vendor.go b/internal/managedcli/vendor.go new file mode 100644 index 000000000..f7ae0c382 --- /dev/null +++ b/internal/managedcli/vendor.go @@ -0,0 +1,240 @@ +package managedcli + +import ( + "context" + "crypto/sha512" + "encoding/base64" + "encoding/hex" + "encoding/json" + "errors" + "fmt" + "io" + "net/http" + "net/url" + "os" + "path" + "path/filepath" + "regexp" + "runtime" + "strings" +) + +const ( + cursorInstallerURL = "https://cursor.com/install" + agyReleaseOrigin = "https://antigravity-cli-auto-updater-974169037036.us-central1.run.app" + agyStoragePrefix = "/antigravity-public/antigravity-cli/" + maxVendorArchive = 512 << 20 +) + +type vendorArtifact struct { + url string + etag string +} + +func (r release) identity() string { + if r.Artifact != nil && r.Dist.Integrity == "" { + return "etag:" + r.Artifact.etag + } + return r.Dist.Integrity +} + +var cursorDownloadLine = regexp.MustCompile(`(?m)^DOWNLOAD_URL="https://downloads\.cursor\.com/lab/([^/"\r\n]+)/\$\{OS\}/\$\{ARCH\}/agent-cli-package\.tar\.gz"\r?$`) + +func cursorArchiveURL(version string) string { + arch := runtime.GOARCH + if arch == "amd64" { + arch = "x64" + } + return fmt.Sprintf("https://downloads.cursor.com/lab/%s/%s/%s/agent-cli-package.tar.gz", version, runtime.GOOS, arch) +} + +func validCursorETag(tag string) bool { + return len(tag) >= 3 && len(tag) <= 128 && strings.HasPrefix(tag, `"`) && strings.HasSuffix(tag, `"`) +} + +func agyArchiveURL(raw, version string) (*url.URL, error) { + artifact, err := url.Parse(raw) + if err != nil || artifact.Scheme != "https" || artifact.Host != "storage.googleapis.com" || + artifact.User != nil || artifact.RawQuery != "" || artifact.Fragment != "" || + artifact.Path != path.Clean(artifact.Path) || !strings.HasSuffix(artifact.Path, ".tar.gz") || + !strings.HasPrefix(artifact.Path, agyStoragePrefix+version+"-") { + return nil, errors.New("invalid Antigravity release archive URL") + } + return artifact, nil +} + +func (m *Manager) vendorCandidate(ctx context.Context, provider string) (release, error) { + if (runtime.GOOS != "linux" && runtime.GOOS != "darwin") || + (runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64") { + return release{}, fmt.Errorf("%s has no managed release for %s/%s", provider, runtime.GOOS, runtime.GOARCH) + } + var candidate release + switch provider { + case "cursor": + script, err := m.vendorMetadata(ctx, cursorInstallerURL) + if err != nil { + return release{}, err + } + match := cursorDownloadLine.FindSubmatch(script) + if len(match) != 2 || !validProviderVersion(provider, string(match[1])) { + return release{}, errors.New("Cursor installer did not identify a supported release") + } + candidate.Version = string(match[1]) + candidate.Artifact = &vendorArtifact{url: cursorArchiveURL(candidate.Version)} + case "agy": + data, err := m.vendorMetadata(ctx, agyReleaseOrigin+"/manifests/"+agyVendorPlatform()+".json") + if err != nil { + return release{}, err + } + var manifest struct { + Version string `json:"version"` + URL string `json:"url"` + SHA512 string `json:"sha512"` + } + if err := json.Unmarshal(data, &manifest); err != nil || !validProviderVersion(provider, manifest.Version) { + return release{}, errors.New("invalid Antigravity release manifest") + } + artifact, err := agyArchiveURL(manifest.URL, manifest.Version) + if err != nil { + return release{}, err + } + hash, err := hex.DecodeString(manifest.SHA512) + if err != nil || len(hash) != sha512.Size { + return release{}, errors.New("Antigravity release requires a valid SHA512") + } + candidate.Version = manifest.Version + candidate.Artifact = &vendorArtifact{url: artifact.String()} + candidate.Dist.Integrity = "sha512-" + base64.StdEncoding.EncodeToString(hash) + default: + return release{}, fmt.Errorf("unsupported vendor artifact provider %q", provider) + } + + resp, err := m.vendorRequest(ctx, http.MethodHead, candidate.Artifact.url, "") + if err != nil { + return release{}, err + } + resp.Body.Close() + candidate.Published, err = http.ParseTime(resp.Header.Get("Last-Modified")) + if err != nil || candidate.Published.IsZero() { + return release{}, errors.New("vendor artifact has no valid publication time") + } + if provider == "cursor" { + // Pin the official build URL and ETag before downloading the archive. + tag := resp.Header.Get("ETag") + if !validCursorETag(tag) { + return release{}, errors.New("Cursor release has no strong ETag") + } + candidate.Artifact.etag = tag + } + return candidate, nil +} + +func agyVendorPlatform() string { + platform := runtime.GOOS + "_" + runtime.GOARCH + if runtime.GOOS == "linux" { + arch := "aarch64" + if runtime.GOARCH == "amd64" { + arch = "x86_64" + } + if _, err := os.Stat("/lib/ld-musl-" + arch + ".so.1"); err == nil { + platform += "_musl" + } + } + return platform +} + +func (m *Manager) vendorMetadata(ctx context.Context, address string) ([]byte, error) { + resp, err := m.vendorRequest(ctx, http.MethodGet, address, "") + if err != nil { + return nil, err + } + defer resp.Body.Close() + const maxMetadata = 1 << 20 + data, err := io.ReadAll(io.LimitReader(resp.Body, maxMetadata+1)) + if err != nil { + return nil, err + } + if len(data) > maxMetadata { + return nil, errors.New("vendor release metadata exceeds size limit") + } + return data, nil +} + +func (m *Manager) vendorRequest(ctx context.Context, method, address, etag string) (*http.Response, error) { + req, err := http.NewRequestWithContext(ctx, method, address, nil) + if err != nil { + return nil, err + } + req.Header.Set("Accept-Encoding", "identity") + if etag != "" { + req.Header.Set("If-Match", etag) + } + client := *m.Client + if method == http.MethodGet && (req.URL.Host == "downloads.cursor.com" || req.URL.Host == "storage.googleapis.com") { + client.Timeout = commandTimeout + } + client.CheckRedirect = func(next *http.Request, via []*http.Request) error { + same := next.URL.Host == req.URL.Host || + (req.URL.Host == "cursor.com" && next.URL.Host == "www.cursor.com") + if next.URL.Scheme != "https" || !same || next.URL.User != nil || len(via) >= 5 { + return errors.New("refuse redirect outside the HTTPS vendor origin") + } + return nil + } + resp, err := client.Do(req) + if err != nil { + return nil, fmt.Errorf("fetch vendor release: %w", err) + } + if resp.StatusCode != http.StatusOK || (etag != "" && resp.Header.Get("ETag") != etag) { + resp.Body.Close() + return nil, fmt.Errorf("vendor release response did not match the candidate (HTTP %d)", resp.StatusCode) + } + return resp, nil +} + +func (m *Manager) installVendorArtifact(ctx context.Context, provider string, candidate release, stage string) error { + resp, err := m.vendorRequest(ctx, http.MethodGet, candidate.Artifact.url, candidate.Artifact.etag) + if err != nil { + return err + } + defer resp.Body.Close() + if resp.ContentLength > maxVendorArchive { + return errors.New("vendor archive exceeds size limit") + } + archive, err := os.CreateTemp(stage, ".artifact-*") + if err != nil { + return err + } + defer os.Remove(archive.Name()) + hash := sha512.New() + size, copyErr := io.Copy(io.MultiWriter(archive, hash), io.LimitReader(resp.Body, maxVendorArchive+1)) + if err := errors.Join(copyErr, archive.Close()); err != nil { + return err + } + if size > maxVendorArchive { + return errors.New("vendor archive exceeds size limit") + } + if integrity := candidate.Dist.Integrity; integrity != "" && integrity != "sha512-"+base64.StdEncoding.EncodeToString(hash.Sum(nil)) { + return errors.New("vendor artifact SHA512 did not match its manifest") + } + if err := extractVendorArchive(ctx, provider, archive.Name(), filepath.Join(stage, "artifact")); err != nil { + return err + } + bin := providerSpecs[provider].Binary + root, err := os.OpenRoot(filepath.Join(stage, "artifact")) + if err != nil { + return err + } + defer root.Close() + payload, err := root.Stat(bin) + if err != nil || !payload.Mode().IsRegular() || payload.Mode()&0111 == 0 { + return errors.New("vendor archive did not provide an executable CLI") + } + // Pinned versions stay immutable when the upstream CLI would normally + // perform its own updates during a request. + launcher := "#!/bin/sh\nAGY_CLI_DISABLE_AUTO_UPDATE=true exec \"${0%/*}/artifact/agy\" \"$@\"\n" + if provider == "cursor" { + launcher = "#!/bin/sh\nexec \"${0%/*}/artifact/cursor-agent\" --disable-auto-update \"$@\"\n" + } + return os.WriteFile(filepath.Join(stage, bin), []byte(launcher), 0700) +} diff --git a/internal/managedcli/vendor_archive.go b/internal/managedcli/vendor_archive.go new file mode 100644 index 000000000..becb1171a --- /dev/null +++ b/internal/managedcli/vendor_archive.go @@ -0,0 +1,113 @@ +package managedcli + +import ( + "archive/tar" + "compress/gzip" + "context" + "errors" + "io" + "os" + "path" + "strings" +) + +const ( + maxExpandedVendorArchive = 1 << 30 + maxVendorMembers = 20000 +) + +func extractVendorArchive(ctx context.Context, provider, archive, dest string) error { + src, err := os.Open(archive) + if err != nil { + return err + } + defer src.Close() + zr, err := gzip.NewReader(src) + if err != nil { + return err + } + defer zr.Close() + if err := os.Mkdir(dest, 0700); err != nil { + return err + } + root, err := os.OpenRoot(dest) + if err != nil { + return err + } + defer root.Close() + expanded := &io.LimitedReader{R: zr, N: maxExpandedVendorArchive + (maxVendorMembers+1)*1024} + reader := tar.NewReader(expanded) + var total int64 + for i := 0; ; i++ { + if err := ctx.Err(); err != nil { + return err + } + h, err := reader.Next() + if err == io.EOF { + _, err = io.Copy(io.Discard, expanded) // finish the gzip checksum check + if expanded.N == 0 { + return errors.New("expanded vendor archive exceeds size limit") + } + return err + } + if err != nil { + return err + } + if i >= maxVendorMembers || h.Size < 0 || h.Size > maxExpandedVendorArchive-total { + return errors.New("expanded vendor archive exceeds size limit") + } + total += h.Size + name := path.Clean(h.Name) + if provider == "agy" { + if name != "antigravity" { + continue + } + if h.Typeflag != tar.TypeReg { + return errors.New("Antigravity archive entry is not a regular file") + } + name = "agy" + } else { + if name == "dist-package" && h.Typeflag == tar.TypeDir { + continue + } + var ok bool + name, ok = strings.CutPrefix(name, "dist-package/") + if !ok { + return errors.New("Cursor archive entry escapes its distribution directory") + } + } + if err := extractVendorMember(root, reader, name, h); err != nil { + return err + } + } +} + +func extractVendorMember(root *os.Root, reader io.Reader, name string, h *tar.Header) error { + if h.Typeflag == tar.TypeDir { + return root.MkdirAll(name, 0700) + } + if err := root.MkdirAll(path.Dir(name), 0700); err != nil { + return err + } + switch h.Typeflag { + case tar.TypeReg: + mode := os.FileMode(0600) + if h.Mode&0111 != 0 { + mode |= 0100 + } + file, err := root.OpenFile(name, os.O_WRONLY|os.O_CREATE|os.O_EXCL, mode) + if err != nil { + return err + } + _, err = io.CopyN(file, reader, h.Size) + return errors.Join(err, file.Close()) + case tar.TypeSymlink: + target := path.Join(path.Dir(name), h.Linkname) + if path.IsAbs(h.Linkname) || target == ".." || strings.HasPrefix(target, "../") { + return errors.New("vendor archive symlink escapes its installation") + } + return root.Symlink(h.Linkname, name) + default: + return errors.New("unsupported vendor archive entry type") + } +} diff --git a/internal/managedcli/vendor_observation.go b/internal/managedcli/vendor_observation.go new file mode 100644 index 000000000..09bbaa3bf --- /dev/null +++ b/internal/managedcli/vendor_observation.go @@ -0,0 +1,100 @@ +package managedcli + +import ( + "slices" + "time" +) + +const maxVendorObservations = 8 + +type vendorObservation struct { + Version string `json:"version"` + Published time.Time `json:"published"` + URL string `json:"url"` + ETag string `json:"etag,omitempty"` + Integrity string `json:"integrity,omitempty"` +} + +func observeVendorRelease(candidate release) vendorObservation { + return vendorObservation{ + Version: candidate.Version, Published: candidate.Published, + URL: candidate.Artifact.url, ETag: candidate.Artifact.etag, Integrity: candidate.Dist.Integrity, + } +} + +func (o vendorObservation) release(provider string) (release, bool) { + if o.Published.IsZero() || !validProviderVersion(provider, o.Version) { + return release{}, false + } + switch provider { + case "cursor": + if o.URL != cursorArchiveURL(o.Version) || !validCursorETag(o.ETag) || o.Integrity != "" { + return release{}, false + } + case "agy": + if _, err := agyArchiveURL(o.URL, o.Version); err != nil || !validIntegrity(o.Integrity) || o.ETag != "" { + return release{}, false + } + default: + return release{}, false + } + candidate := release{ + Version: o.Version, Published: o.Published, + Artifact: &vendorArtifact{url: o.URL, etag: o.ETag}, + } + candidate.Dist.Integrity = o.Integrity + return candidate, true +} + +// Vendor manifests advertise only their latest release. Retain observed +// archives across checks so a new publish cannot perpetually reset the +// observation window for the channel. +func (m *Manager) observeVendorReleases(state *State, provider string, latest release) (release, error) { + installed := state.Current[provider] + isUpgrade := func(candidate release) bool { + return !blockedByRollback(state, provider, candidate) && + (installed.Version == "" || newerRelease(provider, candidate, installed.Version, installed.PublishedAt)) + } + previous := state.VendorObservations[provider] + if !isUpgrade(latest) { + // A channel retreat removes observations above the advertised + // version. Wait for a newly advertised upgrade. + if len(previous) > 0 { + delete(state.VendorObservations, provider) + return latest, m.save(*state) + } + return latest, nil + } + + retained := make([]vendorObservation, 0, maxVendorObservations) + selected := latest + cutoff := m.Now().Add(-observationWindow) + for _, observation := range previous { + seen, ok := observation.release(provider) + if !ok || !isUpgrade(seen) || !newerRelease(provider, latest, seen.Version, &seen.Published) { + continue + } + // Keep older observations until activation or a channel retreat + // supersedes them. Reserve slots for the selection and latest. + if len(retained) < maxVendorObservations-2 { + retained = append(retained, observation) + } + if latest.Published.After(cutoff) && !seen.Published.After(cutoff) && + (selected.Version == latest.Version || newerRelease(provider, seen, selected.Version, &selected.Published)) { + selected = seen + } + } + if selected.Version != latest.Version && !slices.ContainsFunc(retained, func(o vendorObservation) bool { + return o.Version == selected.Version + }) { + retained = append(retained, observeVendorRelease(selected)) + } + retained = append(retained, observeVendorRelease(latest)) + if !slices.Equal(previous, retained) { + state.VendorObservations[provider] = retained + if err := m.save(*state); err != nil { + return release{}, err + } + } + return selected, nil +} diff --git a/internal/managedcli/vendor_test.go b/internal/managedcli/vendor_test.go new file mode 100644 index 000000000..9818cf66d --- /dev/null +++ b/internal/managedcli/vendor_test.go @@ -0,0 +1,248 @@ +package managedcli + +import ( + "archive/tar" + "bytes" + "compress/gzip" + "context" + "crypto/sha512" + "encoding/hex" + "encoding/json" + "fmt" + "net/http" + "strings" + "testing" + "time" +) + +func cursorFixtureVersion(version string) string { + var major, minor, patch int + fmt.Sscanf(version, "%d.%d.%d", &major, &minor, &patch) + return fmt.Sprintf("%04d.%02d.%02d-aabbccd", 2024+major, 1+minor, 1+patch) +} + +func (f *updaterFixture) serveVendorRelease(t *testing.T, w http.ResponseWriter, r *http.Request) bool { + const agyArtifactPath = agyStoragePrefix + "1.0.0-test/linux-x64/cli_linux_x64.tar.gz" + switch r.Host { + case "cursor.com": + _, _ = fmt.Fprintf(w, "DOWNLOAD_URL=\"https://downloads.cursor.com/lab/%s/${OS}/${ARCH}/agent-cli-package.tar.gz\"\n", f.versions["cursor"]) + case "antigravity-cli-auto-updater-974169037036.us-central1.run.app": + version := f.versions["agy"] + sum := sha512.Sum512(vendorFixtureArchive(t, "agy", version)) + artifactPath := strings.Replace(agyArtifactPath, "1.0.0", version, 1) + _ = json.NewEncoder(w).Encode(map[string]string{ + "version": version, "url": "https://storage.googleapis.com" + artifactPath, + "sha512": hex.EncodeToString(sum[:]), + }) + case "storage.googleapis.com", "downloads.cursor.com": + provider := "agy" + segment, _, _ := strings.Cut(strings.TrimPrefix(r.URL.Path, agyStoragePrefix), "/") + version := strings.TrimSuffix(segment, "-test") + if r.Host == "downloads.cursor.com" { + provider = "cursor" + version, _, _ = strings.Cut(strings.TrimPrefix(r.URL.Path, "/lab/"), "/") + etag := fmt.Sprintf("%q", version) + if r.Method == http.MethodGet && r.Header.Get("If-Match") != etag { + w.WriteHeader(http.StatusPreconditionFailed) + return true + } + w.Header().Set("ETag", etag) + } + w.Header().Set("Last-Modified", f.published.Format(http.TimeFormat)) + if r.Method == http.MethodGet { + if version == f.missingVendorVersion { + http.NotFound(w, r) + return true + } + f.installs[provider]++ + _, _ = w.Write(vendorFixtureArchive(t, provider, version)) + } + default: + return false + } + return true +} + +func vendorFixtureArchive(t *testing.T, provider, version string) []byte { + var data bytes.Buffer + compressed := gzip.NewWriter(&data) + tw := tar.NewWriter(compressed) + spec := providerSpecs[provider] + member := "antigravity" + probe := "[ \"$AGY_CLI_DISABLE_AUTO_UPDATE\" = true ] || exit 9\n" + if provider == "cursor" { + member = "dist-package/cursor-agent" + probe = "[ \"$1\" = --disable-auto-update ] || exit 9\nshift\n" + } + body := fmt.Sprintf("#!/bin/sh\n%sif [ \"$1\" = --version ]; then echo %s; else echo '%s'; fi\n", probe, version, strings.Join(spec.Flags, " ")) + must(t, tw.WriteHeader(&tar.Header{Name: member, Mode: 0700, Size: int64(len(body))})) + _, err := tw.Write([]byte(body)) + must(t, err) + must(t, tw.Close()) + must(t, compressed.Close()) + return data.Bytes() +} + +func TestCursorPreventsSameDayDowngrades(t *testing.T) { + now := time.Now().UTC() + v := "2026.11.19-0123456" + older := release{Version: "2026.11.19-abcdef0", Published: now.Add(-time.Hour)} + if newerRelease("cursor", older, v, &now) { + t.Fatal("an older Cursor artifact with the same build date was accepted") + } +} + +func TestCursorRefusesAmbiguousSameDayUpgrade(t *testing.T) { + f := newUpdaterFixture(t) + ctx := context.Background() + first, second := "2025.12.15-abcdef0", "2025.12.15-0123456" + f.mu.Lock() + f.versions["cursor"] = first + f.mu.Unlock() + _, err := f.manager.UpdateProvider(ctx, "cursor") + must(t, err) + f.mu.Lock() + f.versions["cursor"] = second + f.mu.Unlock() + report, err := f.manager.UpdateProvider(ctx, "cursor") + must(t, err) + if len(report.Results) != 1 || report.Results[0].Status != "skipped" || f.state(t).Current["cursor"].Version != first { + t.Fatalf("Cursor switched between distinct builds with the same publication time: %+v", report) + } +} + +func TestVendorRollbackWithoutNode(t *testing.T) { + f := newUpdaterFixture(t) + f.manager.nodeBinary, f.manager.npmBinary = "", "" + t.Setenv("PATH", t.TempDir()) + ctx := context.Background() + _, err := f.manager.UpdateProvider(ctx, "cursor") + must(t, err) + first := f.state(t).Current["cursor"] + f.setVersion("2.0.0") + _, err = f.manager.UpdateProvider(ctx, "cursor") + must(t, err) + report, err := f.manager.Rollback(ctx, "cursor") + must(t, err) + if len(report.Results) != 1 || report.Results[0].Status != "rolled-back" || f.state(t).Current["cursor"].Binary != first.Binary { + t.Fatalf("rollback did not restore the prior Cursor binary: %+v", report) + } +} + +func TestVendorObservationsSurviveDailyChannelChanges(t *testing.T) { + for _, provider := range []string{"cursor", "agy"} { + t.Run(provider, func(t *testing.T) { + f := newUpdaterFixture(t) + now := f.manager.Now() + f.manager.Now = func() time.Time { return now } + fresh := func(version string) { + f.setVersion(version) + f.mu.Lock() + f.published = now.Add(-time.Minute) + f.mu.Unlock() + } + check := func(manager *Manager, status, version string) { + t.Helper() + report, err := manager.UpdateProvider(context.Background(), provider) + must(t, err) + if len(report.Results) != 1 || report.Results[0].Status != status || report.Results[0].To != version { + t.Fatalf("got %+v, want %s %s", report.Results, status, version) + } + } + fresh("1.0.0") + first := f.versions[provider] + check(f.manager, "skipped", first) + + restarted, err := NewManager(f.manager.Root) + must(t, err) + restarted.Client, restarted.RunCommand, restarted.Now = f.manager.Client, f.manager.RunCommand, f.manager.Now + now = now.Add(23*time.Hour + 50*time.Minute) + fresh("2.0.0") + check(restarted, "skipped", f.versions[provider]) + + now = now.Add(23*time.Hour + 55*time.Minute) + fresh("3.0.0") + third := f.versions[provider] + check(restarted, "updated", first) + + now = now.Add(24 * time.Hour) + fresh("4.0.0") + check(restarted, "updated", third) + }) + } +} + +func TestVendorObservationRetainedAfterFailedInstallAndChannelRetreat(t *testing.T) { + f := newUpdaterFixture(t) + now := f.manager.Now() + f.manager.Now = func() time.Time { return now } + update := func(version string) (Report, error) { + t.Helper() + f.setVersion(version) + f.mu.Lock() + f.published = now.Add(-time.Minute) + f.mu.Unlock() + return f.manager.UpdateProvider(context.Background(), "agy") + } + _, err := update("1.1.0") + must(t, err) + now = now.Add(time.Hour) + _, err = update("1.3.0") + must(t, err) + now = now.Add(25 * time.Hour) + f.mu.Lock() + f.missingVendorVersion = "1.3.0" + f.mu.Unlock() + report, err := update("1.4.0") + if err == nil || len(report.Results) != 1 || report.Results[0].To != "1.3.0" { + t.Fatalf("expected a failed attempt to install the newest mature archive: %+v, %v", report, err) + } + report, err = update("1.2.0") + must(t, err) + if len(report.Results) != 1 || report.Results[0].To != "1.1.0" || report.Results[0].Status != "updated" { + t.Fatalf("older eligible observation lost after the release channel retreated: %+v", report) + } +} + +func TestVendorWaitsForNewerReleaseAfterRollback(t *testing.T) { + for _, provider := range []string{"cursor", "agy"} { + t.Run(provider, func(t *testing.T) { + f := newUpdaterFixture(t) + now := f.manager.Now() + f.manager.Now = func() time.Time { return now } + ctx := context.Background() + update := func(version string, age time.Duration, status string) { + t.Helper() + f.setVersion(version) + f.mu.Lock() + f.published = now.Add(-age) + f.mu.Unlock() + report, err := f.manager.UpdateProvider(ctx, provider) + must(t, err) + if len(report.Results) != 1 || report.Results[0].To != f.versions[provider] || report.Results[0].Status != status { + t.Fatalf("update %s got %+v, want %s", version, report.Results, status) + } + } + update("1.0.0", 48*time.Hour, "updated") + first := f.versions[provider] + update("2.0.0", time.Minute, "skipped") + now = now.Add(48 * time.Hour) + update("3.0.0", 25*time.Hour, "updated") + rejected := f.versions[provider] + _, err := f.manager.Rollback(ctx, provider) + must(t, err) + + update("4.0.0", time.Minute, "skipped") + update("3.0.0", 25*time.Hour, "skipped") + state := f.state(t) + if state.Current[provider].Version != first || state.Rejected[provider] != rejected { + t.Fatalf("an older observation undid the rollback: %+v", state) + } + now = now.Add(48 * time.Hour) + update("4.0.0", 48*time.Hour, "updated") + if f.state(t).Rejected[provider] != "" { + t.Fatal("a newer release did not clear the rollback marker") + } + }) + } +} diff --git a/internal/runtime/conversation_process.go b/internal/runtime/conversation_process.go index 53d61ea0f..3898fd2b1 100644 --- a/internal/runtime/conversation_process.go +++ b/internal/runtime/conversation_process.go @@ -643,6 +643,7 @@ func (p *ConversationProcessPool) start(ctx context.Context, root, workspace str } } nativeArgv := append([]string(nil), command.Argv...) + command = withBwrapManagedCLI(command, sandboxDriver(bindSandbox)) command, err = bindCommand(procCtx, bindSandbox, bindWorkspace, command, req.Command.Credentials) if err != nil { return ConversationProcessResult{}, err diff --git a/internal/runtime/conversation_sandbox.go b/internal/runtime/conversation_sandbox.go index 3dd1ff91e..2b88b4be4 100644 --- a/internal/runtime/conversation_sandbox.go +++ b/internal/runtime/conversation_sandbox.go @@ -121,11 +121,7 @@ func conversationGuardPaths(root string) (parents, files []string, err error) { // first use. The native HOME remains separate from installer state. func resolveNativeConversationBinary(provider string) (string, error) { binary := conversationBinary(provider) - override := "AGENTFLOW_" + strings.ToUpper(strings.ReplaceAll(provider, "-", "_")) + "_BIN" - if provider == "claude-code" { - override = "AGENTFLOW_CLAUDE_BIN" - } - if path := strings.TrimSpace(os.Getenv(override)); path != "" && fileIsExecutable(path) { + if path := explicitNativeCLIPath(provider); path != "" { return path, nil } if root := strings.TrimSpace(os.Getenv("AGENTFLOW_MANAGED_CLI_ROOT")); root != "" { diff --git a/internal/runtime/managed_cli.go b/internal/runtime/managed_cli.go new file mode 100644 index 000000000..123ca6a0d --- /dev/null +++ b/internal/runtime/managed_cli.go @@ -0,0 +1,106 @@ +package runtime + +import ( + "context" + "fmt" + "os" + "path/filepath" + "slices" + "strings" + + "agentflow/internal/domain" + "agentflow/internal/managedcli" +) + +func explicitNativeCLIPath(provider string) string { + override := "AGENTFLOW_" + strings.ToUpper(strings.ReplaceAll(provider, "-", "_")) + "_BIN" + if provider == "claude-code" { + override = "AGENTFLOW_CLAUDE_BIN" + } + if binary := strings.TrimSpace(os.Getenv(override)); binary != "" && fileIsExecutable(binary) { + return binary + } + return "" +} + +// Pin host executables for platform-owned workflow runs. Docker sandboxes and +// connected runners resolve the CLI on their own execution machines. +func pinNativeExecutorCLI(ctx context.Context, driver, runID string, executor domain.ExecutorDefinition) (string, *managedcli.ClaimLease, error) { + switch driver { + case "local", "seatbelt", "bwrap": + default: + return "", nil, nil + } + root := strings.TrimSpace(os.Getenv("AGENTFLOW_MANAGED_CLI_ROOT")) + kind := strings.TrimSpace(executor.Kind) + if root == "" || !managedcli.Supports(kind) { + return "", nil, nil + } + if binary := strings.TrimSpace(executor.Binary); binary != "" && binary != conversationBinary(kind) { + return "", nil, nil + } + if path := explicitNativeCLIPath(kind); path != "" { + return path, nil, nil + } + lease, err := managedcli.BeginClaim(ctx, root) + if err != nil { + return "", nil, fmt.Errorf("managed CLI usage for %s: %w", kind, err) + } + var inventory managedcli.Inventory + if runID = strings.TrimSpace(runID); runID != "" { + inventory, err = managedcli.PinInventory(root, "platform:"+runID) + } else { + inventory, err = managedcli.ReadInventory(root) + } + if err != nil { + lease.Close() + return "", nil, fmt.Errorf("managed CLI inventory for %s: %w", kind, err) + } + if binary, ok := inventory.BinaryFor(kind); ok { + return binary, lease, nil + } + return "", nil, lease.Close() +} + +// bwrap overlays a private /tmp. Restore only the selected installation, as a +// read-only bind, when the managed executable lives beneath that directory. +func withBwrapManagedCLI(command CommandSpec, driver string) CommandSpec { + if driver != "bwrap" || !managedcli.Supports(command.Provider) || len(command.Argv) == 0 || !filepath.IsAbs(command.Argv[0]) { + return command + } + root := strings.TrimSpace(os.Getenv("AGENTFLOW_MANAGED_CLI_ROOT")) + if !filepath.IsAbs(root) || filepath.Clean(root) != root || root == "/" { + return command + } + base := filepath.Join(root, "providers", command.Provider) + relative, err := filepath.Rel(base, command.Argv[0]) + if err != nil || relative == "." || !filepath.IsLocal(relative) { + return command + } + resolvedRoot, err := filepath.EvalSymlinks(root) + if err != nil { + return command + } + releaseDir, _, _ := strings.Cut(relative, string(filepath.Separator)) + providerDir := filepath.Join(resolvedRoot, "providers", command.Provider) + install := filepath.Join(providerDir, releaseDir) + binary, err := filepath.EvalSymlinks(command.Argv[0]) + if err != nil { + return command + } + resolvedRelative, err := filepath.Rel(install, binary) + if err != nil || !filepath.IsLocal(resolvedRelative) { + return command + } + // A symlinked ancestor in /tmp can be hidden even when its target is + // visible. Resolve the root prefix without changing an npm bin symlink. + if path := filepath.Join(providerDir, relative); path != command.Argv[0] { + command.Argv = slices.Clone(command.Argv) + command.Argv[0] = path + } + privateTmp, err := filepath.EvalSymlinks("/tmp") + if err == nil && strings.HasPrefix(install, privateTmp+string(filepath.Separator)) { + command.managedCLIInstall = install + } + return command +} diff --git a/internal/runtime/managed_cli_test.go b/internal/runtime/managed_cli_test.go new file mode 100644 index 000000000..2dedda9e7 --- /dev/null +++ b/internal/runtime/managed_cli_test.go @@ -0,0 +1,146 @@ +package runtime + +import ( + "context" + "encoding/json" + "os" + "path/filepath" + "runtime" + "strings" + "testing" + + "agentflow/internal/domain" + "agentflow/internal/managedcli" +) + +func TestExecutorRunnerPinsManagedNativeCLI(t *testing.T) { + root := t.TempDir() + t.Setenv("AGENTFLOW_MANAGED_CLI_ROOT", root) + t.Setenv("AGENTFLOW_PI_BIN", "") + publish := func(version string) string { + t.Helper() + binary := filepath.Join(root, "providers", "pi", version, "pi") + if err := os.MkdirAll(filepath.Dir(binary), 0700); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(binary, []byte("#!/bin/sh\nexit 0\n"), 0700); err != nil { + t.Fatal(err) + } + state := managedcli.State{Current: managedcli.Inventory{"pi": {Version: version, Binary: binary}}} + data, err := json.Marshal(state) + if err != nil { + t.Fatal(err) + } + if err := os.WriteFile(filepath.Join(root, "state.json"), data, 0600); err != nil { + t.Fatal(err) + } + return binary + } + runner := NewExecutorRunner() + check := func(driver, runID, binary, want string) { + t.Helper() + sandbox := &capturingSandbox{workspace: t.TempDir(), driver: driver} + executor := domain.ExecutorDefinition{Kind: "pi", Binary: binary} + agent := domain.AgentDefinition{ID: "agent"} + if _, err := runner.Run(context.Background(), sandbox, "invocation", executor, agent, domain.AgentAssetBundle{}, "hello", InvocationOptions{RunID: runID}, nil); err != nil { + t.Fatal(err) + } + if len(sandbox.argv) == 0 || sandbox.argv[0] != want { + t.Fatalf("%s run %q got %v, want %s", driver, runID, sandbox.argv, want) + } + } + check("local", "legacy", "pi", "pi") + first := publish("1.5.2") + check("local", "legacy", "pi", "pi") + check("local", "run1", "pi", first) + second := publish("1.6.0") + check("local", "run1", "pi", first) + check("seatbelt", "run2", "", second) + check("bwrap", "run3", "pi", second) + override := filepath.Join(t.TempDir(), "pi") + if err := os.WriteFile(override, []byte("#!/bin/sh\nexit 0\n"), 0700); err != nil { + t.Fatal(err) + } + t.Setenv("AGENTFLOW_PI_BIN", override) + check("docker", "run4", "pi", "pi") + check("local", "run5", "/custom/bin/pi", "/custom/bin/pi") + check("local", "run6", "pi", override) +} + +func TestBwrapMountsManagedInstallationUnderPrivateTmp(t *testing.T) { + if runtime.GOOS != "linux" { + t.Skip("bwrap is available on Linux") + } + t.Setenv("TMPDIR", "/tmp") + root := t.TempDir() + t.Setenv("AGENTFLOW_MANAGED_CLI_ROOT", root) + installation := filepath.Join(root, "providers", "pi", "1.5.2-test") + binary := filepath.Join(installation, "node_modules", ".bin", "pi") + if err := os.MkdirAll(filepath.Dir(binary), 0700); err != nil { + t.Fatal(err) + } + payload := filepath.Join(installation, "pi.cjs") + if err := os.WriteFile(payload, []byte("#!/bin/sh\nexit 0\n"), 0700); err != nil { + t.Fatal(err) + } + if err := os.Symlink("../../pi.cjs", binary); err != nil { + t.Fatal(err) + } + workspace := t.TempDir() + prepared, err := NewExecutorRunner().PrepareRemote(workspace, RemoteInvocation{ + InvocationID: "invocation", Executor: domain.ExecutorDefinition{Kind: "pi", Binary: binary}, + Agent: domain.AgentDefinition{ID: "agent"}, Driver: "bwrap", Prompt: "hello", + }) + if err != nil { + t.Fatal(err) + } + sandbox := &processSandbox{workspace: workspace, driver: "bwrap", binary: "bwrap"} + command, err := sandbox.command(context.Background(), prepared.Command, nil) + if err != nil { + t.Fatal(err) + } + args := strings.Join(command.Args, "\x00") + privateTmp := strings.Index(args, "\x00--tmpfs\x00/tmp\x00") + bind := "\x00--ro-bind\x00" + installation + "\x00" + installation + "\x00" + if index := strings.Index(args, bind); privateTmp < 0 || index <= privateTmp { + t.Fatalf("expected a read-only installation bind after the private /tmp mount: %q", command.Args) + } + if strings.Contains(args, "\x00--ro-bind\x00"+root+"\x00") { + t.Fatal("bwrap exposed the entire updater directory") + } +} + +func TestBwrapUsesCanonicalManagedPathWhenTemporarySymlinkIsHidden(t *testing.T) { + if runtime.GOOS != "linux" { + t.Skip("bwrap is available on Linux") + } + storage, err := os.MkdirTemp("/var/tmp", "loopforge-managed-cli-") + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = os.RemoveAll(storage) }) + t.Setenv("TMPDIR", "/tmp") + alias := filepath.Join(t.TempDir(), "storage") + if err := os.Symlink(storage, alias); err != nil { + t.Fatal(err) + } + root := filepath.Join(alias, "managed") + t.Setenv("AGENTFLOW_MANAGED_CLI_ROOT", root) + relative := filepath.Join("providers", "pi", "1.5.2-test", "pi") + binary := filepath.Join(root, relative) + if err := os.MkdirAll(filepath.Dir(binary), 0700); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(binary, []byte("#!/bin/sh\nexit 0\n"), 0700); err != nil { + t.Fatal(err) + } + args := []string{binary, "--version"} + command := withBwrapManagedCLI(CommandSpec{Provider: "pi", Argv: args}, "bwrap") + want := filepath.Join(storage, "managed", relative) + if command.Argv[0] != want || command.managedCLIInstall != "" { + t.Fatalf("expected the visible path %s without another mount, got %q and %q", want, command.Argv[0], command.managedCLIInstall) + } + if args[0] != binary { + t.Fatal("managed CLI path normalization changed the caller's arguments") + } +} diff --git a/internal/runtime/runner.go b/internal/runtime/runner.go index d81889ce3..d588d8831 100644 --- a/internal/runtime/runner.go +++ b/internal/runtime/runner.go @@ -23,6 +23,16 @@ func (r *ExecutorRunner) Run(ctx context.Context, sb Sandbox, invocationID strin return "", err } driver := sandboxDriver(sb) + binary, cliLease, err := pinNativeExecutorCLI(ctx, driver, options.RunID, ex) + if err != nil { + return "", err + } + if cliLease != nil { + defer cliLease.Close() + } + if binary != "" { + ex.Binary = binary + } if options.BrowserMCP == nil && BrowserWantedForExecutor(ex.Kind) { options.BrowserMCP = EnsureSandboxBrowser(ctx, sb, sb.Workspace(), options.RunID, sink) } @@ -62,6 +72,10 @@ func (r *ExecutorRunner) Run(ctx context.Context, sb Sandbox, invocationID strin if err != nil { return "", err } + command = withBwrapManagedCLI(command, driver) + if cliLease != nil && (command.Provider == "claude-code" || command.Provider == "codebuddy") { + command = WithCommandEnvironment(command, map[string]string{"DISABLE_AUTOUPDATER": "1", "DISABLE_UPDATES": "1"}) + } if strings.EqualFold(command.Provider, "codex") { overlay := map[string]string{} for key, value := range sandboxIsolationEnv(sb) { @@ -210,7 +224,7 @@ func (r *ExecutorRunner) PrepareRemote(workspace string, inv RemoteInvocation) ( command.HookOutput = compiled.HookOutput } command = WithCommandEnvironment(command, hookExecutionEnvironment(inv.Options.Repositories)) - return &PreparedRemote{Command: command}, nil + return &PreparedRemote{Command: withBwrapManagedCLI(command, driver)}, nil } func mockShouldSubmitGate(workspace string, agent domain.AgentDefinition, options InvocationOptions) bool { diff --git a/internal/runtime/runtime.go b/internal/runtime/runtime.go index 3be280801..173ba2f67 100644 --- a/internal/runtime/runtime.go +++ b/internal/runtime/runtime.go @@ -131,6 +131,8 @@ type CommandSpec struct { // privateBinds are host directories bwrap binds into this one process // only (for example a terminal's own SSH agent). privateBinds []string + // Only the selected managed installation is exposed beneath bwrap's /tmp. + managedCLIInstall string // Conversation preparation binds credentials before acknowledging start. bindingsPrepared bool // Runner-owned authentication state never enters serialized invocations. diff --git a/internal/runtime/sandbox_process.go b/internal/runtime/sandbox_process.go index 7497056f7..d012b39ad 100644 --- a/internal/runtime/sandbox_process.go +++ b/internal/runtime/sandbox_process.go @@ -161,6 +161,9 @@ func (s *processSandbox) command(ctx context.Context, command CommandSpec, base return nil, err } args = bwrapPrivateBinds(args, command.privateBinds) + if install := command.managedCLIInstall; install != "" { + args = append(args[:len(args)-1], "--ro-bind", install, install, "--") + } if command.runnerLogin != nil { // Hide host sources and the private journal after all other binds. // The managed CLI uses only its own private HOME and host callback.