Skip to content

Self-hosted workflows for coding-agent delivery. Orchestrate CodeBuddy, Codex and Claude Code with scripts and human approval gates. Includes Local workflows for coding assistants.

13.0 KB
Raw Blame
package managedcli

import (
	"bytes"
	"context"
	"encoding/base64"
	"encoding/json"
	"errors"
	"fmt"
	"net/http"
	"net/http/httptest"
	"net/url"
	"os"
	"path/filepath"
	"reflect"
	"strings"
	"sync"
	"testing"
	"time"
)

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
}

func newUpdaterFixture(t *testing.T) *updaterFixture {
	t.Helper()
	f := &updaterFixture{versions: map[string]string{}, installs: map[string]int{}, published: time.Date(2025, 1, 1, 0, 0, 0, 0, time.UTC)}
	for _, provider := range providerNames() {
		f.versions[provider] = "1.0.0"
	}
	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		f.mu.Lock()
		defer f.mu.Unlock()
		for provider, spec := range providerSpecs {
			if r.URL.Path != "/"+spec.Package {
				continue
			}
			version := f.versions[provider]
			entry := release{Name: spec.Package, Version: version}
			entry.Dist.Integrity = testIntegrity()
			published, _ := json.Marshal(f.published)
			_ = json.NewEncoder(w).Encode(packageMetadata{Name: spec.Package, Tags: map[string]string{"latest": version}, Versions: map[string]release{version: entry}, Times: map[string]json.RawMessage{version: published}})
			return
		}
		http.NotFound(w, r)
	}))
	t.Cleanup(server.Close)
	m, err := NewManager(t.TempDir())
	if err != nil {
		t.Fatal(err)
	}
	m.Client = fixtureClient(t, server)
	m.nodeBinary, m.npmBinary = "/fake/node", "/fake/npm"
	m.Now = func() time.Time { return time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC) }
	m.RunCommand = f.run
	f.manager = m
	return f
}

func testIntegrity() string {
	return "sha512-" + base64.StdEncoding.EncodeToString(bytes.Repeat([]byte{42}, 64))
}

func (f *updaterFixture) run(ctx context.Context, name string, args []string, dir string, env []string) ([]byte, error) {
	if err := ctx.Err(); err != nil {
		return nil, err
	}
	f.environments = append(f.environments, append([]string(nil), env...))
	if name == "/fake/node" {
		return []byte("v22.16.0\n"), nil
	}
	if name == "/fake/npm" {
		if len(args) > 0 && args[0] == "rebuild" {
			if !reflect.DeepEqual(args, []string{"rebuild", "--prefix", dir, "--registry", "https://registry.npmjs.org", "--no-audit", "--no-fund"}) {
				return nil, errors.New("rebuild bypassed fixed registry or safety arguments")
			}
			if f.badIntegrity {
				return nil, errors.New("lifecycle hooks ran before integrity verification")
			}
			f.rebuildCalls++
			if f.tamperLock {
				return nil, os.WriteFile(filepath.Join(dir, "package-lock.json"), []byte(`{}`), 0600)
			}
			return nil, nil
		}
		if !strings.Contains(strings.Join(args, " "), "--ignore-scripts") {
			return nil, errors.New("initial package download must not run lifecycle hooks")
		}
		if strings.Contains(strings.Join(args, " "), " -g ") {
			return nil, errors.New("global installation forbidden")
		}
		if !strings.Contains(strings.Join(args, " "), "--engine-strict") {
			return nil, errors.New("missing engine check")
		}
		specArg := args[len(args)-1]
		for provider, spec := range providerSpecs {
			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")
			}
			f.installs[provider]++
			binDir := filepath.Join(dir, "node_modules", ".bin")
			if err := os.MkdirAll(binDir, 0700); err != nil {
				return nil, err
			}
			if err := os.WriteFile(filepath.Join(binDir, spec.Binary), []byte("#!/bin/sh\n"+version+"\n"), 0700); err != nil {
				return nil, err
			}
			integrity := testIntegrity()
			if f.badIntegrity {
				integrity = "sha512-wrong"
			}
			lock := map[string]any{"packages": map[string]any{"node_modules/" + spec.Package: map[string]string{"version": version, "integrity": integrity}}}
			data, _ := json.Marshal(lock)
			return nil, os.WriteFile(filepath.Join(dir, "package-lock.json"), data, 0600)
		}
		return nil, errors.New("unknown package")
	}
	for provider, spec := range providerSpecs {
		if !strings.Contains(name, string(filepath.Separator)+provider+string(filepath.Separator)) {
			continue
		}
		if len(args) == 1 && args[0] == "--version" {
			data, err := os.ReadFile(name)
			if err != nil {
				return nil, err
			}
			return []byte(spec.Binary + " " + strings.TrimSpace(strings.SplitN(string(data), "\n", 3)[1])), nil
		}
		if provider == f.failHelp {
			return []byte("--missing-every-required-flag"), nil
		}
		return []byte(strings.Join(spec.Flags, " ")), nil
	}
	return nil, errors.New("unexpected command " + name)
}

