@kenkaiiii/gg-core 5.92.0 → 5.94.0

package/dist/{chunk-SDUIKPGO.js → chunk-JLEBGMG4.js}

@@ -1,6 +1,6 @@
 import {
   getAppPaths
-} from "./chunk-2X5L6U4Z.js";
+} from "./chunk-GXOFTHM5.js";
 
 // src/oauth/kimi.ts
 import { execFileSync } from "child_process";
@@ -230,141 +230,539 @@ async function refreshKimiToken(refreshToken) {
 }
 
 // src/auth-storage.ts
-import fs3 from "fs/promises";
+import fs5 from "fs/promises";
 import { readFileSync as readFileSync2 } from "fs";
 import crypto5 from "crypto";
 
-// src/oauth/anthropic.ts
+// src/claude-code/runtime.ts
+import { spawn } from "child_process";
 import crypto2 from "crypto";
+import fs2 from "fs";
+import fsp2 from "fs/promises";
+import path2 from "path";
 
-// src/oauth/pkce.ts
-function base64urlEncode(bytes) {
-  let binary = "";
-  for (const byte of bytes) {
-    binary += String.fromCharCode(byte);
+// src/claude-code/tar.ts
+import fs from "fs";
+import fsp from "fs/promises";
+import zlib from "zlib";
+var BLOCK = 512;
+function readString(buf, offset, length) {
+  const end = buf.indexOf(0, offset);
+  return buf.toString("utf8", offset, end === -1 || end > offset + length ? offset + length : end);
+}
+function readSize(buf, offset) {
+  if (buf[offset] & 128) {
+    let value = buf[offset] & 127;
+    for (let i = 1; i < 12; i++) value = value * 256 + buf[offset + i];
+    return value;
+  }
+  const text = readString(buf, offset, 12).trim();
+  return text ? parseInt(text, 8) : 0;
+}
+function paxPath(data) {
+  let pos = 0;
+  while (pos < data.length) {
+    const space = data.indexOf(32, pos);
+    if (space === -1) break;
+    const len = parseInt(data.toString("utf8", pos, space), 10);
+    if (!Number.isFinite(len) || len <= 0) break;
+    const record = data.toString("utf8", space + 1, pos + len - 1);
+    const eq = record.indexOf("=");
+    if (eq !== -1 && record.slice(0, eq) === "path") return record.slice(eq + 1);
+    pos += len;
   }
-  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+  return void 0;
 }
-async function generatePKCE() {
-  const verifierBytes = new Uint8Array(32);
-  crypto.getRandomValues(verifierBytes);
-  const verifier = base64urlEncode(verifierBytes);
-  const data = new TextEncoder().encode(verifier);
-  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
-  const challenge = base64urlEncode(new Uint8Array(hashBuffer));
-  return { verifier, challenge };
+async function extractFileFromTarGz(tgzPath, entryName, destPath) {
+  const input = fs.createReadStream(tgzPath).pipe(zlib.createGunzip());
+  let pending = Buffer.alloc(0);
+  let remaining = 0;
+  let padding = 0;
+  let kind = "skip";
+  let meta = [];
+  let overridePath;
+  let out;
+  let found = false;
+  try {
+    for await (const chunk of input) {
+      pending = pending.length ? Buffer.concat([pending, chunk]) : chunk;
+      let pos = 0;
+      while (pos < pending.length) {
+        if (remaining > 0) {
+          const take = Math.min(remaining, pending.length - pos);
+          const slice = pending.subarray(pos, pos + take);
+          if (kind === "target") await out.write(slice);
+          else if (kind === "pax" || kind === "longname") meta.push(Buffer.from(slice));
+          pos += take;
+          remaining -= take;
+          if (remaining === 0) {
+            if (kind === "target") {
+              await out.close();
+              out = void 0;
+              found = true;
+            } else if (kind === "pax") {
+              overridePath = paxPath(Buffer.concat(meta)) ?? overridePath;
+            } else if (kind === "longname") {
+              overridePath = readString(Buffer.concat(meta), 0, Number.MAX_SAFE_INTEGER);
+            }
+          }
+          continue;
+        }
+        if (padding > 0) {
+          const skip = Math.min(padding, pending.length - pos);
+          pos += skip;
+          padding -= skip;
+          continue;
+        }
+        if (found) break;
+        if (pending.length - pos < BLOCK) break;
+        const header = pending.subarray(pos, pos + BLOCK);
+        pos += BLOCK;
+        if (header.every((b) => b === 0)) continue;
+        const size = readSize(header, 124);
+        const type2 = String.fromCharCode(header[156] || 48);
+        let name = readString(header, 0, 100);
+        if (readString(header, 257, 6) === "ustar") {
+          const prefix = readString(header, 345, 155);
+          if (prefix) name = `${prefix}/${name}`;
+        }
+        remaining = size;
+        padding = (BLOCK - size % BLOCK) % BLOCK;
+        meta = [];
+        if (type2 === "x") kind = "pax";
+        else if (type2 === "L") kind = "longname";
+        else {
+          const path4 = overridePath ?? name;
+          overridePath = void 0;
+          if ((type2 === "0" || type2 === "\0" || type2 === "7") && path4 === entryName) {
+            kind = "target";
+            out = await fsp.open(destPath, "w", 493);
+            if (size === 0) {
+              await out.close();
+              out = void 0;
+              found = true;
+            }
+          } else {
+            kind = "skip";
+          }
+        }
+      }
+      pending = pos < pending.length ? Buffer.from(pending.subarray(pos)) : Buffer.alloc(0);
+      if (found) break;
+    }
+    if (!found && out) throw new Error(`Archive ended inside ${entryName}`);
+    return found;
+  } finally {
+    if (out) await out.close().catch(() => {
+    });
+    input.destroy();
+  }
 }
 
-// src/claude-code-version.ts
-import {
-  getClaudeCodeVersion,
-  getClaudeCliUserAgent,
-  pendingClaudeCodeVersionRefresh
-} from "@kenkaiiii/gg-ai";
+// src/claude-code/manifest.json
+var manifest_default = {
+  sdkVersion: "0.3.318",
+  claudeCodeVersion: "2.1.318",
+  platforms: {
+    "darwin-arm64": {
+      url: "https://registry.npmjs.org/@anthropic-ai/claude-agent-sdk-darwin-arm64/-/claude-agent-sdk-darwin-arm64-0.3.318.tgz",
+      integrity: "sha512-AWoXeDXzAMD3RaA21lWuHvCrKd8xmbTTmKjovninn4j07jheoVSMzFbCFjpp4kk5TdhT36JtWPkAxvjNMbcO8w==",
+      bin: "claude"
+    },
+    "darwin-x64": {
+      url: "https://registry.npmjs.org/@anthropic-ai/claude-agent-sdk-darwin-x64/-/claude-agent-sdk-darwin-x64-0.3.318.tgz",
+      integrity: "sha512-6CkZ5PCdebSY/LePp16sf/HYRtM6zVuxtn8qYICFS5KUZFsjccJJ9swVsOdHXNHi4SWZcSmIFTwoUbfFCzisRw==",
+      bin: "claude"
+    },
+    "linux-arm64": {
+      url: "https://registry.npmjs.org/@anthropic-ai/claude-agent-sdk-linux-arm64/-/claude-agent-sdk-linux-arm64-0.3.318.tgz",
+      integrity: "sha512-mBm4su17aMitLBBCQj3bHdejyUDY6z/ormGih+HG24N689RSbdKECjGjkT87tDBIR/4jyoqmuSeHqM1DI8TJlg==",
+      bin: "claude"
+    },
+    "linux-arm64-musl": {
+      url: "https://registry.npmjs.org/@anthropic-ai/claude-agent-sdk-linux-arm64-musl/-/claude-agent-sdk-linux-arm64-musl-0.3.318.tgz",
+      integrity: "sha512-l4LSYFOrvlYCrUImGfxMTQ0wg+T3s9CBhrBvPF/0oJGKZg+QnxHHU8jUVm9e9/xYmDRTtqFIrr4id/5AfH4XGw==",
+      bin: "claude"
+    },
+    "linux-x64": {
+      url: "https://registry.npmjs.org/@anthropic-ai/claude-agent-sdk-linux-x64/-/claude-agent-sdk-linux-x64-0.3.318.tgz",
+      integrity: "sha512-+mE+ueBD3oRFdaG16rd0h+LMjdeivGxL0pr/+FZK7JeLWVu+yPSw/f/X02b9oK36/DWykiFTu2G6HnJ9/+YO6w==",
+      bin: "claude"
+    },
+    "linux-x64-musl": {
+      url: "https://registry.npmjs.org/@anthropic-ai/claude-agent-sdk-linux-x64-musl/-/claude-agent-sdk-linux-x64-musl-0.3.318.tgz",
+      integrity: "sha512-SAF3lj/2OzTU84p+OOA13QEKA9+5fYAw0M9E7AJjdnRmVFGqQfbV7Do1i1f9Sj0mIubB3rLTRphGRw8O4HZjgA==",
+      bin: "claude"
+    },
+    "win32-arm64": {
+      url: "https://registry.npmjs.org/@anthropic-ai/claude-agent-sdk-win32-arm64/-/claude-agent-sdk-win32-arm64-0.3.318.tgz",
+      integrity: "sha512-19iVSZ4379QbZU1XnGUtfFvhKS1WzS8H1sbU/DbrzqbJ5Kq1eB1drj+obB1fCxTh6m26tRPj0zMJmdeu/jk3Gw==",
+      bin: "claude.exe"
+    },
+    "win32-x64": {
+      url: "https://registry.npmjs.org/@anthropic-ai/claude-agent-sdk-win32-x64/-/claude-agent-sdk-win32-x64-0.3.318.tgz",
+      integrity: "sha512-ZdKVWpyVNVt0cXrOf8sUBaxcxLEAP+oGMdQDLBWr/BqOxTWLy7TBWOj1kzw+wVg/9WIkjkgQWeJzGXPWulR1sA==",
+      bin: "claude.exe"
+    }
+  }
+};
 
-// src/oauth/anthropic.ts
-var CLIENT_ID2 = atob("OWQxYzI1MGEtZTYxYi00NGQ5LTg4ZWQtNTk0NGQxOTYyZjVl");
-var AUTHORIZE_URL = "https://claude.ai/oauth/authorize";
-var TOKEN_URLS = [
-  "https://platform.claude.com/v1/oauth/token",
-  "https://console.anthropic.com/v1/oauth/token"
-];
-var REDIRECT_URI = "https://platform.claude.com/oauth/code/callback";
-var SCOPES = "org:create_api_key user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload";
-async function postTokenRequest(body, label) {
-  const encoded = JSON.stringify(body);
-  const headers = {
-    "Content-Type": "application/json",
-    "User-Agent": await getClaudeCliUserAgent(),
-    "anthropic-beta": "oauth-2025-04-20"
-  };
-  let lastError = null;
-  for (const url of TOKEN_URLS) {
-    let response;
+// src/claude-code/runtime.ts
+var CLAUDE_CODE_MANIFEST = manifest_default;
+var CLAUDE_CODE_AUTH_KEY = "anthropic-claude-code";
+var CLAUDE_CODE_AUTH_MARKER = { via: "claude-code" };
+function isClaudeCodeAuthMarker(value) {
+  return value?.via === CLAUDE_CODE_AUTH_MARKER.via;
+}
+function isLegacyClaudeOAuth(value) {
+  const token = value?.accessToken;
+  return typeof token === "string" && token.startsWith("sk-ant-oat");
+}
+function isMusl() {
+  if (process.platform !== "linux") return false;
+  const report = typeof process.report?.getReport === "function" ? process.report.getReport() : null;
+  return report != null && report.header?.glibcVersionRuntime === void 0;
+}
+function claudeCodePlatformKey(info = { platform: process.platform, arch: process.arch, musl: isMusl() }) {
+  const arch2 = info.arch === "arm64" || info.arch === "x64" ? info.arch : null;
+  if (!arch2) return null;
+  if (info.platform === "darwin" || info.platform === "win32") return `${info.platform}-${arch2}`;
+  if (info.platform === "linux") return `linux-${arch2}${info.musl ? "-musl" : ""}`;
+  return null;
+}
+function resolveAsset(opts) {
+  const manifest = opts.manifest ?? CLAUDE_CODE_MANIFEST;
+  const key = opts.platformKey ?? claudeCodePlatformKey();
+  const asset = key ? manifest.platforms[key] : void 0;
+  if (!asset) {
+    throw new Error(
+      `Claude Code isn't available for ${process.platform}-${process.arch}. Use an Anthropic API key instead.`
+    );
+  }
+  return { manifest, asset };
+}
+function claudeCodeHome(opts = {}) {
+  return opts.home ?? getAppPaths().claudeCodeDir;
+}
+function claudeCodeConfigDir(opts = {}) {
+  return opts.home ? path2.join(opts.home, "config") : getAppPaths().claudeCodeConfigDir;
+}
+function claudeCodeBinaryPath(opts = {}) {
+  const { manifest, asset } = resolveAsset(opts);
+  return path2.join(claudeCodeHome(opts), manifest.claudeCodeVersion, asset.bin);
+}
+function resolveClaudeCodeBinary(opts = {}) {
+  let binary;
+  try {
+    binary = claudeCodeBinaryPath(opts);
+  } catch {
+    return null;
+  }
+  try {
+    return fs2.statSync(binary).isFile() ? binary : null;
+  } catch {
+    return null;
+  }
+}
+var installs = /* @__PURE__ */ new Map();
+async function ensureClaudeCodeBinary(opts = {}) {
+  const existing = resolveClaudeCodeBinary(opts);
+  if (existing) return existing;
+  const target = claudeCodeBinaryPath(opts);
+  let install = installs.get(target);
+  if (!install) {
+    install = installClaudeCode(opts).finally(() => installs.delete(target));
+    installs.set(target, install);
+  }
+  return install;
+}
+async function installClaudeCode(opts) {
+  const { manifest, asset } = resolveAsset(opts);
+  const home = claudeCodeHome(opts);
+  const versionDir = path2.join(home, manifest.claudeCodeVersion);
+  const binary = path2.join(versionDir, asset.bin);
+  await fsp2.mkdir(home, { recursive: true });
+  const tag = `${process.pid}-${crypto2.randomBytes(4).toString("hex")}`;
+  const tarball = path2.join(home, `.download-${tag}.tgz`);
+  const staging = path2.join(home, `.staging-${tag}`);
+  try {
+    await download(asset, tarball, opts);
+    opts.onProgress?.({ phase: "extract" });
+    await fsp2.mkdir(staging, { recursive: true });
+    const found = await extractFileFromTarGz(
+      tarball,
+      `package/${asset.bin}`,
+      path2.join(staging, asset.bin)
+    );
+    if (!found) throw new Error(`The Claude Code download has no ${asset.bin} binary.`);
+    await fsp2.chmod(path2.join(staging, asset.bin), 493);
     try {
-      response = await fetch(url, {
-        method: "POST",
-        headers,
-        body: encoded,
-        signal: oauthRequestSignal()
-      });
+      await fsp2.rename(staging, versionDir);
     } catch (err) {
-      lastError = err instanceof Error ? err : new Error(String(err));
-      continue;
-    }
-    if (response.ok) {
-      return await response.json();
+      if (!fs2.existsSync(binary)) throw err;
     }
-    const text = await response.text();
-    if (response.status >= 400 && response.status < 500) {
-      throw new Error(`Anthropic ${label} failed (${response.status}): ${text}`);
+    await removeOldVersions(home, manifest.claudeCodeVersion);
+    return binary;
+  } finally {
+    await fsp2.rm(tarball, { force: true }).catch(() => {
+    });
+    await fsp2.rm(staging, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+async function download(asset, dest, opts) {
+  const doFetch = opts.fetch ?? fetch;
+  const res = await doFetch(asset.url, { signal: opts.signal });
+  if (!res.ok || !res.body) {
+    throw new Error(`Claude Code download failed (HTTP ${res.status}).`);
+  }
+  const totalBytes = Number(res.headers.get("content-length")) || void 0;
+  const hash = crypto2.createHash("sha512");
+  const out = await fsp2.open(dest, "w");
+  let receivedBytes = 0;
+  let lastReported = -1;
+  try {
+    opts.onProgress?.({ phase: "download", receivedBytes, totalBytes });
+    for await (const chunk of res.body) {
+      if (opts.signal?.aborted) throw opts.signal.reason ?? new Error("Download cancelled.");
+      hash.update(chunk);
+      await out.write(chunk);
+      receivedBytes += chunk.byteLength;
+      const step = totalBytes ? Math.floor(receivedBytes / totalBytes * 100) : Math.floor(receivedBytes / 4194304);
+      if (step !== lastReported) {
+        lastReported = step;
+        opts.onProgress?.({ phase: "download", receivedBytes, totalBytes });
+      }
     }
-    lastError = new Error(`Anthropic ${label} failed (${response.status}): ${text}`);
+  } finally {
+    await out.close();
+  }
+  opts.onProgress?.({ phase: "verify" });
+  const expected = asset.integrity.replace(/^sha512-/, "");
+  if (hash.digest("base64") !== expected) {
+    throw new Error(
+      "The Claude Code download didn't match its pinned checksum, so it was discarded."
+    );
   }
-  throw lastError ?? new Error(`Anthropic ${label} failed: all endpoints unreachable`);
 }
-function toCredentials(data) {
-  return {
-    accessToken: data.access_token,
-    refreshToken: data.refresh_token,
-    expiresAt: Date.now() + data.expires_in * 1e3 - 5 * 60 * 1e3
-  };
+async function removeOldVersions(home, keep) {
+  let entries;
+  try {
+    entries = await fsp2.readdir(home, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name === keep || entry.name === "config") continue;
+    if (!/^\d+\.\d+\.\d+/.test(entry.name)) continue;
+    await fsp2.rm(path2.join(home, entry.name), { recursive: true, force: true }).catch(() => {
+    });
+  }
 }
-async function loginAnthropic(callbacks) {
-  const { verifier, challenge } = await generatePKCE();
-  const state = crypto2.randomBytes(16).toString("hex");
-  const params = new URLSearchParams({
-    code: "true",
-    client_id: CLIENT_ID2,
-    response_type: "code",
-    redirect_uri: REDIRECT_URI,
-    scope: SCOPES,
-    code_challenge: challenge,
-    code_challenge_method: "S256",
-    state
+function formatClaudeCodeInstallProgress(progress) {
+  if (progress.phase === "verify") return "Checking the Claude Code download\u2026";
+  if (progress.phase === "extract") return "Unpacking Claude Code\u2026";
+  const mb = (bytes) => Math.round(bytes / 1048576);
+  if (!progress.totalBytes) return `Downloading Claude Code\u2026 ${mb(progress.receivedBytes)} MB`;
+  const pct = Math.floor(progress.receivedBytes / progress.totalBytes * 100);
+  return `Downloading Claude Code\u2026 ${pct}% (${mb(progress.receivedBytes)} of ${mb(progress.totalBytes)} MB)`;
+}
+var STRIPPED_ENV = [
+  "ANTHROPIC_API_KEY",
+  "ANTHROPIC_AUTH_TOKEN",
+  "ANTHROPIC_BASE_URL",
+  "CLAUDE_CODE_OAUTH_TOKEN",
+  "CLAUDE_CODE_OAUTH_REFRESH_TOKEN",
+  "CLAUDE_CODE_USE_BEDROCK",
+  "CLAUDE_CODE_USE_VERTEX",
+  "CLAUDE_CODE_USE_FOUNDRY",
+  "NODE_OPTIONS"
+];
+function claudeCodeEnv(opts = {}, base = process.env) {
+  const env = {};
+  for (const [key, value] of Object.entries(base)) {
+    if (value !== void 0 && !STRIPPED_ENV.includes(key)) env[key] = value;
+  }
+  env.CLAUDE_CONFIG_DIR = claudeCodeConfigDir(opts);
+  env.DISABLE_AUTOUPDATER = "1";
+  return env;
+}
+function runCommand(opts) {
+  if (opts.binary) return { command: opts.binary, prefix: opts.binaryArgs ?? [] };
+  const binary = resolveClaudeCodeBinary(opts);
+  if (!binary) throw new Error("Claude Code isn't installed yet. Sign in with Claude first.");
+  return { command: binary, prefix: [] };
+}
+function runClaude(args, opts) {
+  const { command, prefix } = runCommand(opts);
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, [...prefix, ...args], {
+      env: claudeCodeEnv(opts),
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true,
+      signal: opts.signal
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (d) => stdout += d.toString());
+    child.stderr.on("data", (d) => stderr += d.toString());
+    child.on("error", reject);
+    child.on("close", (code) => resolve({ code, stdout, stderr }));
   });
-  const authUrl = `${AUTHORIZE_URL}?${params}`;
-  callbacks.onOpenUrl(authUrl);
-  const raw = await callbacks.onPromptCode("Paste the code from the browser (format: code#state):");
-  const parts = raw.trim().split("#");
-  if (parts.length !== 2 || !parts[0] || parts[1] !== state) {
-    throw new Error("Invalid code or state mismatch. Please try again.");
+}
+async function claudeCodeAuthStatus(opts = {}) {
+  if (!opts.binary && !resolveClaudeCodeBinary(opts)) return { loggedIn: false };
+  const { stdout } = await runClaude(["auth", "status", "--json"], opts);
+  try {
+    const parsed = JSON.parse(stdout);
+    return {
+      loggedIn: parsed.loggedIn === true,
+      ...typeof parsed.authMethod === "string" ? { authMethod: parsed.authMethod } : {},
+      ...typeof parsed.email === "string" ? { email: parsed.email } : {},
+      ...typeof parsed.subscriptionType === "string" ? { subscriptionType: parsed.subscriptionType } : {}
+    };
+  } catch {
+    return { loggedIn: false };
   }
-  return exchangeAnthropicCode(parts[0], parts[1], verifier);
 }
-async function exchangeAnthropicCode(code, state, verifier) {
-  const data = await postTokenRequest(
-    {
-      grant_type: "authorization_code",
-      client_id: CLIENT_ID2,
-      code,
-      state,
-      redirect_uri: REDIRECT_URI,
-      code_verifier: verifier
-    },
-    "token exchange"
-  );
-  return toCredentials(data);
+async function logoutClaudeCode(opts = {}) {
+  if (!opts.binary && !resolveClaudeCodeBinary(opts)) return;
+  const { code, stderr } = await runClaude(["auth", "logout"], opts);
+  if (code !== 0) throw new Error(stderr.trim() || `claude auth logout exited with ${code}`);
 }
-async function refreshAnthropicToken(refreshToken) {
-  const data = await postTokenRequest(
-    {
-      grant_type: "refresh_token",
-      client_id: CLIENT_ID2,
-      refresh_token: refreshToken
-    },
-    "token refresh"
-  );
-  return toCredentials(data);
+var OPEN_URL_HOOK = `const arg = String(process.argv[1] || "");
+const file = process.env.GG_CLAUDE_CODE_URL_FILE;
+if (file && /https?:/.test(arg)) {
+  require("node:fs").appendFileSync(file, arg + "\\n");
+  process.exit(0);
+}
+`;
+var CAPTURE_WAIT_MS = 3e3;
+function stripAnsi(text) {
+  return text.replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b\[[0-9;?]*[A-Za-z]/g, "");
+}
+function claudeCodeCallbackUrl(manualUrl, captured) {
+  const port = /localhost(?::|%3A)(\d{2,5})(?:\/|%2F)callback/i.exec(captured)?.[1];
+  if (!port) return null;
+  try {
+    const url = new URL(manualUrl);
+    url.searchParams.set("redirect_uri", `http://localhost:${port}/callback`);
+    return url.toString();
+  } catch {
+    return null;
+  }
+}
+async function loginClaudeCode(callbacks, opts = {}) {
+  const { command, prefix } = runCommand(opts);
+  const home = claudeCodeHome(opts);
+  await fsp2.mkdir(claudeCodeConfigDir(opts), { recursive: true });
+  const tag = `${process.pid}-${crypto2.randomBytes(4).toString("hex")}`;
+  const hookFile = path2.join(home, `.open-url-${tag}.cjs`);
+  const urlFile = path2.join(home, `.open-url-${tag}.txt`);
+  await fsp2.writeFile(hookFile, OPEN_URL_HOOK);
+  const env = {
+    ...claudeCodeEnv(opts),
+    BROWSER: process.execPath,
+    NODE_OPTIONS: `--require ${JSON.stringify(hookFile)}`,
+    GG_CLAUDE_CODE_URL_FILE: urlFile
+  };
+  const promptAbort = new AbortController();
+  let timer;
+  try {
+    await new Promise((resolve, reject) => {
+      const child = spawn(command, [...prefix, "auth", "login", "--claudeai"], {
+        env,
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true
+      });
+      let stdout = "";
+      let stderr = "";
+      let manualUrl = null;
+      let opened = false;
+      const onAbort = () => child.kill();
+      opts.signal?.addEventListener("abort", onAbort, { once: true });
+      const open = (url, needsCode) => {
+        if (opened) return;
+        opened = true;
+        clearInterval(timer);
+        callbacks.onOpenUrl(url);
+        callbacks.onStatus("Finish signing in to Claude in your browser\u2026");
+        if (!needsCode) return;
+        void callbacks.onPromptCode("Paste the code shown after signing in to Claude:", promptAbort.signal).then((code) => {
+          const trimmed = code.trim();
+          if (trimmed && !child.stdin.destroyed) child.stdin.write(`${trimmed}
+`);
+        }).catch(() => {
+        });
+      };
+      child.stdout.on("data", (d) => {
+        stdout += d.toString();
+        if (manualUrl) return;
+        const match = /visit:\s*(https:\/\/\S+)/.exec(stripAnsi(stdout));
+        if (!match) return;
+        manualUrl = match[1];
+        const started = Date.now();
+        timer = setInterval(() => {
+          let captured = "";
+          try {
+            captured = fs2.readFileSync(urlFile, "utf8");
+          } catch {
+          }
+          const callbackUrl = captured ? claudeCodeCallbackUrl(manualUrl, captured) : null;
+          if (callbackUrl) open(callbackUrl, false);
+          else if (Date.now() - started > (opts.browserWaitMs ?? CAPTURE_WAIT_MS))
+            open(manualUrl, true);
+        }, 100);
+      });
+      child.stderr.on("data", (d) => stderr += d.toString());
+      child.on("error", reject);
+      child.on("close", (code) => {
+        opts.signal?.removeEventListener("abort", onAbort);
+        if (opts.signal?.aborted) reject(new Error("Sign-in cancelled."));
+        else if (code === 0) resolve();
+        else {
+          const detail = stripAnsi(stderr).trim().split("\n").pop()?.trim();
+          reject(new Error(detail || `Claude sign-in failed (exit ${code}).`));
+        }
+      });
+    });
+  } finally {
+    clearInterval(timer);
+    promptAbort.abort();
+    await fsp2.rm(hookFile, { force: true }).catch(() => {
+    });
+    await fsp2.rm(urlFile, { force: true }).catch(() => {
+    });
+  }
 }
 
 // src/oauth/openai.ts
 import http from "http";
 import crypto3 from "crypto";
-var CLIENT_ID3 = "app_EMoamEEZ73f0CkXaXp7hrann";
-var AUTHORIZE_URL2 = "https://auth.openai.com/oauth/authorize";
+
+// src/oauth/pkce.ts
+function base64urlEncode(bytes) {
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+async function generatePKCE() {
+  const verifierBytes = new Uint8Array(32);
+  crypto.getRandomValues(verifierBytes);
+  const verifier = base64urlEncode(verifierBytes);
+  const data = new TextEncoder().encode(verifier);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  const challenge = base64urlEncode(new Uint8Array(hashBuffer));
+  return { verifier, challenge };
+}
+
+// src/oauth/openai.ts
+var CLIENT_ID2 = "app_EMoamEEZ73f0CkXaXp7hrann";
+var AUTHORIZE_URL = "https://auth.openai.com/oauth/authorize";
 var TOKEN_URL = "https://auth.openai.com/oauth/token";
-var REDIRECT_URI2 = "http://localhost:1455/auth/callback";
+var REDIRECT_URI = "http://localhost:1455/auth/callback";
 var SCOPE = "openid profile email offline_access api.connectors.read api.connectors.invoke";
 var JWT_CLAIM_PATH = "https://api.openai.com/auth";
 var CALLBACK_TIMEOUT_MS = 12e4;
@@ -373,10 +771,10 @@ var MIN_RAW_CODE_LENGTH = 10;
 async function loginOpenAI(callbacks) {
   const { verifier, challenge } = await generatePKCE();
   const state = crypto3.randomBytes(16).toString("hex");
-  const url = new URL(AUTHORIZE_URL2);
+  const url = new URL(AUTHORIZE_URL);
   url.searchParams.set("response_type", "code");
-  url.searchParams.set("client_id", CLIENT_ID3);
-  url.searchParams.set("redirect_uri", REDIRECT_URI2);
+  url.searchParams.set("client_id", CLIENT_ID2);
+  url.searchParams.set("redirect_uri", REDIRECT_URI);
   url.searchParams.set("scope", SCOPE);
   url.searchParams.set("code_challenge", challenge);
   url.searchParams.set("code_challenge_method", "S256");
@@ -532,9 +930,9 @@ async function exchangeOpenAICode(code, verifier) {
     headers: { "Content-Type": "application/x-www-form-urlencoded" },
     body: new URLSearchParams({
       grant_type: "authorization_code",
-      client_id: CLIENT_ID3,
+      client_id: CLIENT_ID2,
       code,
-      redirect_uri: REDIRECT_URI2,
+      redirect_uri: REDIRECT_URI,
       code_verifier: verifier
     }),
     signal: oauthRequestSignal()
@@ -557,7 +955,7 @@ async function refreshOpenAIToken(refreshToken) {
     body: new URLSearchParams({
       grant_type: "refresh_token",
       refresh_token: refreshToken,
-      client_id: CLIENT_ID3
+      client_id: CLIENT_ID2
     }),
     signal: oauthRequestSignal()
   });
@@ -585,7 +983,7 @@ var CLIENT_ID_ENV = "GGCODER_GEMINI_OAUTH_CLIENT_ID";
 var CLIENT_SECRET_ENV = "GGCODER_GEMINI_OAUTH_CLIENT_SECRET";
 var DEFAULT_CLIENT_ID = "681255809395-oo8ft2oprdrnp9e3aqf6av3hmdib135j.apps.googleusercontent.com";
 var DEFAULT_CLIENT_SECRET = "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";
-var AUTHORIZE_URL3 = "https://accounts.google.com/o/oauth2/v2/auth";
+var AUTHORIZE_URL2 = "https://accounts.google.com/o/oauth2/v2/auth";
 var TOKEN_URL2 = "https://oauth2.googleapis.com/token";
 var CODE_ASSIST_BASE_URL = "https://cloudcode-pa.googleapis.com";
 var CODE_ASSIST_API_VERSION = "v1internal";
@@ -616,7 +1014,7 @@ async function loginGemini(callbacks) {
   const { verifier, challenge } = await generatePKCE();
   const state = crypto4.randomBytes(32).toString("hex");
   const redirectUri = await getLoopbackRedirectUri();
-  const url = new URL(AUTHORIZE_URL3);
+  const url = new URL(AUTHORIZE_URL2);
   url.searchParams.set("response_type", "code");
   url.searchParams.set("client_id", clientId2);
   url.searchParams.set("redirect_uri", redirectUri);
@@ -653,7 +1051,7 @@ async function loginGemini(callbacks) {
 }
 async function refreshGeminiToken(refreshToken) {
   const { clientId: clientId2, clientSecret } = getGeminiOAuthClientCredentials();
-  const data = await postTokenRequest2({
+  const data = await postTokenRequest({
     grant_type: "refresh_token",
     refresh_token: refreshToken,
     client_id: clientId2,
@@ -748,7 +1146,7 @@ async function loginWithServer(authUrl, redirectUri, expectedState, callbacks) {
   });
 }
 async function exchangeGeminiCode(code, verifier, redirectUri, clientId2, clientSecret) {
-  const data = await postTokenRequest2({
+  const data = await postTokenRequest({
     grant_type: "authorization_code",
     client_id: clientId2,
     client_secret: clientSecret,
@@ -765,7 +1163,7 @@ async function exchangeGeminiCode(code, verifier, redirectUri, clientId2, client
     expiresAt: Date.now() + data.expires_in * 1e3 - 5 * 60 * 1e3
   };
 }
-async function postTokenRequest2(body) {
+async function postTokenRequest(body) {
   const response = await fetch(TOKEN_URL2, {
     method: "POST",
     headers: { "Content-Type": "application/x-www-form-urlencoded" },
@@ -1143,7 +1541,7 @@ async function refreshXaiToken(refreshToken) {
 }
 
 // src/file-lock.ts
-import fs from "fs/promises";
+import fs3 from "fs/promises";
 import { setTimeout as setTimeout2 } from "timers/promises";
 var STALE_TIMEOUT_MS = 1e4;
 var RETRY_INTERVAL_MS = 50;
@@ -1164,7 +1562,7 @@ async function acquireLock(lockPath) {
   while (true) {
     try {
       const info = { pid: process.pid, timestamp: Date.now() };
-      await fs.writeFile(lockPath, JSON.stringify(info), { flag: "wx" });
+      await fs3.writeFile(lockPath, JSON.stringify(info), { flag: "wx" });
       return;
     } catch (err) {
       const code = err.code;
@@ -1177,26 +1575,26 @@ async function acquireLock(lockPath) {
         continue;
       }
       try {
-        const content = await fs.readFile(lockPath, "utf-8");
+        const content = await fs3.readFile(lockPath, "utf-8");
         const info = JSON.parse(content);
         const isProcessAlive = isAlive(info.pid);
         const isStale = Date.now() - info.timestamp > STALE_TIMEOUT_MS;
         if (!isProcessAlive || isStale) {
-          await fs.unlink(lockPath).catch(() => {
+          await fs3.unlink(lockPath).catch(() => {
           });
           continue;
         }
       } catch {
-        const stat = await fs.stat(lockPath).catch(() => null);
+        const stat = await fs3.stat(lockPath).catch(() => null);
         if (!stat) continue;
         if (Date.now() - stat.mtimeMs > STALE_TIMEOUT_MS) {
-          await fs.unlink(lockPath).catch(() => {
+          await fs3.unlink(lockPath).catch(() => {
           });
           continue;
         }
       }
       if (Date.now() - startTime > MAX_WAIT_MS) {
-        await fs.unlink(lockPath).catch(() => {
+        await fs3.unlink(lockPath).catch(() => {
         });
         continue;
       }
@@ -1206,14 +1604,14 @@ async function acquireLock(lockPath) {
 }
 async function lockFileExists(lockPath) {
   try {
-    await fs.stat(lockPath);
+    await fs3.stat(lockPath);
     return true;
   } catch (err) {
     return err.code !== "ENOENT";
   }
 }
 async function releaseLock(lockPath) {
-  await fs.unlink(lockPath).catch(() => {
+  await fs3.unlink(lockPath).catch(() => {
   });
 }
 function isAlive(pid) {
@@ -1227,8 +1625,8 @@ function isAlive(pid) {
 }
 
 // src/logger.ts
-import fs2 from "fs";
-import path2 from "path";
+import fs4 from "fs";
+import path3 from "path";
 import { randomBytes } from "crypto";
 import { environmentSecrets, redactText, redactValue } from "@kenkaiiii/gg-ai";
 var MAX_BYTES = 10 * 1024 * 1024;
@@ -1245,14 +1643,14 @@ var cleanups = [];
 var exactSecrets = [];
 function rotateIfNeeded(filePath, force = false) {
   try {
-    const st = fs2.statSync(filePath);
+    const st = fs4.statSync(filePath);
     if (!force && st.size <= MAX_BYTES - MIN_HEADROOM_BYTES) return;
     const rotated = `${filePath}.1`;
     try {
-      fs2.unlinkSync(rotated);
+      fs4.unlinkSync(rotated);
     } catch {
     }
-    fs2.renameSync(filePath, rotated);
+    fs4.renameSync(filePath, rotated);
   } catch {
   }
 }
@@ -1260,18 +1658,18 @@ function rotateOpenLog() {
   if (fd === null || logPath === null) return false;
   const sizeBefore = fileBytes;
   try {
-    fs2.closeSync(fd);
+    fs4.closeSync(fd);
   } catch {
   }
   fd = null;
   rotateIfNeeded(logPath, true);
   try {
-    fd = fs2.openSync(logPath, "a");
-    fileBytes = fs2.fstatSync(fd).size;
+    fd = fs4.openSync(logPath, "a");
+    fileBytes = fs4.fstatSync(fd).size;
   } catch {
     if (fd !== null) {
       try {
-        fs2.closeSync(fd);
+        fs4.closeSync(fd);
       } catch {
       }
     }
@@ -1287,22 +1685,22 @@ function openLog(filePath, name) {
   appName = name;
   exactSecrets = environmentSecrets(process.env);
   try {
-    fs2.mkdirSync(path2.dirname(filePath), { recursive: true, mode: 448 });
+    fs4.mkdirSync(path3.dirname(filePath), { recursive: true, mode: 448 });
   } catch {
   }
   rotateIfNeeded(filePath);
   try {
-    fd = fs2.openSync(filePath, "a");
+    fd = fs4.openSync(filePath, "a");
   } catch {
     fd = null;
     fileBytes = 0;
     return false;
   }
   try {
-    fileBytes = fs2.fstatSync(fd).size;
+    fileBytes = fs4.fstatSync(fd).size;
   } catch {
     try {
-      fs2.closeSync(fd);
+      fs4.closeSync(fd);
     } catch {
     }
     fd = null;
@@ -1315,7 +1713,7 @@ function openLog(filePath, name) {
   sessionId = randomBytes(4).toString("hex");
   try {
     if (fileBytes < MAX_BYTES) {
-      const written = fs2.writeSync(fd, "\n");
+      const written = fs4.writeSync(fd, "\n");
       fileBytes += written;
       processBytes += written;
     }
@@ -1350,9 +1748,9 @@ function log(level, category, message, data) {
 `;
     try {
       if (fileBytes + Buffer.byteLength(capLine) <= MAX_BYTES) {
-        fileBytes += fs2.writeSync(fd, capLine);
+        fileBytes += fs4.writeSync(fd, capLine);
       }
-      fs2.closeSync(fd);
+      fs4.closeSync(fd);
     } catch {
     }
     fd = null;
@@ -1362,7 +1760,7 @@ function log(level, category, message, data) {
   if (fileBytes + lineBytes > MAX_BYTES && !rotationFailed && !rotateOpenLog()) return;
   if (fd === null) return;
   try {
-    const written = fs2.writeSync(fd, line);
+    const written = fs4.writeSync(fd, line);
     fileBytes += written;
     processBytes += written;
   } catch {
@@ -1375,7 +1773,7 @@ function closeLogger(opts) {
   if (fd !== null) {
     if (opts?.shutdownLine !== false) log("INFO", "shutdown", `${appName} shutting down`);
     try {
-      if (fd !== null) fs2.closeSync(fd);
+      if (fd !== null) fs4.closeSync(fd);
     } catch {
     }
   }
@@ -1556,6 +1954,8 @@ function refreshThresholdMs(creds) {
 }
 var USAGE_EXHAUSTED_DEFAULT_MS = 15 * 60 * 1e3;
 var STATIC_API_KEY_PROVIDERS = /* @__PURE__ */ new Set([
+  // Anthropic is API-key only; Claude subscriptions run through Claude Code.
+  "anthropic",
   "glm",
   "moonshot",
   "xiaomi",
@@ -1636,11 +2036,44 @@ var AuthStorage = class {
     if (provider === "gemini") {
       return Boolean(this.data["gemini"] || this.data[GEMINI_API_KEY]);
     }
+    if (provider === "anthropic") {
+      return Boolean(this.data.anthropic) && !isLegacyClaudeOAuth(this.data.anthropic) || isClaudeCodeAuthMarker(this.data[CLAUDE_CODE_AUTH_KEY]);
+    }
     if (provider === "local") {
       return Object.keys(this.data).some((key) => key.startsWith(LOCAL_AUTH_KEY_PREFIX));
     }
     return Boolean(this.data[provider]);
   }
+  /** True when the user signed in with Claude through Claude Code (marker only, no token). */
+  async hasClaudeCodeLogin() {
+    await this.ensureFresh();
+    return isClaudeCodeAuthMarker(this.data[CLAUDE_CODE_AUTH_KEY]);
+  }
+  /** Record a Claude Code sign-in. Claude Code keeps the token; auth.json gets only the marker. */
+  async setClaudeCodeLogin() {
+    await this.mutateLatest((latest) => {
+      latest[CLAUDE_CODE_AUTH_KEY] = { ...CLAUDE_CODE_AUTH_MARKER };
+      if (isLegacyClaudeOAuth(latest.anthropic)) delete latest.anthropic;
+    });
+  }
+  /**
+   * Remove an old GG Claude sign-in token (`sk-ant-oat…`), if any. True when one
+   * was removed, so the caller can tell the user once to sign in with Claude again.
+   */
+  async takeLegacyClaudeSignIn() {
+    await this.ensureFresh();
+    if (!isLegacyClaudeOAuth(this.data.anthropic)) return false;
+    let removed = false;
+    await this.mutateLatest((latest) => {
+      if (!isLegacyClaudeOAuth(latest.anthropic)) return;
+      delete latest.anthropic;
+      removed = true;
+    });
+    return removed;
+  }
+  async clearClaudeCodeLogin() {
+    await this.clearCredentials(CLAUDE_CODE_AUTH_KEY);
+  }
   /** Endpoint ids that currently have a `local:<id>` credential stored. */
   async listLocalEndpointIds() {
     await this.ensureLoaded();
@@ -1694,7 +2127,7 @@ var AuthStorage = class {
     const first = !this.loaded;
     await withFileLock(this.filePath, async () => {
       try {
-        const content = await fs3.readFile(this.filePath, "utf-8");
+        const content = await fs5.readFile(this.filePath, "utf-8");
         this.data = JSON.parse(content);
         if (first) {
           log("INFO", "auth", `Loaded credentials from ${this.filePath}`, {
@@ -1740,7 +2173,7 @@ var AuthStorage = class {
     }
     let changed;
     try {
-      const stat = await fs3.stat(this.filePath);
+      const stat = await fs5.stat(this.filePath);
       changed = stat.ino !== this.snapshotIno || stat.mtimeMs !== this.snapshotMtimeMs || stat.size !== this.snapshotSize;
     } catch {
       changed = this.snapshotSize !== -1;
@@ -1753,7 +2186,7 @@ var AuthStorage = class {
    */
   async rememberSnapshot() {
     try {
-      const stat = await fs3.stat(this.filePath);
+      const stat = await fs5.stat(this.filePath);
       this.snapshotMtimeMs = stat.mtimeMs;
       this.snapshotSize = stat.size;
       this.snapshotIno = stat.ino;
@@ -1894,7 +2327,7 @@ var AuthStorage = class {
       await this.ensureFresh();
     }
     const directStorageKeys = opts?.storageKeys && !(opts.storageKeys.length === 1 && opts.storageKeys[0] === provider) ? opts.storageKeys : providerStorageKeys(provider);
-    if (!directStorageKeys.some((key) => Boolean(this.data[key]))) {
+    if (!directStorageKeys.some((key) => Boolean(this.data[key])) && !(provider === "anthropic" && this.data[CLAUDE_CODE_AUTH_KEY])) {
       await this.reloadLatest();
     }
     if (opts?.storageKeys && !(opts.storageKeys.length === 1 && opts.storageKeys[0] === provider)) {
@@ -1917,6 +2350,12 @@ var AuthStorage = class {
       }
       throw new NotLoggedInError(provider);
     }
+    if (provider === "anthropic" && (!this.data.anthropic || isLegacyClaudeOAuth(this.data.anthropic))) {
+      if (isClaudeCodeAuthMarker(this.data[CLAUDE_CODE_AUTH_KEY])) {
+        return { accessToken: "", refreshToken: "", expiresAt: Number.MAX_SAFE_INTEGER };
+      }
+      if (this.data.anthropic) throw new NotLoggedInError(provider);
+    }
     const dual = dualAuthProvider(provider);
     const dualOAuthCreds = dual ? this.data[dual.oauthKey] : void 0;
     if (dual && dualOAuthCreds) {
@@ -1979,7 +2418,7 @@ var AuthStorage = class {
         this.data = latest;
         return latestCreds;
       }
-      const refreshFn = provider === "anthropic" ? refreshAnthropicToken : provider === "gemini" ? refreshGeminiToken : provider === MOONSHOT_OAUTH_KEY ? refreshKimiToken : provider === XAI_OAUTH_KEY ? refreshXaiToken : refreshOpenAIToken;
+      const refreshFn = provider === "gemini" ? refreshGeminiToken : provider === MOONSHOT_OAUTH_KEY ? refreshKimiToken : provider === XAI_OAUTH_KEY ? refreshXaiToken : refreshOpenAIToken;
       let refreshed;
       try {
         refreshed = await refreshFn(latestCreds.refreshToken);
@@ -2038,7 +2477,7 @@ var AuthStorage = class {
 };
 async function readAuthData(filePath) {
   try {
-    const content = await fs3.readFile(filePath, "utf-8");
+    const content = await fs5.readFile(filePath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (error.code === "ENOENT") return {};
@@ -2048,10 +2487,10 @@ async function readAuthData(filePath) {
 async function atomicWriteFile(filePath, content) {
   const tmpPath = `${filePath}.${process.pid}.${Date.now()}.${crypto5.randomUUID().slice(0, 8)}.tmp`;
   try {
-    await fs3.writeFile(tmpPath, content, { encoding: "utf-8", mode: 384 });
-    await fs3.rename(tmpPath, filePath);
+    await fs5.writeFile(tmpPath, content, { encoding: "utf-8", mode: 384 });
+    await fs5.rename(tmpPath, filePath);
   } catch (err) {
-    await fs3.unlink(tmpPath).catch(() => {
+    await fs5.unlink(tmpPath).catch(() => {
     });
     throw err;
   }
@@ -2254,9 +2693,9 @@ var MODELS = [
     billing: CODEX_FAST_BILLING
   },
   // GPT-6 Sol + Luna — released 2026-09-22 below Astra, replacing the whole
-  // GPT-5.6 family (Sol/Terra/Luna; there is no GPT-6 Terra — OpenAI's Codex
+  // GPT-5.6 family (Sol/Terra/Luna; there was no GPT-6 Terra — OpenAI's Codex
   // catalog upgrades 5.6 Terra to 6 Sol). GPT-6.1 Sol (2026-09-29) then replaced
-  // GPT-6 Sol. Same window split as Astra: 1.05M on the public Responses API,
+  // GPT-6 Sol, and GPT-6.1 Terra (2026-10-26) sits between Sol and Luna. Same window split as Astra: 1.05M on the public Responses API,
   // 272K on the Codex route; 128K output, text+image input, freeform
   // apply_patch, responses-lite transport. The GPT-5.6 ids and `gpt-6-sol` are
   // retired — a saved session on one falls back to the provider default on
@@ -2298,6 +2737,40 @@ var MODELS = [
     maxThinkingLevel: "ultra",
     billing: CODEX_FAST_BILLING
   },
+  {
+    // GPT-6.1 Terra (Codex priority 7, default low, client >= 0.153.0). $1/$5
+    // MTok, cached input $0.05. Unlike Sol/Astra the Codex route gets a 500K
+    // window (catalog `context_window`). Same ladder and Ultra preset as Sol.
+    id: "gpt-6.1-terra",
+    name: "GPT-6.1 Terra",
+    provider: "openai",
+    contextWindow: 105e4,
+    codexContextWindow: 5e5,
+    maxOutputTokens: 128e3,
+    supportsThinking: true,
+    defaultThinkingLevel: "low",
+    supportsImages: true,
+    supportsVideo: false,
+    costTier: "medium",
+    maxThinkingLevel: "ultra"
+  },
+  {
+    // Codex Fast mode for 6.1 Terra ("1.5x speed") — see `gpt-6-astra-fast`
+    // for the wire mapping and billing.
+    id: "gpt-6.1-terra-fast",
+    name: "GPT-6.1 Terra Fast",
+    provider: "openai",
+    contextWindow: 105e4,
+    codexContextWindow: 5e5,
+    maxOutputTokens: 128e3,
+    supportsThinking: true,
+    defaultThinkingLevel: "low",
+    supportsImages: true,
+    supportsVideo: false,
+    costTier: "medium",
+    maxThinkingLevel: "ultra",
+    billing: CODEX_FAST_BILLING
+  },
   {
     // Luna — "Fast and affordable model for easier tasks." (Codex priority 4,
     // default medium, needs a Codex client >= 0.155.0). $0.10/$0.50 MTok.
@@ -2974,12 +3447,24 @@ export {
   isKimiCodingEndpoint,
   loginKimi,
   refreshKimiToken,
+  CLAUDE_CODE_MANIFEST,
+  CLAUDE_CODE_AUTH_KEY,
+  CLAUDE_CODE_AUTH_MARKER,
+  isClaudeCodeAuthMarker,
+  isLegacyClaudeOAuth,
+  claudeCodePlatformKey,
+  claudeCodeHome,
+  claudeCodeConfigDir,
+  claudeCodeBinaryPath,
+  resolveClaudeCodeBinary,
+  ensureClaudeCodeBinary,
+  formatClaudeCodeInstallProgress,
+  claudeCodeEnv,
+  claudeCodeAuthStatus,
+  logoutClaudeCode,
+  claudeCodeCallbackUrl,
+  loginClaudeCode,
   generatePKCE,
-  getClaudeCodeVersion,
-  getClaudeCliUserAgent,
-  pendingClaudeCodeVersionRefresh,
-  loginAnthropic,
-  refreshAnthropicToken,
   loginOpenAI,
   refreshOpenAIToken,
   loginGemini,
@@ -3039,4 +3524,4 @@ export {
   getDefaultThinkingLevel,
   getSummaryModel
 };
-//# sourceMappingURL=chunk-SDUIKPGO.js.map
+//# sourceMappingURL=chunk-JLEBGMG4.js.map