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.
JavaScript agent-orchestrationagentic-workflowai-agentsai-codingclaude-codecode-reviewcodebuddycodexcoding-agentscursordeveloper-toolshuman-on-the-loopllmmcpmulti-agentsdlcself-hostedsopworkflow-automationworkflow-engine
package runtime
import (
"bytes"
"context"
"encoding/base64"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"os"
"path/filepath"
"strings"
"sync"
"sync/atomic"
"testing"
"time"
)
func managedLoginFixture(t *testing.T, provider string) (runnerLoginSource, []byte, []byte) {
t.Helper()
root := t.TempDir()
jwt := func(user string, generation int) string {
claims, _ := json.Marshal(map[string]any{"sub": user, "jti": generation,
"exp": time.Now().Add(time.Hour).Unix(), "https://api.openai.com/auth": map[string]string{"chatgpt_user_id": user}})
return "header." + base64.RawURLEncoding.EncodeToString(claims) + ".signature"
}
makeLogin := func(generation int) []byte {
var doc any
if provider == "codex" {
doc = map[string]any{"auth_mode": "chatgpt", "tokens": map[string]string{
"id_token": jwt("user-a", generation), "account_id": "account-a", "access_token": jwt("user-a", generation), "refresh_token": fmt.Sprintf("host-refresh-%d", generation)}}
} else {
doc = map[string]any{"claudeAiOauth": map[string]any{"accessToken": fmt.Sprintf("claude-access-%d", generation),
"refreshToken": fmt.Sprintf("host-refresh-%d", generation), "expiresAt": time.Now().Add(time.Hour).UnixMilli(), "subscriptionType": "test"}}
}
raw, _ := json.Marshal(doc)
return raw
}
login, _ := runnerLoginSpec(provider)
source := fileRunnerLoginSource(login, root)
if provider == "claude-code" {
if err := os.WriteFile(filepath.Join(root, ".claude.json"), []byte(`{"oauthAccount":{"accountUuid":"user-a","organizationUuid":"org-a"}}`), 0600); err != nil {
t.Fatal(err)
}
}
original, renewed := makeLogin(0), makeLogin(1)
if err := os.WriteFile(source.path, original, 0600); err != nil {
t.Fatal(err)
}
return source, original, renewed
}
func TestRunnerLoginManagerCoalescesConcurrentRefresh(t *testing.T) {
for _, provider := range []string{"codex", "claude-code"} {
t.Run(provider, func(t *testing.T) {
source, original, renewed := managedLoginFixture(t, provider)
var calls atomic.Int32
manager := &runnerLoginManager{stateDir: t.TempDir(), refresh: func(context.Context, string, []byte) ([]byte, error) { calls.Add(1); return renewed, nil }}
stale, err := manager.current(context.Background(), source)
if err != nil {
t.Fatal(err)
}
var workers sync.WaitGroup
for range 12 {
workers.Add(1)
go func() {
defer workers.Done()
got, err := manager.renew(context.Background(), source, stale)
if err != nil || !bytes.Equal(got.raw, renewed) {
t.Error("concurrent refresh did not reuse the authoritative pair")
}
}()
}
workers.Wait()
if calls.Load() != 1 {
t.Fatalf("issuer calls=%d", calls.Load())
}
current, _ := os.ReadFile(source.path)
if bytes.Equal(current, original) || !bytes.Equal(current, renewed) {
t.Fatal("host did not receive the renewed pair")
}
})
}
}
func TestRunnerLoginManagerCoordinatesInstances(t *testing.T) {
source, _, renewed := managedLoginFixture(t, "codex")
state := t.TempDir()
var calls atomic.Int32
refresh := func(context.Context, string, []byte) ([]byte, error) {
calls.Add(1)
time.Sleep(40 * time.Millisecond)
return renewed, nil
}
a, b := &runnerLoginManager{stateDir: state, refresh: refresh}, &runnerLoginManager{stateDir: state, refresh: refresh}
stale, err := a.current(context.Background(), source)
if err != nil {
t.Fatal(err)
}
var wg sync.WaitGroup
for _, manager := range []*runnerLoginManager{a, b} {
wg.Add(1)
go func(m *runnerLoginManager) {
defer wg.Done()
if _, err := m.renew(context.Background(), source, stale); err != nil {
t.Error(err)
}
}(manager)
}
wg.Wait()
if calls.Load() != 1 {
t.Fatalf("issuer exchanges = %d", calls.Load())
}
}
func TestRunnerLoginManagerRecoversBeforeRetry(t *testing.T) {
source, original, renewed := managedLoginFixture(t, "codex")
manager := &runnerLoginManager{stateDir: t.TempDir(), refresh: func(context.Context, string, []byte) ([]byte, error) {
t.Error("consumed refresh token redeemed again")
return nil, errors.New("unexpected exchange")
}}
stale, _ := manager.current(context.Background(), source)
_, path, _ := manager.entry(source)
if err := writeRunnerLoginPending(path+".pending", runnerLoginPending{Expected: loginDigest(original), Identity: stale.identity, Login: renewed}); err != nil {
t.Fatal(err)
}
got, err := manager.renew(context.Background(), source, stale)
if err != nil || !bytes.Equal(got.raw, renewed) {
t.Fatal("renew did not recover the received pair first")
}
}
func TestRunnerLoginManagerReceiptWithoutAccountMetadata(t *testing.T) {
source, _, renewed := managedLoginFixture(t, "claude-code")
source.identity = func([]byte) string { return "" }
state := t.TempDir()
first := &runnerLoginManager{stateDir: state, refresh: func(context.Context, string, []byte) ([]byte, error) { return renewed, nil }}
stale, err := first.current(context.Background(), source)
if err != nil {
t.Fatal(err)
}
if _, err := first.renew(context.Background(), source, stale); err != nil {
t.Fatal(err)
}
restarted := &runnerLoginManager{stateDir: state, refresh: func(context.Context, string, []byte) ([]byte, error) {
t.Error("unnecessary second exchange")
return nil, errors.New("unexpected")
}}
got, err := restarted.renew(context.Background(), source, stale)
if err != nil || !bytes.Equal(got.raw, renewed) {
t.Fatal("another manager could not recognize its canonical receipt")
}
// A host edit without a receipt still needs a new task, even if the JSON
// schema is unchanged. There is no account identity to safely adopt it.
foreign := bytes.ReplaceAll(renewed, []byte("claude-access-1"), []byte("foreign-access"))
if err := os.WriteFile(source.path, foreign, 0600); err != nil {
t.Fatal(err)
}
if _, err := restarted.renew(context.Background(), source, stale); err == nil {
t.Fatal("unanchored external change was adopted")
}
}
type runnerOAuthTransport func(*http.Request) (*http.Response, error)
func (f runnerOAuthTransport) RoundTrip(r *http.Request) (*http.Response, error) { return f(r) }
func TestRunnerLoginOAuthAdapter(t *testing.T) {
for _, provider := range []string{"codex", "claude-code"} {
for _, rotate := range []bool{false, true} {
t.Run(fmt.Sprintf("%s/rotate=%v", provider, rotate), func(t *testing.T) {
source, original, renewed := managedLoginFixture(t, provider)
before, _ := parseRunnerOAuth(provider, original)
after, _ := parseRunnerOAuth(provider, renewed)
manager := &runnerLoginManager{stateDir: t.TempDir(), client: &http.Client{Transport: runnerOAuthTransport(func(req *http.Request) (*http.Response, error) {
if req.Method != "POST" || req.URL.Scheme != "https" {
t.Error("OAuth exchange used an unexpected transport")
}
var request map[string]any
if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
t.Error(err)
}
if request["refresh_token"] != before.refresh || request["grant_type"] != "refresh_token" || request["client_id"] == "" {
t.Error("exchange did not use the host grant")
}
response := map[string]any{"access_token": after.access, "expires_in": 3600, "scope": "user:inference user:profile"}
if rotate {
response["refresh_token"] = after.refresh
}
body, _ := json.Marshal(response)
return &http.Response{StatusCode: 200, Body: io.NopCloser(bytes.NewReader(body)), Header: make(http.Header)}, nil
})}}
stale, err := manager.current(context.Background(), source)
if err != nil {
t.Fatal(err)
}
got, err := manager.renew(context.Background(), source, stale)
if err != nil {
t.Fatal(err)
}
wantRefresh := before.refresh
if rotate {
wantRefresh = after.refresh
}
if got.access != after.access || got.refresh != wantRefresh {
t.Fatal("canonical pair was not preserved")
}
if provider == "claude-code" && time.Until(got.expiry) < 59*time.Minute {
t.Fatal("Claude expiry was not advanced")
}
_, path, _ := manager.entry(source)
if _, err := os.Stat(path + ".pending"); !os.IsNotExist(err) {
t.Fatal("completed exchange retained a second refresh token")
}
receipt, err := os.ReadFile(path + ".receipt")
if err != nil || bytes.Contains(receipt, []byte("host-refresh")) {
t.Fatal("receipt is missing or contains refresh material")
}
})
}
}
}
func TestRunnerLoginRejectsIncompleteOAuth(t *testing.T) {
for _, provider := range []string{"codex", "claude-code"} {
t.Run(provider, func(t *testing.T) {
login, _ := runnerLoginSpec(provider)
host := t.TempDir()
root := t.TempDir()
t.Setenv(login.configEnv, host)
t.Setenv("CLAUDE_CODE_OAUTH_TOKEN", "")
raw := `{"tokens":{"refresh_token":"host-only-refresh"}}`
if provider == "claude-code" {
raw = `{"claudeAiOauth":{"refreshToken":"host-only-refresh"}}`
}
if err := os.WriteFile(filepath.Join(host, login.file), []byte(raw), 0600); err != nil {
t.Fatal(err)
}
if cleanup, _, err := prepareConversationRunnerLogin(root, login, true); err == nil {
if cleanup != nil {
_ = cleanup()
}
t.Fatal("incomplete OAuth grant entered the sandbox")
}
if _, err := os.Stat(filepath.Join(root, "home", login.dir, login.file)); !os.IsNotExist(err) {
t.Fatal("host refresh token was staged")
}
})
}
}
func TestRunnerLoginManagerUncertainExchange(t *testing.T) {
for _, definitive := range []bool{false, true} {
t.Run(fmt.Sprintf("definitive=%v", definitive), func(t *testing.T) {
source, original, _ := managedLoginFixture(t, "codex")
var calls atomic.Int32
manager := &runnerLoginManager{stateDir: t.TempDir(), refresh: func(context.Context, string, []byte) ([]byte, error) {
calls.Add(1)
err := errors.New("no response")
if definitive {
return nil, &runnerRefreshRejected{err}
}
return nil, err
}}
stale, _ := manager.current(context.Background(), source)
for range 2 {
if _, err := manager.renew(context.Background(), source, stale); err == nil {
t.Fatal("exchange unexpectedly succeeded")
}
}
want := int32(1)
if definitive {
want = 2
}
if calls.Load() != want {
t.Fatalf("exchanges=%d want=%d", calls.Load(), want)
}
// A restart preserves the uncertain marker and still permits reading
// the existing access token. A logout is never resurrected.
restarted := &runnerLoginManager{stateDir: manager.stateDir, refresh: manager.refresh}
current, err := restarted.current(context.Background(), source)
if err != nil || !bytes.Equal(current.raw, original) {
t.Fatal("refresh failure damaged host credentials")
}
if !definitive {
if _, err := restarted.renew(context.Background(), source, current); err == nil || calls.Load() != 1 {
t.Fatal("restart retried an uncertain exchange")
}
}
})
}
}
func TestRunnerLoginLeaseKeepsRefreshTokenOnHost(t *testing.T) {
source, _, renewed := managedLoginFixture(t, "codex")
var calls atomic.Int32
manager := &runnerLoginManager{stateDir: t.TempDir(), refresh: func(context.Context, string, []byte) ([]byte, error) { calls.Add(1); return renewed, nil }}
var leases []*runnerLoginLease
for range 3 {
lease, err := newRunnerLoginLease(context.Background(), manager, source, false)
if err != nil {
t.Fatal(err)
}
defer lease.close()
leases = append(leases, lease)
credential, err := lease.credential()
if err != nil || bytes.Contains(credential, []byte("host-refresh")) {
t.Fatal("host refresh token entered a private HOME")
}
}
request := func(lease *runnerLoginLease, nonce string) ([]byte, int, error) {
body, _ := json.Marshal(map[string]string{"grant_type": "refresh_token", "refresh_token": nonce})
resp, err := http.Post(lease.endpoint, "application/json", bytes.NewReader(body))
if err != nil {
return nil, 0, err
}
defer resp.Body.Close()
var result json.RawMessage
err = json.NewDecoder(resp.Body).Decode(&result)
return result, resp.StatusCode, err
}
var workers sync.WaitGroup
for _, lease := range leases {
workers.Add(1)
go func(l *runnerLoginLease) {
defer workers.Done()
raw, status, err := request(l, l.id)
if err != nil || status != 200 || bytes.Contains(raw, []byte("host-refresh")) {
t.Error("lease refresh failed or exposed a host token")
}
}(lease)
}
workers.Wait()
if calls.Load() != 1 {
t.Fatalf("issuer calls=%d", calls.Load())
}
a, status, err := request(leases[0], leases[0].id)
if err != nil || status != 200 {
t.Fatal("lost-response replay failed")
}
b, status, err := request(leases[0], leases[0].id)
if err != nil || status != 200 || !bytes.Equal(a, b) || calls.Load() != 1 {
t.Fatal("replay repeated the exchange or changed its response")
}
_, status, err = request(leases[0], "host-refresh-0")
if err != nil || status != 400 || calls.Load() != 1 {
t.Fatal("a sandbox supplied its own upstream refresh token")
}
}
func TestRunnerLoginPendingRecovery(t *testing.T) {
for _, scenario := range []string{"recover", "logout", "other account"} {
t.Run(scenario, func(t *testing.T) {
source, original, renewed := managedLoginFixture(t, "codex")
manager := &runnerLoginManager{stateDir: t.TempDir()}
_, path, err := manager.entry(source)
if err != nil {
t.Fatal(err)
}
if err := writeRunnerLoginPending(path+".pending", runnerLoginPending{Expected: loginDigest(original), Identity: source.identity(original), Login: renewed}); err != nil {
t.Fatal(err)
}
switch scenario {
case "logout":
if err := os.Remove(source.path); err != nil {
t.Fatal(err)
}
case "other account":
if err := os.WriteFile(source.path, bytes.ReplaceAll(original, []byte("account-a"), []byte("account-b")), 0600); err != nil {
t.Fatal(err)
}
}
got, err := manager.current(context.Background(), source)
if scenario == "recover" && (err != nil || !bytes.Equal(got.raw, renewed)) {
t.Fatal("durable response not recovered")
}
if scenario == "logout" {
if err == nil {
t.Fatal("logout resurrected")
}
if _, err := os.Stat(source.path); !os.IsNotExist(err) {
t.Fatal("logout file recreated")
}
}
if scenario == "other account" && (err != nil || !bytes.Contains(got.raw, []byte("account-b"))) {
t.Fatal("pending refresh replaced another account")
}
})
}
}
func TestRunnerLoginRefreshSurvivesCallerCancellation(t *testing.T) {
source, _, renewed := managedLoginFixture(t, "codex")
started, release := make(chan struct{}), make(chan struct{})
manager := &runnerLoginManager{stateDir: t.TempDir(), refresh: func(ctx context.Context, _ string, _ []byte) ([]byte, error) {
close(started)
<-release
if ctx.Err() != nil {
return nil, ctx.Err()
}
return renewed, nil
}}
stale, err := manager.current(context.Background(), source)
if err != nil {
t.Fatal(err)
}
ctx, cancel := context.WithCancel(context.Background())
done := make(chan error, 1)
go func() { _, err := manager.renew(ctx, source, stale); done <- err }()
<-started
cancel()
close(release)
if err := <-done; err != nil {
t.Fatal(err)
}
raw, _ := os.ReadFile(source.path)
if !bytes.Equal(raw, renewed) {
t.Fatal("cancellation lost a rotated pair")
}
}
func TestRunnerLoginDoesNotAdoptAnotherAccount(t *testing.T) {
source, _, renewed := managedLoginFixture(t, "codex")
manager := &runnerLoginManager{stateDir: t.TempDir(), refresh: func(context.Context, string, []byte) ([]byte, error) {
t.Fatal("unexpected issuer request")
return nil, nil
}}
stale, err := manager.current(context.Background(), source)
if err != nil {
t.Fatal(err)
}
if err := os.WriteFile(source.path, bytes.ReplaceAll(renewed, []byte("account-a"), []byte("account-b")), 0600); err != nil {
t.Fatal(err)
}
if _, err := manager.renew(context.Background(), source, stale); err == nil {
t.Fatal("adopted another host account")
}
}
func TestRunnerLoginSourceAliasChanges(t *testing.T) {
for _, scenario := range []string{"logout", "retarget", "logout-during-exchange", "retarget-during-exchange"} {
t.Run(scenario, func(t *testing.T) {
target, original, renewed := managedLoginFixture(t, "codex")
config := t.TempDir()
login, _ := runnerLoginSpec("codex")
alias := filepath.Join(config, login.file)
if err := os.Symlink(target.path, alias); err != nil {
t.Fatal(err)
}
source := fileRunnerLoginSource(login, config)
change := func() {
if err := os.Remove(alias); err != nil {
t.Fatal(err)
}
if strings.HasPrefix(scenario, "retarget") {
other, _, _ := managedLoginFixture(t, "codex")
if err := os.Symlink(other.path, alias); err != nil {
t.Fatal(err)
}
}
}
manager := &runnerLoginManager{stateDir: t.TempDir(), refresh: func(context.Context, string, []byte) ([]byte, error) {
if !strings.HasSuffix(scenario, "during-exchange") {
t.Error("detached source refreshed")
return nil, errors.New("unexpected")
}
change()
return renewed, nil
}}
stale, err := manager.current(context.Background(), source)
if err != nil {
t.Fatal(err)
}
if !strings.HasSuffix(scenario, "during-exchange") {
change()
}
if _, err := manager.renew(context.Background(), source, stale); err == nil {
t.Fatal("continued using a detached login target")
}
got, err := os.ReadFile(target.path)
if err != nil || !bytes.Equal(got, original) {
t.Fatal("detached host source changed")
}
})
}
}
func TestManagedClaudeBridge(t *testing.T) {
source, _, renewed := managedLoginFixture(t, "claude-code")
manager := &runnerLoginManager{stateDir: t.TempDir(), refresh: func(context.Context, string, []byte) ([]byte, error) { return renewed, nil }}
lease, err := newRunnerLoginLease(context.Background(), manager, source, false)
if err != nil {
t.Fatal(err)
}
defer lease.close()
root := t.TempDir()
bin := filepath.Join(root, "claude")
script := `#!/usr/bin/env python3
import sys,json
for line in sys.stdin:
x=json.loads(line)
if x.get('type')=='control_request':
print(json.dumps({'type':'control_response','response':{'subtype':'success','request_id':x['request_id']}}),flush=True)
elif x.get('type')=='user':
assert x['message']['content']=='original task prompt'
print(json.dumps({'type':'control_request','request_id':'refresh-one','request':{'subtype':'oauth_token_refresh'}}),flush=True)
elif x.get('type')=='control_response':
assert x['response']['response']['accessToken']=='claude-access-1'
print(json.dumps({'type':'result','is_error':False,'result':'bridge-ok'}),flush=True)
break
`
if err := os.WriteFile(bin, []byte(script), 0700); err != nil {
t.Fatal(err)
}
command := WithCommandEnvironment(CommandSpec{Provider: "claude-code", Argv: []string{bin, "-p", "original task prompt"}}, lease.environment())
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
out, err := (&localSandbox{workspace: root}).Exec(ctx, command, nil)
if err != nil || !strings.Contains(out, "bridge-ok") || strings.Contains(out, "oauth_token_refresh") || strings.Contains(out, "claude-access-1") {
t.Fatalf("managed bridge failed or leaked control messages: %v", err)
}
}
func TestManagedLoginSandboxReplacement(t *testing.T) {
for _, provider := range []string{"codex", "claude-code"} {
for _, mutation := range []string{"whole-account", "refresh-only", "forged-identity"} {
t.Run(provider+"/"+mutation, func(t *testing.T) {
source, original, _ := managedLoginFixture(t, provider)
login, _ := runnerLoginSpec(provider)
t.Setenv(login.configEnv, filepath.Dir(source.path))
t.Setenv("CLAUDE_CODE_OAUTH_TOKEN", "")
previous := nativeRunnerLogins
nativeRunnerLogins = &runnerLoginManager{stateDir: t.TempDir(), refresh: func(context.Context, string, []byte) ([]byte, error) {
t.Error("sandbox caused upstream exchange")
return nil, errors.New("unexpected")
}}
defer func() { nativeRunnerLogins = previous }()
root := t.TempDir()
cleanup, _, err := prepareConversationRunnerLogin(root, login, true)
if err != nil {
t.Fatal(err)
}
var doc map[string]any
_ = json.Unmarshal(original, &doc)
if provider == "codex" {
tokens := doc["tokens"].(map[string]any)
tokens["refresh_token"] = "foreign-refresh"
if mutation != "refresh-only" {
tokens["access_token"] = "foreign-access"
tokens["id_token"] = "forged-id"
}
if mutation == "whole-account" {
tokens["account_id"] = "another-account"
}
} else {
tokens := doc["claudeAiOauth"].(map[string]any)
tokens["refreshToken"] = "foreign-refresh"
if mutation != "refresh-only" {
tokens["accessToken"] = "foreign-access"
}
}
candidate, _ := json.Marshal(doc)
if err := os.WriteFile(filepath.Join(root, "home", login.dir, login.file), candidate, 0600); err != nil {
t.Fatal(err)
}
if err := cleanup(); err != nil {
t.Fatal(err)
}
got, err := os.ReadFile(source.path)
if err != nil || !bytes.Equal(got, original) {
t.Fatal("sandbox replacement entered host credentials")
}
})
}
}
}