func (f *updaterFixture) setVersion(version string) {
	f.mu.Lock()
	defer f.mu.Unlock()
	for provider := range f.versions {
		f.versions[provider] = version
	}
}

func (f *updaterFixture) state(t *testing.T) State {
	t.Helper()
	state, err := ReadState(f.manager.Root)
	must(t, err)
	return state
}

func (f *updaterFixture) update(t *testing.T, wantError bool) Report {
	t.Helper()
	report, err := f.manager.Update(context.Background())
	if (err != nil) != wantError {
		t.Fatalf("update err=%v report=%+v", err, report)
	}
	return report
}

func (f *updaterFixture) pin(t *testing.T, key string) Inventory {
	t.Helper()
	inventory, err := PinInventory(f.manager.Root, key)
	must(t, err)
	return inventory
}

func TestUpdatePinsRollbackAndIdempotence(t *testing.T) {
	f := newUpdaterFixture(t)
	f.pin(t, "empty")
	for _, result := range f.update(t, false).Results {
		if result.Status != "updated" || result.Validation != "version-and-required-arguments" {
			t.Fatalf("result=%+v", result)
		}
	}
	first := f.pin(t, "run1")
	for _, result := range f.update(t, false).Results {
		if result.Status != "unchanged" || f.installs[result.Provider] != 1 {
			t.Fatalf("reinstalled: %+v", result)
		}
	}
	f.setVersion("2.0.0")
	f.update(t, false)
	second := f.pin(t, "run2")
	_, err := f.manager.Rollback(context.Background(), "codex")
	must(t, err)
	state := f.state(t)
	if state.Current["codex"] != first["codex"] || state.Rejected["codex"] != "2.0.0" {
		t.Fatalf("rollback=%+v", state)
	}
	for key, want := range map[string]Inventory{"run1": first, "run2": second, "empty": {}} {
		if !reflect.DeepEqual(f.pin(t, key), want) {
			t.Fatalf("pin %s moved", key)
		}
		for _, installation := range want {
			_, err := os.Stat(installation.Binary)
			must(t, err) // No GC of old versions/pins, including the rejected version.
		}
	}
	f.update(t, false)
	if f.state(t).Current["codex"].Version != "1.0.0" {
		t.Fatal("automatic update retried rejected release")
	}
	f.setVersion("3.0.0")
	f.update(t, false)
	if f.state(t).Current["codex"].Version != "3.0.0" {
		t.Fatal("new release did not advance beyond rejected release")
	}
	_, err = os.Stat(filepath.Join(f.manager.Root, "last-report.json"))
	must(t, err)
}

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) {
			f := newUpdaterFixture(t)
			f.update(t, false)
			f.setVersion("2.0.0")
			var lease *ClaimLease
			switch mode {
			case "help":
				f.failHelp = "codex"
			case "integrity-before-hook":
				f.badIntegrity = true
			case "integrity-after-hook":
				f.tamperLock = true
			case "offline":
				f.manager.Client = &http.Client{Transport: failingTransport{}}
			case "maintenance":
				var err error
				lease, err = BeginClaim(context.Background(), f.manager.Root)
				must(t, err)
				defer lease.Close()
			}
			// Maintenance blocks on the claim lock until this context ends.
			// The other cases fail on their own; a 200ms budget cancelled
			// healthy providers when the machine was busy running other packages.
			limit := 10 * time.Second
			if mode == "maintenance" {
				limit = 2 * time.Second
			}
			ctx, cancel := context.WithTimeout(context.Background(), limit)
			defer cancel()
			if _, err := f.manager.Update(ctx); err == nil {
				t.Fatal("expected update failure")
			}
			state := f.state(t)
			if state.Current["codex"].Version != "1.0.0" {
				t.Fatal("failed candidate activated")
			}
			if mode == "help" {
				if state.Current["codebuddy"].Version != "2.0.0" {
					t.Fatal("one provider blocked healthy updates")
				}
				f.update(t, true) // repeated failed smoke test reuses its cache too
				f.failHelp = ""
			}
			if mode == "maintenance" || mode == "help" {
				must(t, lease.Close())
				f.update(t, false)
				if f.installs["codex"] != 2 || f.state(t).Candidates["codex"].Version != "2.0.0" {
					t.Fatal("complete candidate was downloaded again")
				}
			}
			if mode == "integrity-before-hook" && f.rebuildCalls != 3 {
				t.Fatal("hooks executed before integrity check")
			}
		})
	}
}

