@xkei/openclaude 0.30.0-antigravity

package/vendor/openclaude-antigravity-provider/hooks/SessionStart.ps1

@@ -0,0 +1,111 @@
+# SessionStart.ps1
+# OpenClaude hook: ensures the Antigravity proxy is running BEFORE OpenClaude
+# sends its first request, and ensures OpenClaude's provider config points at
+# the proxy (idempotent — injects only on fresh setups).
+#
+# Prefers the compiled exe (no bun dependency, fast start); falls back to
+# `bun run src/server.ts` if the exe is missing.
+#
+# Path resolution is fully relative to this script, so the hook works from:
+#   - the npm-installed package (node_modules/@xkei/openclaude/vendor/...)
+#   - OpenClaude's versioned plugin cache (~/.openclaude/plugins/cache/...)
+#   - any source checkout
+# Compatible with PowerShell 5.1+
+
+$ProxyPort        = 51122
+$HealthUrl        = "http://127.0.0.1:$ProxyPort/health"
+$ProjectRoot      = Split-Path -Parent $PSScriptRoot
+$ServerScript     = Join-Path $ProjectRoot "src\server.ts"
+$ServerExe        = Join-Path $ProjectRoot "bin\antigravity-proxy.exe"
+$PidFile          = Join-Path $env:USERPROFILE ".openclaude\antigravity-proxy.pid"
+
+# ── 1. Is the proxy already healthy? ─────────────────────────────────────────
+$healthy = $false
+try {
+    $r = Invoke-RestMethod -Uri $HealthUrl -TimeoutSec 1 -ErrorAction Stop
+    if ($r.status -eq "ok") { $healthy = $true }
+} catch {}
+
+# ── 2. Not healthy → resolve launcher and spawn ──────────────────────────────
+if (-not $healthy) {
+    $cmdLine = $null
+    if (Test-Path -LiteralPath $ServerExe) {
+        $cmdLine = "`"$ServerExe`""
+    } else {
+        # Fallback: run from source via bun (absolute path incl. Kiro-CLI fallback)
+        $bunExe = $null
+        $bunCmd = Get-Command bun -ErrorAction SilentlyContinue
+        if ($bunCmd) {
+            $bunExe = $bunCmd.Source
+        } else {
+            $fallback = Join-Path $env:LOCALAPPDATA "Kiro-Cli\bun.exe"
+            if (Test-Path -LiteralPath $fallback) { $bunExe = $fallback }
+        }
+        if ($bunExe -and (Test-Path -LiteralPath $ServerScript)) {
+            $cmdLine = "`"$bunExe`" run `"$ServerScript`""
+        }
+    }
+    if (-not $cmdLine) {
+        Write-Warning "[antigravity-provider] No launcher found. Build with: bun run build"
+    } else {
+        # Spawn proxy via WMI (fully detached)
+        $result = Invoke-WmiMethod -Class Win32_Process -Name Create `
+                      -ArgumentList $cmdLine, $ProjectRoot
+        if ($result.ReturnValue -ne 0) {
+            Write-Warning "[antigravity-provider] Failed to spawn proxy (WMI code $($result.ReturnValue))"
+        } else {
+            $result.ProcessId | Out-File -FilePath $PidFile -Encoding utf8 -Force
+
+            # Wait until healthy so the port is OPEN before OpenClaude proceeds.
+            # Blocks briefly to prevent the ECONNREFUSED race; exits as soon as
+            # healthy (typically < 2s).
+            for ($i = 0; $i -lt 20; $i++) {
+                Start-Sleep -Milliseconds 400
+                try {
+                    $check = Invoke-RestMethod -Uri $HealthUrl -TimeoutSec 1 -ErrorAction Stop
+                    if ($check.status -eq "ok") { $healthy = $true; break }
+                } catch {}
+            }
+        }
+    }
+}
+
+if ($healthy) {
+    Write-Host "[antigravity-provider] Proxy ready -> http://127.0.0.1:$ProxyPort/v1"
+} else {
+    Write-Warning "[antigravity-provider] Proxy not healthy yet (slow AV scan?). It may come up shortly."
+}
+
+# ── 3. Ensure OpenClaude's provider config points at the proxy ───────────────
+# Idempotent no-op when already configured; injects on fresh setups so /model
+# auto-discovers the Antigravity/Gemini models via the /v1/models endpoint.
+$Injector = Join-Path $ProjectRoot "hooks\inject-provider.js"
+if (Test-Path -LiteralPath $Injector) {
+    $jsExe = $null
+    $bunCmd2 = Get-Command bun -ErrorAction SilentlyContinue
+    if ($bunCmd2) {
+        $jsExe = $bunCmd2.Source
+    } else {
+        $k = Join-Path $env:LOCALAPPDATA "Kiro-Cli\bun.exe"
+        if (Test-Path -LiteralPath $k) { $jsExe = $k }
+        else {
+            $n = Get-Command node -ErrorAction SilentlyContinue
+            if ($n) { $jsExe = $n.Source }
+        }
+    }
+    if ($jsExe) {
+        try {
+            $injectOut = & $jsExe $Injector 2>&1
+            if ($injectOut) { Write-Host "$injectOut" }
+        } catch {}
+    }
+}
+
+# ── 4. Pre-warm /v1/models so model discovery is instant ─────────────────────
+if ($healthy) {
+    try {
+        $null = Invoke-RestMethod -Uri "http://127.0.0.1:$ProxyPort/v1/models" -TimeoutSec 3 -ErrorAction Stop
+    } catch {}
+}
+
+exit 0

package/vendor/openclaude-antigravity-provider/hooks/Watchdog-Stop.ps1

@@ -0,0 +1,82 @@
+# Watchdog-Stop.ps1
+# Detached shutdown watchdog for the Antigravity proxy.
+# Spawned via WMI by SessionEnd.ps1 (fully detached — survives OpenClaude's
+# shutdown even when the SessionEnd hook itself gets cancelled during teardown).
+#
+# Polls up to 20 times (3s apart, ~60s total) so that even a slow OpenClaude
+# teardown is outlived. At each poll, if NO openclaude process is still alive,
+# the proxy is stopped. If any openclaude session survives (interactive,
+# background, or teardown in progress), the proxy stays.
+#
+# Identity-verified kill: only processes named "antigravity-proxy" or "bun"
+# are ever stopped, so nothing else can be harmed.
+# Compatible with PowerShell 5.1+
+
+$ProxyPort   = 51122
+$PidFile     = Join-Path $env:USERPROFILE ".openclaude\antigravity-proxy.pid"
+
+function Get-ProxyPid {
+    try {
+        if (Test-Path -LiteralPath $PidFile) {
+            return [int]((Get-Content $PidFile -Raw).Trim())
+        }
+    } catch {}
+    return 0
+}
+
+function Stop-Proxy {
+    $killed = $false
+    $proxyPid = Get-ProxyPid
+    if ($proxyPid -gt 0) {
+        $p = Get-Process -Id $proxyPid -ErrorAction SilentlyContinue
+        if ($p -and ($p.Name -eq "antigravity-proxy" -or $p.Name -eq "bun")) {
+            Stop-Process -Id $proxyPid -Force -ErrorAction SilentlyContinue
+            $killed = $true
+        }
+    }
+    if (-not $killed) {
+        try {
+            $line = netstat -ano | Select-String ":$ProxyPort\s.*LISTENING" | Select-Object -First 1
+            if ($line) {
+                $ownerPid = [int](($line.ToString().Trim() -split "\s+")[-1])
+                $p = Get-Process -Id $ownerPid -ErrorAction SilentlyContinue
+                if ($p -and ($p.Name -eq "antigravity-proxy" -or $p.Name -eq "bun")) {
+                    Stop-Process -Id $ownerPid -Force -ErrorAction SilentlyContinue
+                    $killed = $true
+                }
+            }
+        } catch {}
+    }
+    if ($killed -and (Test-Path -LiteralPath $PidFile)) {
+        Remove-Item -LiteralPath $PidFile -Force -ErrorAction SilentlyContinue
+    }
+    return $killed
+}
+
+for ($poll = 1; $poll -le 20; $poll++) {
+    Start-Sleep -Seconds 3
+
+    # Any live openclaude process? (node/bun with "openclaude" on its command
+    # line — covers interactive, --resume, and --bg sessions. The proxy itself
+    # is "antigravity-proxy.exe" or "bun ... server.ts" and never matches.)
+    $alive = $false
+    try {
+        $procs = Get-CimInstance Win32_Process -Filter "Name = 'node.exe' OR Name = 'bun.exe'" -ErrorAction Stop
+        foreach ($proc in $procs) {
+            if ($proc.CommandLine -and $proc.CommandLine -match "openclaude") {
+                $alive = $true
+                break
+            }
+        }
+    } catch {
+        # WMI query failed — fail-safe: do not kill
+        $alive = $true
+    }
+
+    if (-not $alive) {
+        $null = Stop-Proxy
+        break
+    }
+}
+
+exit 0

package/vendor/openclaude-antigravity-provider/hooks/hooks.json

@@ -0,0 +1,37 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup",
+        "hooks": [
+          { "type": "command", "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/start.bat\"", "timeout": 45 }
+        ]
+      },
+      {
+        "matcher": "resume",
+        "hooks": [
+          { "type": "command", "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/start.bat\"", "timeout": 45 }
+        ]
+      },
+      {
+        "matcher": "clear",
+        "hooks": [
+          { "type": "command", "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/start.bat\"", "timeout": 45 }
+        ]
+      },
+      {
+        "matcher": "compact",
+        "hooks": [
+          { "type": "command", "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/start.bat\"", "timeout": 45 }
+        ]
+      }
+    ],
+    "SessionEnd": [
+      {
+        "hooks": [
+          { "type": "command", "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/session-end.bat\"", "timeout": 30 }
+        ]
+      }
+    ]
+  }
+}

package/vendor/openclaude-antigravity-provider/hooks/inject-provider.js

@@ -0,0 +1,110 @@
+/**
+ * inject-provider.js
+ * Ensures OpenClaude's provider configuration points at the local
+ * Antigravity proxy (http://localhost:51122/v1).
+ *
+ * Idempotent: only writes when configuration is missing/mispointed.
+ * Creates .plugin-bak backups before any write. Exits 0 always.
+ *
+ * Run via: bun hooks/inject-provider.js  (or: node hooks/inject-provider.js)
+ */
+
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+
+const HOME = os.homedir();
+const OC_DIR = path.join(HOME, ".openclaude");
+const PROFILE_PATH = path.join(OC_DIR, ".openclaude-profile.json");
+const MAIN_PATH = path.join(HOME, ".openclaude.json");
+
+const BASE_URL = "http://localhost:51122/v1";
+const MODEL = "antigravity-claude-sonnet-4-6";
+
+function backup(file) {
+  try {
+    if (fs.existsSync(file)) {
+      fs.copyFileSync(file, file + ".plugin-bak");
+    }
+  } catch {}
+}
+
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function writeJson(file, data) {
+  const tmp = file + ".plugin-tmp";
+  fs.writeFileSync(tmp, JSON.stringify(data, null, 2) + "\n");
+  fs.renameSync(tmp, file);
+}
+
+try {
+  // ── 1. ~/.openclaude/.openclaude-profile.json (active profile env) ──────────
+  let needProfile = true;
+  const existing = readJson(PROFILE_PATH);
+  if (
+    existing &&
+    existing.env &&
+    typeof existing.env.OPENAI_BASE_URL === "string" &&
+    existing.env.OPENAI_BASE_URL.includes(":51122")
+  ) {
+    needProfile = false;
+  }
+
+  if (needProfile) {
+    backup(PROFILE_PATH);
+    fs.mkdirSync(OC_DIR, { recursive: true });
+    writeJson(PROFILE_PATH, {
+      profile: "openai",
+      env: {
+        OPENAI_BASE_URL: BASE_URL,
+        OPENAI_MODEL: MODEL,
+        OPENAI_AUTH_HEADER: "dummy",
+        OPENAI_AUTH_SCHEME: "raw",
+      },
+      createdAt: existing && existing.createdAt ? existing.createdAt : new Date().toISOString(),
+    });
+    console.log("[antigravity-provider] injected provider profile (.openclaude-profile.json)");
+  }
+
+  // ── 2. ~/.openclaude.json providerProfiles entry (only when absent) ────────
+  // Never overrides the user's active provider if an entry already exists —
+  // they may have deliberately switched. Injection is for fresh setups only.
+  if (fs.existsSync(MAIN_PATH)) {
+    const main = readJson(MAIN_PATH);
+    if (main) {
+      const profiles = Array.isArray(main.providerProfiles) ? main.providerProfiles : [];
+      const has = profiles.some(
+        (p) => p && typeof p.baseUrl === "string" && p.baseUrl.includes(":51122"),
+      );
+
+      if (!has) {
+        backup(MAIN_PATH);
+        const id = "provider_antigravity_local";
+        profiles.push({
+          id: id,
+          name: "Antigravity (Local Proxy)",
+          provider: "custom",
+          baseUrl: BASE_URL,
+          model: MODEL,
+          authHeader: "dummy",
+          authScheme: "raw",
+        });
+        main.providerProfiles = profiles;
+        main.activeProviderProfileId = id;
+        writeJson(MAIN_PATH, main);
+        console.log("[antigravity-provider] injected providerProfiles entry (.openclaude.json)");
+      }
+    }
+  }
+} catch (e) {
+  // Never fail the hook because of injection problems.
+  console.error("[antigravity-provider] provider inject skipped: " + (e && e.message));
+}
+
+process.exit(0);

package/vendor/openclaude-antigravity-provider/hooks/session-end.bat

@@ -0,0 +1,22 @@
+@echo off
+rem session-end.bat - OpenClaude SessionEnd hook wrapper.
+rem Spawns the detached Watchdog-Stop.ps1 which stops the Antigravity proxy
+rem once no openclaude process remains alive.
+rem
+rem IMPORTANT: OpenClaude aborts SessionEnd hooks after ~1.5s
+rem (SESSION_END_HOOK_TIMEOUT_MS_DEFAULT). This wrapper therefore spawns the
+rem watchdog as FAST as possible: wmic first (no PowerShell cold-start,
+rem ~0.4s), PowerShell+WMI as fallback when wmic is unavailable.
+rem The watchdog itself is created by the WMI service, fully detached from
+rem this process tree, so it survives this hook being cancelled.
+
+set "WATCHDOG=%~dp0Watchdog-Stop.ps1"
+
+where wmic >nul 2>&1
+if %errorlevel%==0 (
+    wmic process call create "powershell -NoProfile -ExecutionPolicy Bypass -WindowStyle Hidden -File %WATCHDOG%" >nul 2>&1
+    exit /b 0
+)
+
+powershell -NoProfile -ExecutionPolicy Bypass -Command "try { $null = Invoke-WmiMethod -Class Win32_Process -Name Create -ArgumentList ('powershell -NoProfile -ExecutionPolicy Bypass -WindowStyle Hidden -File ' + [char]34 + '%WATCHDOG%' + [char]34) } catch {}"
+exit /b 0

package/vendor/openclaude-antigravity-provider/hooks/start.bat

@@ -0,0 +1,7 @@
+@echo off
+rem start.bat - OpenClaude SessionStart hook wrapper.
+rem Simple entry point that OpenClaude's command runner can execute on Windows.
+rem Delegates to SessionStart.ps1 which ensures the Antigravity proxy is running.
+
+powershell -NoProfile -ExecutionPolicy Bypass -File "%~dp0SessionStart.ps1"
+exit /b 0

package/vendor/openclaude-antigravity-provider/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "openclaude-antigravity-provider",
+  "version": "1.0.0",
+  "description": "Local OpenAI-compatible proxy that authenticates via Google Antigravity OAuth, enabling OpenClaude to use Claude Opus/Sonnet and Gemini models with your Google credentials.",
+  "module": "src/server.ts",
+  "type": "module",
+  "license": "MIT",
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "scripts": {
+    "start": "bun run src/server.ts",
+    "auth": "bun run src/auth-cli.ts",
+    "build": "bun build --compile src/server.ts --outfile bin/antigravity-proxy.exe",
+    "typecheck": "bun tsc --noEmit"
+  },
+  "dependencies": {
+    "open": "^10.1.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.6.0"
+  }
+}

package/vendor/openclaude-antigravity-provider/src/accounts.ts

@@ -0,0 +1,115 @@
+/**
+ * accounts.ts
+ * Multi-account manager with in-memory access token cache,
+ * automatic rate-limit rotation, and least-recently-used selection.
+ */
+
+import { loadAccounts, saveAccounts, type StoredAccount } from "./storage.ts";
+import { refreshAccessToken, accessTokenExpired } from "./auth.ts";
+
+interface CachedToken {
+  access: string;
+  expires: number;
+}
+
+// In-memory token cache — keyed by refreshToken string
+const tokenCache = new Map<string, CachedToken>();
+
+// ── Token retrieval with auto-refresh ─────────────────────────────────────────
+
+export async function getValidAccessToken(
+  account: StoredAccount,
+): Promise<string> {
+  const cached = tokenCache.get(account.refreshToken);
+  if (cached && !accessTokenExpired(cached.expires)) {
+    return cached.access;
+  }
+  const result = await refreshAccessToken(account.refreshToken);
+  tokenCache.set(account.refreshToken, result);
+  return result.access;
+}
+
+// ── Account selection (LRU, skips rate-limited/disabled) ─────────────────────
+
+export async function getAvailableAccount(): Promise<{
+  account: StoredAccount;
+  index: number;
+} | null> {
+  const data = await loadAccounts();
+  if (!data || data.accounts.length === 0) return null;
+
+  const now = Date.now();
+
+  const active = data.accounts
+    .map((acc, index) => ({ acc, index }))
+    .filter(({ acc }) => {
+      if (!acc.enabled) return false;
+      if (acc.rateLimitedUntil && acc.rateLimitedUntil > now) return false;
+      return true;
+    });
+
+  if (active.length === 0) {
+    // All limited — find the one whose limit expires soonest.
+    const soonest = data.accounts
+      .filter((a) => a.enabled && a.rateLimitedUntil)
+      .sort((a, b) => (a.rateLimitedUntil ?? 0) - (b.rateLimitedUntil ?? 0))[0];
+
+    if (soonest?.rateLimitedUntil) {
+      const waitMs = soonest.rateLimitedUntil - now;
+      // If the wait is short enough (<= 2 min), sleep and retry automatically
+      // instead of crashing — mirrors the opencode-antigravity-auth plugin behavior.
+      if (waitMs > 0 && waitMs <= 120_000) {
+        console.log(
+          `[antigravity-provider] All accounts rate-limited. Sleeping ${Math.ceil(waitMs / 1000)}s...`,
+        );
+        await new Promise<void>((r) => setTimeout(r, waitMs + 200)); // +200ms buffer
+        return getAvailableAccount(); // retry after sleep
+      }
+      const waitSec = Math.ceil(waitMs / 1000);
+      throw new Error(
+        `All accounts are rate-limited. Next available in ${waitSec}s.`,
+      );
+    }
+    return null;
+  }
+
+  // Pick least-recently-used
+  const best = active.sort(
+    (a, b) => (a.acc.lastUsed ?? 0) - (b.acc.lastUsed ?? 0),
+  )[0]!;
+
+  return { account: best.acc, index: best.index };
+}
+
+// ── Mark account rate-limited ─────────────────────────────────────────────────
+
+export async function markAccountRateLimited(
+  index: number,
+  retryAfterMs: number,
+): Promise<void> {
+  const data = await loadAccounts();
+  if (!data || !data.accounts[index]) return;
+  data.accounts[index]!.rateLimitedUntil = Date.now() + retryAfterMs;
+  tokenCache.delete(data.accounts[index]!.refreshToken);
+  await saveAccounts(data);
+}
+
+// ── Mark account as successfully used ────────────────────────────────────────
+
+export async function markAccountUsed(index: number): Promise<void> {
+  const data = await loadAccounts();
+  if (!data || !data.accounts[index]) return;
+  data.accounts[index]!.lastUsed = Date.now();
+  data.accounts[index]!.rateLimitedUntil = undefined;
+  await saveAccounts(data);
+}
+
+export async function getAccountCount(): Promise<number> {
+  const data = await loadAccounts();
+  return data?.accounts.length ?? 0;
+}
+
+export async function getAllAccounts(): Promise<StoredAccount[]> {
+  const data = await loadAccounts();
+  return data?.accounts ?? [];
+}

package/vendor/openclaude-antigravity-provider/src/auth-cli.ts

@@ -0,0 +1,125 @@
+/**
+ * auth-cli.ts
+ * Interactive first-time Google OAuth login for OpenClaude Antigravity Provider.
+ * Run: bun run src/auth-cli.ts
+ */
+
+import { loadAccounts, saveAccounts, type StoredAccount } from "./storage.ts";
+import {
+  buildAuthorizationUrl,
+  waitForOAuthCallback,
+  exchangeCodeForTokens,
+} from "./auth.ts";
+import { ACCOUNTS_FILE } from "./constants.ts";
+
+async function openBrowser(url: string): Promise<void> {
+  try {
+    if (process.platform === "win32") {
+      // cmd.exe splits URLs at '&' — use PowerShell Start-Process instead
+      // which correctly passes the full URL as a single string argument.
+      Bun.spawn(
+        ["powershell", "-NoProfile", "-NonInteractive", "-Command",
+          `Start-Process "${url.replace(/"/g, '`"')}"`,
+        ],
+        { stdout: "ignore", stderr: "ignore" },
+      );
+    } else if (process.platform === "darwin") {
+      Bun.spawn(["open", url], { stdout: "ignore", stderr: "ignore" });
+    } else {
+      Bun.spawn(["xdg-open", url], { stdout: "ignore", stderr: "ignore" });
+    }
+  } catch {
+    // Browser open failed — user will copy URL manually
+  }
+}
+
+async function main(): Promise<void> {
+  console.log("\n=== OpenClaude Antigravity Auth ===\n");
+
+  const existing = await loadAccounts();
+  if (existing && existing.accounts.length > 0) {
+    console.log(`Found ${existing.accounts.length} existing account(s):`);
+    for (const acc of existing.accounts) {
+      const status = acc.enabled ? "enabled" : "disabled";
+      console.log(`  - ${acc.email ?? "unknown"} [${status}]`);
+    }
+    console.log("\nAdding / re-authenticating...\n");
+  }
+
+  const { url, verifier, state } = await buildAuthorizationUrl();
+
+  console.log("Opening your browser for Google sign-in...");
+  console.log("If the browser does not open, paste this URL manually:\n");
+  console.log(url);
+  console.log();
+
+  await openBrowser(url);
+
+  console.log(
+    `Waiting for OAuth callback on http://localhost:51121/oauth-callback ...\n`,
+  );
+
+  let code: string;
+  try {
+    const result = await waitForOAuthCallback(state);
+    code = result.code;
+  } catch (err: unknown) {
+    console.error(
+      "OAuth callback failed:",
+      err instanceof Error ? err.message : String(err),
+    );
+    process.exit(1);
+  }
+
+  console.log("Exchanging authorization code for tokens...");
+
+  let tokens: Awaited<ReturnType<typeof exchangeCodeForTokens>>;
+  try {
+    tokens = await exchangeCodeForTokens(code, verifier);
+  } catch (err: unknown) {
+    console.error(
+      "Token exchange failed:",
+      err instanceof Error ? err.message : String(err),
+    );
+    process.exit(1);
+  }
+
+  const data = existing ?? { version: 1, accounts: [] as StoredAccount[], activeIndex: 0 };
+
+  // Update existing account if same email, otherwise add new
+  const existingIdx = tokens.email
+    ? data.accounts.findIndex((a) => a.email === tokens.email)
+    : -1;
+
+  const now = Date.now();
+  const newAccount: StoredAccount = {
+    email: tokens.email,
+    refreshToken: tokens.refresh_token,
+    addedAt: existingIdx >= 0 ? (data.accounts[existingIdx]!.addedAt) : now,
+    lastUsed: now,
+    enabled: true,
+  };
+
+  if (existingIdx >= 0) {
+    data.accounts[existingIdx] = newAccount;
+    console.log(`\nUpdated existing account: ${tokens.email ?? "unknown"}`);
+  } else {
+    data.accounts.push(newAccount);
+    console.log(`\nAdded new account: ${tokens.email ?? "unknown"}`);
+  }
+
+  await saveAccounts(data);
+
+  console.log(`\nAccounts saved to: ${ACCOUNTS_FILE}`);
+  console.log(`Total accounts: ${data.accounts.length}`);
+  console.log("\nStart the proxy server with:");
+  console.log("  bun run src/server.ts\n");
+}
+
+main().catch((err: unknown) => {
+  console.error(
+    "Fatal error:",
+    err instanceof Error ? err.message : String(err),
+  );
+  process.exit(1);
+});