From 6bdb3189f7a1e299c6d99bbfa8ac530449160c44 Mon Sep 17 00:00:00 2001 From: crispinhu27 Date: Fri, 20 Nov 2026 14:25:27 +0800 Subject: [PATCH 1/6] feat(managedcli): expand managed updates to six agent CLIs --- docs/deployment.md | 4 + .../httpapi/assistant_agentcli_bin_test.go | 22 +- internal/httpapi/assistant_engine_cli.go | 4 +- .../managedcli/coordinator_process_test.go | 3 +- internal/managedcli/manifest.go | 15 +- internal/managedcli/npm.go | 78 ++++-- internal/managedcli/providers.go | 63 ++++- internal/managedcli/providers_test.go | 12 +- internal/managedcli/registry.go | 59 +++-- internal/managedcli/registry_mature_test.go | 31 ++- internal/managedcli/scheduler_test.go | 12 +- internal/managedcli/updater.go | 30 ++- internal/managedcli/updater_test.go | 36 ++- internal/managedcli/vendor.go | 227 ++++++++++++++++++ internal/managedcli/vendor_archive.go | 113 +++++++++ internal/managedcli/vendor_test.go | 103 ++++++++ 16 files changed, 722 insertions(+), 90 deletions(-) create mode 100644 internal/managedcli/vendor.go create mode 100644 internal/managedcli/vendor_archive.go create mode 100644 internal/managedcli/vendor_test.go diff --git a/docs/deployment.md b/docs/deployment.md index ed1819455..05d3c014d 100644 --- a/docs/deployment.md +++ b/docs/deployment.md @@ -15,6 +15,10 @@ 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. + +For native execution, the platform checks the explicit binary override, then the managed inventory and PATH. 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..7e9b46e52 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 @@ -161,10 +162,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..c76a1bd41 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) @@ -130,7 +130,9 @@ func (m *Manager) updateProvidersLocked(ctx context.Context, state *State, repor 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,7 +183,7 @@ 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 != "" && olderRelease(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" @@ -191,11 +193,21 @@ func (m *Manager) releaseGate(state *State, provider, from string, candidate rel return "", "" } +func olderRelease(provider string, candidate release, from string, published *time.Time) bool { + if provider == "cursor" { + // Build hashes have no ordering within a day. The artifact's + // timestamp orders multiple releases stamped with the same date. + candidateDate, currentDate := candidate.Version[:10], from[:10] + return candidateDate < currentDate || (candidateDate == currentDate && published != nil && candidate.Published.Before(*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 +226,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 +234,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_test.go b/internal/managedcli/updater_test.go index 3089e39e6..a10f58bf3 100644 --- a/internal/managedcli/updater_test.go +++ b/internal/managedcli/updater_test.go @@ -38,11 +38,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 +108,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 +146,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 +170,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 { @@ -278,7 +293,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 +310,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 +383,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..143861937 --- /dev/null +++ b/internal/managedcli/vendor.go @@ -0,0 +1,227 @@ +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 (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]) + arch := runtime.GOARCH + if arch == "amd64" { + arch = "x64" + } + candidate.Artifact = &vendorArtifact{url: fmt.Sprintf( + "https://downloads.cursor.com/lab/%s/%s/%s/agent-cli-package.tar.gz", + candidate.Version, runtime.GOOS, arch, + )} + 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 := url.Parse(manifest.URL) + 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+manifest.Version+"-") { + return release{}, errors.New("invalid Antigravity release archive URL") + } + 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 len(tag) < 3 || len(tag) > 128 || !strings.HasPrefix(tag, `"`) || !strings.HasSuffix(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_test.go b/internal/managedcli/vendor_test.go new file mode 100644 index 000000000..54abee335 --- /dev/null +++ b/internal/managedcli/vendor_test.go @@ -0,0 +1,103 @@ +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": + sum := sha512.Sum512(f.vendorArchive(t, "agy")) + artifactPath := strings.Replace(agyArtifactPath, "1.0.0", f.versions["agy"], 1) + _ = json.NewEncoder(w).Encode(map[string]string{ + "version": f.versions["agy"], "url": "https://storage.googleapis.com" + artifactPath, + "sha512": hex.EncodeToString(sum[:]), + }) + case "storage.googleapis.com", "downloads.cursor.com": + provider := "agy" + if r.Host == "downloads.cursor.com" { + provider = "cursor" + etag := fmt.Sprintf("%q", f.versions[provider]) + 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 { + f.installs[provider]++ + _, _ = w.Write(f.vendorArchive(t, provider)) + } + default: + return false + } + return true +} + +func (f *updaterFixture) vendorArchive(t *testing.T, provider 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, f.versions[provider], 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 !olderRelease("cursor", older, v, &now) { + t.Fatal("an older Cursor artifact with the same build date was accepted") + } +} + +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) + } +} From 51e4150c74ccf82c1f4432cafa4d9644e98dae09 Mon Sep 17 00:00:00 2001 From: crispinhu27 Date: Fri, 20 Nov 2026 14:41:04 +0800 Subject: [PATCH 2/6] fix(managedcli): pin native workflow CLIs and retain vendor releases --- docs/deployment.md | 2 +- internal/managedcli/manifest.go | 16 ++-- internal/managedcli/updater.go | 3 + internal/managedcli/vendor.go | 43 ++++++---- internal/managedcli/vendor_observation.go | 99 +++++++++++++++++++++++ internal/managedcli/vendor_test.go | 61 ++++++++++++-- internal/runtime/managed_cli.go | 47 +++++++++++ internal/runtime/managed_cli_test.go | 59 ++++++++++++++ internal/runtime/runner.go | 11 +++ 9 files changed, 312 insertions(+), 29 deletions(-) create mode 100644 internal/managedcli/vendor_observation.go create mode 100644 internal/runtime/managed_cli.go create mode 100644 internal/runtime/managed_cli_test.go diff --git a/docs/deployment.md b/docs/deployment.md index 05d3c014d..2590c559d 100644 --- a/docs/deployment.md +++ b/docs/deployment.md @@ -17,7 +17,7 @@ Ensure the service can find `codebuddy` and Node.js on its PATH, or set `AGENTFL 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. -For native execution, the platform checks the explicit binary override, then the managed inventory and PATH. Docker sandboxes use the CLI supplied by their image or sandbox installer. ZCode uses the executable supplied by the deployment. +For native execution, the platform checks the explicit binary override, then the managed inventory and PATH. Platform-owned native workflows pin that inventory for the run. 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). diff --git a/internal/managedcli/manifest.go b/internal/managedcli/manifest.go index 7e9b46e52..68625fbae 100644 --- a/internal/managedcli/manifest.go +++ b/internal/managedcli/manifest.go @@ -36,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. @@ -64,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) } diff --git a/internal/managedcli/updater.go b/internal/managedcli/updater.go index c76a1bd41..f2bd67351 100644 --- a/internal/managedcli/updater.go +++ b/internal/managedcli/updater.go @@ -125,6 +125,9 @@ 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) diff --git a/internal/managedcli/vendor.go b/internal/managedcli/vendor.go index 143861937..f7ae0c382 100644 --- a/internal/managedcli/vendor.go +++ b/internal/managedcli/vendor.go @@ -40,6 +40,29 @@ func (r release) identity() string { 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") { @@ -57,14 +80,7 @@ func (m *Manager) vendorCandidate(ctx context.Context, provider string) (release return release{}, errors.New("Cursor installer did not identify a supported release") } candidate.Version = string(match[1]) - arch := runtime.GOARCH - if arch == "amd64" { - arch = "x64" - } - candidate.Artifact = &vendorArtifact{url: fmt.Sprintf( - "https://downloads.cursor.com/lab/%s/%s/%s/agent-cli-package.tar.gz", - candidate.Version, runtime.GOOS, arch, - )} + candidate.Artifact = &vendorArtifact{url: cursorArchiveURL(candidate.Version)} case "agy": data, err := m.vendorMetadata(ctx, agyReleaseOrigin+"/manifests/"+agyVendorPlatform()+".json") if err != nil { @@ -78,12 +94,9 @@ func (m *Manager) vendorCandidate(ctx context.Context, provider string) (release if err := json.Unmarshal(data, &manifest); err != nil || !validProviderVersion(provider, manifest.Version) { return release{}, errors.New("invalid Antigravity release manifest") } - artifact, err := url.Parse(manifest.URL) - 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+manifest.Version+"-") { - return release{}, errors.New("invalid Antigravity release archive URL") + 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 { @@ -108,7 +121,7 @@ func (m *Manager) vendorCandidate(ctx context.Context, provider string) (release if provider == "cursor" { // Pin the official build URL and ETag before downloading the archive. tag := resp.Header.Get("ETag") - if len(tag) < 3 || len(tag) > 128 || !strings.HasPrefix(tag, `"`) || !strings.HasSuffix(tag, `"`) { + if !validCursorETag(tag) { return release{}, errors.New("Cursor release has no strong ETag") } candidate.Artifact.etag = tag diff --git a/internal/managedcli/vendor_observation.go b/internal/managedcli/vendor_observation.go new file mode 100644 index 000000000..434cfccef --- /dev/null +++ b/internal/managedcli/vendor_observation.go @@ -0,0 +1,99 @@ +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 candidate.Version != installed.Version && candidate.Version != state.Rejected[provider] && + (installed.Version == "" || !olderRelease(provider, candidate, installed.Version, installed.PublishedAt)) + } + if !isUpgrade(latest) { + return latest, nil + } + + previous := state.VendorObservations[provider] + retained := make([]vendorObservation, 0, maxVendorObservations) + selected := latest + cutoff := m.Now().Add(-observationWindow) + if latest.Published.After(cutoff) { + var mature release + for _, observation := range previous { + seen, ok := observation.release(provider) + if !ok || seen.Version == latest.Version || !isUpgrade(seen) || + olderRelease(provider, latest, seen.Version, &seen.Published) { + continue + } + if seen.Published.After(cutoff) { + // Retain the oldest pending observations if checks happen + // frequently, so at least one survives long enough to mature. + if len(retained) < maxVendorObservations-2 { + retained = append(retained, observation) + } + continue + } + if mature.Version == "" || olderRelease(provider, mature, seen.Version, &seen.Published) { + mature = seen + } + } + if mature.Version != "" { + selected = mature + retained = append(retained, observeVendorRelease(mature)) + } + } + 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 index 54abee335..213abe736 100644 --- a/internal/managedcli/vendor_test.go +++ b/internal/managedcli/vendor_test.go @@ -27,17 +27,21 @@ func (f *updaterFixture) serveVendorRelease(t *testing.T, w http.ResponseWriter, 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": - sum := sha512.Sum512(f.vendorArchive(t, "agy")) - artifactPath := strings.Replace(agyArtifactPath, "1.0.0", f.versions["agy"], 1) + 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": f.versions["agy"], "url": "https://storage.googleapis.com" + artifactPath, + "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" - etag := fmt.Sprintf("%q", f.versions[provider]) + 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 @@ -47,7 +51,7 @@ func (f *updaterFixture) serveVendorRelease(t *testing.T, w http.ResponseWriter, w.Header().Set("Last-Modified", f.published.Format(http.TimeFormat)) if r.Method == http.MethodGet { f.installs[provider]++ - _, _ = w.Write(f.vendorArchive(t, provider)) + _, _ = w.Write(vendorFixtureArchive(t, provider, version)) } default: return false @@ -55,7 +59,7 @@ func (f *updaterFixture) serveVendorRelease(t *testing.T, w http.ResponseWriter, return true } -func (f *updaterFixture) vendorArchive(t *testing.T, provider string) []byte { +func vendorFixtureArchive(t *testing.T, provider, version string) []byte { var data bytes.Buffer compressed := gzip.NewWriter(&data) tw := tar.NewWriter(compressed) @@ -66,7 +70,7 @@ func (f *updaterFixture) vendorArchive(t *testing.T, provider string) []byte { 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, f.versions[provider], strings.Join(spec.Flags, " ")) + 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) @@ -101,3 +105,46 @@ func TestVendorRollbackWithoutNode(t *testing.T) { 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) + }) + } +} diff --git a/internal/runtime/managed_cli.go b/internal/runtime/managed_cli.go new file mode 100644 index 000000000..4dcc6b2d7 --- /dev/null +++ b/internal/runtime/managed_cli.go @@ -0,0 +1,47 @@ +package runtime + +import ( + "context" + "fmt" + "os" + "strings" + + "agentflow/internal/domain" + "agentflow/internal/managedcli" +) + +// 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 + } + 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() +} diff --git a/internal/runtime/managed_cli_test.go b/internal/runtime/managed_cli_test.go new file mode 100644 index 000000000..8cf786b9c --- /dev/null +++ b/internal/runtime/managed_cli_test.go @@ -0,0 +1,59 @@ +package runtime + +import ( + "context" + "encoding/json" + "os" + "path/filepath" + "testing" + + "agentflow/internal/domain" + "agentflow/internal/managedcli" +) + +func TestExecutorRunnerPinsManagedNativeCLI(t *testing.T) { + root := t.TempDir() + t.Setenv("AGENTFLOW_MANAGED_CLI_ROOT", root) + 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) + check("docker", "run4", "pi", "pi") + check("local", "run5", "/custom/bin/pi", "/custom/bin/pi") +} diff --git a/internal/runtime/runner.go b/internal/runtime/runner.go index d81889ce3..f326608cb 100644 --- a/internal/runtime/runner.go +++ b/internal/runtime/runner.go @@ -23,6 +23,14 @@ func (r *ExecutorRunner) Run(ctx context.Context, sb Sandbox, invocationID strin return "", err } driver := sandboxDriver(sb) + managedBinary, cliLease, err := pinNativeExecutorCLI(ctx, driver, options.RunID, ex) + if err != nil { + return "", err + } + if cliLease != nil { + defer cliLease.Close() + ex.Binary = managedBinary + } if options.BrowserMCP == nil && BrowserWantedForExecutor(ex.Kind) { options.BrowserMCP = EnsureSandboxBrowser(ctx, sb, sb.Workspace(), options.RunID, sink) } @@ -62,6 +70,9 @@ func (r *ExecutorRunner) Run(ctx context.Context, sb Sandbox, invocationID strin if err != nil { return "", err } + 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) { From 03dcc012cf4b9d711aecd31da605e217afa5e437 Mon Sep 17 00:00:00 2001 From: crispinhu27 Date: Fri, 20 Nov 2026 14:50:20 +0800 Subject: [PATCH 3/6] fix(runtime): preserve managed CLI selection in native sandboxes --- internal/managedcli/updater_test.go | 21 ++++----- internal/managedcli/vendor_observation.go | 48 +++++++++++---------- internal/managedcli/vendor_test.go | 36 ++++++++++++++++ internal/runtime/conversation_process.go | 1 + internal/runtime/conversation_sandbox.go | 6 +-- internal/runtime/managed_cli.go | 50 ++++++++++++++++++++++ internal/runtime/managed_cli_test.go | 52 +++++++++++++++++++++++ internal/runtime/runner.go | 9 ++-- internal/runtime/runtime.go | 2 + internal/runtime/sandbox_process.go | 3 ++ 10 files changed, 187 insertions(+), 41 deletions(-) diff --git a/internal/managedcli/updater_test.go b/internal/managedcli/updater_test.go index a10f58bf3..bb61875e1 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 { diff --git a/internal/managedcli/vendor_observation.go b/internal/managedcli/vendor_observation.go index 434cfccef..33ba03dcc 100644 --- a/internal/managedcli/vendor_observation.go +++ b/internal/managedcli/vendor_observation.go @@ -55,38 +55,40 @@ func (m *Manager) observeVendorReleases(state *State, provider string, latest re return candidate.Version != installed.Version && candidate.Version != state.Rejected[provider] && (installed.Version == "" || !olderRelease(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 } - previous := state.VendorObservations[provider] retained := make([]vendorObservation, 0, maxVendorObservations) selected := latest cutoff := m.Now().Add(-observationWindow) - if latest.Published.After(cutoff) { - var mature release - for _, observation := range previous { - seen, ok := observation.release(provider) - if !ok || seen.Version == latest.Version || !isUpgrade(seen) || - olderRelease(provider, latest, seen.Version, &seen.Published) { - continue - } - if seen.Published.After(cutoff) { - // Retain the oldest pending observations if checks happen - // frequently, so at least one survives long enough to mature. - if len(retained) < maxVendorObservations-2 { - retained = append(retained, observation) - } - continue - } - if mature.Version == "" || olderRelease(provider, mature, seen.Version, &seen.Published) { - mature = seen - } + for _, observation := range previous { + seen, ok := observation.release(provider) + if !ok || seen.Version == latest.Version || !isUpgrade(seen) || + olderRelease(provider, latest, seen.Version, &seen.Published) { + continue } - if mature.Version != "" { - selected = mature - retained = append(retained, observeVendorRelease(mature)) + // 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 || olderRelease(provider, selected, seen.Version, &seen.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) { diff --git a/internal/managedcli/vendor_test.go b/internal/managedcli/vendor_test.go index 213abe736..fbaf40658 100644 --- a/internal/managedcli/vendor_test.go +++ b/internal/managedcli/vendor_test.go @@ -50,6 +50,10 @@ func (f *updaterFixture) serveVendorRelease(t *testing.T, w http.ResponseWriter, } 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)) } @@ -148,3 +152,35 @@ func TestVendorObservationsSurviveDailyChannelChanges(t *testing.T) { }) } } + +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) + } +} 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 index 4dcc6b2d7..0413f65d0 100644 --- a/internal/runtime/managed_cli.go +++ b/internal/runtime/managed_cli.go @@ -4,12 +4,24 @@ import ( "context" "fmt" "os" + "path/filepath" "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) { @@ -26,6 +38,9 @@ func pinNativeExecutorCLI(ctx context.Context, driver, runID string, executor do 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) @@ -45,3 +60,38 @@ func pinNativeExecutorCLI(ctx context.Context, driver, runID string, executor do } 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)) + install := filepath.Join(resolvedRoot, "providers", command.Provider, releaseDir) + if !strings.HasPrefix(install, "/tmp/") { + return command + } + binary, err := filepath.EvalSymlinks(command.Argv[0]) + if err != nil { + return command + } + relative, err = filepath.Rel(install, binary) + if err == nil && filepath.IsLocal(relative) { + command.managedCLIInstall = install + } + return command +} diff --git a/internal/runtime/managed_cli_test.go b/internal/runtime/managed_cli_test.go index 8cf786b9c..e337b5fe5 100644 --- a/internal/runtime/managed_cli_test.go +++ b/internal/runtime/managed_cli_test.go @@ -5,6 +5,8 @@ import ( "encoding/json" "os" "path/filepath" + "runtime" + "strings" "testing" "agentflow/internal/domain" @@ -14,6 +16,7 @@ import ( 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") @@ -54,6 +57,55 @@ func TestExecutorRunnerPinsManagedNativeCLI(t *testing.T) { 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") + } } diff --git a/internal/runtime/runner.go b/internal/runtime/runner.go index f326608cb..d588d8831 100644 --- a/internal/runtime/runner.go +++ b/internal/runtime/runner.go @@ -23,13 +23,15 @@ func (r *ExecutorRunner) Run(ctx context.Context, sb Sandbox, invocationID strin return "", err } driver := sandboxDriver(sb) - managedBinary, cliLease, err := pinNativeExecutorCLI(ctx, driver, options.RunID, ex) + binary, cliLease, err := pinNativeExecutorCLI(ctx, driver, options.RunID, ex) if err != nil { return "", err } if cliLease != nil { defer cliLease.Close() - ex.Binary = managedBinary + } + if binary != "" { + ex.Binary = binary } if options.BrowserMCP == nil && BrowserWantedForExecutor(ex.Kind) { options.BrowserMCP = EnsureSandboxBrowser(ctx, sb, sb.Workspace(), options.RunID, sink) @@ -70,6 +72,7 @@ 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"}) } @@ -221,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. From 1950b1655965a924f56d979314c9159775e2b177 Mon Sep 17 00:00:00 2001 From: crispinhu27 Date: Fri, 20 Nov 2026 14:59:01 +0800 Subject: [PATCH 4/6] fix(managedcli): order Cursor builds and resolve native CLI paths --- internal/managedcli/updater.go | 16 +++++++---- internal/managedcli/vendor_observation.go | 9 +++--- internal/managedcli/vendor_test.go | 21 +++++++++++++- internal/runtime/managed_cli.go | 21 ++++++++++---- internal/runtime/managed_cli_test.go | 35 +++++++++++++++++++++++ 5 files changed, 85 insertions(+), 17 deletions(-) diff --git a/internal/managedcli/updater.go b/internal/managedcli/updater.go index f2bd67351..c66d4fba8 100644 --- a/internal/managedcli/updater.go +++ b/internal/managedcli/updater.go @@ -186,7 +186,7 @@ func (m *Manager) releaseGate(state *State, provider, from string, candidate rel switch { case candidate.Version == from: return "unchanged", "" - case from != "" && olderRelease(provider, candidate, from, state.Current[provider].PublishedAt): + 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" @@ -196,14 +196,20 @@ func (m *Manager) releaseGate(state *State, provider, from string, candidate rel return "", "" } -func olderRelease(provider string, candidate release, from string, published *time.Time) bool { +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 orders multiple releases stamped with the same date. + // timestamp must establish a strictly newer same-day release. candidateDate, currentDate := candidate.Version[:10], from[:10] - return candidateDate < currentDate || (candidateDate == currentDate && published != nil && candidate.Published.Before(*published)) + if candidateDate != currentDate { + return candidateDate > currentDate + } + return published != nil && candidate.Published.After(*published) } - return compareVersions(candidate.Version, from) < 0 + return compareVersions(candidate.Version, from) > 0 } // stageCandidate reuses the cached candidate installation when it still matches diff --git a/internal/managedcli/vendor_observation.go b/internal/managedcli/vendor_observation.go index 33ba03dcc..a07714363 100644 --- a/internal/managedcli/vendor_observation.go +++ b/internal/managedcli/vendor_observation.go @@ -52,8 +52,8 @@ func (o vendorObservation) release(provider string) (release, bool) { func (m *Manager) observeVendorReleases(state *State, provider string, latest release) (release, error) { installed := state.Current[provider] isUpgrade := func(candidate release) bool { - return candidate.Version != installed.Version && candidate.Version != state.Rejected[provider] && - (installed.Version == "" || !olderRelease(provider, candidate, installed.Version, installed.PublishedAt)) + return candidate.Version != state.Rejected[provider] && + (installed.Version == "" || newerRelease(provider, candidate, installed.Version, installed.PublishedAt)) } previous := state.VendorObservations[provider] if !isUpgrade(latest) { @@ -71,8 +71,7 @@ func (m *Manager) observeVendorReleases(state *State, provider string, latest re cutoff := m.Now().Add(-observationWindow) for _, observation := range previous { seen, ok := observation.release(provider) - if !ok || seen.Version == latest.Version || !isUpgrade(seen) || - olderRelease(provider, latest, seen.Version, &seen.Published) { + if !ok || !isUpgrade(seen) || !newerRelease(provider, latest, seen.Version, &seen.Published) { continue } // Keep older observations until activation or a channel retreat @@ -81,7 +80,7 @@ func (m *Manager) observeVendorReleases(state *State, provider string, latest re retained = append(retained, observation) } if latest.Published.After(cutoff) && !seen.Published.After(cutoff) && - (selected.Version == latest.Version || olderRelease(provider, selected, seen.Version, &seen.Published)) { + (selected.Version == latest.Version || newerRelease(provider, seen, selected.Version, &selected.Published)) { selected = seen } } diff --git a/internal/managedcli/vendor_test.go b/internal/managedcli/vendor_test.go index fbaf40658..a9ab4ccac 100644 --- a/internal/managedcli/vendor_test.go +++ b/internal/managedcli/vendor_test.go @@ -87,11 +87,30 @@ 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 !olderRelease("cursor", older, v, &now) { + 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 = "", "" diff --git a/internal/runtime/managed_cli.go b/internal/runtime/managed_cli.go index 0413f65d0..123ca6a0d 100644 --- a/internal/runtime/managed_cli.go +++ b/internal/runtime/managed_cli.go @@ -5,6 +5,7 @@ import ( "fmt" "os" "path/filepath" + "slices" "strings" "agentflow/internal/domain" @@ -81,16 +82,24 @@ func withBwrapManagedCLI(command CommandSpec, driver string) CommandSpec { return command } releaseDir, _, _ := strings.Cut(relative, string(filepath.Separator)) - install := filepath.Join(resolvedRoot, "providers", command.Provider, releaseDir) - if !strings.HasPrefix(install, "/tmp/") { - return command - } + providerDir := filepath.Join(resolvedRoot, "providers", command.Provider) + install := filepath.Join(providerDir, releaseDir) binary, err := filepath.EvalSymlinks(command.Argv[0]) if err != nil { return command } - relative, err = filepath.Rel(install, binary) - if err == nil && filepath.IsLocal(relative) { + 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 index e337b5fe5..2dedda9e7 100644 --- a/internal/runtime/managed_cli_test.go +++ b/internal/runtime/managed_cli_test.go @@ -109,3 +109,38 @@ func TestBwrapMountsManagedInstallationUnderPrivateTmp(t *testing.T) { 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") + } +} From 5255b50a25bb80b297839ababcaace46cfd15ec4 Mon Sep 17 00:00:00 2001 From: crispinhu27 Date: Fri, 20 Nov 2026 15:07:04 +0800 Subject: [PATCH 5/6] fix(managedcli): preserve vendor rollback across observed releases --- cmd/agentflow/main.go | 2 +- docs/deployment.md | 4 ++- internal/managedcli/manifest.go | 4 +-- internal/managedcli/updater.go | 27 ++++++++++++-- internal/managedcli/vendor_observation.go | 2 +- internal/managedcli/vendor_test.go | 43 +++++++++++++++++++++++ 6 files changed, 75 insertions(+), 7 deletions(-) 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 2590c559d..389bb8b7d 100644 --- a/docs/deployment.md +++ b/docs/deployment.md @@ -17,7 +17,9 @@ Ensure the service can find `codebuddy` and Node.js on its PATH, or set `AGENTFL 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. -For native execution, the platform checks the explicit binary override, then the managed inventory and PATH. Platform-owned native workflows pin that inventory for the run. 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. +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). diff --git a/internal/managedcli/manifest.go b/internal/managedcli/manifest.go index 68625fbae..fe71667fd 100644 --- a/internal/managedcli/manifest.go +++ b/internal/managedcli/manifest.go @@ -79,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. diff --git a/internal/managedcli/updater.go b/internal/managedcli/updater.go index c66d4fba8..525342ed5 100644 --- a/internal/managedcli/updater.go +++ b/internal/managedcli/updater.go @@ -188,14 +188,37 @@ func (m *Manager) releaseGate(state *State, provider, from string, candidate rel return "unchanged", "" 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 + } + if candidate.Artifact == nil { + return candidate.Version == rejected + } + // An older observed vendor 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 diff --git a/internal/managedcli/vendor_observation.go b/internal/managedcli/vendor_observation.go index a07714363..09bbaa3bf 100644 --- a/internal/managedcli/vendor_observation.go +++ b/internal/managedcli/vendor_observation.go @@ -52,7 +52,7 @@ func (o vendorObservation) release(provider string) (release, bool) { func (m *Manager) observeVendorReleases(state *State, provider string, latest release) (release, error) { installed := state.Current[provider] isUpgrade := func(candidate release) bool { - return candidate.Version != state.Rejected[provider] && + return !blockedByRollback(state, provider, candidate) && (installed.Version == "" || newerRelease(provider, candidate, installed.Version, installed.PublishedAt)) } previous := state.VendorObservations[provider] diff --git a/internal/managedcli/vendor_test.go b/internal/managedcli/vendor_test.go index a9ab4ccac..9818cf66d 100644 --- a/internal/managedcli/vendor_test.go +++ b/internal/managedcli/vendor_test.go @@ -203,3 +203,46 @@ func TestVendorObservationRetainedAfterFailedInstallAndChannelRetreat(t *testing 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") + } + }) + } +} From 0c8bbc0184c060e5c163fc48a1294c1c7d491781 Mon Sep 17 00:00:00 2001 From: crispinhu27 Date: Fri, 20 Nov 2026 15:14:20 +0800 Subject: [PATCH 6/6] fix(managedcli): retain npm rollback past registry tag retreats --- docs/deployment.md | 2 +- internal/managedcli/updater.go | 7 ++---- internal/managedcli/updater_gate_test.go | 11 +++++---- internal/managedcli/updater_test.go | 29 ++++++++++++++++++++++++ 4 files changed, 38 insertions(+), 11 deletions(-) diff --git a/docs/deployment.md b/docs/deployment.md index 389bb8b7d..85a09442d 100644 --- a/docs/deployment.md +++ b/docs/deployment.md @@ -15,7 +15,7 @@ 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. +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. diff --git a/internal/managedcli/updater.go b/internal/managedcli/updater.go index 525342ed5..24575ea78 100644 --- a/internal/managedcli/updater.go +++ b/internal/managedcli/updater.go @@ -204,11 +204,8 @@ func blockedByRollback(state *State, provider string, candidate release) bool { if rejected == "" { return false } - if candidate.Artifact == nil { - return candidate.Version == rejected - } - // An older observed vendor release could otherwise activate and clear - // the rejection, allowing the rolled-back version to return later. + // An intermediate release could otherwise activate and clear the + // rejection, allowing the rolled-back version to return later. if !validProviderVersion(provider, rejected) { return true } 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 bb61875e1..0813025a9 100644 --- a/internal/managedcli/updater_test.go +++ b/internal/managedcli/updater_test.go @@ -242,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) {