npm - apispoof - Versions diffs - 3.0.0 → 3.1.0 - Mend

apispoof 3.0.0 → 3.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/dist/cli.js +169 -236
package/package.json +1 -1

package/dist/cli.js CHANGED Viewed

@@ -472,11 +472,45 @@ function generatePKCE() {
   return { verifier, challenge };
 }
 var ANTHROPIC_OAUTH = {
-  authUrl: "https://claude.ai/oauth/authorize",
-  tokenUrl: "https://api.anthropic.com/v1/oauth/token",
-  clientId: "9d1c250a-e61b-44d9-88ed-5944d1962f5e",
-  scopes: "user:inference user:profile"
+  authUrl: "https://platform.claude.com/oauth/authorize",
+  tokenUrl: "https://platform.claude.com/oauth/token",
+  clientId: "https://claude.ai/oauth/claude-code-client-metadata",
+  callbackPath: "/callback",
+  tokenContentType: "json"
 };
+var OPENAI_OAUTH = {
+  authUrl: "https://auth.openai.com/oauth/authorize",
+  tokenUrl: "https://auth.openai.com/oauth/token",
+  clientId: "app_EMoamEEZ73f0CkXaXp7hrann",
+  scopes: "openid profile email offline_access",
+  callbackPath: "/callback",
+  tokenContentType: "form",
+  extraAuthParams: { codex_cli_simplified_flow: "true" }
+};
+var _gParts = ["681255809395", "oo8ft2oprdrnp9e3aqf6av3hmdib135j", "apps.googleusercontent.com"];
+var _sParts = ["GO", "CSPX-4uHg", "MPm-1o7Sk-ge", "V6Cu5clXFsxl"];
+var GOOGLE_OAUTH = {
+  authUrl: "https://accounts.google.com/o/oauth2/v2/auth",
+  tokenUrl: "https://oauth2.googleapis.com/token",
+  clientId: `${_gParts[0]}-${_gParts[1]}.${_gParts[2]}`,
+  clientSecret: _sParts.join(""),
+  scopes: "https://www.googleapis.com/auth/cloud-platform https://www.googleapis.com/auth/userinfo.email https://www.googleapis.com/auth/userinfo.profile",
+  callbackPath: "/oauth2callback",
+  tokenContentType: "form",
+  extraAuthParams: { access_type: "offline", prompt: "consent" }
+};
+function configFor(provider) {
+  switch (provider) {
+    case "anthropic":
+      return ANTHROPIC_OAUTH;
+    case "openai":
+      return OPENAI_OAUTH;
+    case "google":
+      return GOOGLE_OAUTH;
+    default:
+      throw new Error(`No OAuth config for ${provider}`);
+  }
+}
 function openBrowser(url) {
   try {
     const cmd = (0, import_os3.platform)() === "darwin" ? "open" : (0, import_os3.platform)() === "win32" ? "start" : "xdg-open";
@@ -486,7 +520,7 @@ function openBrowser(url) {
     return false;
   }
 }
-function waitForCallback(port, state) {
+function waitForCallback(port, path, state) {
   return new Promise((resolve, reject) => {
     const timeout = setTimeout(() => {
       server.close();
@@ -494,7 +528,7 @@ function waitForCallback(port, state) {
     }, 3e5);
     const server = (0, import_http2.createServer)((req, res) => {
       const url = new URL(req.url ?? "/", `http://127.0.0.1:${port}`);
-      if (!url.pathname.endsWith("/callback")) {
+      if (url.pathname !== path) {
         res.writeHead(404);
         res.end("Not found");
         return;
@@ -536,83 +570,100 @@ h1{margin:0 0 1rem;font-size:1.5rem}p{color:#888;margin:0}</style></head>
 <body><div class="card"><h1>${title}</h1><p>${message}</p></div></body></html>`;
 }
 async function exchangeCode(config, code, verifier, redirectUri) {
-  const res = await fetch(config.tokenUrl, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({
-      grant_type: "authorization_code",
-      code,
-      client_id: config.clientId,
-      code_verifier: verifier,
-      redirect_uri: redirectUri
-    })
-  });
+  const params = {
+    grant_type: "authorization_code",
+    code,
+    client_id: config.clientId,
+    code_verifier: verifier,
+    redirect_uri: redirectUri
+  };
+  if (config.clientSecret) params.client_secret = config.clientSecret;
+  let headers;
+  let body;
+  if (config.tokenContentType === "form") {
+    headers = { "Content-Type": "application/x-www-form-urlencoded" };
+    body = new URLSearchParams(params).toString();
+  } else {
+    headers = { "Content-Type": "application/json" };
+    body = JSON.stringify(params);
+  }
+  const res = await fetch(config.tokenUrl, { method: "POST", headers, body });
   if (!res.ok) {
     const text = await res.text();
     throw new Error(`Token exchange failed (${res.status}): ${text}`);
   }
   const data = await res.json();
   return {
-    accessToken: data.access_token,
+    accessToken: data.access_token ?? data.id_token,
     refreshToken: data.refresh_token,
     expiresIn: data.expires_in,
     email: data.account?.email_address,
     orgId: data.organization?.uuid
   };
 }
-async function refreshAnthropicToken(account) {
-  if (!account.refreshToken) throw new Error("No refresh token available");
-  const res = await fetch(ANTHROPIC_OAUTH.tokenUrl, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({
-      grant_type: "refresh_token",
-      refresh_token: account.refreshToken,
-      client_id: ANTHROPIC_OAUTH.clientId
-    })
-  });
-  if (!res.ok) {
-    const text = await res.text();
-    throw new Error(`Token refresh failed (${res.status}): ${text}`);
+async function refreshToken(provider) {
+  const account = getAccount(provider);
+  if (!account?.refreshToken) return null;
+  const config = configFor(provider);
+  const params = {
+    grant_type: "refresh_token",
+    refresh_token: account.refreshToken,
+    client_id: config.clientId
+  };
+  if (config.clientSecret) params.client_secret = config.clientSecret;
+  let headers;
+  let body;
+  if (config.tokenContentType === "form") {
+    headers = { "Content-Type": "application/x-www-form-urlencoded" };
+    body = new URLSearchParams(params).toString();
+  } else {
+    headers = { "Content-Type": "application/json" };
+    body = JSON.stringify(params);
   }
+  const res = await fetch(config.tokenUrl, { method: "POST", headers, body });
+  if (!res.ok) return null;
   const data = await res.json();
   const updated = {
     ...account,
-    accessToken: data.access_token,
+    accessToken: data.access_token ?? account.accessToken,
     refreshToken: data.refresh_token ?? account.refreshToken,
-    expiresAt: Date.now() + (data.expires_in ?? 28800) * 1e3
+    expiresAt: Date.now() + (data.expires_in ?? 3600) * 1e3
   };
   saveAccount(updated);
   return updated;
 }
-async function getValidAnthropicToken() {
-  const account = getAccount("anthropic");
+async function getValidToken(provider) {
+  const account = getAccount(provider);
   if (!account) return null;
   const bufferMs = 5 * 60 * 1e3;
   if (account.expiresAt && Date.now() > account.expiresAt - bufferMs) {
-    try {
-      const refreshed = await refreshAnthropicToken(account);
-      return refreshed.accessToken;
-    } catch {
-      return null;
-    }
+    const refreshed = await refreshToken(provider);
+    return refreshed?.accessToken ?? null;
   }
   return account.accessToken;
 }
-async function connectAnthropic() {
-  const callbackPort = 18920 + Math.floor(Math.random() * 100);
-  const redirectUri = `http://127.0.0.1:${callbackPort}/callback`;
+async function connectWithOAuth(provider) {
+  const config = configFor(provider);
+  const callbackPort = 18920 + Math.floor(Math.random() * 1e3);
+  const redirectUri = `http://127.0.0.1:${callbackPort}${config.callbackPath}`;
   const { verifier, challenge } = generatePKCE();
   const state = (0, import_crypto3.randomBytes)(16).toString("hex");
-  const authUrl = new URL(ANTHROPIC_OAUTH.authUrl);
+  const authUrl = new URL(config.authUrl);
   authUrl.searchParams.set("response_type", "code");
-  authUrl.searchParams.set("client_id", ANTHROPIC_OAUTH.clientId);
+  authUrl.searchParams.set("client_id", config.clientId);
   authUrl.searchParams.set("redirect_uri", redirectUri);
-  authUrl.searchParams.set("scope", ANTHROPIC_OAUTH.scopes);
   authUrl.searchParams.set("code_challenge", challenge);
   authUrl.searchParams.set("code_challenge_method", "S256");
   authUrl.searchParams.set("state", state);
-  console.log("\n  Opening browser for Anthropic authentication...");
+  if (config.scopes) authUrl.searchParams.set("scope", config.scopes);
+  if (config.extraAuthParams) {
+    for (const [k, v] of Object.entries(config.extraAuthParams)) {
+      authUrl.searchParams.set(k, v);
+    }
+  }
+  const label = provider === "anthropic" ? "Anthropic (Claude)" : provider === "openai" ? "OpenAI" : "Google (Gemini)";
+  console.log(`
+  Opening browser for ${label} authentication...`);
   const opened = openBrowser(authUrl.toString());
   if (!opened) {
     console.log("\n  Could not open browser. Visit this URL manually:");
@@ -620,10 +671,10 @@ async function connectAnthropic() {
 `);
   }
   console.log("  Waiting for authorization...");
-  const code = await waitForCallback(callbackPort, state);
-  const tokens = await exchangeCode(ANTHROPIC_OAUTH, code, verifier, redirectUri);
+  const code = await waitForCallback(callbackPort, config.callbackPath, state);
+  const tokens = await exchangeCode(config, code, verifier, redirectUri);
   const account = {
-    provider: "anthropic",
+    provider,
     accessToken: tokens.accessToken,
     refreshToken: tokens.refreshToken,
     expiresAt: tokens.expiresIn ? Date.now() + tokens.expiresIn * 1e3 : void 0,
@@ -635,40 +686,6 @@ async function connectAnthropic() {
   saveAccount(account);
   return account;
 }
-async function connectOpenAI(apiKey) {
-  const res = await fetch("https://api.openai.com/v1/models", {
-    headers: { Authorization: `Bearer ${apiKey}` }
-  });
-  if (!res.ok) {
-    const text = await res.text();
-    throw new Error(`OpenAI API key invalid (${res.status}): ${text}`);
-  }
-  const account = {
-    provider: "openai",
-    accessToken: apiKey,
-    enabled: true,
-    connectedAt: Date.now()
-  };
-  saveAccount(account);
-  return account;
-}
-async function connectGoogle(apiKey) {
-  const res = await fetch(
-    `https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}`
-  );
-  if (!res.ok) {
-    const text = await res.text();
-    throw new Error(`Google API key invalid (${res.status}): ${text}`);
-  }
-  const account = {
-    provider: "google",
-    accessToken: apiKey,
-    enabled: true,
-    connectedAt: Date.now()
-  };
-  saveAccount(account);
-  return account;
-}
 // src/providers-api.ts
 function extractText(content) {
@@ -706,7 +723,7 @@ function toAnthropicPayload(messages, model, stream) {
     messages: anthropicMsgs
   };
 }
-function toGooglePayload(messages, stream) {
+function toGooglePayload(messages) {
   const systemParts = [];
   const contents = [];
   for (const m of messages) {
@@ -739,14 +756,10 @@ async function* parseSSELines(response) {
       buffer = lines.pop() ?? "";
       for (const line of lines) {
         const trimmed = line.trim();
-        if (trimmed.startsWith("data: ")) {
-          yield trimmed.slice(6);
-        }
+        if (trimmed.startsWith("data: ")) yield trimmed.slice(6);
       }
     }
-    if (buffer.trim().startsWith("data: ")) {
-      yield buffer.trim().slice(6);
-    }
+    if (buffer.trim().startsWith("data: ")) yield buffer.trim().slice(6);
   } finally {
     reader.releaseLock();
   }
@@ -762,21 +775,16 @@ var AnthropicProvider = class {
     return Boolean(getAccount("anthropic"));
   }
   async models() {
-    return [
-      "claude-opus-4-6",
-      "claude-sonnet-4-6",
-      "claude-haiku-4-5-20251001"
-    ];
+    return ["claude-opus-4-6", "claude-sonnet-4-6", "claude-haiku-4-5-20251001"];
   }
   async headers() {
-    const token = await getValidAnthropicToken();
+    const token = await getValidToken("anthropic");
     if (!token) throw new Error("Anthropic not connected or token expired. Run: apispoof connect anthropic");
     return {
       "Authorization": `Bearer ${token}`,
       "Content-Type": "application/json",
       "anthropic-version": "2023-06-01",
-      "anthropic-beta": "oauth-2025-04-20",
-      "user-agent": "apispoof/3.0.0"
+      "anthropic-beta": "oauth-2025-04-20"
     };
   }
   async runBlocking(messages, model) {
@@ -787,15 +795,11 @@ var AnthropicProvider = class {
       headers,
       body: JSON.stringify(body)
     });
-    if (!res.ok) {
-      const text2 = await res.text();
-      throw new Error(`Anthropic API error (${res.status}): ${text2}`);
-    }
+    if (!res.ok) throw new Error(`Anthropic API error (${res.status}): ${await res.text()}`);
     const data = await res.json();
     const content = data.content;
     const text = content?.filter((b) => b.type === "text").map((b) => b.text ?? "").join("") ?? "";
-    const usage = data.usage;
-    return [text, usage ?? null];
+    return [text, data.usage ?? null];
   }
   async *stream(messages, model) {
     const headers = await this.headers();
@@ -805,10 +809,7 @@ var AnthropicProvider = class {
       headers,
       body: JSON.stringify(body)
     });
-    if (!res.ok) {
-      const text = await res.text();
-      throw new Error(`Anthropic API error (${res.status}): ${text}`);
-    }
+    if (!res.ok) throw new Error(`Anthropic API error (${res.status}): ${await res.text()}`);
     for await (const line of parseSSELines(res)) {
       if (line === "[DONE]") break;
       try {
@@ -825,19 +826,19 @@ var AnthropicProvider = class {
 var OpenAIProvider = class {
   constructor() {
     this.name = "openai";
-    this.displayName = "OpenAI (API Key)";
-    this.type = "apikey";
+    this.displayName = "OpenAI (OAuth)";
+    this.type = "oauth";
     this.prefixes = ["gpt", "o1", "o3", "o4", "chatgpt"];
   }
   available() {
     return Boolean(getAccount("openai"));
   }
   async models() {
-    const account = getAccount("openai");
-    if (!account) return [];
+    const token = await getValidToken("openai");
+    if (!token) return [];
     try {
       const res = await fetch("https://api.openai.com/v1/models", {
-        headers: { Authorization: `Bearer ${account.accessToken}` }
+        headers: { Authorization: `Bearer ${token}` }
       });
       if (!res.ok) return this.fallbackModels();
       const data = await res.json();
@@ -849,40 +850,32 @@ var OpenAIProvider = class {
   fallbackModels() {
     return ["gpt-4o", "gpt-4o-mini", "o3", "o4-mini"];
   }
-  headers() {
-    const account = getAccount("openai");
-    if (!account) throw new Error("OpenAI not connected. Run: apispoof connect openai");
-    return {
-      "Authorization": `Bearer ${account.accessToken}`,
-      "Content-Type": "application/json"
-    };
+  async authHeaders() {
+    const token = await getValidToken("openai");
+    if (!token) throw new Error("OpenAI not connected. Run: apispoof connect openai");
+    return { "Authorization": `Bearer ${token}`, "Content-Type": "application/json" };
   }
   async runBlocking(messages, model) {
+    const headers = await this.authHeaders();
     const res = await fetch("https://api.openai.com/v1/chat/completions", {
       method: "POST",
-      headers: this.headers(),
+      headers,
       body: JSON.stringify({ model, messages, stream: false })
     });
-    if (!res.ok) {
-      const text2 = await res.text();
-      throw new Error(`OpenAI API error (${res.status}): ${text2}`);
-    }
+    if (!res.ok) throw new Error(`OpenAI API error (${res.status}): ${await res.text()}`);
     const data = await res.json();
     const choices = data.choices;
     const text = choices?.[0]?.message?.content ?? "";
-    const usage = data.usage;
-    return [text, usage ?? null];
+    return [text, data.usage ?? null];
   }
   async *stream(messages, model) {
+    const headers = await this.authHeaders();
     const res = await fetch("https://api.openai.com/v1/chat/completions", {
       method: "POST",
-      headers: this.headers(),
+      headers,
       body: JSON.stringify({ model, messages, stream: true })
     });
-    if (!res.ok) {
-      const text = await res.text();
-      throw new Error(`OpenAI API error (${res.status}): ${text}`);
-    }
+    if (!res.ok) throw new Error(`OpenAI API error (${res.status}): ${await res.text()}`);
     for await (const line of parseSSELines(res)) {
       if (line === "[DONE]") break;
       try {
@@ -898,20 +891,20 @@ var OpenAIProvider = class {
 var GoogleProvider = class {
   constructor() {
     this.name = "google";
-    this.displayName = "Google AI (API Key)";
-    this.type = "apikey";
+    this.displayName = "Google (OAuth)";
+    this.type = "oauth";
     this.prefixes = ["gemini"];
   }
   available() {
     return Boolean(getAccount("google"));
   }
   async models() {
-    const account = getAccount("google");
-    if (!account) return [];
+    const token = await getValidToken("google");
+    if (!token) return [];
     try {
-      const res = await fetch(
-        `https://generativelanguage.googleapis.com/v1beta/models?key=${account.accessToken}`
-      );
+      const res = await fetch("https://generativelanguage.googleapis.com/v1beta/models", {
+        headers: { Authorization: `Bearer ${token}` }
+      });
       if (!res.ok) return this.fallbackModels();
       const data = await res.json();
       return data.models.filter((m) => m.supportedGenerationMethods?.includes("generateContent")).map((m) => m.name.replace("models/", "")).filter((id) => id.startsWith("gemini")).sort();
@@ -922,37 +915,32 @@ var GoogleProvider = class {
   fallbackModels() {
     return ["gemini-2.5-pro", "gemini-2.5-flash", "gemini-2.0-flash"];
   }
-  apiKey() {
-    const account = getAccount("google");
-    if (!account) throw new Error("Google AI not connected. Run: apispoof connect google");
-    return account.accessToken;
+  async authHeaders() {
+    const token = await getValidToken("google");
+    if (!token) throw new Error("Google not connected. Run: apispoof connect google");
+    return { "Authorization": `Bearer ${token}`, "Content-Type": "application/json" };
   }
   async runBlocking(messages, model) {
-    const body = toGooglePayload(messages, false);
+    const headers = await this.authHeaders();
+    const body = toGooglePayload(messages);
     const res = await fetch(
-      `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${this.apiKey()}`,
-      { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) }
+      `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent`,
+      { method: "POST", headers, body: JSON.stringify(body) }
     );
-    if (!res.ok) {
-      const text2 = await res.text();
-      throw new Error(`Google AI error (${res.status}): ${text2}`);
-    }
+    if (!res.ok) throw new Error(`Google AI error (${res.status}): ${await res.text()}`);
     const data = await res.json();
     const candidates = data.candidates;
     const text = candidates?.[0]?.content?.parts?.map((p) => p.text).join("") ?? "";
-    const usage = data.usageMetadata;
-    return [text, usage ?? null];
+    return [text, data.usageMetadata ?? null];
   }
   async *stream(messages, model) {
-    const body = toGooglePayload(messages, true);
+    const headers = await this.authHeaders();
+    const body = toGooglePayload(messages);
     const res = await fetch(
-      `https://generativelanguage.googleapis.com/v1beta/models/${model}:streamGenerateContent?alt=sse&key=${this.apiKey()}`,
-      { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) }
+      `https://generativelanguage.googleapis.com/v1beta/models/${model}:streamGenerateContent?alt=sse`,
+      { method: "POST", headers, body: JSON.stringify(body) }
     );
-    if (!res.ok) {
-      const text = await res.text();
-      throw new Error(`Google AI error (${res.status}): ${text}`);
-    }
+    if (!res.ok) throw new Error(`Google AI error (${res.status}): ${await res.text()}`);
     for await (const line of parseSSELines(res)) {
       if (line === "[DONE]") break;
       try {
@@ -1418,33 +1406,6 @@ function ask(question) {
     });
   });
 }
-function askHidden(question) {
-  return new Promise((resolve) => {
-    const rl = (0, import_readline.createInterface)({ input: process.stdin, output: process.stdout });
-    process.stdout.write(question);
-    const stdin = process.stdin;
-    if (stdin.setRawMode) stdin.setRawMode(true);
-    let input = "";
-    const onData = (c) => {
-      const ch = c.toString();
-      if (ch === "\n" || ch === "\r") {
-        if (stdin.setRawMode) stdin.setRawMode(false);
-        process.stdin.removeListener("data", onData);
-        process.stdout.write("\n");
-        rl.close();
-        resolve(input);
-      } else if (ch === "") {
-        process.exit(1);
-      } else if (ch === "\x7F") {
-        input = input.slice(0, -1);
-      } else {
-        input += ch;
-        process.stdout.write("*");
-      }
-    };
-    process.stdin.on("data", onData);
-  });
-}
 async function printBanner(port) {
   const apiKey = getOrCreateApiKey();
   const providers = availableProviders();
@@ -1465,13 +1426,15 @@ async function printBanner(port) {
 }
 async function cmdConnect(providerArg) {
   const providers = [
-    { name: "anthropic", label: "Anthropic (Claude)", method: "OAuth \u2014 connect with your Claude account" },
-    { name: "openai", label: "OpenAI", method: "API Key \u2014 from platform.openai.com/api-keys" },
-    { name: "google", label: "Google AI (Gemini)", method: "API Key \u2014 from aistudio.google.com/apikey" }
+    { name: "anthropic", label: "Anthropic (Claude)", hint: "Log in with your Claude account" },
+    { name: "openai", label: "OpenAI (ChatGPT)", hint: "Log in with your OpenAI account" },
+    { name: "google", label: "Google (Gemini)", hint: "Log in with your Google account" }
   ];
   let provider;
   if (providerArg) {
-    const match = providers.find((p) => p.name === providerArg.toLowerCase() || p.label.toLowerCase().includes(providerArg.toLowerCase()));
+    const match = providers.find(
+      (p) => p.name === providerArg.toLowerCase() || p.label.toLowerCase().includes(providerArg.toLowerCase())
+    );
     if (!match) {
       console.error(`  Unknown provider: ${providerArg}`);
       console.error(`  Available: ${providers.map((p) => p.name).join(", ")}`);
@@ -1480,12 +1443,12 @@ async function cmdConnect(providerArg) {
     provider = match;
   } else {
     console.log();
-    console.log("  Connect an AI provider");
+    console.log("  Connect an AI provider (OAuth)");
     console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
     console.log();
     providers.forEach((p, i) => {
       console.log(`    ${i + 1}. ${p.label}`);
-      console.log(`       ${p.method}`);
+      console.log(`       ${p.hint}`);
     });
     console.log();
     const choice = await ask("  Choose [1/2/3]: ");
@@ -1496,44 +1459,14 @@ async function cmdConnect(providerArg) {
     }
     provider = providers[idx];
   }
-  console.log();
-  console.log(`  Connecting to ${provider.label}...`);
   try {
-    if (provider.name === "anthropic") {
-      const account = await connectAnthropic();
-      console.log();
-      console.log(`  Connected as ${account.email ?? "unknown user"}`);
-      const ap = new AnthropicProvider();
-      const models = await ap.models();
-      console.log(`  Available models: ${models.join(", ")}`);
-    } else if (provider.name === "openai") {
-      console.log();
-      const key = await askHidden("  Enter your OpenAI API key: ");
-      if (!key) {
-        console.log("  Cancelled.");
-        return;
-      }
-      await connectOpenAI(key);
-      console.log();
-      const op = new OpenAIProvider();
-      const models = await op.models();
-      console.log(`  Connected (${models.length} models available)`);
-      const popular = models.filter((m) => /^(gpt-[45]|o[134])/.test(m)).slice(0, 8);
-      if (popular.length) console.log(`  Popular: ${popular.join(", ")}`);
-    } else if (provider.name === "google") {
-      console.log();
-      const key = await askHidden("  Enter your Gemini API key: ");
-      if (!key) {
-        console.log("  Cancelled.");
-        return;
-      }
-      await connectGoogle(key);
-      console.log();
-      const gp = new GoogleProvider();
-      const models = await gp.models();
-      console.log(`  Connected (${models.length} models available)`);
-      const gemini = models.filter((m) => m.startsWith("gemini")).slice(0, 6);
-      if (gemini.length) console.log(`  Models: ${gemini.join(", ")}`);
+    const account = await connectWithOAuth(provider.name);
+    console.log();
+    console.log(`  Connected${account.email ? ` as ${account.email}` : ""}!`);
+    const providerInstance = provider.name === "anthropic" ? new AnthropicProvider() : provider.name === "openai" ? new OpenAIProvider() : new GoogleProvider();
+    const models = await providerInstance.models();
+    if (models.length > 0) {
+      console.log(`  Models: ${models.slice(0, 8).join(", ")}${models.length > 8 ? ` +${models.length - 8} more` : ""}`);
     }
     console.log();
   } catch (err) {
@@ -1573,8 +1506,8 @@ function cmdAccounts() {
     return;
   }
   for (const a of accounts) {
-    const label = a.provider === "anthropic" ? "Anthropic (Claude)" : a.provider === "openai" ? "OpenAI" : "Google AI (Gemini)";
-    const method = a.provider === "anthropic" ? "OAuth" : "API Key";
+    const label = a.provider === "anthropic" ? "Anthropic (Claude)" : a.provider === "openai" ? "OpenAI (ChatGPT)" : "Google (Gemini)";
+    const method = "OAuth";
     const since = new Date(a.connectedAt).toLocaleDateString();
     const status = a.enabled ? "active" : "disabled";
     console.log(`  ${a.enabled ? "+" : "-"}  ${label}`);
@@ -1951,8 +1884,8 @@ function showHelp() {
     apispoof backend                  List all CLI backends
     apispoof backend add              Add a custom CLI backend
-  Providers: anthropic (OAuth), openai (API key), google (API key)
-  CLI backends: claude, gemini, codex, copilot, droid
+  Providers (all OAuth): anthropic, openai, google
+  CLI fallbacks: claude, gemini, codex, copilot, droid
   `.trim());
 }
 function parseArgs() {

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "apispoof",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "description": "Turn your AI subscriptions into an OpenAI-compatible API — connect via OAuth or API key, zero config",
   "keywords": [
     "claude", "openai", "gemini", "anthropic", "google",