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 (
"context"
"encoding/base64"
"encoding/json"
"errors"
"io"
"net/http"
"os"
"path/filepath"
"reflect"
"strings"
"testing"
"time"
)
const agyOriginalLogin = `{"token":{"access_token":"old-access","refresh_token":"original-refresh","expiry":"2026-11-01T00:00:00Z"},"auth_method":"consumer","id_token_email":"[email protected]"}`
var agyRefreshedExpiry = time.Now().UTC().Add(time.Hour).Format(time.RFC3339)
var agyRefreshedLogin = `{"token":{"access_token":"new-access","refresh_token":"original-refresh","token_type":"Bearer","expiry":"` + agyRefreshedExpiry + `"},"auth_method":"consumer","id_token_email":"[email protected]"}`
func sameAgyFixtureJSON(a, b []byte) bool {
var left, right any
return json.Unmarshal(a, &left) == nil && json.Unmarshal(b, &right) == nil && reflect.DeepEqual(left, right)
}
func TestAntigravityRefreshKeepsTrustedMetadata(t *testing.T) {
setAgyIdentityFixture(t, "[email protected]")
var candidate map[string]any
_ = json.Unmarshal([]byte(agyRefreshedLogin), &candidate)
candidate["id_token"] = "sandbox-forged-identity"
candidate["extra_setting"] = "sandbox-setting"
raw, _ := json.Marshal(candidate)
canonical, err := canonicalAntigravityRefresh([]byte(agyOriginalLogin), raw)
if err != nil || !sameAgyFixtureJSON(canonical, []byte(agyRefreshedLogin)) {
t.Fatal("sandbox metadata entered trusted source")
}
}
func TestAntigravityIdentityFailureKeepsHost(t *testing.T) {
before := antigravityIdentityClient
antigravityIdentityClient = &http.Client{Transport: agyIdentityFixtureTransport(func(*http.Request) (*http.Response, error) { return nil, errors.New("offline") })}
t.Cleanup(func() { antigravityIdentityClient = before })
stored, writes := agyOriginalLogin, 0
_, keep, err := antigravityKeyringLogin(func() (string, error) { return stored, nil }, func(value string) error { stored = value; writes++; return nil })
if err != nil {
t.Fatal(err)
}
if err := keep([]byte(agyRefreshedLogin)); err == nil || writes != 0 || stored != agyOriginalLogin {
t.Fatal("unverified access token replaced host login")
}
}
type agyIdentityFixtureTransport func(*http.Request) (*http.Response, error)
func (f agyIdentityFixtureTransport) RoundTrip(r *http.Request) (*http.Response, error) { return f(r) }
func setAgyIdentityFixture(t *testing.T, email string) {
t.Helper()
previous := antigravityIdentityClient
antigravityIdentityClient = &http.Client{Transport: agyIdentityFixtureTransport(func(r *http.Request) (*http.Response, error) {
owner := email
if strings.Contains(r.Header.Get("Authorization"), "foreign-access") {
owner = "[email protected]"
}
body, _ := json.Marshal(map[string]any{"sub": "fixture-subject-" + owner, "email": owner, "email_verified": true})
return &http.Response{StatusCode: 200, Body: io.NopCloser(strings.NewReader(string(body))), Header: make(http.Header)}, nil
})}
t.Cleanup(func() { antigravityIdentityClient = previous })
}
func agyFileLoginFixture(t *testing.T) string {
t.Helper()
setAgyIdentityFixture(t, "[email protected]")
host := t.TempDir()
t.Setenv("HOME", host)
t.Setenv("SSH_CONNECTION", "test-remote-session")
path := filepath.Join(host, ".gemini", "antigravity-cli", antigravityTokenFile)
if err := os.MkdirAll(filepath.Dir(path), 0700); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(path, []byte(agyOriginalLogin), 0600); err != nil {
t.Fatal(err)
}
return path
}
func TestAntigravityRunnerLoginLifecycle(t *testing.T) {
source := agyFileLoginFixture(t)
root := t.TempDir()
login, _ := runnerLoginSpec(AgentCLIAntigravity)
settings := filepath.Join(root, "home", login.dir, "settings.json")
if err := os.MkdirAll(filepath.Dir(settings), 0700); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(settings, []byte(`{"modelProvider":"gemini"}`), 0600); err != nil {
t.Fatal(err)
}
cleanup, env, err := prepareConversationRunnerLogin(root, login, true)
if err != nil {
t.Fatal(err)
}
if env["SSH_CONNECTION"] == "" {
t.Fatal("sandbox did not select official file authentication")
}
for _, key := range []string{"GEMINI_API_KEY", "GOOGLE_API_KEY", "AGY_ADC_AUTH", "AGY_LLM_GATEWAY_API_KEY"} {
if value, present := env[key]; !present || value != "" {
t.Fatalf("host credential %s was not cleared", key)
}
}
if raw, err := os.ReadFile(settings); err != nil || string(raw) != "{}" {
t.Fatal("previous API billing mode was retained")
}
copy := filepath.Join(root, "home", login.dir, login.file)
if info, err := os.Stat(copy); err != nil || info.Mode().Perm() != 0600 {
t.Fatal("login copy must be private")
}
if err := os.WriteFile(copy, []byte(agyRefreshedLogin), 0600); err != nil {
t.Fatal(err)
}
if err := cleanup(); err != nil {
t.Fatal(err)
}
if raw, err := os.ReadFile(source); err != nil || !sameAgyFixtureJSON(raw, []byte(agyRefreshedLogin)) {
t.Fatal("refreshed login was not saved to its source")
}
if _, err := os.Stat(copy); !os.IsNotExist(err) {
t.Fatal("isolated credential copy survived cleanup")
}
cleanup, _, err = prepareConversationRunnerLogin(root, login, true)
if err != nil {
t.Fatal(err)
}
if raw, _ := os.ReadFile(copy); !sameAgyFixtureJSON(raw, []byte(agyRefreshedLogin)) {
t.Fatal("next invocation did not use the refreshed source")
}
if err := cleanup(); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(copy, []byte(agyOriginalLogin), 0600); err != nil {
t.Fatal(err)
}
if _, _, err := prepareConversationRunnerLogin(root, login, false); err != nil {
t.Fatal(err)
}
if _, err := os.Stat(copy); !os.IsNotExist(err) {
t.Fatal("API-key mode retained an account credential")
}
if err := os.WriteFile(copy, []byte(agyOriginalLogin), 0600); err != nil {
t.Fatal(err)
}
_, keyEnv, err := ApplyAgentCLICredential(AgentCLIAntigravity, ProviderCredential{APIKey: "personal-key"}, AgentCLIOptions{Model: "gemini-test"}, HostAgentCLIHome(filepath.Join(root, "home")), filepath.Join(root, "home"), []string{"agy", "-p", "test"})
if err != nil || keyEnv["GEMINI_API_KEY"] != "personal-key" {
t.Fatalf("API-key configuration failed: %v", err)
}
if _, err := os.Stat(copy); !os.IsNotExist(err) {
t.Fatal("API-key binding retained a credential from an interrupted account-login run")
}
}
func TestAntigravityKeyringLoginRefresh(t *testing.T) {
setAgyIdentityFixture(t, "[email protected]")
expiryField := `"expiry":"` + agyRefreshedExpiry + `"`
for _, tc := range []struct {
name, concurrent, refreshed string
wantWrite, wantError bool
}{
{name: "refresh", refreshed: agyRefreshedLogin, wantWrite: true},
{name: "host switched accounts", concurrent: "different-host-login", refreshed: agyRefreshedLogin},
{name: "host logged out", concurrent: "missing", refreshed: agyRefreshedLogin},
{name: "sandbox switched accounts", refreshed: strings.ReplaceAll(agyRefreshedLogin, "[email protected]", "[email protected]"), wantError: true},
{name: "sandbox changed only refresh token", refreshed: strings.ReplaceAll(agyOriginalLogin, "original-refresh", "foreign-refresh"), wantError: true},
{name: "sandbox forged local identity", refreshed: strings.ReplaceAll(agyRefreshedLogin, "new-access", "foreign-access"), wantError: true},
{name: "unchanged", refreshed: agyOriginalLogin},
{name: "unchanged access with updated metadata", refreshed: strings.Replace(agyRefreshedLogin, "new-access", "old-access", 1)},
{name: "refresh with malformed expiry", refreshed: strings.Replace(agyRefreshedLogin, expiryField, `"expiry":"invalid"`, 1), wantError: true},
{name: "refresh with missing expiry", refreshed: strings.Replace(agyRefreshedLogin, ","+expiryField, "", 1), wantError: true},
{name: "refresh with null expiry", refreshed: strings.Replace(agyRefreshedLogin, expiryField, `"expiry":null`, 1), wantError: true},
{name: "refresh with already expired metadata", refreshed: strings.Replace(agyRefreshedLogin, expiryField, `"expiry":"2000-01-01T00:00:00Z"`, 1), wantError: true},
{name: "refresh with invalid token type", refreshed: strings.Replace(agyRefreshedLogin, `"Bearer"`, `"unsupported"`, 1), wantError: true},
{name: "refresh without token type", refreshed: strings.Replace(agyRefreshedLogin, `"token_type":"Bearer",`, "", 1), wantWrite: true},
} {
t.Run(tc.name, func(t *testing.T) {
stored, writes := agyOriginalLogin, 0
read := func() (string, error) {
if stored == "missing" {
return "", os.ErrNotExist
}
return stored, nil
}
write := func(value string) error { stored = value; writes++; return nil }
_, keep, err := antigravityKeyringLogin(read, write)
if err != nil {
t.Fatal(err)
}
if tc.concurrent != "" {
stored = tc.concurrent
}
err = keep([]byte(tc.refreshed))
if (err != nil) != tc.wantError || (writes == 1) != tc.wantWrite {
t.Fatalf("writes=%d error=%v", writes, err)
}
})
}
t.Run("credential errors do not expose secrets", func(t *testing.T) {
_, _, err := antigravityKeyringLogin(func() (string, error) { return "", errors.New("private-keychain-diagnostic") }, func(string) error { return nil })
if err == nil || strings.Contains(err.Error(), "private-keychain-diagnostic") {
t.Fatal("raw keychain error exposed")
}
})
}
func TestAntigravityFileLoginIgnoresMetadataOnlyUpdate(t *testing.T) {
path := agyFileLoginFixture(t)
original, keep, err := readAntigravityRunnerLogin()
if err != nil {
t.Fatal(err)
}
candidate := strings.Replace(string(original), "2026-11-01T00:00:00Z", "invalid", 1)
if err := keep([]byte(candidate)); err != nil {
t.Fatal(err)
}
current, err := os.ReadFile(path)
if err != nil || string(current) != string(original) {
t.Fatal("metadata-only update changed the host credential file")
}
}
func TestAntigravityLoginIdentityMigration(t *testing.T) {
claims := base64.RawURLEncoding.EncodeToString([]byte(`{"email":"[email protected]"}`))
var original map[string]any
if err := json.Unmarshal([]byte(agyOriginalLogin), &original); err != nil {
t.Fatal(err)
}
delete(original, "id_token_email")
original["id_token"] = "header." + claims + ".signature"
raw, _ := json.Marshal(original)
if !sameAntigravityLogin(raw, []byte(agyRefreshedLogin)) {
t.Fatal("official id_token to id_token_email migration rejected")
}
if sameAntigravityLogin(raw, []byte(strings.ReplaceAll(agyRefreshedLogin, "[email protected]", "[email protected]"))) {
t.Fatal("another account accepted")
}
}
func TestAntigravityAccountModelsSaveRefreshedLogin(t *testing.T) {
source := agyFileLoginFixture(t)
bin := filepath.Join(t.TempDir(), "agy")
script := `#!/bin/sh
set -eu
test "$1" = models
test -n "$SSH_CONNECTION"
test -z "${GEMINI_API_KEY:-}${GOOGLE_API_KEY:-}${AGY_ADC_AUTH:-}"
test -f "$HOME/.gemini/antigravity-cli/antigravity-oauth-token"
printf '%s' '` + agyRefreshedLogin + `' > "$HOME/.gemini/antigravity-cli/antigravity-oauth-token"
printf 'gemini-4-hydrogen-high\tGemini 4 Hydrogen (High)\n'
printf 'gemini-4-hydrogen-high\tDuplicate\n'
printf 'Fetching available models...\n' >&2
`
if err := os.WriteFile(bin, []byte(script), 0700); err != nil {
t.Fatal(err)
}
models, err := DiscoverRunnerLoginModels(context.Background(), AgentCLIAntigravity, bin)
if err != nil || len(models) != 1 || models[0].ID != "gemini-4-hydrogen-high" {
t.Fatalf("models=%+v error=%v", models, err)
}
if raw, _ := os.ReadFile(source); !sameAgyFixtureJSON(raw, []byte(agyRefreshedLogin)) {
t.Fatal("model query lost its refreshed credential")
}
}