func TestActivationCancellationBeforePublication(t *testing.T) {
	f := newUpdaterFixture(t)
	f.update(t, false)
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()
	// Cancel after inventory validation, not merely while waiting for locks.
	f.manager.Now = func() time.Time { cancel(); return time.Now() }
	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 {
		t.Fatalf("canceled activation published state: %v", err)
	}
}

func TestObservationAndDowngrade(t *testing.T) {
	f := newUpdaterFixture(t)
	f.setVersion("2.0.0")
	f.update(t, false)
	for _, tc := range []struct {
		version   string
		age       time.Duration
		wantError bool
	}{
		{"3.0.0", time.Hour, false},
		{"3.0.0-beta.1", 48 * time.Hour, true},
		{"1.0.0", 48 * time.Hour, false},
	} {
		f.setVersion(tc.version)
		f.mu.Lock()
		f.published = f.manager.Now().Add(-tc.age)
		f.mu.Unlock()
		f.update(t, tc.wantError)
		want := "2.0.0"
		if f.state(t).Current["codex"].Version != want {
			t.Fatalf("observation/downgrade safety ignored: %+v", tc)
		}
	}
}

func TestMissingRollback(t *testing.T) {
	f := newUpdaterFixture(t)
	for _, provider := range []string{"codex", "shell"} {
		if _, err := f.manager.Rollback(context.Background(), provider); err == nil {
			t.Fatal("missing/unknown rollback accepted")
		}
	}
}

type failingTransport struct{}

func (failingTransport) RoundTrip(*http.Request) (*http.Response, error) {
	return nil, errors.New("network unavailable")
}

func TestUpdaterEnvironment(t *testing.T) {
	for _, key := range []string{"OPENAI_API_KEY", "ANTHROPIC_API_KEY", "CODEBUDDY_API_KEY", "AGENTFLOW_WORKER_CONTROL_TOKEN", "AGENTFLOW_PLATFORM_MCP_TOKEN", "AGENTFLOW_API_KEY", "AGENTFLOW_RUNNER_BOOTSTRAP_TOKEN", "NODE_OPTIONS", "NPM_TOKEN", "NPM_CONFIG_REGISTRY", "npm_config_registry", "NPM_CONFIG_USERCONFIG", "NPM_CONFIG_GLOBALCONFIG", "AGENTFLOW_MANAGED_CLI_CONFIG"} {
		t.Setenv(key, "not-for-updater")
	}
	f := newUpdaterFixture(t)
	f.update(t, false)
	for _, env := range f.environments {
		joined := strings.Join(env, "\n")
		if strings.Contains(joined, "not-for-updater") {
			t.Fatal("task/host environment leaked")
		}
		for _, required := range []string{"HOME=" + filepath.Join(f.manager.Root, "updater-home"), "DISABLE_AUTOUPDATER=1", "DISABLE_UPDATES=1"} {
			if !strings.Contains(joined, required) {
				t.Fatalf("missing isolated environment %s", required)
			}
		}
	}
}

// Only the transport redirects requests: production always constructs the
// official registry URL and has no configurable endpoint or env override.
func fixtureClient(t *testing.T, server *httptest.Server) *http.Client {
	t.Helper()
	endpoint, err := url.Parse(server.URL)
	must(t, err)
	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" {
			return nil, fmt.Errorf("unexpected production registry URL: %s", req.URL)
		}
		local := req.Clone(req.Context())
		local.URL.Scheme, local.URL.Host = endpoint.Scheme, endpoint.Host
		return transport.RoundTrip(local)
	})
	return client
}

type roundTripFunc func(*http.Request) (*http.Response, error)

func (f roundTripFunc) RoundTrip(r *http.Request) (*http.Response, error) { return f(r) }

func TestUpdateProviderOnlyChangesTheRequestedCLI(t *testing.T) {
	f := newUpdaterFixture(t)
	f.update(t, false)
	f.setVersion("2.0.0")
	report, err := f.manager.UpdateProvider(context.Background(), "codex")
	must(t, err)
	if len(report.Results) != 1 || report.Results[0].Provider != "codex" || report.Results[0].Status != "updated" {
		t.Fatalf("update results = %+v", report.Results)
	}
	state := f.state(t)
	if state.Current["codex"].Version != "2.0.0" || state.Current["claude-code"].Version != "1.0.0" ||
		state.Current["codebuddy"].Version != "1.0.0" {
		t.Fatal("single CLI update changed unrelated active versions")
	}
}