ampcode-connector 0.1.0 → 0.1.2

package/README.md

@@ -0,0 +1,97 @@
+# ampcode-connector
+
+Stop burning AmpCode credits. Route [AmpCode](https://ampcode.com) through your **existing** Claude Code, Codex CLI & Gemini CLI subscriptions — for free.
+
+![demo](demo.gif)
+
+```
+AmpCode → ampcode-connector → Claude Code      (free)
+                             → OpenAI Codex CLI (free)
+                             → Gemini CLI       (free)
+                             → AmpCode upstream (paid, last resort)
+```
+
+## Supported Providers
+
+| Provider | Models | How |
+|----------|--------|-----|
+| **Claude Code** | Opus 4, Sonnet 4, Haiku | Anthropic OAuth |
+| **OpenAI Codex CLI** | GPT-5, o3, Codex | OpenAI OAuth |
+| **Gemini CLI** | Gemini Pro, Flash | Google OAuth (dual: Gemini + Vertex pools) |
+
+> **Multi-account** — log in multiple times per provider to multiply your quota.
+
+## Quick Start
+
+Three commands. That's it.
+
+```bash
+bunx ampcode-connector setup    # point AmpCode → proxy
+bunx ampcode-connector login    # authenticate providers (browser OAuth)
+bunx ampcode-connector          # start proxy
+```
+
+<details>
+<summary>Or clone & run locally</summary>
+
+```bash
+git clone https://github.com/nghyane/ampcode-connector.git
+cd ampcode-connector
+bun install
+
+bun run setup
+bun run login
+bun start
+```
+
+</details>
+
+Requires [Bun](https://bun.sh) 1.3+.
+
+### Provider Login
+
+```bash
+bunx ampcode-connector login              # interactive TUI (↑↓ navigate, enter to login, d to disconnect)
+bunx ampcode-connector login anthropic    # Claude Code
+bunx ampcode-connector login codex        # OpenAI Codex CLI
+bunx ampcode-connector login google       # Gemini CLI + Antigravity
+```
+
+Each login opens your browser. Log in multiple times to stack accounts.
+
+## How It Works
+
+```
+Request in → local OAuth available? → yes → forward to provider API (free)
+                                    → no  → forward to ampcode.com  (paid)
+
+On 429 → retry with different account/pool
+On 401 → fallback to AmpCode upstream
+```
+
+Non-AI routes (auth, threads, telemetry) pass through to `ampcode.com` transparently — the proxy is invisible to AmpCode.
+
+### Smart Routing
+
+- **Thread affinity** — same thread sticks to the same account for consistency
+- **Least-connections** — new threads go to the least-loaded account
+- **Cooldown** — rate-limited accounts are temporarily skipped
+- **Google cascade** — Gemini → Antigravity (separate quota pools, double the free tier)
+
+## Configuration
+
+Edit [`config.yaml`](config.yaml) to change port, log level, or toggle providers.
+
+Amp API key resolution: `config.yaml` → `AMP_API_KEY` env → `~/.local/share/amp/secrets.json`.
+
+## Development
+
+```bash
+bun run dev        # --watch mode
+bun test           # run tests
+bun run check      # lint + typecheck + test
+```
+
+## License
+
+[MIT](LICENSE)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ampcode-connector",
-  "version": "0.1.0",
-  "description": "Proxy Amp CLI through local OAuth subscriptions (Claude Code, Codex, Gemini CLI, Antigravity)",
+  "version": "0.1.2",
+  "description": "Proxy AmpCode through local OAuth subscriptions (Claude Code, Codex, Gemini CLI, Antigravity)",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/index.ts

@@ -42,6 +42,10 @@ async function main(): Promise<void> {
   const config = await loadConfig();
   setLogLevel(config.logLevel);
   startServer(config);
+
+  // Non-blocking update check — runs in background after server starts
+  const { checkForUpdates } = await import("./utils/update-check.ts");
+  checkForUpdates();
 }
 
 function usage(): void {

package/src/routing/affinity.ts

@@ -1,5 +1,7 @@
-/** Thread → (quotaPool, account) affinity map.
- *  Ensures a thread sticks to the same account for session consistency. */
+/** Thread+provider → (quotaPool, account) affinity map.
+ *  Ensures a thread sticks to the same account per provider for session consistency.
+ *  Key is composite (threadId, ampProvider) so a single thread can hold
+ *  independent affinities for different providers (e.g. anthropic AND google). */
 
 import type { QuotaPool } from "./cooldown.ts";
 
@@ -16,23 +18,29 @@ const CLEANUP_INTERVAL_MS = 10 * 60_000;
 
 const map = new Map<string, AffinityEntry>();
 
-export function get(threadId: string): AffinityEntry | undefined {
-  const entry = map.get(threadId);
+function key(threadId: string, ampProvider: string): string {
+  return `${threadId}\0${ampProvider}`;
+}
+
+export function get(threadId: string, ampProvider: string): AffinityEntry | undefined {
+  const entry = map.get(key(threadId, ampProvider));
   if (!entry) return undefined;
   if (Date.now() - entry.assignedAt > TTL_MS) {
-    map.delete(threadId);
+    map.delete(key(threadId, ampProvider));
     return undefined;
   }
+  // Touch: keep affinity alive while thread is active
+  entry.assignedAt = Date.now();
   return entry;
 }
 
-export function set(threadId: string, pool: QuotaPool, account: number): void {
-  map.set(threadId, { pool, account, assignedAt: Date.now() });
+export function set(threadId: string, ampProvider: string, pool: QuotaPool, account: number): void {
+  map.set(key(threadId, ampProvider), { pool, account, assignedAt: Date.now() });
 }
 
 /** Break affinity when account is exhausted — allow re-routing. */
-export function clear(threadId: string): void {
-  map.delete(threadId);
+export function clear(threadId: string, ampProvider: string): void {
+  map.delete(key(threadId, ampProvider));
 }
 
 /** Count active threads pinned to a specific (pool, account). */
@@ -50,7 +58,7 @@ export function activeCount(pool: QuotaPool, account: number): number {
 /** Periodic cleanup of expired entries. */
 setInterval(() => {
   const now = Date.now();
-  for (const [threadId, entry] of map) {
-    if (now - entry.assignedAt > TTL_MS) map.delete(threadId);
+  for (const [k, entry] of map) {
+    if (now - entry.assignedAt > TTL_MS) map.delete(k);
   }
 }, CLEANUP_INTERVAL_MS);

package/src/routing/router.ts

@@ -44,9 +44,9 @@ export function routeRequest(
 ): RouteResult {
   const modelStr = model ?? "unknown";
 
-  // Check thread affinity first
+  // Check thread affinity (keyed by threadId + ampProvider)
   if (threadId) {
-    const pinned = affinity.get(threadId);
+    const pinned = affinity.get(threadId, ampProvider);
     if (pinned && !cooldown.isExhausted(pinned.pool, pinned.account)) {
       const handler = providerForPool(pinned.pool);
       if (handler && handler.isAvailable(pinned.account)) {
@@ -58,7 +58,7 @@ export function routeRequest(
       }
     }
     // Affinity broken (exhausted / unavailable) — clear and re-route
-    if (pinned) affinity.clear(threadId);
+    if (pinned) affinity.clear(threadId, ampProvider);
   }
 
   // Build candidate list
@@ -76,7 +76,7 @@ export function routeRequest(
   }
 
   // Pin thread affinity
-  if (threadId) affinity.set(threadId, picked.pool, picked.account);
+  if (threadId) affinity.set(threadId, ampProvider, picked.pool, picked.account);
 
   logger.route(picked.provider.routeDecision, ampProvider, modelStr);
   return result(picked.provider, ampProvider, modelStr, picked.account, picked.pool);
@@ -96,7 +96,7 @@ export function rerouteAfter429(
 
   // If exhausted, break thread affinity
   if (threadId && cooldown.isExhausted(failedPool, failedAccount)) {
-    affinity.clear(threadId);
+    affinity.clear(threadId, ampProvider);
   }
 
   const modelStr = model ?? "unknown";
@@ -105,7 +105,7 @@ export function rerouteAfter429(
 
   if (!picked) return null;
 
-  if (threadId) affinity.set(threadId, picked.pool, picked.account);
+  if (threadId) affinity.set(threadId, ampProvider, picked.pool, picked.account);
   logger.route(picked.provider.routeDecision, ampProvider, modelStr);
   return result(picked.provider, ampProvider, modelStr, picked.account, picked.pool);
 }

package/src/server/server.ts

@@ -10,6 +10,8 @@ import * as path from "../utils/path.ts";
 
 /** Max 429-reroute attempts before falling back to upstream. */
 const MAX_REROUTE_ATTEMPTS = 4;
+/** Max seconds to wait-and-retry on the same account (preserves prompt cache). */
+const CACHE_PRESERVE_WAIT_MAX_S = 10;
 
 export function startServer(config: ProxyConfig): ReturnType<typeof Bun.serve> {
   const server = Bun.serve({
@@ -74,17 +76,37 @@ async function handleProvider(
   const model = path.model(body) ?? path.modelFromUrl(sub);
   let route = routeRequest(providerName, model, config, threadId);
 
-  logger.info(`ROUTE ${route.decision} provider=${providerName} model=${model ?? "?"} account=${route.account} sub=${sub}`);
+  logger.info(
+    `ROUTE ${route.decision} provider=${providerName} model=${model ?? "?"} account=${route.account} sub=${sub}`,
+  );
 
   if (route.handler) {
     const rewrite = model ? rewriter.rewrite(model) : undefined;
     const response = await route.handler.forward(sub, body, req.headers, rewrite, route.account);
 
-    // 429 → attempt reroute to different account/pool
+    // 429 → try to preserve prompt cache by waiting briefly on same account,
+    // then fall back to rerouting to a different account/pool.
     if (response.status === 429 && route.pool) {
       const retryAfter = parseRetryAfter(response.headers.get("retry-after"));
       logger.warn(`429 from ${route.decision} account=${route.account}`, { retryAfter });
 
+      // Short burst: wait and retry same account to preserve prompt cache
+      if (retryAfter !== undefined && retryAfter <= CACHE_PRESERVE_WAIT_MAX_S) {
+        logger.debug(`Waiting ${retryAfter}s to preserve prompt cache on account=${route.account}`);
+        await Bun.sleep(retryAfter * 1000);
+        const retryResponse = await route.handler.forward(sub, body, req.headers, rewrite, route.account);
+        if (retryResponse.status !== 429 && retryResponse.status !== 401) {
+          recordSuccess(route.pool, route.account);
+          return retryResponse;
+        }
+        // Still failing — fall through to reroute
+        if (retryResponse.status === 429) {
+          const nextRetryAfter = parseRetryAfter(retryResponse.headers.get("retry-after"));
+          record429(route.pool, route.account, nextRetryAfter);
+        }
+      }
+
+      // Reroute to different account/pool (cache loss accepted)
       for (let attempt = 0; attempt < MAX_REROUTE_ATTEMPTS; attempt++) {
         const next = rerouteAfter429(providerName, model, config, route.pool, route.account, retryAfter, threadId);
         if (!next) break;

package/src/utils/update-check.ts

@@ -0,0 +1,46 @@
+/** Check npm registry for newer versions on startup. */
+
+import { s, line } from "../cli/ansi.ts";
+
+const PACKAGE_NAME = "ampcode-connector";
+const REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+const TIMEOUT_MS = 3_000;
+
+function currentVersion(): string {
+  // Read from package.json at import time
+  const pkg = require("../../package.json");
+  return pkg.version;
+}
+
+async function fetchLatestVersion(): Promise<string | null> {
+  try {
+    const res = await fetch(REGISTRY_URL, {
+      signal: AbortSignal.timeout(TIMEOUT_MS),
+    });
+    if (!res.ok) return null;
+    const data = (await res.json()) as { version: string };
+    return data.version;
+  } catch {
+    return null;
+  }
+}
+
+function isNewer(latest: string, current: string): boolean {
+  const parse = (v: string) => v.split(".").map(Number);
+  const [la, lb, lc] = parse(latest);
+  const [ca, cb, cc] = parse(current);
+  return la > ca || (la === ca && lb > cb) || (la === ca && lb === cb && lc > cc);
+}
+
+/** Non-blocking update check — logs a notice if a newer version exists. */
+export async function checkForUpdates(): Promise<void> {
+  const current = currentVersion();
+  const latest = await fetchLatestVersion();
+
+  if (!latest || !isNewer(latest, current)) return;
+
+  line();
+  line(`${s.yellow}⬆ Update available${s.reset}  ${s.dim}${current}${s.reset} → ${s.green}${latest}${s.reset}`);
+  line(`  Run ${s.cyan}bunx ampcode-connector@latest${s.reset} to update`);
+  line();
+}