@kenkaiiii/gg-core 5.93.0 → 5.94.0

package/dist/index.cjs

@@ -32,6 +32,9 @@ var index_exports = {};
 __export(index_exports, {
   AUTH_PROVIDERS: () => AUTH_PROVIDERS,
   AuthStorage: () => AuthStorage,
+  CLAUDE_CODE_AUTH_KEY: () => CLAUDE_CODE_AUTH_KEY,
+  CLAUDE_CODE_AUTH_MARKER: () => CLAUDE_CODE_AUTH_MARKER,
+  CLAUDE_CODE_MANIFEST: () => CLAUDE_CODE_MANIFEST,
   DEFAULT_LOCAL_ENDPOINTS: () => DEFAULT_LOCAL_ENDPOINTS,
   DEFAULT_MAX_VIDEO_BYTES: () => DEFAULT_MAX_VIDEO_BYTES,
   FALLBACK_CONTEXT_WINDOW: () => FALLBACK_CONTEXT_WINDOW,
@@ -54,6 +57,14 @@ __export(index_exports, {
   XIAOMI_TOKEN_PLAN_BASE_URLS: () => XIAOMI_TOKEN_PLAN_BASE_URLS,
   authPriorityNote: () => authPriorityNote,
   clampThinkingForPlanMode: () => clampThinkingForPlanMode,
+  claudeCodeAuthStatus: () => claudeCodeAuthStatus,
+  claudeCodeBinaryPath: () => claudeCodeBinaryPath,
+  claudeCodeCallbackUrl: () => claudeCodeCallbackUrl,
+  claudeCodeConfigDir: () => claudeCodeConfigDir,
+  claudeCodeEnv: () => claudeCodeEnv,
+  claudeCodeHome: () => claudeCodeHome,
+  claudeCodePlatformKey: () => claudeCodePlatformKey,
+  clearClaudeCodeUsage: () => clearClaudeCodeUsage,
   clearLocalDiscoveryCache: () => clearLocalDiscoveryCache,
   clearRuntimeModels: () => clearRuntimeModels,
   closeLogger: () => closeLogger,
@@ -67,8 +78,10 @@ __export(index_exports, {
   dualAuthProvider: () => dualAuthProvider,
   dualAuthProviderByOAuthKey: () => dualAuthProviderByOAuthKey,
   endpointRoot: () => endpointRoot,
+  ensureClaudeCodeBinary: () => ensureClaudeCodeBinary,
   fetchSubscriptionUsage: () => fetchSubscriptionUsage,
   findProbedModel: () => findProbedModel,
+  formatClaudeCodeInstallProgress: () => formatClaudeCodeInstallProgress,
   formatLocalModelId: () => formatLocalModelId,
   generatePKCE: () => generatePKCE,
   getAllModels: () => getAllModels,
@@ -76,8 +89,6 @@ __export(index_exports, {
   getAuthProvider: () => getAuthProvider,
   getAuthStorageKey: () => getAuthStorageKey,
   getAuthStorageKeys: () => getAuthStorageKeys,
-  getClaudeCliUserAgent: () => import_gg_ai.getClaudeCliUserAgent,
-  getClaudeCodeVersion: () => import_gg_ai.getClaudeCodeVersion,
   getContextWindow: () => getContextWindow,
   getDefaultModel: () => getDefaultModel,
   getDefaultThinkingLevel: () => getDefaultThinkingLevel,
@@ -95,9 +106,11 @@ __export(index_exports, {
   getVideoByteLimit: () => getVideoByteLimit,
   grokCliBaseUrl: () => grokCliBaseUrl,
   grokCliHeaders: () => grokCliHeaders,
+  isClaudeCodeAuthMarker: () => isClaudeCodeAuthMarker,
   isGrokCliEndpoint: () => isGrokCliEndpoint,
   isHiddenProvider: () => isHiddenProvider,
   isKimiCodingEndpoint: () => isKimiCodingEndpoint,
+  isLegacyClaudeOAuth: () => isLegacyClaudeOAuth,
   isLocalModelId: () => isLocalModelId,
   isLoggerOpen: () => isLoggerOpen,
   isModelLoaded: () => isModelLoaded,
@@ -108,21 +121,23 @@ __export(index_exports, {
   localAuthStorageKey: () => localAuthStorageKey,
   localModelShortName: () => localModelShortName,
   log: () => log,
-  loginAnthropic: () => loginAnthropic,
+  loginClaudeCode: () => loginClaudeCode,
   loginGemini: () => loginGemini,
   loginKimi: () => loginKimi,
   loginOpenAI: () => loginOpenAI,
   loginXai: () => loginXai,
+  logoutClaudeCode: () => logoutClaudeCode,
+  mergeClaudeCodeRateLimit: () => mergeClaudeCodeRateLimit,
   oauthStorageKey: () => oauthStorageKey,
   ollamaServedContext: () => ollamaServedContext,
   openLog: () => openLog,
   parseLocalModelId: () => parseLocalModelId,
   parseOpenRouterCatalog: () => parseOpenRouterCatalog,
-  pendingClaudeCodeVersionRefresh: () => import_gg_ai.pendingClaudeCodeVersionRefresh,
   probeEndpoint: () => probeEndpoint,
   providerStorageKeys: () => providerStorageKeys,
+  readClaudeCodeUsage: () => readClaudeCodeUsage,
   readStoredBaseUrlSync: () => readStoredBaseUrlSync,
-  refreshAnthropicToken: () => refreshAnthropicToken,
+  recordClaudeCodeRateLimit: () => recordClaudeCodeRateLimit,
   refreshGeminiToken: () => refreshGeminiToken,
   refreshKimiToken: () => refreshKimiToken,
   refreshOpenAIToken: () => refreshOpenAIToken,
@@ -130,8 +145,11 @@ __export(index_exports, {
   registerLogCleanup: () => registerLogCleanup,
   registerRuntimeModels: () => registerRuntimeModels,
   resample: () => resample,
+  resolveClaudeCodeBinary: () => resolveClaudeCodeBinary,
   setProgressCallback: () => setProgressCallback,
   setProviderCatalog: () => setProviderCatalog,
+  signInWithClaudeCode: () => signInWithClaudeCode,
+  signOutOfClaudeCode: () => signOutOfClaudeCode,
   toModelInfo: () => toModelInfo,
   transcribeVoice: () => transcribeVoice,
   usesOpenAICodexTransport: () => usesOpenAICodexTransport,
@@ -170,7 +188,9 @@ function getAppPaths() {
     agentsDir: import_node_path.default.join(agentDir, "agents"),
     progressFile: import_node_path.default.join(agentDir, "progress.json"),
     progressBackupFile: import_node_path.default.join(agentDir, "progress.backup.json"),
-    trophiesFile: import_node_path.default.join(agentDir, "trophies.json")
+    trophiesFile: import_node_path.default.join(agentDir, "trophies.json"),
+    claudeCodeDir: import_node_path.default.join(agentDir, "claude-code"),
+    claudeCodeConfigDir: import_node_path.default.join(agentDir, "claude-code", "config")
   };
 }
 
@@ -395,137 +415,539 @@ async function refreshKimiToken(refreshToken) {
 }
 
 // src/auth-storage.ts
-var import_promises3 = __toESM(require("fs/promises"), 1);
-var import_node_fs3 = require("fs");
+var import_promises5 = __toESM(require("fs/promises"), 1);
+var import_node_fs5 = require("fs");
 var import_node_crypto6 = __toESM(require("crypto"), 1);
 
-// src/oauth/anthropic.ts
+// src/claude-code/runtime.ts
+var import_node_child_process2 = require("child_process");
 var import_node_crypto2 = __toESM(require("crypto"), 1);
+var import_node_fs3 = __toESM(require("fs"), 1);
+var import_promises2 = __toESM(require("fs/promises"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
 
-// src/oauth/pkce.ts
-function base64urlEncode(bytes) {
-  let binary = "";
-  for (const byte of bytes) {
-    binary += String.fromCharCode(byte);
+// src/claude-code/tar.ts
+var import_node_fs2 = __toESM(require("fs"), 1);
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_node_zlib = __toESM(require("zlib"), 1);
+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 = import_node_fs2.default.createReadStream(tgzPath).pipe(import_node_zlib.default.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 path7 = overridePath ?? name;
+          overridePath = void 0;
+          if ((type2 === "0" || type2 === "\0" || type2 === "7") && path7 === entryName) {
+            kind = "target";
+            out = await import_promises.default.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
-var import_gg_ai = require("@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 (0, import_gg_ai.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 ? import_node_path3.default.join(opts.home, "config") : getAppPaths().claudeCodeConfigDir;
+}
+function claudeCodeBinaryPath(opts = {}) {
+  const { manifest, asset } = resolveAsset(opts);
+  return import_node_path3.default.join(claudeCodeHome(opts), manifest.claudeCodeVersion, asset.bin);
+}
+function resolveClaudeCodeBinary(opts = {}) {
+  let binary;
+  try {
+    binary = claudeCodeBinaryPath(opts);
+  } catch {
+    return null;
+  }
+  try {
+    return import_node_fs3.default.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 = import_node_path3.default.join(home, manifest.claudeCodeVersion);
+  const binary = import_node_path3.default.join(versionDir, asset.bin);
+  await import_promises2.default.mkdir(home, { recursive: true });
+  const tag = `${process.pid}-${import_node_crypto2.default.randomBytes(4).toString("hex")}`;
+  const tarball = import_node_path3.default.join(home, `.download-${tag}.tgz`);
+  const staging = import_node_path3.default.join(home, `.staging-${tag}`);
+  try {
+    await download(asset, tarball, opts);
+    opts.onProgress?.({ phase: "extract" });
+    await import_promises2.default.mkdir(staging, { recursive: true });
+    const found = await extractFileFromTarGz(
+      tarball,
+      `package/${asset.bin}`,
+      import_node_path3.default.join(staging, asset.bin)
+    );
+    if (!found) throw new Error(`The Claude Code download has no ${asset.bin} binary.`);
+    await import_promises2.default.chmod(import_node_path3.default.join(staging, asset.bin), 493);
     try {
-      response = await fetch(url, {
-        method: "POST",
-        headers,
-        body: encoded,
-        signal: oauthRequestSignal()
-      });
+      await import_promises2.default.rename(staging, versionDir);
     } catch (err) {
-      lastError = err instanceof Error ? err : new Error(String(err));
-      continue;
+      if (!import_node_fs3.default.existsSync(binary)) throw err;
     }
-    if (response.ok) {
-      return await response.json();
-    }
-    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 import_promises2.default.rm(tarball, { force: true }).catch(() => {
+    });
+    await import_promises2.default.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 = import_node_crypto2.default.createHash("sha512");
+  const out = await import_promises2.default.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 import_promises2.default.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 import_promises2.default.rm(import_node_path3.default.join(home, entry.name), { recursive: true, force: true }).catch(() => {
+    });
+  }
 }
-async function loginAnthropic(callbacks) {
-  const { verifier, challenge } = await generatePKCE();
-  const state = import_node_crypto2.default.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 = (0, import_node_child_process2.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 import_promises2.default.mkdir(claudeCodeConfigDir(opts), { recursive: true });
+  const tag = `${process.pid}-${import_node_crypto2.default.randomBytes(4).toString("hex")}`;
+  const hookFile = import_node_path3.default.join(home, `.open-url-${tag}.cjs`);
+  const urlFile = import_node_path3.default.join(home, `.open-url-${tag}.txt`);
+  await import_promises2.default.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 = (0, import_node_child_process2.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 = import_node_fs3.default.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 import_promises2.default.rm(hookFile, { force: true }).catch(() => {
+    });
+    await import_promises2.default.rm(urlFile, { force: true }).catch(() => {
+    });
+  }
 }
 
 // src/oauth/openai.ts
 var import_node_http = __toESM(require("http"), 1);
 var import_node_crypto3 = __toESM(require("crypto"), 1);
-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;
@@ -534,10 +956,10 @@ var MIN_RAW_CODE_LENGTH = 10;
 async function loginOpenAI(callbacks) {
   const { verifier, challenge } = await generatePKCE();
   const state = import_node_crypto3.default.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");
@@ -693,9 +1115,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()
@@ -718,7 +1140,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()
   });
@@ -746,7 +1168,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";
@@ -777,7 +1199,7 @@ async function loginGemini(callbacks) {
   const { verifier, challenge } = await generatePKCE();
   const state = import_node_crypto4.default.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);
@@ -814,7 +1236,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,
@@ -909,7 +1331,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,
@@ -926,7 +1348,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" },
@@ -1304,8 +1726,8 @@ async function refreshXaiToken(refreshToken) {
 }
 
 // src/file-lock.ts
-var import_promises = __toESM(require("fs/promises"), 1);
-var import_promises2 = require("timers/promises");
+var import_promises3 = __toESM(require("fs/promises"), 1);
+var import_promises4 = require("timers/promises");
 var STALE_TIMEOUT_MS = 1e4;
 var RETRY_INTERVAL_MS = 50;
 var MAX_WAIT_MS = 5e3;
@@ -1325,7 +1747,7 @@ async function acquireLock(lockPath) {
   while (true) {
     try {
       const info = { pid: process.pid, timestamp: Date.now() };
-      await import_promises.default.writeFile(lockPath, JSON.stringify(info), { flag: "wx" });
+      await import_promises3.default.writeFile(lockPath, JSON.stringify(info), { flag: "wx" });
       return;
     } catch (err) {
       const code = err.code;
@@ -1334,47 +1756,47 @@ async function acquireLock(lockPath) {
         const lockPresent = await lockFileExists(lockPath);
         if (!lockPresent && ++refusedWithoutLock > 3) throw err;
         if (Date.now() - startTime > MAX_WAIT_MS) throw err;
-        await (0, import_promises2.setTimeout)(RETRY_INTERVAL_MS);
+        await (0, import_promises4.setTimeout)(RETRY_INTERVAL_MS);
         continue;
       }
       try {
-        const content = await import_promises.default.readFile(lockPath, "utf-8");
+        const content = await import_promises3.default.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 import_promises.default.unlink(lockPath).catch(() => {
+          await import_promises3.default.unlink(lockPath).catch(() => {
           });
           continue;
         }
       } catch {
-        const stat = await import_promises.default.stat(lockPath).catch(() => null);
+        const stat = await import_promises3.default.stat(lockPath).catch(() => null);
         if (!stat) continue;
         if (Date.now() - stat.mtimeMs > STALE_TIMEOUT_MS) {
-          await import_promises.default.unlink(lockPath).catch(() => {
+          await import_promises3.default.unlink(lockPath).catch(() => {
           });
           continue;
         }
       }
       if (Date.now() - startTime > MAX_WAIT_MS) {
-        await import_promises.default.unlink(lockPath).catch(() => {
+        await import_promises3.default.unlink(lockPath).catch(() => {
         });
         continue;
       }
-      await (0, import_promises2.setTimeout)(RETRY_INTERVAL_MS);
+      await (0, import_promises4.setTimeout)(RETRY_INTERVAL_MS);
     }
   }
 }
 async function lockFileExists(lockPath) {
   try {
-    await import_promises.default.stat(lockPath);
+    await import_promises3.default.stat(lockPath);
     return true;
   } catch (err) {
     return err.code !== "ENOENT";
   }
 }
 async function releaseLock(lockPath) {
-  await import_promises.default.unlink(lockPath).catch(() => {
+  await import_promises3.default.unlink(lockPath).catch(() => {
   });
 }
 function isAlive(pid) {
@@ -1388,10 +1810,10 @@ function isAlive(pid) {
 }
 
 // src/logger.ts
-var import_node_fs2 = __toESM(require("fs"), 1);
-var import_node_path3 = __toESM(require("path"), 1);
+var import_node_fs4 = __toESM(require("fs"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
 var import_node_crypto5 = require("crypto");
-var import_gg_ai2 = require("@kenkaiiii/gg-ai");
+var import_gg_ai = require("@kenkaiiii/gg-ai");
 var MAX_BYTES = 10 * 1024 * 1024;
 var MIN_HEADROOM_BYTES = 64 * 1024;
 var fd = null;
@@ -1406,14 +1828,14 @@ var cleanups = [];
 var exactSecrets = [];
 function rotateIfNeeded(filePath, force = false) {
   try {
-    const st = import_node_fs2.default.statSync(filePath);
+    const st = import_node_fs4.default.statSync(filePath);
     if (!force && st.size <= MAX_BYTES - MIN_HEADROOM_BYTES) return;
     const rotated = `${filePath}.1`;
     try {
-      import_node_fs2.default.unlinkSync(rotated);
+      import_node_fs4.default.unlinkSync(rotated);
     } catch {
     }
-    import_node_fs2.default.renameSync(filePath, rotated);
+    import_node_fs4.default.renameSync(filePath, rotated);
   } catch {
   }
 }
@@ -1421,18 +1843,18 @@ function rotateOpenLog() {
   if (fd === null || logPath === null) return false;
   const sizeBefore = fileBytes;
   try {
-    import_node_fs2.default.closeSync(fd);
+    import_node_fs4.default.closeSync(fd);
   } catch {
   }
   fd = null;
   rotateIfNeeded(logPath, true);
   try {
-    fd = import_node_fs2.default.openSync(logPath, "a");
-    fileBytes = import_node_fs2.default.fstatSync(fd).size;
+    fd = import_node_fs4.default.openSync(logPath, "a");
+    fileBytes = import_node_fs4.default.fstatSync(fd).size;
   } catch {
     if (fd !== null) {
       try {
-        import_node_fs2.default.closeSync(fd);
+        import_node_fs4.default.closeSync(fd);
       } catch {
       }
     }
@@ -1446,24 +1868,24 @@ function rotateOpenLog() {
 function openLog(filePath, name) {
   if (fd !== null || capped) return false;
   appName = name;
-  exactSecrets = (0, import_gg_ai2.environmentSecrets)(process.env);
+  exactSecrets = (0, import_gg_ai.environmentSecrets)(process.env);
   try {
-    import_node_fs2.default.mkdirSync(import_node_path3.default.dirname(filePath), { recursive: true, mode: 448 });
+    import_node_fs4.default.mkdirSync(import_node_path4.default.dirname(filePath), { recursive: true, mode: 448 });
   } catch {
   }
   rotateIfNeeded(filePath);
   try {
-    fd = import_node_fs2.default.openSync(filePath, "a");
+    fd = import_node_fs4.default.openSync(filePath, "a");
   } catch {
     fd = null;
     fileBytes = 0;
     return false;
   }
   try {
-    fileBytes = import_node_fs2.default.fstatSync(fd).size;
+    fileBytes = import_node_fs4.default.fstatSync(fd).size;
   } catch {
     try {
-      import_node_fs2.default.closeSync(fd);
+      import_node_fs4.default.closeSync(fd);
     } catch {
     }
     fd = null;
@@ -1476,7 +1898,7 @@ function openLog(filePath, name) {
   sessionId = (0, import_node_crypto5.randomBytes)(4).toString("hex");
   try {
     if (fileBytes < MAX_BYTES) {
-      const written = import_node_fs2.default.writeSync(fd, "\n");
+      const written = import_node_fs4.default.writeSync(fd, "\n");
       fileBytes += written;
       processBytes += written;
     }
@@ -1493,10 +1915,10 @@ function isLoggerOpen() {
 function log(level, category, message, data) {
   if (fd === null) return;
   const ts = (/* @__PURE__ */ new Date()).toISOString();
-  const safeMessage = (0, import_gg_ai2.redactText)(message, { secrets: exactSecrets });
+  const safeMessage = (0, import_gg_ai.redactText)(message, { secrets: exactSecrets });
   let line = `[${ts}] [sid=${sessionId}] [${level}] [${category}] ${safeMessage}`;
   if (data) {
-    const safeData = (0, import_gg_ai2.redactValue)(data, { secrets: exactSecrets });
+    const safeData = (0, import_gg_ai.redactValue)(data, { secrets: exactSecrets });
     const pairs = Object.entries(safeData).map(([k, v]) => {
       if (typeof v === "string") return `${k}=${v}`;
       if (typeof v === "bigint") return `${k}=${String(v)}`;
@@ -1511,9 +1933,9 @@ function log(level, category, message, data) {
 `;
     try {
       if (fileBytes + Buffer.byteLength(capLine) <= MAX_BYTES) {
-        fileBytes += import_node_fs2.default.writeSync(fd, capLine);
+        fileBytes += import_node_fs4.default.writeSync(fd, capLine);
       }
-      import_node_fs2.default.closeSync(fd);
+      import_node_fs4.default.closeSync(fd);
     } catch {
     }
     fd = null;
@@ -1523,7 +1945,7 @@ function log(level, category, message, data) {
   if (fileBytes + lineBytes > MAX_BYTES && !rotationFailed && !rotateOpenLog()) return;
   if (fd === null) return;
   try {
-    const written = import_node_fs2.default.writeSync(fd, line);
+    const written = import_node_fs4.default.writeSync(fd, line);
     fileBytes += written;
     processBytes += written;
   } catch {
@@ -1536,7 +1958,7 @@ function closeLogger(opts) {
   if (fd !== null) {
     if (opts?.shutdownLine !== false) log("INFO", "shutdown", `${appName} shutting down`);
     try {
-      if (fd !== null) import_node_fs2.default.closeSync(fd);
+      if (fd !== null) import_node_fs4.default.closeSync(fd);
     } catch {
     }
   }
@@ -1558,7 +1980,7 @@ function isHiddenProvider(provider) {
 }
 
 // src/auth-storage.ts
-var import_gg_ai3 = require("@kenkaiiii/gg-ai");
+var import_gg_ai2 = require("@kenkaiiii/gg-ai");
 
 // src/minimax-region.ts
 var MINIMAX_GLOBAL_BASE_URL = "https://api.minimax.io/anthropic";
@@ -1703,7 +2125,7 @@ function cachedMiniMaxRegion(apiKey) {
 }
 function readStoredBaseUrlSync(authFile, provider) {
   try {
-    const data = JSON.parse((0, import_node_fs3.readFileSync)(authFile, "utf-8"));
+    const data = JSON.parse((0, import_node_fs5.readFileSync)(authFile, "utf-8"));
     return activeBaseUrlEntry(data, provider)?.baseUrl;
   } catch {
     return void 0;
@@ -1717,6 +2139,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",
@@ -1797,11 +2221,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();
@@ -1814,7 +2271,7 @@ var AuthStorage = class {
    */
   async setLocalEndpoint(endpointId, baseUrl, apiKey) {
     await this.setCredentials(`${LOCAL_AUTH_KEY_PREFIX}${endpointId}`, {
-      accessToken: apiKey && apiKey.length > 0 ? apiKey : import_gg_ai3.LOCAL_NO_API_KEY,
+      accessToken: apiKey && apiKey.length > 0 ? apiKey : import_gg_ai2.LOCAL_NO_API_KEY,
       refreshToken: "",
       expiresAt: Date.now() + LOCAL_CREDENTIAL_LIFETIME_MS,
       baseUrl
@@ -1855,7 +2312,7 @@ var AuthStorage = class {
     const first = !this.loaded;
     await withFileLock(this.filePath, async () => {
       try {
-        const content = await import_promises3.default.readFile(this.filePath, "utf-8");
+        const content = await import_promises5.default.readFile(this.filePath, "utf-8");
         this.data = JSON.parse(content);
         if (first) {
           log("INFO", "auth", `Loaded credentials from ${this.filePath}`, {
@@ -1901,7 +2358,7 @@ var AuthStorage = class {
     }
     let changed;
     try {
-      const stat = await import_promises3.default.stat(this.filePath);
+      const stat = await import_promises5.default.stat(this.filePath);
       changed = stat.ino !== this.snapshotIno || stat.mtimeMs !== this.snapshotMtimeMs || stat.size !== this.snapshotSize;
     } catch {
       changed = this.snapshotSize !== -1;
@@ -1914,7 +2371,7 @@ var AuthStorage = class {
    */
   async rememberSnapshot() {
     try {
-      const stat = await import_promises3.default.stat(this.filePath);
+      const stat = await import_promises5.default.stat(this.filePath);
       this.snapshotMtimeMs = stat.mtimeMs;
       this.snapshotSize = stat.size;
       this.snapshotIno = stat.ino;
@@ -2055,7 +2512,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)) {
@@ -2078,6 +2535,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) {
@@ -2140,7 +2603,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);
@@ -2199,7 +2662,7 @@ var AuthStorage = class {
 };
 async function readAuthData(filePath) {
   try {
-    const content = await import_promises3.default.readFile(filePath, "utf-8");
+    const content = await import_promises5.default.readFile(filePath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (error.code === "ENOENT") return {};
@@ -2209,10 +2672,10 @@ async function readAuthData(filePath) {
 async function atomicWriteFile(filePath, content) {
   const tmpPath = `${filePath}.${process.pid}.${Date.now()}.${import_node_crypto6.default.randomUUID().slice(0, 8)}.tmp`;
   try {
-    await import_promises3.default.writeFile(tmpPath, content, { encoding: "utf-8", mode: 384 });
-    await import_promises3.default.rename(tmpPath, filePath);
+    await import_promises5.default.writeFile(tmpPath, content, { encoding: "utf-8", mode: 384 });
+    await import_promises5.default.rename(tmpPath, filePath);
   } catch (err) {
-    await import_promises3.default.unlink(tmpPath).catch(() => {
+    await import_promises5.default.unlink(tmpPath).catch(() => {
     });
     throw err;
   }
@@ -2415,9 +2878,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
@@ -2459,6 +2922,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.
@@ -3319,12 +3816,12 @@ function clampThinkingForPlanMode(level) {
 }
 
 // src/local-models.ts
-var import_gg_ai4 = require("@kenkaiiii/gg-ai");
+var import_gg_ai3 = require("@kenkaiiii/gg-ai");
 var DEFAULT_LOCAL_ENDPOINTS = [
   { id: "ollama", label: "Ollama", baseUrl: "http://127.0.0.1:11434/v1", kind: "ollama" }
 ];
 var FALLBACK_CONTEXT_WINDOW = 4096;
-var LOCAL_API_KEY_PLACEHOLDER = import_gg_ai4.LOCAL_NO_API_KEY;
+var LOCAL_API_KEY_PLACEHOLDER = import_gg_ai3.LOCAL_NO_API_KEY;
 var DEFAULT_PROBE_TIMEOUT_MS = 1200;
 var ENRICH_CONCURRENCY = 6;
 var CACHE_TTL_MS = 3e4;
@@ -3353,7 +3850,7 @@ function endpointRoot(baseUrl) {
   return baseUrl.replace(/\/+$/, "").replace(/\/v1$/, "");
 }
 function authHeaders(endpoint) {
-  const key = (0, import_gg_ai4.localBearerKey)(endpoint.apiKey);
+  const key = (0, import_gg_ai3.localBearerKey)(endpoint.apiKey);
   return {
     ...key ? { Authorization: `Bearer ${key}` } : {},
     Accept: "application/json"
@@ -3643,18 +4140,138 @@ function findProbedModel(probes, modelId) {
   return void 0;
 }
 
+// src/claude-code/usage.ts
+var import_promises6 = __toESM(require("fs/promises"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
+var USAGE_FILE = "usage.json";
+var WINDOWS = {
+  five_hour: { kind: "current", label: "5-hour" },
+  seven_day: { kind: "weekly", label: "Weekly" }
+};
+function finite(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function toWindow(key, raw) {
+  const shape = WINDOWS[key];
+  const fraction = finite(raw?.utilization);
+  if (!shape || fraction === void 0) return null;
+  const resetsAt = finite(raw?.resetsAt);
+  return {
+    ...shape,
+    usedPercent: Math.min(100, Math.max(0, fraction * 100)),
+    ...resetsAt !== void 0 ? { resetsAt: resetsAt * 1e3 } : {}
+  };
+}
+function mergeClaudeCodeRateLimit(info, previous, now = Date.now()) {
+  const reported = info.unifiedWindows ? Object.entries(info.unifiedWindows).map(([key, raw]) => toWindow(key, raw)) : info.rateLimitType ? [toWindow(info.rateLimitType, info)] : [];
+  const byKind = new Map(previous?.windows.map((w) => [w.kind, w]) ?? []);
+  for (const window of reported) if (window) byKind.set(window.kind, window);
+  const windows = [...byKind.values()].sort(
+    (a, b) => a.kind === b.kind ? 0 : a.kind === "current" ? -1 : 1
+  );
+  return { provider: "anthropic", displayName: "Anthropic", windows, fetchedAt: now };
+}
+function usagePath(opts) {
+  return import_node_path5.default.join(claudeCodeHome(opts), USAGE_FILE);
+}
+async function readClaudeCodeUsage(opts = {}) {
+  let parsed;
+  try {
+    parsed = JSON.parse(await import_promises6.default.readFile(usagePath(opts), "utf8"));
+  } catch {
+    return null;
+  }
+  if (!Array.isArray(parsed?.windows) || typeof parsed.fetchedAt !== "number") return null;
+  const now = opts.now ?? Date.now();
+  const windows = parsed.windows.filter(
+    (w) => (w.kind === "current" || w.kind === "weekly") && typeof w.usedPercent === "number" && (w.resetsAt === void 0 || w.resetsAt > now)
+  );
+  return { provider: "anthropic", displayName: "Anthropic", windows, fetchedAt: parsed.fetchedAt };
+}
+var writeQueue = Promise.resolve();
+function recordClaudeCodeRateLimit(info, opts = {}) {
+  const write = async () => {
+    const now = opts.now ?? Date.now();
+    const next = mergeClaudeCodeRateLimit(info, await readClaudeCodeUsage({ ...opts, now }), now);
+    if (next.windows.length === 0) return;
+    const file = usagePath(opts);
+    await import_promises6.default.mkdir(import_node_path5.default.dirname(file), { recursive: true });
+    await import_promises6.default.writeFile(file, JSON.stringify(next), "utf8");
+  };
+  writeQueue = writeQueue.then(write).catch(() => {
+  });
+  return writeQueue;
+}
+async function clearClaudeCodeUsage(opts = {}) {
+  await writeQueue;
+  await import_promises6.default.rm(usagePath(opts), { force: true }).catch(() => {
+  });
+}
+
+// src/claude-code/sign-in.ts
+async function signInWithClaudeCode(auth, callbacks, opts = {}) {
+  if (!opts.binary && !resolveClaudeCodeBinary(opts)) {
+    callbacks.onStatus("Downloading Claude Code (one time)\u2026");
+    await ensureClaudeCodeBinary({
+      ...opts,
+      onProgress: (progress) => {
+        callbacks.onStatus(formatClaudeCodeInstallProgress(progress));
+        opts.onProgress?.(progress);
+      }
+    });
+  }
+  let status = await claudeCodeAuthStatus(opts);
+  if (!status.loggedIn) {
+    callbacks.onStatus("Opening Claude sign-in\u2026");
+    await loginClaudeCode(callbacks, opts);
+    status = await claudeCodeAuthStatus(opts);
+  }
+  if (!status.loggedIn) throw new Error("Claude sign-in didn't finish. Try again.");
+  await auth.setClaudeCodeLogin();
+  return status;
+}
+async function signOutOfClaudeCode(auth, opts = {}) {
+  await auth.clearClaudeCodeLogin();
+  await clearClaudeCodeUsage(opts);
+  try {
+    await logoutClaudeCode(opts);
+  } catch (err) {
+    log(
+      "WARN",
+      "auth",
+      `claude auth logout failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+
 // src/auth-providers.ts
 var ALL_AUTH_PROVIDERS = [
   {
     value: "anthropic",
     label: "Anthropic",
     description: "Claude Fable 5.1, Opus 5.5, Opus 5.5 Fast, Sonnet 5.5, Haiku 5.5",
-    methods: ["oauth"]
+    methods: ["oauth", "apikey"],
+    apiKeyLabel: "Anthropic",
+    methodDetails: {
+      oauth: {
+        method: "oauth",
+        label: "Sign in with Claude",
+        billing: "Uses your Claude Pro or Max plan.",
+        when: "Runs through Anthropic's Claude Code, which GG Coder downloads once (about 140 MB) the first time you pick this.",
+        requires: "A Claude Pro or Max subscription."
+      },
+      apikey: {
+        method: "apikey",
+        label: "Anthropic API key",
+        billing: "Pay-per-token from an Anthropic Console key.",
+        when: "No subscription needed. Used only while you are not signed in with Claude."
+      }
+    }
   },
   {
     value: "openai",
     label: "OpenAI",
-    description: "GPT-6 Astra, GPT-6 Astra Fast, GPT-6.1 Sol, GPT-6.1 Sol Fast, GPT-6 Luna, GPT-6 Luna Fast",
+    description: "GPT-6 Astra, GPT-6 Astra Fast, GPT-6.1 Sol, GPT-6.1 Sol Fast, GPT-6.1 Terra, GPT-6.1 Terra Fast, GPT-6 Luna, GPT-6 Luna Fast",
     methods: ["oauth"]
   },
   {
@@ -3817,6 +4434,9 @@ function authPriorityNote(provider) {
   if (provider === "gemini") {
     return "Uses the Gemini API key first when one is set; otherwise the Google sign-in.";
   }
+  if (provider === "anthropic") {
+    return "Uses Sign in with Claude while you are signed in; otherwise the Anthropic API key.";
+  }
   const dual = dualAuthProvider(provider);
   if (!dual) return void 0;
   return `Uses ${dual.oauthLabel} first; the ${dual.apiKeyLabel} takes over when it runs out, then switches back.`;
@@ -3831,7 +4451,6 @@ var SubscriptionUsageError = class extends Error {
     this.name = "SubscriptionUsageError";
   }
 };
-var ANTHROPIC_USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
 var CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
 function finiteNumber(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
@@ -3899,45 +4518,6 @@ async function readUsageResponse(response, now) {
     throw new SubscriptionUsageError("Subscription usage response was not valid JSON");
   }
 }
-async function fetchAnthropicUsage(credentials, fetchFn, signal, now) {
-  const response = await fetchFn(ANTHROPIC_USAGE_URL, {
-    method: "GET",
-    signal,
-    headers: {
-      Authorization: `Bearer ${credentials.accessToken}`,
-      Accept: "application/json",
-      "anthropic-version": "2023-06-01",
-      "anthropic-beta": "oauth-2025-04-20",
-      "User-Agent": "ggcoder"
-    }
-  });
-  const data = await readUsageResponse(response, now());
-  const windows = [];
-  const currentPercent = clampPercent(data.five_hour?.utilization);
-  if (currentPercent !== void 0) {
-    windows.push({
-      kind: "current",
-      label: "5-hour",
-      usedPercent: currentPercent,
-      resetsAt: isoTimestamp(data.five_hour?.resets_at)
-    });
-  }
-  const weeklyPercent = clampPercent(data.seven_day?.utilization);
-  if (weeklyPercent !== void 0) {
-    windows.push({
-      kind: "weekly",
-      label: "Weekly",
-      usedPercent: weeklyPercent,
-      resetsAt: isoTimestamp(data.seven_day?.resets_at)
-    });
-  }
-  return {
-    provider: "anthropic",
-    displayName: "Anthropic",
-    windows,
-    fetchedAt: now()
-  };
-}
 async function fetchCodexUsage(credentials, fetchFn, signal, now) {
   const headers = {
     Authorization: `Bearer ${credentials.accessToken}`,
@@ -4053,7 +4633,7 @@ async function fetchSubscriptionUsage(provider, credentials, options = {}) {
   const now = options.now ?? Date.now;
   const signal = AbortSignal.timeout(options.timeoutMs ?? 8e3);
   try {
-    return provider === "anthropic" ? await fetchAnthropicUsage(credentials, fetchFn, signal, now) : provider === "openai" ? await fetchCodexUsage(credentials, fetchFn, signal, now) : await fetchKimiUsage(credentials, fetchFn, signal, now);
+    return provider === "openai" ? await fetchCodexUsage(credentials, fetchFn, signal, now) : await fetchKimiUsage(credentials, fetchFn, signal, now);
   } catch (error) {
     if (error instanceof SubscriptionUsageError) throw error;
     const message = error instanceof Error ? error.message : String(error);
@@ -4389,9 +4969,9 @@ async function transcribeVoice(fileUrl) {
 }
 
 // src/auto-update.ts
-var import_node_child_process2 = require("child_process");
-var import_node_fs4 = __toESM(require("fs"), 1);
-var import_node_path4 = __toESM(require("path"), 1);
+var import_node_child_process3 = require("child_process");
+var import_node_fs6 = __toESM(require("fs"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
 var CHECK_INTERVAL_MS = 60 * 60 * 1e3;
 var FETCH_TIMEOUT_MS = 1e4;
 function compareVersions(a, b) {
@@ -4406,7 +4986,7 @@ function compareVersions(a, b) {
 function performUpdateInBackground(command) {
   try {
     const parts = command.split(" ");
-    const child = (0, import_node_child_process2.spawn)(parts[0], parts.slice(1), {
+    const child = (0, import_node_child_process3.spawn)(parts[0], parts.slice(1), {
       detached: true,
       stdio: "ignore",
       env: { ...process.env, npm_config_loglevel: "silent" }
@@ -4424,7 +5004,7 @@ function createAutoUpdater(config) {
   }
   function readState() {
     try {
-      const raw = import_node_fs4.default.readFileSync(stateFilePath(), "utf-8");
+      const raw = import_node_fs6.default.readFileSync(stateFilePath(), "utf-8");
       return JSON.parse(raw);
     } catch {
       return null;
@@ -4433,8 +5013,8 @@ function createAutoUpdater(config) {
   function writeState(state) {
     try {
       const filePath = stateFilePath();
-      import_node_fs4.default.mkdirSync(import_node_path4.default.dirname(filePath), { recursive: true, mode: 448 });
-      import_node_fs4.default.writeFileSync(filePath, JSON.stringify(state));
+      import_node_fs6.default.mkdirSync(import_node_path6.default.dirname(filePath), { recursive: true, mode: 448 });
+      import_node_fs6.default.writeFileSync(filePath, JSON.stringify(state));
     } catch {
     }
   }
@@ -4560,6 +5140,9 @@ function createAutoUpdater(config) {
 0 && (module.exports = {
   AUTH_PROVIDERS,
   AuthStorage,
+  CLAUDE_CODE_AUTH_KEY,
+  CLAUDE_CODE_AUTH_MARKER,
+  CLAUDE_CODE_MANIFEST,
   DEFAULT_LOCAL_ENDPOINTS,
   DEFAULT_MAX_VIDEO_BYTES,
   FALLBACK_CONTEXT_WINDOW,
@@ -4582,6 +5165,14 @@ function createAutoUpdater(config) {
   XIAOMI_TOKEN_PLAN_BASE_URLS,
   authPriorityNote,
   clampThinkingForPlanMode,
+  claudeCodeAuthStatus,
+  claudeCodeBinaryPath,
+  claudeCodeCallbackUrl,
+  claudeCodeConfigDir,
+  claudeCodeEnv,
+  claudeCodeHome,
+  claudeCodePlatformKey,
+  clearClaudeCodeUsage,
   clearLocalDiscoveryCache,
   clearRuntimeModels,
   closeLogger,
@@ -4595,8 +5186,10 @@ function createAutoUpdater(config) {
   dualAuthProvider,
   dualAuthProviderByOAuthKey,
   endpointRoot,
+  ensureClaudeCodeBinary,
   fetchSubscriptionUsage,
   findProbedModel,
+  formatClaudeCodeInstallProgress,
   formatLocalModelId,
   generatePKCE,
   getAllModels,
@@ -4604,8 +5197,6 @@ function createAutoUpdater(config) {
   getAuthProvider,
   getAuthStorageKey,
   getAuthStorageKeys,
-  getClaudeCliUserAgent,
-  getClaudeCodeVersion,
   getContextWindow,
   getDefaultModel,
   getDefaultThinkingLevel,
@@ -4623,9 +5214,11 @@ function createAutoUpdater(config) {
   getVideoByteLimit,
   grokCliBaseUrl,
   grokCliHeaders,
+  isClaudeCodeAuthMarker,
   isGrokCliEndpoint,
   isHiddenProvider,
   isKimiCodingEndpoint,
+  isLegacyClaudeOAuth,
   isLocalModelId,
   isLoggerOpen,
   isModelLoaded,
@@ -4636,21 +5229,23 @@ function createAutoUpdater(config) {
   localAuthStorageKey,
   localModelShortName,
   log,
-  loginAnthropic,
+  loginClaudeCode,
   loginGemini,
   loginKimi,
   loginOpenAI,
   loginXai,
+  logoutClaudeCode,
+  mergeClaudeCodeRateLimit,
   oauthStorageKey,
   ollamaServedContext,
   openLog,
   parseLocalModelId,
   parseOpenRouterCatalog,
-  pendingClaudeCodeVersionRefresh,
   probeEndpoint,
   providerStorageKeys,
+  readClaudeCodeUsage,
   readStoredBaseUrlSync,
-  refreshAnthropicToken,
+  recordClaudeCodeRateLimit,
   refreshGeminiToken,
   refreshKimiToken,
   refreshOpenAIToken,
@@ -4658,8 +5253,11 @@ function createAutoUpdater(config) {
   registerLogCleanup,
   registerRuntimeModels,
   resample,
+  resolveClaudeCodeBinary,
   setProgressCallback,
   setProviderCatalog,
+  signInWithClaudeCode,
+  signOutOfClaudeCode,
   toModelInfo,
   transcribeVoice,
   usesOpenAICodexTransport,