@kenkaiiii/gg-core 4.4.0

package/dist/index.js

@@ -0,0 +1,1635 @@
+import {
+  MODELS,
+  getContextWindow,
+  getDefaultModel,
+  getMaxThinkingLevel,
+  getModel,
+  getModelsForProvider,
+  getSummaryModel,
+  usesOpenAICodexTransport
+} from "./chunk-USAVZGPP.js";
+import {
+  getAppPaths
+} from "./chunk-TZNVRILI.js";
+
+// src/thinking-level.ts
+var OPENAI_GPT_THINKING_LEVELS = ["medium", "high", "xhigh"];
+var ANTHROPIC_OPUS_48_47_THINKING_LEVELS = [
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+var ANTHROPIC_ADAPTIVE_THINKING_LEVELS = [
+  "low",
+  "medium",
+  "high",
+  "max"
+];
+function isOpenAIGptModel(provider, model) {
+  return provider === "openai" && model.startsWith("gpt-");
+}
+function isAnthropicOpus48Or47Model(provider, model) {
+  return provider === "anthropic" && /opus-4-8|opus-4-7/.test(model);
+}
+function isAnthropicAdaptiveModel(provider, model) {
+  return provider === "anthropic" && /opus-4-8|opus-4-7|opus-4-6|sonnet-4-6/.test(model);
+}
+function getSupportedThinkingLevels(provider, model) {
+  const maxLevel = getMaxThinkingLevel(model);
+  if (isAnthropicAdaptiveModel(provider, model)) {
+    const levels = isAnthropicOpus48Or47Model(provider, model) ? ANTHROPIC_OPUS_48_47_THINKING_LEVELS : ANTHROPIC_ADAPTIVE_THINKING_LEVELS;
+    const maxIndex2 = levels.indexOf(maxLevel);
+    if (maxIndex2 === -1) return ["low", "medium", "high"];
+    return levels.slice(0, maxIndex2 + 1);
+  }
+  if (!isOpenAIGptModel(provider, model)) return [maxLevel];
+  const maxIndex = OPENAI_GPT_THINKING_LEVELS.indexOf(maxLevel);
+  if (maxIndex === -1) return ["medium"];
+  return OPENAI_GPT_THINKING_LEVELS.slice(0, maxIndex + 1);
+}
+function isThinkingLevelSupported(provider, model, level) {
+  return getSupportedThinkingLevels(provider, model).includes(level);
+}
+function getNextThinkingLevel(provider, model, current) {
+  const supportedLevels = getSupportedThinkingLevels(provider, model);
+  const shouldCycleLevels = isOpenAIGptModel(provider, model) || isAnthropicAdaptiveModel(provider, model);
+  if (!shouldCycleLevels) {
+    return current ? void 0 : supportedLevels[0];
+  }
+  if (!current) return supportedLevels[0];
+  const index = supportedLevels.indexOf(current);
+  if (index === -1) return supportedLevels[0];
+  return supportedLevels[index + 1];
+}
+
+// src/logger.ts
+import fs from "fs";
+import path from "path";
+import { randomBytes } from "crypto";
+var MAX_BYTES = 10 * 1024 * 1024;
+var fd = null;
+var sessionId = "";
+var appName = "app";
+var cleanups = [];
+function rotateIfNeeded(filePath) {
+  try {
+    const st = fs.statSync(filePath);
+    if (st.size < MAX_BYTES) return;
+    const rotated = `${filePath}.1`;
+    try {
+      fs.unlinkSync(rotated);
+    } catch {
+    }
+    fs.renameSync(filePath, rotated);
+  } catch {
+  }
+}
+function openLog(filePath, name) {
+  if (fd !== null) return false;
+  appName = name;
+  try {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 448 });
+  } catch {
+  }
+  rotateIfNeeded(filePath);
+  try {
+    fd = fs.openSync(filePath, "a");
+  } catch {
+    return false;
+  }
+  sessionId = randomBytes(4).toString("hex");
+  try {
+    fs.writeSync(fd, "\n");
+  } catch {
+  }
+  return true;
+}
+function getSessionId() {
+  return sessionId;
+}
+function isLoggerOpen() {
+  return fd !== null;
+}
+function log(level, category, message, data) {
+  if (fd === null) return;
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  let line = `[${ts}] [sid=${sessionId}] [${level}] [${category}] ${message}`;
+  if (data) {
+    const pairs = Object.entries(data).map(([k, v]) => `${k}=${typeof v === "string" ? v : JSON.stringify(v)}`).join(" ");
+    if (pairs) line += ` ${pairs}`;
+  }
+  line += "\n";
+  try {
+    fs.writeSync(fd, line);
+  } catch {
+  }
+}
+function registerLogCleanup(fn) {
+  cleanups.push(fn);
+}
+function closeLogger(opts) {
+  if (fd === null) return;
+  if (opts?.shutdownLine !== false) log("INFO", "shutdown", `${appName} shutting down`);
+  try {
+    fs.closeSync(fd);
+  } catch {
+  }
+  fd = null;
+  for (const unsub of cleanups) unsub();
+  cleanups = [];
+}
+
+// src/file-lock.ts
+import fs2 from "fs/promises";
+import { setTimeout as setTimeout2 } from "timers/promises";
+var STALE_TIMEOUT_MS = 1e4;
+var RETRY_INTERVAL_MS = 50;
+var MAX_WAIT_MS = 5e3;
+async function withFileLock(filePath, fn) {
+  const lockPath = filePath + ".lock";
+  await acquireLock(lockPath);
+  try {
+    return await fn();
+  } finally {
+    await releaseLock(lockPath);
+  }
+}
+async function acquireLock(lockPath) {
+  const startTime = Date.now();
+  while (true) {
+    try {
+      const info = { pid: process.pid, timestamp: Date.now() };
+      await fs2.writeFile(lockPath, JSON.stringify(info), { flag: "wx" });
+      return;
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+      try {
+        const content = await fs2.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 fs2.unlink(lockPath).catch(() => {
+          });
+          continue;
+        }
+      } catch {
+        await fs2.unlink(lockPath).catch(() => {
+        });
+        continue;
+      }
+      if (Date.now() - startTime > MAX_WAIT_MS) {
+        await fs2.unlink(lockPath).catch(() => {
+        });
+        continue;
+      }
+      await setTimeout2(RETRY_INTERVAL_MS);
+    }
+  }
+}
+async function releaseLock(lockPath) {
+  await fs2.unlink(lockPath).catch(() => {
+  });
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    if (err.code === "EPERM") return true;
+    return false;
+  }
+}
+
+// src/claude-code-version.ts
+import fs3 from "fs/promises";
+import path2 from "path";
+var NPM_LATEST_URL = "https://registry.npmjs.org/@anthropic-ai/claude-code/latest";
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var FETCH_TIMEOUT_MS = 3e3;
+var FALLBACK_VERSION = "2.1.88";
+var memoryCache = null;
+var inflight = null;
+function cachePath() {
+  return path2.join(getAppPaths().agentDir, "claude-code-version.json");
+}
+async function readDiskCache() {
+  try {
+    const raw = await fs3.readFile(cachePath(), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.version === "string" && typeof parsed.fetchedAt === "number") {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function writeDiskCache(data) {
+  try {
+    await fs3.mkdir(getAppPaths().agentDir, { recursive: true, mode: 448 });
+    await fs3.writeFile(cachePath(), JSON.stringify(data), { mode: 384 });
+  } catch (err) {
+    log(
+      "WARN",
+      "claude-code-version",
+      `Failed to write cache: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+async function fetchLatest() {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const response = await fetch(NPM_LATEST_URL, { signal: controller.signal });
+    if (!response.ok) return null;
+    const data = await response.json();
+    if (typeof data.version === "string" && /^\d/.test(data.version)) {
+      return data.version;
+    }
+    return null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function getClaudeCodeVersion() {
+  if (memoryCache && Date.now() < memoryCache.expiresAt) {
+    return memoryCache.version;
+  }
+  if (inflight) return inflight;
+  inflight = (async () => {
+    const disk = await readDiskCache();
+    const diskFresh = disk && Date.now() - disk.fetchedAt < CACHE_TTL_MS;
+    if (disk && diskFresh) {
+      memoryCache = { version: disk.version, expiresAt: Date.now() + CACHE_TTL_MS };
+      return disk.version;
+    }
+    const fetched = await fetchLatest();
+    if (fetched) {
+      await writeDiskCache({ version: fetched, fetchedAt: Date.now() });
+      memoryCache = { version: fetched, expiresAt: Date.now() + CACHE_TTL_MS };
+      return fetched;
+    }
+    const resolved = disk?.version ?? FALLBACK_VERSION;
+    memoryCache = { version: resolved, expiresAt: Date.now() + 5 * 60 * 1e3 };
+    log(
+      "WARN",
+      "claude-code-version",
+      `Failed to fetch latest Claude Code version; using ${resolved}`
+    );
+    return resolved;
+  })();
+  try {
+    return await inflight;
+  } finally {
+    inflight = null;
+  }
+}
+async function getClaudeCliUserAgent() {
+  const version = await getClaudeCodeVersion();
+  return `claude-cli/${version} (external, cli)`;
+}
+
+// src/auth-storage.ts
+import fs4 from "fs/promises";
+import crypto5 from "crypto";
+
+// src/oauth/anthropic.ts
+import crypto2 from "crypto";
+
+// 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/anthropic.ts
+var CLIENT_ID = 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;
+    try {
+      response = await fetch(url, { method: "POST", headers, body: encoded });
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+      continue;
+    }
+    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}`);
+    }
+    lastError = new Error(`Anthropic ${label} failed (${response.status}): ${text}`);
+  }
+  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 loginAnthropic(callbacks) {
+  const { verifier, challenge } = await generatePKCE();
+  const state = crypto2.randomBytes(16).toString("hex");
+  const params = new URLSearchParams({
+    code: "true",
+    client_id: CLIENT_ID,
+    response_type: "code",
+    redirect_uri: REDIRECT_URI,
+    scope: SCOPES,
+    code_challenge: challenge,
+    code_challenge_method: "S256",
+    state
+  });
+  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.");
+  }
+  return exchangeAnthropicCode(parts[0], parts[1], verifier);
+}
+async function exchangeAnthropicCode(code, state, verifier) {
+  const data = await postTokenRequest(
+    {
+      grant_type: "authorization_code",
+      client_id: CLIENT_ID,
+      code,
+      state,
+      redirect_uri: REDIRECT_URI,
+      code_verifier: verifier
+    },
+    "token exchange"
+  );
+  return toCredentials(data);
+}
+async function refreshAnthropicToken(refreshToken) {
+  const data = await postTokenRequest(
+    {
+      grant_type: "refresh_token",
+      client_id: CLIENT_ID,
+      refresh_token: refreshToken
+    },
+    "token refresh"
+  );
+  return toCredentials(data);
+}
+
+// src/oauth/openai.ts
+import http from "http";
+import crypto3 from "crypto";
+var CLIENT_ID2 = "app_EMoamEEZ73f0CkXaXp7hrann";
+var AUTHORIZE_URL2 = "https://auth.openai.com/oauth/authorize";
+var TOKEN_URL = "https://auth.openai.com/oauth/token";
+var REDIRECT_URI2 = "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";
+async function loginOpenAI(callbacks) {
+  const { verifier, challenge } = await generatePKCE();
+  const state = crypto3.randomBytes(16).toString("hex");
+  const url = new URL(AUTHORIZE_URL2);
+  url.searchParams.set("response_type", "code");
+  url.searchParams.set("client_id", CLIENT_ID2);
+  url.searchParams.set("redirect_uri", REDIRECT_URI2);
+  url.searchParams.set("scope", SCOPE);
+  url.searchParams.set("code_challenge", challenge);
+  url.searchParams.set("code_challenge_method", "S256");
+  url.searchParams.set("state", state);
+  url.searchParams.set("id_token_add_organizations", "true");
+  url.searchParams.set("codex_cli_simplified_flow", "true");
+  url.searchParams.set("originator", "ggcoder");
+  let code;
+  try {
+    code = await loginWithServer(url.toString(), state, callbacks);
+  } catch {
+    callbacks.onOpenUrl(url.toString());
+    const raw = await callbacks.onPromptCode(
+      "Could not start local server. Paste the callback URL or code from the browser:"
+    );
+    const parsed = parseAuthorizationInput(raw);
+    if (!parsed.code) {
+      throw new Error("No authorization code found in input.");
+    }
+    code = parsed.code;
+  }
+  const creds = await exchangeOpenAICode(code, verifier);
+  const accountId = getAccountId(creds.accessToken);
+  if (!accountId) {
+    throw new Error("Failed to extract accountId from OpenAI token.");
+  }
+  creds.accountId = accountId;
+  return creds;
+}
+function parseAuthorizationInput(input) {
+  const value = input.trim();
+  if (!value) return {};
+  try {
+    const url = new URL(value);
+    return {
+      code: url.searchParams.get("code") ?? void 0,
+      state: url.searchParams.get("state") ?? void 0
+    };
+  } catch {
+  }
+  if (value.includes("#")) {
+    const [code, state] = value.split("#", 2);
+    return { code, state };
+  }
+  if (value.includes("code=")) {
+    const params = new URLSearchParams(value);
+    return {
+      code: params.get("code") ?? void 0,
+      state: params.get("state") ?? void 0
+    };
+  }
+  return { code: value };
+}
+function decodeJwt(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3) return null;
+    const decoded = atob(parts[1]);
+    return JSON.parse(decoded);
+  } catch {
+    return null;
+  }
+}
+function getAccountId(accessToken) {
+  const payload = decodeJwt(accessToken);
+  const auth = payload?.[JWT_CLAIM_PATH];
+  const accountId = auth?.chatgpt_account_id;
+  return typeof accountId === "string" && accountId.length > 0 ? accountId : null;
+}
+async function loginWithServer(authUrl, expectedState, callbacks) {
+  return new Promise((resolve, reject) => {
+    let receivedCode = null;
+    const server = http.createServer((req, res) => {
+      const url = new URL(req.url || "", "http://localhost");
+      if (url.pathname !== "/auth/callback") {
+        res.statusCode = 404;
+        res.end("Not found");
+        return;
+      }
+      if (url.searchParams.get("state") !== expectedState) {
+        res.statusCode = 400;
+        res.end("State mismatch");
+        return;
+      }
+      receivedCode = url.searchParams.get("code");
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end("<html><body><h1>Login successful!</h1><p>You can close this tab.</p></body></html>");
+      server.close();
+    });
+    server.on("error", (err) => {
+      reject(err);
+    });
+    server.listen(1455, "127.0.0.1", () => {
+      callbacks.onOpenUrl(authUrl);
+      callbacks.onStatus("Waiting for browser callback...");
+    });
+    const timeout = setTimeout(() => {
+      if (!receivedCode) {
+        server.close();
+      }
+    }, 12e4);
+    timeout.unref();
+    server.on("close", () => {
+      clearTimeout(timeout);
+      if (receivedCode) {
+        resolve(receivedCode);
+      } else {
+        reject(new Error("Server closed without receiving code"));
+      }
+    });
+  });
+}
+async function exchangeOpenAICode(code, verifier) {
+  const response = await fetch(TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      client_id: CLIENT_ID2,
+      code,
+      redirect_uri: REDIRECT_URI2,
+      code_verifier: verifier
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`OpenAI token exchange failed (${response.status}): ${text}`);
+  }
+  const data = await response.json();
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token,
+    expiresAt: Date.now() + data.expires_in * 1e3
+  };
+}
+async function refreshOpenAIToken(refreshToken) {
+  const response = await fetch(TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: refreshToken,
+      client_id: CLIENT_ID2
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`OpenAI token refresh failed (${response.status}): ${text}`);
+  }
+  const data = await response.json();
+  const creds = {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token,
+    expiresAt: Date.now() + data.expires_in * 1e3
+  };
+  const accountId = getAccountId(creds.accessToken);
+  if (accountId) {
+    creds.accountId = accountId;
+  }
+  return creds;
+}
+
+// src/oauth/gemini.ts
+import http2 from "http";
+import crypto4 from "crypto";
+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 TOKEN_URL2 = "https://oauth2.googleapis.com/token";
+var CODE_ASSIST_BASE_URL = "https://cloudcode-pa.googleapis.com";
+var CODE_ASSIST_API_VERSION = "v1internal";
+var CODE_ASSIST_POST_RETRIES = 3;
+var CODE_ASSIST_POST_RETRY_DELAY_MS = 100;
+var SCOPE2 = [
+  "https://www.googleapis.com/auth/cloud-platform",
+  "https://www.googleapis.com/auth/userinfo.email",
+  "https://www.googleapis.com/auth/userinfo.profile"
+].join(" ");
+var USER_TIER_FREE = "free-tier";
+var USER_TIER_LEGACY = "legacy-tier";
+var USER_TIER_STANDARD = "standard-tier";
+var VALIDATION_REQUIRED_REASON = "VALIDATION_REQUIRED";
+var VPC_SC_REASON = "SECURITY_POLICY_VIOLATED";
+var CodeAssistHttpError = class extends Error {
+  status;
+  body;
+  constructor(label, status, body) {
+    super(`Gemini Code Assist ${label} failed (${status}): ${body}`);
+    this.name = "CodeAssistHttpError";
+    this.status = status;
+    this.body = body;
+  }
+};
+async function loginGemini(callbacks) {
+  const { clientId, clientSecret } = getGeminiOAuthClientCredentials();
+  const { verifier, challenge } = await generatePKCE();
+  const state = crypto4.randomBytes(32).toString("hex");
+  const redirectUri = await getLoopbackRedirectUri();
+  const url = new URL(AUTHORIZE_URL3);
+  url.searchParams.set("response_type", "code");
+  url.searchParams.set("client_id", clientId);
+  url.searchParams.set("redirect_uri", redirectUri);
+  url.searchParams.set("scope", SCOPE2);
+  url.searchParams.set("access_type", "offline");
+  url.searchParams.set("prompt", "consent");
+  url.searchParams.set("code_challenge", challenge);
+  url.searchParams.set("code_challenge_method", "S256");
+  url.searchParams.set("state", state);
+  let code;
+  try {
+    code = await loginWithServer2(url.toString(), redirectUri, state, callbacks);
+  } catch {
+    callbacks.onOpenUrl(url.toString());
+    const raw = await callbacks.onPromptCode(
+      "Could not start local server. Paste the callback URL or code from the browser:"
+    );
+    const parsed = parseAuthorizationInput2(raw);
+    if (!parsed.code) {
+      throw new Error("No authorization code found in input.");
+    }
+    if (parsed.state && parsed.state !== state) {
+      throw new Error("Invalid state. Please try again.");
+    }
+    code = parsed.code;
+  }
+  const creds = await exchangeGeminiCode(code, verifier, redirectUri, clientId, clientSecret);
+  callbacks.onStatus("Setting up Gemini Code Assist access...");
+  const projectId = await setupCodeAssistProject(creds.accessToken, callbacks);
+  return {
+    ...creds,
+    projectId
+  };
+}
+async function refreshGeminiToken(refreshToken) {
+  const { clientId, clientSecret } = getGeminiOAuthClientCredentials();
+  const data = await postTokenRequest2({
+    grant_type: "refresh_token",
+    refresh_token: refreshToken,
+    client_id: clientId,
+    client_secret: clientSecret
+  });
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token ?? refreshToken,
+    expiresAt: Date.now() + data.expires_in * 1e3 - 5 * 60 * 1e3
+  };
+}
+function getGeminiOAuthClientCredentials() {
+  const clientId = process.env[CLIENT_ID_ENV]?.trim() || DEFAULT_CLIENT_ID;
+  const clientSecret = process.env[CLIENT_SECRET_ENV]?.trim() || DEFAULT_CLIENT_SECRET;
+  return { clientId, clientSecret };
+}
+async function getLoopbackRedirectUri() {
+  return new Promise((resolve, reject) => {
+    const server = http2.createServer();
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      server.close(() => {
+        if (addr && typeof addr === "object") {
+          resolve(`http://127.0.0.1:${addr.port}/oauth2callback`);
+        } else {
+          reject(new Error("Failed to allocate OAuth callback port."));
+        }
+      });
+    });
+    server.on("error", reject);
+  });
+}
+function parseAuthorizationInput2(input) {
+  const value = input.trim();
+  if (!value) return {};
+  try {
+    const url = new URL(value);
+    return {
+      code: url.searchParams.get("code") ?? void 0,
+      state: url.searchParams.get("state") ?? void 0
+    };
+  } catch {
+  }
+  if (value.includes("code=")) {
+    const params = new URLSearchParams(value);
+    return {
+      code: params.get("code") ?? void 0,
+      state: params.get("state") ?? void 0
+    };
+  }
+  return { code: value };
+}
+async function loginWithServer2(authUrl, redirectUri, expectedState, callbacks) {
+  const redirect = new URL(redirectUri);
+  const port = Number(redirect.port);
+  return new Promise((resolve, reject) => {
+    let receivedCode = null;
+    const server = http2.createServer((req, res) => {
+      const url = new URL(req.url || "", redirect.origin);
+      if (url.pathname !== redirect.pathname) {
+        res.statusCode = 404;
+        res.end("Not found");
+        return;
+      }
+      if (url.searchParams.get("state") !== expectedState) {
+        res.statusCode = 400;
+        res.end("State mismatch");
+        return;
+      }
+      receivedCode = url.searchParams.get("code");
+      res.writeHead(200, { "Content-Type": "text/html", Connection: "close" });
+      res.end("<html><body><h1>Login successful!</h1><p>You can close this tab.</p></body></html>");
+      server.close();
+    });
+    server.on("error", (err) => reject(err));
+    server.listen(port, "127.0.0.1", () => {
+      callbacks.onOpenUrl(authUrl);
+      callbacks.onStatus("Waiting for browser callback...");
+    });
+    const timeout = setTimeout(() => {
+      if (!receivedCode) server.close();
+    }, 12e4);
+    timeout.unref();
+    server.on("close", () => {
+      clearTimeout(timeout);
+      if (receivedCode) {
+        resolve(receivedCode);
+      } else {
+        reject(new Error("Server closed without receiving code."));
+      }
+    });
+  });
+}
+async function exchangeGeminiCode(code, verifier, redirectUri, clientId, clientSecret) {
+  const data = await postTokenRequest2({
+    grant_type: "authorization_code",
+    client_id: clientId,
+    client_secret: clientSecret,
+    code,
+    redirect_uri: redirectUri,
+    code_verifier: verifier
+  });
+  if (!data.refresh_token) {
+    throw new Error("Gemini OAuth did not return a refresh token. Please try login again.");
+  }
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token,
+    expiresAt: Date.now() + data.expires_in * 1e3 - 5 * 60 * 1e3
+  };
+}
+async function postTokenRequest2(body) {
+  const response = await fetch(TOKEN_URL2, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams(body)
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Gemini token request failed (${response.status}): ${text}`);
+  }
+  return await response.json();
+}
+async function setupCodeAssistProject(accessToken, callbacks) {
+  const envProject = process.env.GOOGLE_CLOUD_PROJECT ?? process.env.GOOGLE_CLOUD_PROJECT_ID;
+  if (envProject && /^\d+$/.test(envProject)) {
+    throw new Error("GOOGLE_CLOUD_PROJECT must be a project ID, not a numeric project number.");
+  }
+  const coreMetadata = {
+    ideType: "IDE_UNSPECIFIED",
+    platform: "PLATFORM_UNSPECIFIED",
+    pluginType: "GEMINI"
+  };
+  const projectMetadata = {
+    ...coreMetadata,
+    ...envProject ? { duetProject: envProject } : {}
+  };
+  let loadRes;
+  while (true) {
+    loadRes = await loadCodeAssist(accessToken, envProject, projectMetadata);
+    const validation = getValidationRequiredTier(loadRes);
+    if (!validation) break;
+    callbacks.onStatus(
+      `Gemini Code Assist requires account validation${validation.reasonMessage ? `: ${validation.reasonMessage}` : ""}`
+    );
+    callbacks.onOpenUrl(validation.validationUrl);
+    const answer = await callbacks.onPromptCode(
+      "Complete validation in the browser, then press Enter to retry (or type cancel):"
+    );
+    if (answer.trim().toLowerCase() === "cancel") {
+      throw new Error("Gemini Code Assist account validation was cancelled.");
+    }
+  }
+  if (loadRes.currentTier) {
+    const project2 = loadRes.cloudaicompanionProject ?? envProject;
+    if (!project2) throwProjectError(loadRes);
+    return project2;
+  }
+  const tier = getOnboardTier(loadRes);
+  const onboardReq = tier.id === USER_TIER_FREE ? {
+    tierId: tier.id,
+    cloudaicompanionProject: void 0,
+    metadata: coreMetadata
+  } : {
+    tierId: tier.id,
+    cloudaicompanionProject: envProject,
+    metadata: projectMetadata
+  };
+  let operation = await codeAssistPost(
+    accessToken,
+    "onboardUser",
+    onboardReq
+  );
+  while (!operation.done && operation.name) {
+    await new Promise((resolve) => setTimeout(resolve, 5e3));
+    operation = await codeAssistGet(accessToken, operation.name);
+  }
+  const project = operation.response?.cloudaicompanionProject?.id ?? envProject;
+  if (!project) throwProjectError(loadRes);
+  return project;
+}
+async function loadCodeAssist(accessToken, envProject, metadata) {
+  try {
+    return await codeAssistPost(accessToken, "loadCodeAssist", {
+      ...envProject ? { cloudaicompanionProject: envProject } : {},
+      metadata
+    });
+  } catch (err) {
+    if (err instanceof CodeAssistHttpError && isVpcScAffectedError(err)) {
+      return { currentTier: { id: USER_TIER_STANDARD } };
+    }
+    if (err instanceof CodeAssistHttpError && err.status === 403 && envProject === "cloudshell-gca") {
+      throw new Error(
+        "Access to the default Cloud Shell Gemini project was denied.\nPlease set your own Google Cloud project by running:\ngcloud config set project [PROJECT_ID]\nor setting export GOOGLE_CLOUD_PROJECT=...",
+        { cause: err }
+      );
+    }
+    throw err;
+  }
+}
+function getValidationRequiredTier(response) {
+  return response.ineligibleTiers?.find(
+    (tier) => tier.reasonCode === VALIDATION_REQUIRED_REASON && typeof tier.validationUrl === "string"
+  );
+}
+function getOnboardTier(response) {
+  const defaultTier = response.allowedTiers?.find((tier) => tier.isDefault);
+  return defaultTier ?? { id: USER_TIER_LEGACY, name: "" };
+}
+function throwProjectError(response) {
+  const reasons = response.ineligibleTiers?.map((tier) => tier.reasonMessage ?? tier.tierName).filter((reason) => Boolean(reason));
+  if (reasons && reasons.length > 0) {
+    throw new Error(`Gemini Code Assist setup failed: ${reasons.join(", ")}`);
+  }
+  throw new Error(
+    "Gemini requires a Google Cloud project for this account. Set GOOGLE_CLOUD_PROJECT and try again."
+  );
+}
+async function codeAssistPost(accessToken, method, body) {
+  let lastError;
+  for (let attempt = 0; attempt <= CODE_ASSIST_POST_RETRIES; attempt++) {
+    try {
+      return await codeAssistRequest(getCodeAssistMethodUrl(method), accessToken, method, {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+    } catch (err) {
+      if (!(err instanceof CodeAssistHttpError) || attempt === CODE_ASSIST_POST_RETRIES || !shouldRetryCodeAssistStatus(err.status)) {
+        throw err;
+      }
+      lastError = err;
+    }
+    await new Promise((resolve) => setTimeout(resolve, CODE_ASSIST_POST_RETRY_DELAY_MS));
+  }
+  throw lastError ?? new Error(`Gemini Code Assist ${method} failed.`);
+}
+async function codeAssistGet(accessToken, operationName) {
+  return codeAssistRequest(getCodeAssistOperationUrl(operationName), accessToken, "operation", {
+    method: "GET"
+  });
+}
+async function codeAssistRequest(url, accessToken, label, init) {
+  const response = await fetch(url, {
+    ...init,
+    headers: codeAssistHeaders(accessToken)
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new CodeAssistHttpError(label, response.status, text);
+  }
+  return await response.json();
+}
+function getCodeAssistBaseUrl() {
+  const endpoint = process.env.CODE_ASSIST_ENDPOINT ?? CODE_ASSIST_BASE_URL;
+  const version = process.env.CODE_ASSIST_API_VERSION || CODE_ASSIST_API_VERSION;
+  return `${endpoint}/${version}`;
+}
+function getCodeAssistMethodUrl(method) {
+  return `${getCodeAssistBaseUrl()}:${method}`;
+}
+function getCodeAssistOperationUrl(operationName) {
+  return `${getCodeAssistBaseUrl()}/${operationName}`;
+}
+function shouldRetryCodeAssistStatus(status) {
+  return status === 429 || status === 499 || status >= 500 && status <= 599;
+}
+function isVpcScAffectedError(error) {
+  try {
+    const parsed = JSON.parse(error.body);
+    if (!parsed || typeof parsed !== "object" || !("error" in parsed)) return false;
+    const details = parsed.error?.details;
+    return Array.isArray(details) ? details.some(
+      (detail) => detail != null && typeof detail === "object" && "reason" in detail && detail.reason === VPC_SC_REASON
+    ) : false;
+  } catch {
+    return false;
+  }
+}
+function codeAssistHeaders(accessToken) {
+  return {
+    Authorization: `Bearer ${accessToken}`,
+    "Content-Type": "application/json",
+    "User-Agent": "google-gemini-cli",
+    "X-Goog-Api-Client": "gemini-cli/0.0.0"
+  };
+}
+
+// src/auth-storage.ts
+var AuthStorage = class {
+  data = {};
+  filePath;
+  loaded = false;
+  /** Per-provider lock to serialize concurrent refresh calls. */
+  refreshLocks = /* @__PURE__ */ new Map();
+  constructor(filePath) {
+    this.filePath = filePath ?? getAppPaths().authFile;
+  }
+  /** Path to the on-disk auth file. Useful for status output. */
+  get path() {
+    return this.filePath;
+  }
+  /** List provider keys with stored credentials. */
+  async listProviders() {
+    await this.ensureLoaded();
+    return Object.keys(this.data);
+  }
+  /** True if credentials exist for `provider`. */
+  async hasCredentials(provider) {
+    await this.ensureLoaded();
+    return Boolean(this.data[provider]);
+  }
+  async load() {
+    await withFileLock(this.filePath, async () => {
+      try {
+        const content = await fs4.readFile(this.filePath, "utf-8");
+        this.data = JSON.parse(content);
+        log("INFO", "auth", `Loaded credentials from ${this.filePath}`, {
+          providers: Object.keys(this.data).join(",") || "(none)"
+        });
+      } catch (err) {
+        this.data = {};
+        const code = err.code;
+        if (code === "ENOENT") {
+          log("INFO", "auth", `No auth file found at ${this.filePath} (first run)`);
+        } else {
+          log(
+            "ERROR",
+            "auth",
+            `Failed to load auth file: ${err instanceof Error ? err.message : String(err)}`,
+            { path: this.filePath, code: code ?? "unknown" }
+          );
+        }
+      }
+    });
+    this.loaded = true;
+  }
+  async ensureLoaded() {
+    if (!this.loaded) await this.load();
+  }
+  async getCredentials(provider) {
+    await this.ensureLoaded();
+    return this.data[provider];
+  }
+  async setCredentials(provider, creds) {
+    await this.ensureLoaded();
+    this.data[provider] = creds;
+    await this.save();
+  }
+  async clearCredentials(provider) {
+    await this.ensureLoaded();
+    delete this.data[provider];
+    await this.save();
+  }
+  async clearAll() {
+    this.data = {};
+    await this.save();
+  }
+  /**
+   * Returns valid credentials, auto-refreshing if expired.
+   * If `forceRefresh` is true, refreshes even if the token hasn't expired
+   * (useful when the provider rejects a token with 401 before its stored expiry).
+   * Throws if not logged in.
+   */
+  async resolveCredentials(provider, opts) {
+    await this.ensureLoaded();
+    const creds = this.data[provider];
+    if (!creds) {
+      throw new NotLoggedInError(provider);
+    }
+    if (provider === "glm" || provider === "moonshot" || provider === "xiaomi" || provider === "minimax" || provider === "deepseek" || provider === "openrouter") {
+      return creds;
+    }
+    if (!opts?.forceRefresh && Date.now() < creds.expiresAt) {
+      return creds;
+    }
+    const existing = this.refreshLocks.get(provider);
+    if (existing) return existing;
+    const refreshPromise = withFileLock(this.filePath, async () => {
+      try {
+        const content = await fs4.readFile(this.filePath, "utf-8");
+        const freshData = JSON.parse(content);
+        const freshCreds = freshData[provider];
+        if (freshCreds && !opts?.forceRefresh && Date.now() < freshCreds.expiresAt) {
+          this.data[provider] = freshCreds;
+          return freshCreds;
+        }
+      } catch {
+      }
+      const refreshFn = provider === "anthropic" ? refreshAnthropicToken : provider === "gemini" ? refreshGeminiToken : refreshOpenAIToken;
+      let refreshed;
+      try {
+        refreshed = await refreshFn(creds.refreshToken);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        const isAuthFailure = /\((401|400)\)/.test(msg) || /invalid_grant|invalid_token|invalid.*refresh/i.test(msg) || /unauthorized/i.test(msg);
+        if (isAuthFailure) {
+          delete this.data[provider];
+          await atomicWriteFile(this.filePath, JSON.stringify(this.data, null, 2));
+          throw new NotLoggedInError(provider);
+        }
+        throw err;
+      }
+      if (!refreshed.accountId && creds.accountId) {
+        refreshed.accountId = creds.accountId;
+      }
+      if (!refreshed.projectId && creds.projectId) {
+        refreshed.projectId = creds.projectId;
+      }
+      this.data[provider] = refreshed;
+      await atomicWriteFile(this.filePath, JSON.stringify(this.data, null, 2));
+      return refreshed;
+    });
+    this.refreshLocks.set(provider, refreshPromise);
+    try {
+      return await refreshPromise;
+    } finally {
+      this.refreshLocks.delete(provider);
+    }
+  }
+  /**
+   * Returns a valid access token, auto-refreshing if expired.
+   * Throws if not logged in.
+   */
+  async resolveToken(provider) {
+    const creds = await this.resolveCredentials(provider);
+    return creds.accessToken;
+  }
+  async save() {
+    await withFileLock(this.filePath, async () => {
+      await atomicWriteFile(this.filePath, JSON.stringify(this.data, null, 2));
+    });
+  }
+};
+async function atomicWriteFile(filePath, content) {
+  const tmpPath = `${filePath}.${process.pid}.${Date.now()}.${crypto5.randomUUID().slice(0, 8)}.tmp`;
+  try {
+    await fs4.writeFile(tmpPath, content, { encoding: "utf-8", mode: 384 });
+    await fs4.rename(tmpPath, filePath);
+  } catch (err) {
+    await fs4.unlink(tmpPath).catch(() => {
+    });
+    throw err;
+  }
+}
+var NotLoggedInError = class extends Error {
+  provider;
+  constructor(provider) {
+    super(`Not logged in to ${provider}. Run "ggcoder login" to authenticate.`);
+    this.name = "NotLoggedInError";
+    this.provider = provider;
+  }
+};
+
+// src/telegram.ts
+var TELEGRAM_API = "https://api.telegram.org";
+var MAX_MESSAGE_LENGTH = 4096;
+var TelegramBot = class {
+  token;
+  allowedUserId;
+  offset = 0;
+  running = false;
+  onMessage = null;
+  onVoiceMessage = null;
+  onCallback = null;
+  onBotAdded = null;
+  onBotRemoved = null;
+  constructor(config) {
+    this.token = config.botToken;
+    this.allowedUserId = config.allowedUserId;
+  }
+  /** Register handler for incoming text messages. */
+  onText(handler) {
+    this.onMessage = handler;
+  }
+  /** Register handler for incoming voice notes. */
+  onVoice(handler) {
+    this.onVoiceMessage = handler;
+  }
+  /** Register handler for inline keyboard button presses. */
+  onCallbackQuery(handler) {
+    this.onCallback = handler;
+  }
+  /** Register handler for when the bot is added to a group. */
+  onAddedToGroup(handler) {
+    this.onBotAdded = handler;
+  }
+  /** Register handler for when the bot is removed from a group. */
+  onRemovedFromGroup(handler) {
+    this.onBotRemoved = handler;
+  }
+  /** Start long polling. Blocks until stop() is called. */
+  async start() {
+    this.running = true;
+    const me = await this.apiCall("getMe");
+    if (!me.ok) {
+      throw new Error(`Invalid bot token: ${JSON.stringify(me)}`);
+    }
+    while (this.running) {
+      try {
+        const updates = await this.getUpdates();
+        for (const update of updates) {
+          await this.handleUpdate(update);
+        }
+      } catch (err) {
+        if (!this.running) break;
+        console.error(`[telegram] Poll error: ${err instanceof Error ? err.message : err}`);
+        await sleep(3e3);
+      }
+    }
+  }
+  /** Stop long polling. */
+  stop() {
+    this.running = false;
+  }
+  /** Send a text message to a specific chat. Converts markdown and splits long messages. */
+  async send(chatId, text, buttons) {
+    const converted = toTelegramMarkdown(text);
+    const chunks = splitMessage(converted);
+    for (let i = 0; i < chunks.length; i++) {
+      const isLast = i === chunks.length - 1;
+      const replyMarkup = isLast && buttons ? {
+        inline_keyboard: buttons.map(
+          (row) => row.map((b) => ({ text: b.text, callback_data: b.callback_data }))
+        )
+      } : void 0;
+      await this.apiCall("sendMessage", {
+        chat_id: chatId,
+        text: chunks[i],
+        parse_mode: "Markdown",
+        ...replyMarkup ? { reply_markup: replyMarkup } : {}
+      });
+    }
+  }
+  /** Send a plain text message (no markdown parsing) to a specific chat. */
+  async sendPlain(chatId, text) {
+    const chunks = splitMessage(text);
+    for (const chunk of chunks) {
+      await this.apiCall("sendMessage", {
+        chat_id: chatId,
+        text: chunk
+      });
+    }
+  }
+  /** Send a typing indicator to a specific chat. */
+  async sendTyping(chatId) {
+    await this.apiCall("sendChatAction", {
+      chat_id: chatId,
+      action: "typing"
+    });
+  }
+  /** Get a direct download URL for a Telegram file. */
+  async getFileUrl(fileId) {
+    const result = await this.apiCall("getFile", { file_id: fileId });
+    if (!result.ok) throw new Error(`Failed to get file: ${JSON.stringify(result)}`);
+    const filePath = result.result.file_path;
+    return `${TELEGRAM_API}/file/bot${this.token}/${filePath}`;
+  }
+  // ── Private ───────────────────────────────────────────
+  async getUpdates() {
+    const result = await this.apiCall("getUpdates", {
+      offset: this.offset,
+      timeout: 30,
+      allowed_updates: ["message", "callback_query", "my_chat_member"]
+    });
+    if (!result.ok || !Array.isArray(result.result)) return [];
+    const updates = result.result;
+    if (updates.length > 0) {
+      this.offset = updates[updates.length - 1].update_id + 1;
+    }
+    return updates;
+  }
+  async handleUpdate(update) {
+    if (update.message) {
+      const msg = update.message;
+      if (msg.from.id !== this.allowedUserId) {
+        return;
+      }
+      if (msg.text && this.onMessage) {
+        this.onMessage({
+          text: msg.text,
+          chatId: msg.chat.id,
+          chatType: msg.chat.type,
+          chatTitle: msg.chat.title
+        });
+      } else if (msg.voice && this.onVoiceMessage) {
+        this.onVoiceMessage({
+          fileId: msg.voice.file_id,
+          duration: msg.voice.duration,
+          chatId: msg.chat.id,
+          chatType: msg.chat.type,
+          chatTitle: msg.chat.title
+        });
+      }
+    }
+    if (update.my_chat_member) {
+      const member = update.my_chat_member;
+      const status = member.new_chat_member.status;
+      if ((status === "member" || status === "administrator") && this.onBotAdded) {
+        this.onBotAdded(member.chat.id, member.chat.title);
+      } else if ((status === "left" || status === "kicked") && this.onBotRemoved) {
+        this.onBotRemoved(member.chat.id);
+      }
+    }
+    if (update.callback_query) {
+      const cb = update.callback_query;
+      if (cb.from.id !== this.allowedUserId) return;
+      await this.apiCall("answerCallbackQuery", { callback_query_id: cb.id });
+      if (cb.data && this.onCallback) {
+        this.onCallback(cb.data, cb.message.chat.id);
+      }
+    }
+  }
+  async apiCall(method, body) {
+    const url = `${TELEGRAM_API}/bot${this.token}/${method}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!response.ok) {
+      return { ok: false };
+    }
+    return response.json();
+  }
+};
+function toTelegramMarkdown(text) {
+  const lines = text.split("\n");
+  const result = [];
+  let inCodeBlock = false;
+  for (const line of lines) {
+    if (line.trimStart().startsWith("```")) {
+      inCodeBlock = !inCodeBlock;
+      result.push(line);
+      continue;
+    }
+    if (inCodeBlock) {
+      result.push(line);
+      continue;
+    }
+    let transformed = line;
+    const headingMatch = transformed.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch) {
+      transformed = `*${headingMatch[2]}*`;
+      result.push(transformed);
+      continue;
+    }
+    if (/^(-{3,}|_{3,}|\*{3,})$/.test(transformed.trim())) {
+      result.push("");
+      continue;
+    }
+    transformed = transformed.replace(/\*\*(.+?)\*\*/g, "*$1*");
+    result.push(transformed);
+  }
+  return result.join("\n");
+}
+function splitMessage(text) {
+  if (text.length <= MAX_MESSAGE_LENGTH) return [text];
+  const chunks = [];
+  let remaining = text;
+  while (remaining.length > 0) {
+    if (remaining.length <= MAX_MESSAGE_LENGTH) {
+      chunks.push(remaining);
+      break;
+    }
+    let splitAt = remaining.lastIndexOf("\n", MAX_MESSAGE_LENGTH);
+    if (splitAt === -1 || splitAt < MAX_MESSAGE_LENGTH * 0.5) {
+      splitAt = remaining.lastIndexOf(" ", MAX_MESSAGE_LENGTH);
+    }
+    if (splitAt === -1 || splitAt < MAX_MESSAGE_LENGTH * 0.5) {
+      splitAt = MAX_MESSAGE_LENGTH;
+    }
+    chunks.push(remaining.slice(0, splitAt));
+    remaining = remaining.slice(splitAt).trimStart();
+  }
+  return chunks;
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// src/voice-transcriber.ts
+var TARGET_SAMPLE_RATE = 16e3;
+var MODEL_ID = "Xenova/whisper-tiny.en";
+var transcriber = null;
+var loadPromise = null;
+var onProgress = null;
+function setProgressCallback(cb) {
+  onProgress = cb;
+}
+function resample(audio, fromRate, toRate) {
+  if (fromRate === toRate) return audio;
+  const ratio = fromRate / toRate;
+  const newLength = Math.round(audio.length / ratio);
+  const result = new Float32Array(newLength);
+  for (let i = 0; i < newLength; i++) {
+    const srcIndex = i * ratio;
+    const low = Math.floor(srcIndex);
+    const high = Math.min(low + 1, audio.length - 1);
+    const frac = srcIndex - low;
+    result[i] = audio[low] * (1 - frac) + audio[high] * frac;
+  }
+  return result;
+}
+function downmixToMono(channelData) {
+  if (channelData.length === 0) return new Float32Array();
+  if (channelData.length === 1) return channelData[0];
+  const samples = channelData[0].length;
+  const out = new Float32Array(samples);
+  const scale = 1 / channelData.length;
+  for (let i = 0; i < samples; i++) {
+    let mixed = 0;
+    for (const channel of channelData) mixed += channel[i] ?? 0;
+    out[i] = mixed * scale;
+  }
+  return out;
+}
+async function decodeOggOpus(buffer) {
+  const { OggOpusDecoder } = await import("ogg-opus-decoder");
+  const decoder = new OggOpusDecoder();
+  await decoder.ready;
+  try {
+    const decoded = await decoder.decodeFile(buffer);
+    if (!decoded.channelData?.length || !decoded.channelData[0]?.length) {
+      throw new Error("Decoded audio is empty");
+    }
+    const mono = downmixToMono(decoded.channelData);
+    return resample(mono, decoded.sampleRate, TARGET_SAMPLE_RATE);
+  } finally {
+    decoder.free();
+  }
+}
+async function getTranscriber() {
+  if (transcriber) return transcriber;
+  if (!loadPromise) {
+    loadPromise = (async () => {
+      const { pipeline } = await import("@huggingface/transformers");
+      const instance = await pipeline("automatic-speech-recognition", MODEL_ID, {
+        dtype: "fp32",
+        progress_callback: onProgress ?? void 0
+      });
+      transcriber = instance;
+      return instance;
+    })();
+  }
+  return loadPromise;
+}
+function isModelLoaded() {
+  return transcriber !== null;
+}
+async function transcribeVoice(fileUrl) {
+  const response = await fetch(fileUrl);
+  if (!response.ok) throw new Error(`Failed to download voice file: ${response.status}`);
+  const buffer = new Uint8Array(await response.arrayBuffer());
+  const pcm = await decodeOggOpus(buffer);
+  const asr = await getTranscriber();
+  const result = await asr(pcm);
+  const text = Array.isArray(result) ? result[0]?.text : result.text;
+  return (text ?? "").trim();
+}
+
+// src/auto-update.ts
+import { spawn } from "child_process";
+import fs5 from "fs";
+import path3 from "path";
+var CHECK_INTERVAL_MS = 60 * 60 * 1e3;
+var FETCH_TIMEOUT_MS2 = 1e4;
+function compareVersions(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    const diff = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+function performUpdateInBackground(command) {
+  try {
+    const parts = command.split(" ");
+    const child = spawn(parts[0], parts.slice(1), {
+      detached: true,
+      stdio: "ignore",
+      env: { ...process.env, npm_config_loglevel: "silent" }
+    });
+    child.unref();
+  } catch {
+  }
+}
+function createAutoUpdater(config) {
+  const REGISTRY_URL = `https://registry.npmjs.org/${config.packageName}/latest`;
+  const periodicMessage = config.periodicMessage ?? (({ currentVersion, latestVersion, updateCommand }) => `Ken just pushed a fresh update \u2014 ${currentVersion} \u2192 ${latestVersion}! I'll grab it on next launch (or run ${updateCommand} if you can't wait).`);
+  let periodicTimer = null;
+  function stateFilePath() {
+    return typeof config.stateFilePath === "function" ? config.stateFilePath() : config.stateFilePath;
+  }
+  function readState() {
+    try {
+      const raw = fs5.readFileSync(stateFilePath(), "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  function writeState(state) {
+    try {
+      const filePath = stateFilePath();
+      fs5.mkdirSync(path3.dirname(filePath), { recursive: true, mode: 448 });
+      fs5.writeFileSync(filePath, JSON.stringify(state));
+    } catch {
+    }
+  }
+  function detectInstallInfo() {
+    const scriptPath = (process.argv[1] ?? "").replace(/\\/g, "/");
+    if (scriptPath.includes("/_npx/")) {
+      return { packageManager: "unknown" /* UNKNOWN */, updateCommand: null };
+    }
+    if (scriptPath.includes("/.pnpm") || scriptPath.includes("/pnpm/global")) {
+      return {
+        packageManager: "pnpm" /* PNPM */,
+        updateCommand: `pnpm add -g ${config.packageName}@latest`
+      };
+    }
+    if (scriptPath.includes("/.yarn/") || scriptPath.includes("/yarn/global")) {
+      return {
+        packageManager: "yarn" /* YARN */,
+        updateCommand: `yarn global add ${config.packageName}@latest`
+      };
+    }
+    return {
+      packageManager: "npm" /* NPM */,
+      updateCommand: `npm install -g ${config.packageName}@latest`
+    };
+  }
+  async function fetchLatestVersion() {
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS2);
+      const response = await fetch(REGISTRY_URL, { signal: controller.signal });
+      clearTimeout(timeout);
+      const data = await response.json();
+      const version = data.version?.trim();
+      return version && /^\d+\.\d+\.\d+/.test(version) ? version : null;
+    } catch {
+      return null;
+    }
+  }
+  function scheduleBackgroundCheck(currentVersion) {
+    fetchLatestVersion().then((latestVersion) => {
+      const newState = {
+        lastCheckedAt: Date.now(),
+        latestVersion: latestVersion ?? void 0,
+        updatePending: false
+      };
+      if (latestVersion && compareVersions(latestVersion, currentVersion) > 0) {
+        newState.updatePending = true;
+      }
+      writeState(newState);
+    }).catch(() => {
+    });
+  }
+  function checkAndAutoUpdate(currentVersion) {
+    try {
+      const state = readState();
+      let message = null;
+      if (state?.updatePending && state.latestVersion) {
+        if (compareVersions(state.latestVersion, currentVersion) > 0) {
+          const info = detectInstallInfo();
+          if (info.updateCommand) {
+            performUpdateInBackground(info.updateCommand);
+            message = `Ken just shipped ${state.latestVersion}! Installing in the background \u2014 takes effect next launch.`;
+            writeState({
+              ...state,
+              lastCheckedAt: Date.now(),
+              updatePending: false,
+              lastUpdateAttempt: Date.now()
+            });
+          }
+        } else {
+          writeState({ ...state, updatePending: false });
+        }
+      }
+      const shouldCheck = !state || Date.now() - state.lastCheckedAt > CHECK_INTERVAL_MS;
+      if (shouldCheck) scheduleBackgroundCheck(currentVersion);
+      return message;
+    } catch {
+      return null;
+    }
+  }
+  function getPendingUpdate(currentVersion) {
+    try {
+      const state = readState();
+      if (!state?.latestVersion) return null;
+      if (compareVersions(state.latestVersion, currentVersion) <= 0) return null;
+      return { latestVersion: state.latestVersion };
+    } catch {
+      return null;
+    }
+  }
+  function startPeriodicUpdateCheck(currentVersion, onUpdate) {
+    if (periodicTimer) return;
+    periodicTimer = setInterval(() => {
+      fetchLatestVersion().then((latestVersion) => {
+        if (!latestVersion) return;
+        if (compareVersions(latestVersion, currentVersion) <= 0) return;
+        const info = detectInstallInfo();
+        if (!info.updateCommand) return;
+        writeState({ lastCheckedAt: Date.now(), latestVersion, updatePending: true });
+        onUpdate(
+          periodicMessage({ currentVersion, latestVersion, updateCommand: info.updateCommand })
+        );
+        stopPeriodicUpdateCheck();
+      }).catch(() => {
+      });
+    }, CHECK_INTERVAL_MS);
+    periodicTimer.unref();
+  }
+  function stopPeriodicUpdateCheck() {
+    if (periodicTimer) {
+      clearInterval(periodicTimer);
+      periodicTimer = null;
+    }
+  }
+  return {
+    checkAndAutoUpdate,
+    getPendingUpdate,
+    startPeriodicUpdateCheck,
+    stopPeriodicUpdateCheck
+  };
+}
+export {
+  AuthStorage,
+  MODELS,
+  NotLoggedInError,
+  TelegramBot,
+  closeLogger,
+  createAutoUpdater,
+  decodeOggOpus,
+  downmixToMono,
+  generatePKCE,
+  getAppPaths,
+  getClaudeCliUserAgent,
+  getClaudeCodeVersion,
+  getContextWindow,
+  getDefaultModel,
+  getMaxThinkingLevel,
+  getModel,
+  getModelsForProvider,
+  getNextThinkingLevel,
+  getSessionId,
+  getSummaryModel,
+  getSupportedThinkingLevels,
+  isLoggerOpen,
+  isModelLoaded,
+  isThinkingLevelSupported,
+  log,
+  loginAnthropic,
+  loginGemini,
+  loginOpenAI,
+  openLog,
+  refreshAnthropicToken,
+  refreshGeminiToken,
+  refreshOpenAIToken,
+  registerLogCleanup,
+  resample,
+  setProgressCallback,
+  transcribeVoice,
+  usesOpenAICodexTransport,
+  withFileLock
+};
+//# sourceMappingURL=index.js.map