codexuse-cli 2.5.4 → 2.5.8

package/dist/index.js

@@ -743,6 +743,7 @@ var REFRESH_TOKEN_REDEEMED_SNIPPET = "refresh token was already used";
 var REFRESH_TOKEN_REDEEMED_REASON = "Your access token could not be refreshed because your refresh token was already used. Please log out and sign in again.";
 var AUTH_BACKUP_MISSING_MARKER = "__codexuse_missing_auth__";
 var DEFAULT_WORKSPACE_ID = "__default__";
+var globalAuthSwapLock = Promise.resolve();
 var ProfileManager = class {
   constructor() {
     const homeDir = process.env.HOME || process.env.USERPROFILE || "";
@@ -751,7 +752,6 @@ var ProfileManager = class {
     this.activeAuth = (0, import_path2.join)(this.codexDir, "auth.json");
     this.activeAuthBackup = `${this.activeAuth}.swap`;
     this.lastActiveAuthErrorSignature = null;
-    this.authSwapLock = Promise.resolve();
   }
   computeExpiryIso(data) {
     if (!data) {
@@ -1195,8 +1195,8 @@ var ProfileManager = class {
     await this.recoverActiveAuthBackup();
   }
   enqueueAuthSwap(task) {
-    const run = this.authSwapLock.then(task, task);
-    this.authSwapLock = run.then(
+    const run = globalAuthSwapLock.then(task, task);
+    globalAuthSwapLock = run.then(
       () => void 0,
       () => void 0
     );
@@ -2266,17 +2266,51 @@ async function getLicenseSecret() {
   return secret;
 }
 
+// ../../lib/offer-config.ts
+function getActiveOffer() {
+  const basePriceUsd = 39;
+  const discountPercent = 50;
+  const salePriceUsd = basePriceUsd * (100 - discountPercent) / 100;
+  return {
+    basePriceUsd,
+    basePriceDisplay: `$${basePriceUsd}`,
+    couponCode: "SPRING50",
+    discountPercent,
+    salePriceUsd,
+    salePriceDisplay: `$${salePriceUsd.toFixed(2)}`,
+    isActive: true,
+    campaign: "spring-2026",
+    productPermalink: "codex-use",
+    checkoutBaseUrl: "https://hweihwang.gumroad.com/l/codex-use"
+  };
+}
+function buildCheckoutUrl(offer2, utm) {
+  const base = offer2.checkoutBaseUrl;
+  const withCoupon = offer2.isActive && offer2.couponCode ? `${base}/${offer2.couponCode}` : base;
+  if (!utm) {
+    return withCoupon;
+  }
+  const params = new URLSearchParams();
+  params.set("utm_source", utm.source);
+  params.set("utm_medium", utm.medium);
+  if (utm.campaign) {
+    params.set("utm_campaign", utm.campaign);
+  } else if (offer2.campaign) {
+    params.set("utm_campaign", offer2.campaign);
+  }
+  return `${withCoupon}?${params.toString()}`;
+}
+
 // ../../lib/license-service.ts
-var PRODUCT_PERMALINK = "codex-use";
+var offer = getActiveOffer();
+var PRODUCT_PERMALINK = offer.productPermalink;
 var PRODUCT_ID = "3_CcyVEXt2FOMiEpPx8xzw==";
-var BASE_PRICE = 19;
-var BASE_PRICE_DISPLAY = "$19";
-var PROMO_CODE = "NOELNEWYEAR50";
-var PROMO_PERCENT = 50;
-var PROMO_ACTIVE = true;
-var PROMO_PRICE_DISPLAY = `$${(BASE_PRICE * (100 - PROMO_PERCENT) / 100).toFixed(2)}`;
-var PRODUCT_URL = PROMO_ACTIVE ? `https://hweihwang.gumroad.com/l/${PRODUCT_PERMALINK}/${PROMO_CODE}` : "https://hweihwang.gumroad.com/l/codex-use";
-var LICENSE_PRICE_DISPLAY = PROMO_ACTIVE ? PROMO_PRICE_DISPLAY : BASE_PRICE_DISPLAY;
+var PRODUCT_URL = buildCheckoutUrl(offer);
+var LICENSE_PRICE_DISPLAY = offer.isActive ? offer.salePriceDisplay : offer.basePriceDisplay;
+var BASE_PRICE_DISPLAY = offer.basePriceDisplay;
+var PROMO_CODE = offer.couponCode;
+var PROMO_PERCENT = offer.discountPercent;
+var PROMO_ACTIVE = offer.isActive;
 var LICENSE_MAX_USES = 5;
 var FREE_PROFILE_LIMIT = 2;
 var LICENSE_REFRESH_INTERVAL_MS = 5 * 60 * 1e3;
@@ -2438,7 +2472,8 @@ function toLicenseStatus(stored, overrides = {}) {
     priceDisplay: LICENSE_PRICE_DISPLAY,
     basePriceDisplay: BASE_PRICE_DISPLAY,
     promoCode: PROMO_ACTIVE ? PROMO_CODE : null,
-    promoPercent: PROMO_ACTIVE ? PROMO_PERCENT : null
+    promoPercent: PROMO_ACTIVE ? PROMO_PERCENT : null,
+    maxDevices: LICENSE_MAX_USES
   };
   return { ...base, ...overrides };
 }
@@ -2607,6 +2642,25 @@ var LicenseService = class {
   }
 };
 var licenseService = new LicenseService();
+function isExplicitInvalidation(message) {
+  if (!message) {
+    return false;
+  }
+  const normalized = message.toLowerCase();
+  return normalized.includes("revoked") || normalized.includes("refunded") || normalized.includes("invalid") || normalized.includes("no longer active");
+}
+function shouldEnforceProfileLimit(status) {
+  if (status.isPro) {
+    return false;
+  }
+  if (status.state === "grace" || status.state === "verifying" || status.state === "error") {
+    return false;
+  }
+  if (isExplicitInvalidation(status.error)) {
+    return true;
+  }
+  return status.state === "inactive";
+}
 
 // ../../lib/cloud-sync-service.ts
 var import_node_fs4 = require("fs");
@@ -2780,6 +2834,7 @@ var import_node_path4 = __toESM(require("path"));
 var import_node_fs3 = require("fs");
 var import_node_path3 = __toESM(require("path"));
 var STABLE_CHANNEL = "stable";
+var ENV_HINTS = ["CODEX_BINARY", "CODEX_CLI_PATH", "CODEX_PATH"];
 var cachedStatus = null;
 function fileExists(candidate) {
   if (!candidate) {
@@ -2819,16 +2874,68 @@ function resolveBundledCodexBinary() {
   }
   return null;
 }
-function buildUnavailableStatus() {
+function isElectronRuntime() {
+  return typeof process.versions?.electron === "string" && process.versions.electron.length > 0;
+}
+function resolveCodexFromEnv() {
+  for (const key of ENV_HINTS) {
+    const value = process.env[key];
+    if (!value) {
+      continue;
+    }
+    const resolved = fileExists(value);
+    if (resolved) {
+      return resolved;
+    }
+  }
+  return null;
+}
+function resolveCodexFromNodeModules() {
+  const packageSegments = ["@openai", "codex", "bin"];
+  const fileNames = ["codex.js", "codex"];
+  let current = import_node_path3.default.resolve(__dirname);
+  let last = "";
+  while (current !== last) {
+    for (const fileName of fileNames) {
+      const candidate = fileExists(
+        import_node_path3.default.join(current, "node_modules", ...packageSegments, fileName)
+      );
+      if (candidate) {
+        return candidate;
+      }
+    }
+    last = current;
+    current = import_node_path3.default.dirname(current);
+  }
+  return null;
+}
+function resolveCodexFromPath() {
+  const pathValue = process.env.PATH ?? "";
+  if (!pathValue) {
+    return null;
+  }
+  const entries = pathValue.split(import_node_path3.default.delimiter).map((entry) => entry.trim()).filter(Boolean);
+  const names = process.platform === "win32" ? ["codex.exe", "codex.cmd", "codex.bat", "codex"] : ["codex"];
+  for (const entry of entries) {
+    for (const name of names) {
+      const candidate = fileExists(import_node_path3.default.join(entry, name));
+      if (candidate) {
+        return candidate;
+      }
+    }
+  }
+  return null;
+}
+function buildUnavailableStatus(reason) {
   return {
     available: false,
     path: null,
-    reason: "Bundled Codex CLI is missing. Reinstall CodexUse to restore the CLI.",
+    reason: reason ?? "Codex CLI not found. Install @openai/codex or set CODEX_BINARY.",
     source: null,
     channel: STABLE_CHANNEL
   };
 }
-function evaluateCodexCliStatus() {
+function evaluateBundledOnlyStatus() {
   const resolvedPath = resolveBundledCodexBinary();
   if (resolvedPath) {
     return {
@@ -2839,8 +2946,55 @@ function evaluateCodexCliStatus() {
       channel: STABLE_CHANNEL
     };
   }
+  return buildUnavailableStatus("Bundled Codex CLI is missing. Reinstall CodexUse.");
+}
+function evaluateExternalStatus() {
+  const envPath = resolveCodexFromEnv();
+  if (envPath) {
+    return {
+      available: true,
+      path: envPath,
+      reason: null,
+      source: "env",
+      channel: STABLE_CHANNEL
+    };
+  }
+  const nodeModulesPath = resolveCodexFromNodeModules();
+  if (nodeModulesPath) {
+    return {
+      available: true,
+      path: nodeModulesPath,
+      reason: null,
+      source: "node_modules",
+      channel: STABLE_CHANNEL
+    };
+  }
+  const pathResolved = resolveCodexFromPath();
+  if (pathResolved) {
+    return {
+      available: true,
+      path: pathResolved,
+      reason: null,
+      source: "path",
+      channel: STABLE_CHANNEL
+    };
+  }
   return buildUnavailableStatus();
 }
+function evaluateCodexCliStatus() {
+  const bundledStatus = evaluateBundledOnlyStatus();
+  if (bundledStatus.available) {
+    return bundledStatus;
+  }
+  const externalStatus = evaluateExternalStatus();
+  if (externalStatus.available) {
+    return externalStatus;
+  }
+  if (isElectronRuntime()) {
+    return bundledStatus;
+  }
+  return externalStatus;
+}
 async function refreshCodexStatus() {
   cachedStatus = evaluateCodexCliStatus();
   return { ...cachedStatus };
@@ -3950,6 +4104,7 @@ async function pullCloudSync() {
 }
 
 // ../../lib/license-guard.ts
+var PROJECT_LIMIT_MESSAGE = "CodexUse Free supports up to 2 projects. Upgrade to CodexUse Pro for unlimited projects.";
 async function assertProfileCreationAllowed(profileManager) {
   const manager = profileManager ?? new ProfileManager();
   await manager.initialize();
@@ -3960,13 +4115,25 @@ async function assertProfileCreationAllowed(profileManager) {
     throw new Error("CodexUse Free supports up to 2 profiles. Upgrade to CodexUse Pro for unlimited profiles.");
   }
 }
+function countMainProjects(workspaces) {
+  return workspaces.filter((workspace) => (workspace.kind ?? "main") !== "worktree").length;
+}
+async function assertProjectCreationAllowed(workspaces) {
+  const license = await licenseService.getStatus();
+  if (!shouldEnforceProfileLimit(license)) {
+    return;
+  }
+  const mainProjectCount = countMainProjects(workspaces);
+  if (mainProjectCount >= 2) {
+    throw new Error(PROJECT_LIMIT_MESSAGE);
+  }
+}
 
 // src/codex-cli.ts
 var import_node_child_process2 = require("child_process");
 var import_node_fs5 = require("fs");
 var import_node_path7 = __toESM(require("path"));
-var ENV_HINTS = ["CODEX_BINARY", "CODEX_CLI_PATH", "CODEX_PATH"];
-var NODE_MODULE_CANDIDATES = [["@openai", "codex"]];
+var ENV_HINTS2 = ["CODEX_BINARY", "CODEX_CLI_PATH", "CODEX_PATH"];
 function fileExists2(candidate) {
   if (!candidate) return null;
   const resolved = import_node_path7.default.resolve(candidate);
@@ -3979,7 +4146,7 @@ function fileExists2(candidate) {
   return null;
 }
 function resolveFromEnv() {
-  for (const key of ENV_HINTS) {
+  for (const key of ENV_HINTS2) {
     const value = process.env[key];
     if (!value) continue;
     const resolved = fileExists2(value);
@@ -3987,37 +4154,6 @@ function resolveFromEnv() {
   }
   return null;
 }
-function resolveFromAppResources() {
-  const roots = [
-    import_node_path7.default.resolve(__dirname, ".."),
-    import_node_path7.default.resolve(__dirname, "..", "..")
-  ];
-  for (const root of roots) {
-    const base = import_node_path7.default.join(root, "app.asar.unpacked", "node_modules");
-    for (const segments of NODE_MODULE_CANDIDATES) {
-      const candidate = fileExists2(import_node_path7.default.join(base, ...segments, "bin", "codex"));
-      if (candidate) return candidate;
-      const jsCandidate = fileExists2(import_node_path7.default.join(base, ...segments, "bin", "codex.js"));
-      if (jsCandidate) return jsCandidate;
-    }
-  }
-  return null;
-}
-function resolveFromNodeModules() {
-  let current = import_node_path7.default.resolve(__dirname, "..");
-  let last = "";
-  while (current !== last) {
-    for (const segments of NODE_MODULE_CANDIDATES) {
-      const candidate = fileExists2(import_node_path7.default.join(current, "node_modules", ...segments, "bin", "codex"));
-      if (candidate) return candidate;
-      const jsCandidate = fileExists2(import_node_path7.default.join(current, "node_modules", ...segments, "bin", "codex.js"));
-      if (jsCandidate) return jsCandidate;
-    }
-    last = current;
-    current = import_node_path7.default.dirname(current);
-  }
-  return null;
-}
 function resolveFromPath() {
   const pathValue = process.env.PATH ?? "";
   const entries = pathValue.split(import_node_path7.default.delimiter).filter(Boolean);
@@ -4031,7 +4167,7 @@ function resolveFromPath() {
   return null;
 }
 function resolveCodexBinary() {
-  return resolveFromEnv() || resolveFromAppResources() || resolveFromNodeModules() || resolveFromPath();
+  return resolveFromEnv() || resolveFromPath();
 }
 function requireCodexBinary(context) {
   const resolved = resolveCodexBinary();
@@ -4093,6 +4229,98 @@ var import_node_fs6 = require("fs");
 var import_node_os2 = __toESM(require("os"));
 var import_node_path8 = __toESM(require("path"));
 var RPC_TIMEOUT_MS = 1e4;
+var MAX_STDERR_CAPTURE_CHARS = 32768;
+var REFRESH_TOKEN_REDEEMED_SNIPPET2 = "refresh token was already used";
+function parseTimestamp2(value) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    return null;
+  }
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? null : parsed;
+}
+function decodeJwtPayload(token) {
+  if (typeof token !== "string" || token.trim().length === 0) {
+    return null;
+  }
+  const segments = token.split(".");
+  if (segments.length < 2) {
+    return null;
+  }
+  try {
+    const payloadRaw = Buffer.from(segments[1], "base64url").toString("utf8");
+    const payload = JSON.parse(payloadRaw);
+    return payload && typeof payload === "object" ? payload : null;
+  } catch {
+    return null;
+  }
+}
+function extractJwtIssuedAtMs(token) {
+  const payload = decodeJwtPayload(token);
+  if (!payload) {
+    return null;
+  }
+  const issuedAt = payload["iat"];
+  if (typeof issuedAt !== "number" || !Number.isFinite(issuedAt)) {
+    return null;
+  }
+  return issuedAt * 1e3;
+}
+function parseAuthRecord(content) {
+  try {
+    const parsed = JSON.parse(content);
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function extractAuthRecencyMs(content) {
+  const parsed = parseAuthRecord(content);
+  if (!parsed) {
+    return null;
+  }
+  const rootLastRefresh = parseTimestamp2(parsed.last_refresh);
+  const nestedLastRefresh = parseTimestamp2(parsed.tokens?.last_refresh);
+  const rootAccessIssuedAt = extractJwtIssuedAtMs(parsed.access_token);
+  const nestedAccessIssuedAt = extractJwtIssuedAtMs(parsed.tokens?.access_token);
+  const candidates = [rootLastRefresh, nestedLastRefresh, rootAccessIssuedAt, nestedAccessIssuedAt].filter((value) => typeof value === "number" && Number.isFinite(value));
+  if (candidates.length === 0) {
+    return null;
+  }
+  return Math.max(...candidates);
+}
+function shouldWriteBackAuth(initialSourceAuth, currentSourceAuth, updatedAuth) {
+  if (updatedAuth.trim().length === 0) {
+    return false;
+  }
+  if (!currentSourceAuth) {
+    return true;
+  }
+  if (currentSourceAuth === updatedAuth) {
+    return false;
+  }
+  if (currentSourceAuth === initialSourceAuth) {
+    return true;
+  }
+  const currentRecency = extractAuthRecencyMs(currentSourceAuth);
+  const updatedRecency = extractAuthRecencyMs(updatedAuth);
+  if (typeof updatedRecency === "number" && typeof currentRecency === "number") {
+    return updatedRecency > currentRecency;
+  }
+  if (typeof updatedRecency === "number" && typeof currentRecency !== "number") {
+    return true;
+  }
+  return false;
+}
+function inferRefreshFailureHint(stderrOutput) {
+  if (!stderrOutput) {
+    return null;
+  }
+  const normalized = stderrOutput.toLowerCase();
+  if (normalized.includes(REFRESH_TOKEN_REDEEMED_SNIPPET2)) {
+    return REFRESH_TOKEN_REDEEMED_SNIPPET2;
+  }
+  return null;
+}
 async function sendPayload(child, payload) {
   child.stdin?.write(JSON.stringify(payload));
   child.stdin?.write("\n");
@@ -4198,17 +4426,18 @@ async function fetchRateLimitsViaRpc(envOverride, options = {}) {
   const binaryPath = options.codexPath ?? await requireCodexCli();
   const tempHome = await import_node_fs6.promises.mkdtemp(import_node_path8.default.join(import_node_os2.default.tmpdir(), "codex-rpc-"));
   const tempAuthPath = import_node_path8.default.join(tempHome, "auth.json");
+  let initialSourceAuth = null;
   const sourceAuthPath = options.authPath ?? (envOverride?.CODEX_HOME ? import_node_path8.default.join(envOverride.CODEX_HOME, "auth.json") : import_node_path8.default.join(
     envOverride?.HOME ?? process.env.HOME ?? process.env.USERPROFILE ?? import_node_os2.default.homedir(),
     ".codex",
     "auth.json"
   ));
   try {
-    const authContent = await import_node_fs6.promises.readFile(sourceAuthPath, "utf8").catch(() => null);
-    if (!authContent) {
+    initialSourceAuth = await import_node_fs6.promises.readFile(sourceAuthPath, "utf8").catch(() => null);
+    if (!initialSourceAuth) {
       return null;
     }
-    await import_node_fs6.promises.writeFile(tempAuthPath, authContent, "utf8");
+    await import_node_fs6.promises.writeFile(tempAuthPath, initialSourceAuth, "utf8");
   } catch {
     await import_node_fs6.promises.rm(tempHome, { recursive: true, force: true }).catch(() => {
     });
@@ -4230,6 +4459,15 @@ async function fetchRateLimitsViaRpc(envOverride, options = {}) {
     input: child.stdout,
     crlfDelay: Infinity
   });
+  let stderrOutput = "";
+  child.stderr?.on("data", (chunk) => {
+    if (stderrOutput.length >= MAX_STDERR_CAPTURE_CHARS) {
+      return;
+    }
+    const text = chunk.toString("utf8");
+    const remaining = MAX_STDERR_CAPTURE_CHARS - stderrOutput.length;
+    stderrOutput += text.slice(0, Math.max(0, remaining));
+  });
   try {
     await sendPayload(child, {
       id: 1,
@@ -4243,6 +4481,14 @@ async function fetchRateLimitsViaRpc(envOverride, options = {}) {
     await sendPayload(child, { method: "initialized", params: {} });
     await sendPayload(child, { id: 2, method: "account/rateLimits/read", params: {} });
     const message = await readRpcResponseById(rl, 2, RPC_TIMEOUT_MS);
+    if (message.error) {
+      const base = formatRpcError("account/rateLimits/read", message.error);
+      const hint = inferRefreshFailureHint(stderrOutput);
+      if (hint && !base.toLowerCase().includes(hint)) {
+        throw new Error(`${base}; ${hint}`);
+      }
+      throw new Error(base);
+    }
     return parseRateLimitSnapshotFromRpcMessage(message);
   } finally {
     child.kill();
@@ -4250,7 +4496,16 @@ async function fetchRateLimitsViaRpc(envOverride, options = {}) {
     try {
       const updatedAuth = await import_node_fs6.promises.readFile(tempAuthPath, "utf8");
       if (updatedAuth.trim().length > 0) {
-        await import_node_fs6.promises.writeFile(sourceAuthPath, updatedAuth, "utf8");
+        const currentSourceAuth = await import_node_fs6.promises.readFile(sourceAuthPath, "utf8").catch(() => null);
+        if (shouldWriteBackAuth(initialSourceAuth, currentSourceAuth, updatedAuth)) {
+          await import_node_fs6.promises.writeFile(sourceAuthPath, updatedAuth, "utf8");
+        } else if (currentSourceAuth && currentSourceAuth !== updatedAuth && currentSourceAuth !== initialSourceAuth) {
+          logWarn("Skipped stale auth sync-back after rate-limit probe; source auth changed in flight.", {
+            sourceAuthPath,
+            currentRecencyMs: extractAuthRecencyMs(currentSourceAuth),
+            updatedRecencyMs: extractAuthRecencyMs(updatedAuth)
+          });
+        }
       }
     } catch {
     }
@@ -5035,103 +5290,3795 @@ async function importLegacyLocalStorageOnce(payload) {
   return { completed: true, importedKeys: consumedKeys, skippedKeys };
 }
 
-// src/index.ts
-var VERSION = true ? "2.5.4" : "0.0.0";
-var cliStorageReadyPromise = null;
-async function ensureCliStorageReady() {
-  if (cliStorageReadyPromise) {
-    return cliStorageReadyPromise;
-  }
-  cliStorageReadyPromise = (async () => {
-    await initializeAppState(getUserDataDir());
-    const migrated = await runStorageMigrationV1();
-    if (migrated.migration.status === "pending_local_storage") {
-      await importLegacyLocalStorageOnce({});
-    }
-    const state = await getAppState();
-    if (state.migration.status !== "complete") {
-      throw new Error(
-        `Storage migration is not complete (status: ${state.migration.status}). CLI cannot continue until migration succeeds.`
-      );
-    }
-  })().catch((error) => {
-    cliStorageReadyPromise = null;
-    throw error;
-  });
-  return cliStorageReadyPromise;
-}
-function printHelp() {
-  console.log(`CodexUse CLI v${VERSION}
-
-Usage:
-  codexuse profile list [--no-usage] [--compact]
-  codexuse profile current
-  codexuse profile add <name> [--skip-login] [--device-auth] [--login=browser|device]
-  codexuse profile refresh <name> [--skip-login] [--device-auth] [--login=browser|device]
-  codexuse profile switch <name>
-  codexuse profile autoroll [--threshold=50-100] [--dry-run] [--watch] [--interval=seconds]
-  codexuse profile delete <name>
-  codexuse profile rename <old> <new>
-
-  codexuse license status [--refresh]
-  codexuse license activate <license-key>
+// src/daemon.ts
+var import_node_path14 = __toESM(require("path"));
 
-  codexuse sync status
-  codexuse sync pull
-  codexuse sync push
+// ../../lib/codex-app-server.ts
+var import_node_child_process4 = require("child_process");
+var import_node_events = require("events");
+var import_node_readline2 = __toESM(require("readline"));
+var import_node_path10 = __toESM(require("path"));
 
-Flags:
-  -h, --help       Show help
-  -v, --version    Show version
-  --no-usage       Skip rate-limit usage fetch
-  --compact        Names only
-  --device-auth    Use device auth for Codex login
-  --login=MODE     Login mode: browser | device
-  --threshold=NN   Auto-roll switch threshold percent (50-100)
-  --watch          Keep checking and auto-switch when threshold is reached
-  --interval=SEC   Watch interval in seconds (default: 30)
-  --dry-run        Print planned switch without changing active profile
-`);
+// ../../lib/apps-list-rpc.ts
+var APPS_LIST_METHODS = /* @__PURE__ */ new Set(["app/list", "apps/list", "apps_list"]);
+function isAppsListMethod(method) {
+  return APPS_LIST_METHODS.has(method);
 }
-function hasFlag(args, flag) {
-  return args.includes(flag);
+function buildAppsListPayload(params) {
+  return {
+    threadId: params?.threadId ?? null,
+    cursor: params?.cursor ?? null,
+    limit: params?.limit ?? null
+  };
 }
-function stripFlags(args) {
-  return args.filter((arg) => !arg.startsWith("-"));
+function isMethodUnavailableError(error, method) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const code = typeof error.code === "number" ? error.code : null;
+  if (code !== -32601 && code !== -32600) {
+    return false;
+  }
+  const message = typeof error.message === "string" ? error.message.toLowerCase() : "";
+  if (!message) {
+    return false;
+  }
+  const normalizedMethod = method.toLowerCase();
+  if (message.includes("method not found") || message.includes("unknown method")) {
+    return true;
+  }
+  return message.includes("unknown variant") && message.includes(normalizedMethod);
 }
-function parseLoginMode(flags) {
-  if (flags.includes("--device-auth")) return "device";
-  const explicit = flags.find((flag) => flag.startsWith("--login="));
-  if (!explicit) return null;
-  const value = explicit.split("=")[1];
-  if (value === "browser" || value === "device") {
-    return value;
+function isAppsListThreadNotFoundError(error) {
+  if (!error || typeof error !== "object") {
+    return false;
   }
-  return null;
+  const message = typeof error.message === "string" ? error.message.toLowerCase() : "";
+  if (!message) {
+    return false;
+  }
+  const mentionsThread = message.includes("thread");
+  const mentionsNotFound = message.includes("not found") || message.includes("unknown thread");
+  return mentionsThread && mentionsNotFound;
 }
-var DEFAULT_AUTOROLL_INTERVAL_SECONDS = 30;
-var DEFAULT_AUTOROLL_THRESHOLD = 95;
-function parseNumericFlag(flags, name) {
-  const explicit = flags.find((flag) => flag.startsWith(`${name}=`));
-  if (!explicit) {
+
+// ../../lib/cli-env.ts
+var import_path3 = __toESM(require("path"));
+function buildCliEnv(codexPath, overrides = {}) {
+  const env = { ...process.env, ...overrides };
+  const currentPath = env.PATH ?? "";
+  const codexDir = import_path3.default.dirname(codexPath);
+  const homeDir = process.env.HOME ?? "";
+  const extraPathHints = (process.env.CODEX_PATH_HINTS ?? "").split(import_path3.default.delimiter).map((entry) => entry.trim()).filter(Boolean);
+  const extras = [
+    codexDir,
+    "/usr/local/bin",
+    "/opt/homebrew/bin",
+    import_path3.default.join(homeDir, ".local", "bin"),
+    import_path3.default.join(homeDir, ".fnm", "aliases", "default", "bin"),
+    import_path3.default.join(homeDir, ".fnm", "current", "bin"),
+    ...extraPathHints
+  ].filter(Boolean);
+  const segments = [
+    ...extras,
+    ...currentPath.split(import_path3.default.delimiter).filter(Boolean)
+  ];
+  env.PATH = Array.from(new Set(segments)).join(import_path3.default.delimiter);
+  return env;
+}
+
+// ../../lib/codex-app-server.ts
+function isRecord6(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function requestIdToToken(id) {
+  return typeof id === "string" ? id : String(id);
+}
+function isAlreadyInitializedError(error) {
+  if (!error || typeof error !== "object") return false;
+  const message = error.message;
+  return typeof message === "string" && message.toLowerCase().includes("already initialized");
+}
+function isThreadNotFoundError(error) {
+  if (!error || typeof error !== "object") return false;
+  const message = error.message;
+  if (typeof message !== "string") return false;
+  const lower = message.toLowerCase();
+  return lower.includes("thread not found") || lower.includes("rollout");
+}
+function asString4(value) {
+  return typeof value === "string" ? value : value != null ? String(value) : "";
+}
+function isInlineImageValue(value) {
+  const normalized = value.trim().toLowerCase();
+  return normalized.startsWith("data:") || normalized.startsWith("http://") || normalized.startsWith("https://");
+}
+function normalizeSendUserMessageItem(value) {
+  if (!isRecord6(value)) {
     return null;
   }
-  const raw = explicit.slice(`${name}=`.length);
-  const value = Number.parseFloat(raw);
-  return Number.isFinite(value) ? value : Number.NaN;
-}
-function parseIntegerFlag(flags, name) {
-  const explicit = flags.find((flag) => flag.startsWith(`${name}=`));
-  if (!explicit) {
+  const type = asString4(value.type).trim();
+  if (!type) {
     return null;
   }
-  const raw = explicit.slice(`${name}=`.length);
-  const value = Number.parseInt(raw, 10);
-  return Number.isFinite(value) ? value : Number.NaN;
-}
-function formatProfileLabel(name, displayName) {
-  if (displayName && displayName.trim() && displayName !== name) {
-    return `${displayName} (${name})`;
+  const data = isRecord6(value.data) ? value.data : {};
+  if (type === "text") {
+    const text = asString4(data.text ?? value.text);
+    if (!text.trim()) {
+      return null;
+    }
+    return { type: "text", data: { text } };
+  }
+  if (type === "image") {
+    const imageUrl = asString4(
+      data.image_url ?? data.imageUrl ?? data.url ?? value.image_url ?? value.imageUrl ?? value.url
+    ).trim();
+    if (!imageUrl) {
+      return null;
+    }
+    return { type: "image", data: { image_url: imageUrl } };
+  }
+  if (type === "localImage") {
+    const path17 = asString4(data.path ?? value.path).trim();
+    if (!path17) {
+      return null;
+    }
+    return { type: "localImage", data: { path: path17 } };
+  }
+  return value;
+}
+function normalizeTurnInputParams(params) {
+  const normalized = { ...params };
+  const threadId = asString4(
+    params.threadId ?? params.thread_id ?? params.conversationId ?? params.conversation_id ?? ""
+  ).trim();
+  if (threadId && !asString4(params.threadId).trim()) {
+    normalized.threadId = threadId;
+  }
+  const expectedTurnId = asString4(
+    params.expectedTurnId ?? params.expected_turn_id ?? params.turnId ?? params.turn_id ?? ""
+  ).trim();
+  if (expectedTurnId && !asString4(params.expectedTurnId).trim()) {
+    normalized.expectedTurnId = expectedTurnId;
+  }
+  const turnId = asString4(params.turnId ?? params.turn_id ?? expectedTurnId).trim();
+  if (turnId && !asString4(params.turnId).trim()) {
+    normalized.turnId = turnId;
+  }
+  const providedInput = Array.isArray(params.input) ? params.input.filter((entry) => isRecord6(entry)) : [];
+  if (providedInput.length > 0) {
+    normalized.input = providedInput;
+    return normalized;
+  }
+  const providedItems = Array.isArray(params.items) ? params.items.map((item) => normalizeSendUserMessageItem(item)).filter((item) => item !== null) : [];
+  if (providedItems.length > 0) {
+    const input2 = providedItems.flatMap((item) => {
+      const type = asString4(item.type).trim();
+      const data = isRecord6(item.data) ? item.data : item;
+      if (type === "text") {
+        const text2 = asString4(data.text).trim();
+        return text2 ? [{ type: "text", text: text2 }] : [];
+      }
+      if (type === "localImage") {
+        const path17 = asString4(data.path).trim();
+        return path17 ? [{ type: "localImage", path: path17 }] : [];
+      }
+      return [];
+    });
+    if (input2.length > 0) {
+      normalized.input = input2;
+      return normalized;
+    }
+  }
+  const input = [];
+  const text = asString4(params.text);
+  if (text.trim()) {
+    input.push({ type: "text", text });
+  }
+  if (Array.isArray(params.images)) {
+    for (const candidate of params.images) {
+      const image = asString4(candidate).trim();
+      if (!image || isInlineImageValue(image)) {
+        continue;
+      }
+      input.push({
+        type: "localImage",
+        path: image
+      });
+    }
+  }
+  if (input.length > 0) {
+    normalized.input = input;
+  }
+  return normalized;
+}
+function pickMethodKind(method, params) {
+  const normalized = method.toLowerCase();
+  if (normalized.includes("requestapproval")) return "approval";
+  if (normalized.includes("requestuserinput")) return "user_input";
+  if (isRecord6(params)) {
+    if ("file_changes" in params || "fileChanges" in params || "grant_root" in params || "grantRoot" in params) {
+      return "patch";
+    }
+    if ("command" in params || "parsed_cmd" in params || "parsedCmd" in params || "cwd" in params) {
+      return "exec";
+    }
+  }
+  if (normalized.includes("apply") && normalized.includes("patch")) return "patch";
+  if (normalized.includes("file") && normalized.includes("change")) return "patch";
+  if (normalized.includes("exec") || normalized.includes("command")) return "exec";
+  return null;
+}
+var DEFAULT_REQUEST_TIMEOUT_MS = 45e3;
+var THREAD_LIST_REQUEST_TIMEOUT_MS = 18e4;
+var MAX_PARSE_BUFFER_CHARS = 2e6;
+var DEFAULT_THREAD_LIVE_WORKSPACE_ID = "__default__";
+var REQUEST_TIMEOUT_WARNING_COOLDOWN_MS = 3e4;
+function isLikelyRecoverableJsonParseError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const message = error.message.toLowerCase();
+  return message.includes("unterminated string") || message.includes("unexpected end of json input") || message.includes("bad control character");
+}
+function isIgnorableAppsListTransportStderr(message) {
+  const normalized = message.toLowerCase();
+  if (!normalized.includes("backend-api/wham/apps")) {
+    return false;
+  }
+  return normalized.includes("worker quit with fatal") && normalized.includes("transport channel closed");
+}
+function isIgnorableMissingSkillsSymlinkStderr(message) {
+  const normalized = message.toLowerCase();
+  return normalized.includes("codex_core::skills::loader") && normalized.includes("failed to stat skills entry") && normalized.includes("(symlink)") && normalized.includes("no such file or directory");
+}
+function isRequestTimeoutErrorMessage(value) {
+  if (typeof value !== "string") {
+    return false;
+  }
+  return value.toLowerCase().includes("request timed out");
+}
+function getRequestTimeoutMs(method) {
+  if (method === "thread/list") {
+    return THREAD_LIST_REQUEST_TIMEOUT_MS;
+  }
+  return DEFAULT_REQUEST_TIMEOUT_MS;
+}
+function normalizeThreadLiveWorkspaceId(value) {
+  const workspaceId = asString4(value).trim();
+  return workspaceId || DEFAULT_THREAD_LIVE_WORKSPACE_ID;
+}
+function threadLiveKey(workspaceId, threadId) {
+  return `${workspaceId}:${threadId}`;
+}
+function escapeInvalidJsonStringChars(input) {
+  let output = "";
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < input.length; i += 1) {
+    const char = input[i];
+    if (escaped) {
+      output += char;
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      output += char;
+      escaped = true;
+      continue;
+    }
+    if (char === '"') {
+      output += char;
+      inString = !inString;
+      continue;
+    }
+    if (inString) {
+      if (char === "\n") {
+        output += "\\n";
+        continue;
+      }
+      if (char === "\r") {
+        output += "\\r";
+        continue;
+      }
+      if (char === "	") {
+        output += "\\t";
+        continue;
+      }
+      const code = char.charCodeAt(0);
+      if (code >= 0 && code < 32) {
+        output += `\\u${code.toString(16).padStart(4, "0")}`;
+        continue;
+      }
+    }
+    output += char;
+  }
+  return output;
+}
+var cachedRuntimeBinary = null;
+function resolveRuntimeBinary(env) {
+  const override = env?.CODEX_NODE_RUNTIME?.trim() || env?.CODEX_NODE_BIN?.trim() || env?.CODEX_NODE?.trim() || process.env.CODEX_NODE_RUNTIME?.trim() || process.env.CODEX_NODE_BIN?.trim() || process.env.CODEX_NODE?.trim() || null;
+  if (override) {
+    return override;
+  }
+  if (cachedRuntimeBinary) {
+    return cachedRuntimeBinary;
+  }
+  const runtimeEnv = { ...process.env, ...env };
+  const homeDir = runtimeEnv.HOME ?? runtimeEnv.USERPROFILE ?? "";
+  const pathHints = (runtimeEnv.CODEX_PATH_HINTS ?? process.env.CODEX_PATH_HINTS ?? "").split(import_node_path10.default.delimiter).map((entry) => entry.trim()).filter(Boolean);
+  const extraPathEntries = [
+    "/usr/local/bin",
+    "/opt/homebrew/bin",
+    import_node_path10.default.join(homeDir, ".local", "bin"),
+    import_node_path10.default.join(homeDir, ".fnm", "aliases", "default", "bin"),
+    import_node_path10.default.join(homeDir, ".fnm", "current", "bin"),
+    ...pathHints
+  ].filter(Boolean);
+  const currentPath = runtimeEnv.PATH ?? "";
+  runtimeEnv.PATH = Array.from(
+    /* @__PURE__ */ new Set([...extraPathEntries, ...currentPath.split(import_node_path10.default.delimiter).filter(Boolean)])
+  ).join(import_node_path10.default.delimiter);
+  const candidates = Array.from(
+    new Set(
+      [
+        runtimeEnv.CODEX_NODE_RUNTIME?.trim(),
+        runtimeEnv.CODEX_NODE_BIN?.trim(),
+        runtimeEnv.CODEX_NODE?.trim(),
+        "/opt/homebrew/bin/node",
+        "/usr/local/bin/node",
+        "node"
+      ].filter(Boolean)
+    )
+  );
+  for (const candidate of candidates) {
+    const probe = (0, import_node_child_process4.spawnSync)(candidate, ["-v"], { env: runtimeEnv, stdio: "ignore" });
+    if (!probe.error && probe.status === 0) {
+      cachedRuntimeBinary = candidate;
+      return candidate;
+    }
+  }
+  cachedRuntimeBinary = process.execPath;
+  return process.execPath;
+}
+var CodexAppServer = class extends import_node_events.EventEmitter {
+  constructor() {
+    super();
+    this.child = null;
+    this.reader = null;
+    this.nextRequestId = 1;
+    this.pendingRequests = /* @__PURE__ */ new Map();
+    this.pendingServerRequests = /* @__PURE__ */ new Map();
+    this.timeoutRecoveryPromise = null;
+    this.lastTimeoutWarningAtByMethod = /* @__PURE__ */ new Map();
+    this.startPromise = null;
+    this.initializePromise = null;
+    this.initializeResponse = null;
+    this.parseLineBuffer = null;
+    this.threadLiveSubscriptionIdByKey = /* @__PURE__ */ new Map();
+    this.threadLiveModeByKey = /* @__PURE__ */ new Map();
+    this.addConversationListenerSupported = null;
+    this.setMaxListeners(50);
+  }
+  async start() {
+    if (this.child) {
+      return;
+    }
+    if (!this.startPromise) {
+      this.startPromise = this.spawnProcess().finally(() => {
+        this.startPromise = null;
+      });
+    }
+    await this.startPromise;
+  }
+  async stop() {
+    if (this.reader) {
+      this.reader.close();
+      this.reader = null;
+    }
+    if (this.child) {
+      const child = this.child;
+      this.child = null;
+      try {
+        child.kill();
+      } catch {
+      }
+    }
+    this.initializePromise = null;
+    this.initializeResponse = null;
+    this.parseLineBuffer = null;
+    this.threadLiveSubscriptionIdByKey.clear();
+    this.threadLiveModeByKey.clear();
+    this.addConversationListenerSupported = null;
+    this.clearPendingRequests(new Error("codex app-server stopped"));
+  }
+  isRunning() {
+    return Boolean(this.child && !this.child.killed);
+  }
+  async initialize(clientInfo) {
+    if (this.initializeResponse) {
+      return this.initializeResponse;
+    }
+    if (!this.initializePromise) {
+      this.initializePromise = (async () => {
+        await this.start();
+        const payload = {
+          clientInfo: clientInfo ?? {
+            name: "codexuse",
+            title: "CodexUse",
+            version: "0.0.0"
+          }
+        };
+        try {
+          const response = await this.request("initialize", payload);
+          await this.notify("initialized", {});
+          this.initializeResponse = response;
+          return response;
+        } catch (error) {
+          if (isAlreadyInitializedError(error)) {
+            this.initializeResponse = this.initializeResponse ?? {};
+            return this.initializeResponse;
+          }
+          throw error;
+        }
+      })().finally(() => {
+        this.initializePromise = null;
+      });
+    }
+    return this.initializePromise;
+  }
+  async getAccount(refreshToken = false) {
+    return this.request("account/read", { refreshToken });
+  }
+  async getAccountRateLimits() {
+    return this.request("account/rateLimits/read");
+  }
+  async loginAccount(params) {
+    return this.request("account/login/start", params);
+  }
+  async cancelLoginAccount(loginId) {
+    return this.request("account/login/cancel", { loginId });
+  }
+  async logoutAccount() {
+    return this.request("account/logout");
+  }
+  async newConversation(params, overrides) {
+    const merged = overrides ? { ...params, ...overrides } : params;
+    return this.request("newConversation", merged);
+  }
+  async resumeConversation(params, overrides) {
+    const merged = overrides ? { ...params, ...overrides } : params;
+    return this.request("resumeConversation", merged);
+  }
+  async addConversationListenerWithResumeFallback(threadId, workspaceId = null) {
+    if (this.addConversationListenerSupported === false) {
+      return {};
+    }
+    const listenerParams = {
+      conversationId: threadId
+    };
+    const resolvedWorkspaceId = workspaceId ? workspaceId.trim() : "";
+    if (resolvedWorkspaceId) {
+      listenerParams.workspaceId = resolvedWorkspaceId;
+      listenerParams.workspace_id = resolvedWorkspaceId;
+    }
+    try {
+      const response = await this.request("addConversationListener", listenerParams);
+      this.addConversationListenerSupported = true;
+      return isRecord6(response) ? response : null;
+    } catch (error) {
+      if (isMethodUnavailableError(error, "addConversationListener")) {
+        this.addConversationListenerSupported = false;
+        return {};
+      }
+      if (!isThreadNotFoundError(error)) {
+        throw error;
+      }
+      await this.threadResume(
+        resolvedWorkspaceId ? { threadId, workspaceId: resolvedWorkspaceId, workspace_id: resolvedWorkspaceId } : { threadId }
+      );
+      try {
+        const response = await this.request("addConversationListener", listenerParams);
+        this.addConversationListenerSupported = true;
+        return isRecord6(response) ? response : null;
+      } catch (resumeError) {
+        if (isMethodUnavailableError(resumeError, "addConversationListener")) {
+          this.addConversationListenerSupported = false;
+          return {};
+        }
+        throw resumeError;
+      }
+    }
+  }
+  async removeConversationListenerBySubscriptionId(subscriptionId) {
+    if (!subscriptionId || this.addConversationListenerSupported === false) {
+      return;
+    }
+    try {
+      await this.request("removeConversationListener", { subscriptionId });
+    } catch (error) {
+      if (isMethodUnavailableError(error, "removeConversationListener")) {
+        this.addConversationListenerSupported = false;
+        return;
+      }
+      throw error;
+    }
+  }
+  async addConversationListener(params) {
+    if (this.addConversationListenerSupported === false) {
+      return {};
+    }
+    const conversationId = asString4(
+      params.conversationId ?? params.threadId ?? params.thread_id ?? ""
+    ).trim();
+    const workspaceId = asString4(
+      params.workspaceId ?? params.workspace_id ?? ""
+    ).trim();
+    if (!conversationId) {
+      try {
+        const response = await this.request("addConversationListener", params);
+        this.addConversationListenerSupported = true;
+        return response;
+      } catch (error) {
+        if (isMethodUnavailableError(error, "addConversationListener")) {
+          this.addConversationListenerSupported = false;
+          return {};
+        }
+        throw error;
+      }
+    }
+    return this.addConversationListenerWithResumeFallback(
+      conversationId,
+      workspaceId || null
+    );
+  }
+  async removeConversationListener(params) {
+    if (this.addConversationListenerSupported === false) {
+      return {};
+    }
+    try {
+      return await this.request("removeConversationListener", params);
+    } catch (error) {
+      if (isMethodUnavailableError(error, "removeConversationListener")) {
+        this.addConversationListenerSupported = false;
+        return {};
+      }
+      throw error;
+    }
+  }
+  async threadLiveSubscribe(params) {
+    const workspaceId = normalizeThreadLiveWorkspaceId(
+      params.workspaceId ?? params.workspace_id
+    );
+    const threadId = asString4(
+      params.threadId ?? params.thread_id ?? params.conversationId
+    ).trim();
+    if (!threadId) {
+      return {};
+    }
+    const key = threadLiveKey(workspaceId, threadId);
+    this.threadLiveModeByKey.set(key, "listener");
+    this.threadLiveSubscriptionIdByKey.delete(key);
+    return {};
+  }
+  async threadLiveUnsubscribe(params) {
+    const workspaceId = normalizeThreadLiveWorkspaceId(
+      params.workspaceId ?? params.workspace_id
+    );
+    const threadId = asString4(
+      params.threadId ?? params.thread_id ?? params.conversationId
+    ).trim();
+    if (!threadId) {
+      return {};
+    }
+    const key = threadLiveKey(workspaceId, threadId);
+    this.threadLiveModeByKey.delete(key);
+    const subscriptionId = this.threadLiveSubscriptionIdByKey.get(key) ?? null;
+    this.threadLiveSubscriptionIdByKey.delete(key);
+    if (subscriptionId) {
+      await this.removeConversationListenerBySubscriptionId(subscriptionId);
+    }
+    return {};
+  }
+  async sendUserMessage(params) {
+    return this.request("turn/start", normalizeTurnInputParams(params));
+  }
+  async threadStart(params) {
+    return this.request("thread/start", params);
+  }
+  async threadResume(params) {
+    const sanitized = { ...params };
+    delete sanitized.rolloutPath;
+    delete sanitized.rollout_path;
+    return this.request("thread/resume", sanitized);
+  }
+  async turnStart(params) {
+    return this.request("turn/start", normalizeTurnInputParams(params));
+  }
+  async steerTurn(params) {
+    return this.request("turn/steer", normalizeTurnInputParams(params));
+  }
+  async interruptTurn(params) {
+    return this.request("turn/interrupt", params);
+  }
+  async turnSteer(params) {
+    return this.steerTurn(params);
+  }
+  async turnInterrupt(params) {
+    return this.interruptTurn(params);
+  }
+  async interruptConversation(params) {
+    return this.request("interruptConversation", params);
+  }
+  async archiveConversation(conversationId) {
+    try {
+      await this.request("thread/archive", { threadId: conversationId });
+      return;
+    } catch {
+    }
+    try {
+      await this.request("archiveConversation", { conversationId });
+    } catch {
+    }
+  }
+  async listConversations(params) {
+    return this.request("thread/list", {
+      cursor: params.cursor ?? null,
+      limit: params.limit ?? 20,
+      cwd: params.cwd ?? null,
+      sortKey: params.sortKey ?? null,
+      searchQuery: params.searchQuery ?? null,
+      sourceKinds: params.sourceKinds ?? null,
+      archived: params.archived ?? null,
+      modelProviders: params.modelProviders ?? null
+    });
+  }
+  async listSkillsCore(params) {
+    const cwd = typeof params?.cwd === "string" ? params.cwd.trim() : "";
+    return this.request("skills/list", {
+      cwds: cwd ? [cwd] : [],
+      forceReload: Boolean(params?.forceReload)
+    });
+  }
+  async listApps(params) {
+    const payload = buildAppsListPayload(params);
+    const methods = ["app/list", "apps/list", "apps_list"];
+    for (let index = 0; index < methods.length; index += 1) {
+      const method = methods[index];
+      try {
+        return await this.request(method, payload);
+      } catch (error) {
+        const hasLegacyFallback = index < methods.length - 1;
+        if (hasLegacyFallback && isMethodUnavailableError(error, method)) {
+          continue;
+        }
+        if (isAppsListThreadNotFoundError(error)) {
+          return { data: [] };
+        }
+        throw error;
+      }
+    }
+    throw new Error("Apps list is unavailable from the connected Codex backend.");
+  }
+  async setSkillEnabledCore(params) {
+    const skillPath = typeof params.path === "string" ? params.path.trim() : "";
+    if (!skillPath) {
+      throw new Error("Skill path is required.");
+    }
+    return this.request("skills/config/write", {
+      path: skillPath,
+      enabled: Boolean(params.enabled)
+    });
+  }
+  async readThread(params) {
+    return this.request("thread/read", {
+      threadId: params.threadId,
+      includeTurns: Boolean(params.includeTurns)
+    });
+  }
+  async setThreadName(threadId, name) {
+    return this.request("thread/name/set", { threadId, name });
+  }
+  async startReview(params) {
+    return this.request("review/start", params);
+  }
+  async startCompact(params) {
+    try {
+      return await this.request("thread/compact/start", params);
+    } catch {
+      try {
+        return await this.request("thread/compact", params);
+      } catch {
+        return this.request("compactThread", params);
+      }
+    }
+  }
+  async respondExecCommandRequest(requestToken, decision) {
+    await this.respondReviewDecision(requestToken, "exec", decision);
+  }
+  async respondApplyPatchRequest(requestToken, decision) {
+    await this.respondReviewDecision(requestToken, "patch", decision);
+  }
+  async respondToServerRequest(requestId, result) {
+    const token = requestIdToToken(requestId);
+    const pending = this.pendingServerRequests.get(token);
+    if (!pending) {
+      throw new Error(`Unknown server request: ${requestId}`);
+    }
+    this.pendingServerRequests.delete(token);
+    await this.sendResponse(pending.id, result ?? {});
+  }
+  async spawnProcess() {
+    const codexPath = await requireCodexCli();
+    const env = buildCliEnv(codexPath, { ELECTRON_RUN_AS_NODE: "1" });
+    const runtimeBin = resolveRuntimeBinary(env);
+    const child = (0, import_node_child_process4.spawn)(runtimeBin, [codexPath, "app-server"], {
+      stdio: ["pipe", "pipe", "pipe"],
+      env
+    });
+    this.child = child;
+    this.initializeResponse = null;
+    this.initializePromise = null;
+    this.parseLineBuffer = null;
+    this.addConversationListenerSupported = null;
+    child.on("exit", (code, signal) => {
+      logWarn("[app-server] exited", { code, signal });
+      this.child = null;
+      this.initializeResponse = null;
+      this.initializePromise = null;
+      this.threadLiveSubscriptionIdByKey.clear();
+      this.threadLiveModeByKey.clear();
+      this.addConversationListenerSupported = null;
+      this.clearPendingRequests(new Error("codex app-server exited"));
+      this.emit("codex:process-exited", {});
+    });
+    child.on("error", (error) => {
+      logError("[app-server] process error", error);
+      this.threadLiveSubscriptionIdByKey.clear();
+      this.threadLiveModeByKey.clear();
+      this.addConversationListenerSupported = null;
+      this.emit("codex:process-exited", {});
+    });
+    if (child.stderr) {
+      child.stderr.on("data", (chunk) => {
+        const lines = chunk.toString().split(/\r?\n/);
+        for (const line of lines) {
+          const message = line.trim();
+          if (!message) continue;
+          const normalized = message.toLowerCase();
+          if (normalized.includes("state db missing rollout path for thread")) {
+            continue;
+          }
+          if (normalized.includes("rollout::recorder") && normalized.includes("falling back on rollout system")) {
+            continue;
+          }
+          if (isIgnorableAppsListTransportStderr(message)) {
+            continue;
+          }
+          if (isIgnorableMissingSkillsSymlinkStderr(message)) {
+            continue;
+          }
+          logWarn("[app-server] stderr", message);
+        }
+      });
+    }
+    if (!child.stdout) {
+      throw new Error("codex app-server missing stdout");
+    }
+    this.reader = import_node_readline2.default.createInterface({
+      input: child.stdout,
+      crlfDelay: Infinity
+    });
+    this.reader.on("line", (line) => {
+      this.handleIncomingLine(line);
+    });
+    logInfo("[app-server] started");
+  }
+  handleIncomingLine(line) {
+    if (this.parseLineBuffer !== null) {
+      const merged = `${this.parseLineBuffer}
+${line}`;
+      const handled2 = this.tryHandleMessage(merged);
+      if (handled2) {
+        this.parseLineBuffer = null;
+        return;
+      }
+      if (merged.length < MAX_PARSE_BUFFER_CHARS) {
+        this.parseLineBuffer = merged;
+        return;
+      }
+      this.logParseFailure(
+        merged,
+        new Error("Buffered JSON message exceeded max size while recovering malformed output.")
+      );
+      this.parseLineBuffer = null;
+      return;
+    }
+    if (!line.trim()) {
+      return;
+    }
+    const handled = this.tryHandleMessage(line);
+    if (handled) {
+      return;
+    }
+    if (line.trimStart().startsWith("{")) {
+      this.parseLineBuffer = line;
+    }
+  }
+  tryHandleMessage(line) {
+    let parsed;
+    let parseError = null;
+    try {
+      parsed = JSON.parse(line);
+    } catch (error) {
+      parseError = error;
+      const repaired = escapeInvalidJsonStringChars(line);
+      if (repaired !== line) {
+        try {
+          parsed = JSON.parse(repaired);
+          parseError = null;
+        } catch (repairError) {
+          parseError = repairError;
+        }
+      }
+    }
+    if (parseError) {
+      if (isLikelyRecoverableJsonParseError(parseError)) {
+        return false;
+      }
+      this.logParseFailure(line, parseError);
+      return true;
+    }
+    if (!isRecord6(parsed)) {
+      logWarn("[app-server] unexpected JSON message", parsed);
+      return true;
+    }
+    const hasId = "id" in parsed;
+    const hasMethod = typeof parsed.method === "string";
+    const hasResult = "result" in parsed;
+    const hasError = "error" in parsed;
+    if (hasMethod && hasId) {
+      this.handleServerRequest(parsed);
+      return true;
+    }
+    if (hasMethod) {
+      this.handleNotification(parsed);
+      return true;
+    }
+    if (hasId && (hasResult || hasError)) {
+      this.handleResponse(parsed);
+      return true;
+    }
+    logWarn("[app-server] unknown message shape", parsed);
+    return true;
+  }
+  logParseFailure(line, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logWarn("[app-server] failed to parse JSON", {
+      error: message,
+      length: line.length,
+      startsWithJsonObject: line.trimStart().startsWith("{")
+    });
+  }
+  handleResponse(response) {
+    const token = requestIdToToken(response.id);
+    const pending = this.pendingRequests.get(token);
+    if (!pending) {
+      logWarn("[app-server] response with no pending request", response.id);
+      return;
+    }
+    this.pendingRequests.delete(token);
+    if (response.error) {
+      const error = new Error(response.error.message || "codex app-server error");
+      error.code = response.error.code;
+      error.data = response.error.data;
+      const suppressBackendErrorEvent = isAppsListMethod(pending.method) || pending.method === "addConversationListener" && isThreadNotFoundError(error) || pending.method === "thread/resume" && isThreadNotFoundError(error);
+      if (!suppressBackendErrorEvent) {
+        this.emit("codex:backend-error", {
+          code: response.error.code,
+          message: response.error.message,
+          data: response.error.data
+        });
+      }
+      pending.reject(error);
+      return;
+    }
+    pending.resolve(response.result);
+  }
+  handleNotification(notification) {
+    const { method, params } = notification;
+    if (method.startsWith("codex/event/")) {
+      this.emit("codex:event", { method, params });
+      return;
+    }
+    const normalized = method.toLowerCase();
+    if (normalized.includes("auth") && normalized.includes("status")) {
+      this.emit("codex:auth-status", params ?? {});
+      return;
+    }
+    if (normalized.includes("login") && normalized.includes("complete")) {
+      this.emit("codex:login-complete", params ?? {});
+      return;
+    }
+    this.emit("codex:notification", { method, params });
+  }
+  handleServerRequest(request) {
+    const kind = pickMethodKind(request.method, request.params);
+    if (!kind) {
+      void this.sendError(request.id, {
+        code: -32601,
+        message: `Unsupported request: ${request.method}`
+      });
+      return;
+    }
+    const token = requestIdToToken(request.id);
+    this.pendingServerRequests.set(token, { id: request.id, kind, method: request.method });
+    const params = isRecord6(request.params) ? request.params : {};
+    if (kind === "exec") {
+      this.emit("codex:exec-command-request", {
+        requestToken: token,
+        params
+      });
+    } else if (kind === "patch") {
+      this.emit("codex:apply-patch-request", {
+        requestToken: token,
+        params
+      });
+    } else {
+      this.emit("codex:server-request", {
+        requestId: request.id,
+        method: request.method,
+        params
+      });
+    }
+  }
+  async respondReviewDecision(requestToken, kind, decision) {
+    const pending = this.pendingServerRequests.get(requestToken);
+    if (!pending) {
+      throw new Error(`Unknown approval request: ${requestToken}`);
+    }
+    if (pending.kind !== kind) {
+      throw new Error(`Mismatched approval request type for ${requestToken}`);
+    }
+    this.pendingServerRequests.delete(requestToken);
+    await this.sendResponse(pending.id, { decision });
+  }
+  async request(method, params) {
+    if (method !== "initialize") {
+      await this.initialize();
+    } else {
+      await this.start();
+    }
+    const id = this.nextRequestId++;
+    const token = requestIdToToken(id);
+    const timeoutMs = getRequestTimeoutMs(method);
+    const payload = params ? { id, method, params } : { id, method };
+    const result = new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        const pending = this.pendingRequests.get(token);
+        if (!pending) {
+          return;
+        }
+        this.pendingRequests.delete(token);
+        const timeoutError = new Error(
+          `codex app-server request timed out after ${timeoutMs}ms (${method})`
+        );
+        pending.reject(timeoutError);
+        this.maybeRecoverFromTimeout(method, timeoutError);
+      }, timeoutMs);
+      this.pendingRequests.set(token, {
+        method,
+        resolve: (value) => {
+          clearTimeout(timeout);
+          resolve(value);
+        },
+        reject: (error) => {
+          clearTimeout(timeout);
+          reject(error);
+        }
+      });
+    });
+    await this.writeMessage(payload);
+    return result;
+  }
+  async notify(method, params) {
+    await this.start();
+    const payload = params ? { method, params } : { method };
+    await this.writeMessage(payload);
+  }
+  async sendResponse(id, result) {
+    await this.writeMessage({ id, result });
+  }
+  async sendError(id, error) {
+    await this.writeMessage({ id, error });
+  }
+  async writeMessage(message) {
+    if (!this.child || !this.child.stdin) {
+      throw new Error("codex app-server is not running");
+    }
+    const payload = JSON.stringify({ jsonrpc: "2.0", ...message });
+    this.child.stdin.write(`${payload}
+`);
+  }
+  clearPendingRequests(error) {
+    for (const pending of this.pendingRequests.values()) {
+      pending.reject(error);
+    }
+    this.pendingRequests.clear();
+    this.pendingServerRequests.clear();
+    this.threadLiveSubscriptionIdByKey.clear();
+    this.threadLiveModeByKey.clear();
+  }
+  maybeRecoverFromTimeout(method, error) {
+    const message = error instanceof Error ? error.message : String(error ?? "");
+    if (!isRequestTimeoutErrorMessage(message)) {
+      return;
+    }
+    if (method !== "initialize") {
+      const now = Date.now();
+      const lastWarning = this.lastTimeoutWarningAtByMethod.get(method) ?? 0;
+      if (now - lastWarning >= REQUEST_TIMEOUT_WARNING_COOLDOWN_MS) {
+        this.lastTimeoutWarningAtByMethod.set(method, now);
+        logWarn("[app-server] request timed out (keeping process alive)", { method });
+      }
+      return;
+    }
+    if (this.timeoutRecoveryPromise) {
+      return;
+    }
+    this.timeoutRecoveryPromise = (async () => {
+      logWarn("[app-server] recycling after request timeout", { method });
+      try {
+        await this.stop();
+      } catch (stopError) {
+        logWarn("[app-server] failed to recycle after timeout", stopError);
+      }
+    })().finally(() => {
+      this.timeoutRecoveryPromise = null;
+    });
+  }
+};
+
+// ../../lib/workspace-parity-store.ts
+var import_node_path12 = __toESM(require("path"));
+var import_promises3 = __toESM(require("fs/promises"));
+var import_node_crypto3 = require("crypto");
+
+// ../../lib/git/git-service.ts
+var import_node_fs8 = __toESM(require("fs"));
+var import_node_path11 = __toESM(require("path"));
+var import_node_child_process6 = require("child_process");
+var import_node_util2 = require("util");
+
+// ../../lib/git/git-cli.ts
+var import_node_child_process5 = require("child_process");
+var import_node_util = require("util");
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process5.execFile);
+var MAX_BUFFER_BYTES = 10 * 1024 * 1024;
+
+// ../../lib/git/git-service.ts
+var execFileAsync2 = (0, import_node_util2.promisify)(import_node_child_process6.execFile);
+
+// ../../lib/workspace-parity-store.ts
+var STORE_FILE = "workspace-parity.json";
+var LEGACY_STORE_FILE = "workspace-parity.json";
+var PROFILE_ROOT_DIR = "profiles";
+var PROFILE_PARITY_DIR = "parity";
+var LEGACY_MIGRATION_MARKER_FILE = "workspace-parity-profile-migration.json";
+function defaultSettings() {
+  return {
+    sidebarCollapsed: false,
+    sortOrder: null,
+    groupId: null,
+    cloneSourceWorkspaceId: null,
+    gitRoot: null,
+    launchScript: null,
+    launchScripts: null,
+    worktreeSetupScript: null
+  };
+}
+function defaultStore() {
+  return {
+    version: 1,
+    workspaces: []
+  };
+}
+function normalizeProfileName(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function toProfileStorageKey(profileName) {
+  const normalized = (profileName ?? "default").toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+  return normalized || "default";
+}
+async function getActiveProfileContext() {
+  let profileName = null;
+  try {
+    const state = await getAppState();
+    profileName = normalizeProfileName(state.app.lastProfileName);
+  } catch {
+    profileName = null;
+  }
+  const profileKey = toProfileStorageKey(profileName);
+  const profileRootDir = import_node_path12.default.join(getUserDataDir(), PROFILE_ROOT_DIR, profileKey);
+  return {
+    profileName,
+    profileKey,
+    profileRootDir,
+    parityStoreDir: import_node_path12.default.join(profileRootDir, PROFILE_PARITY_DIR)
+  };
+}
+function toWorkspaceName(inputPath) {
+  const normalized = inputPath.replace(/\\/g, "/").replace(/\/+$/, "");
+  const parts = normalized.split("/").filter(Boolean);
+  return parts[parts.length - 1] ?? inputPath;
+}
+async function ensureStoreDir() {
+  const context = await getActiveProfileContext();
+  const dir = context.parityStoreDir;
+  await import_promises3.default.mkdir(dir, { recursive: true });
+  return dir;
+}
+async function fileExists3(filePath) {
+  try {
+    await import_promises3.default.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function legacyStorePath() {
+  return import_node_path12.default.join(getUserDataDir(), LEGACY_STORE_FILE);
+}
+function legacyMigrationMarkerPath() {
+  return import_node_path12.default.join(getUserDataDir(), LEGACY_MIGRATION_MARKER_FILE);
+}
+async function readLegacyMigrationMarker() {
+  try {
+    const raw = await import_promises3.default.readFile(legacyMigrationMarkerPath(), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && parsed.version === 1 && typeof parsed.migratedToProfileKey === "string" && parsed.migratedToProfileKey.trim()) {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function writeLegacyMigrationMarker(profileKey) {
+  const marker = {
+    version: 1,
+    migratedToProfileKey: profileKey,
+    migratedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const markerPath = legacyMigrationMarkerPath();
+  await import_promises3.default.mkdir(import_node_path12.default.dirname(markerPath), { recursive: true });
+  await import_promises3.default.writeFile(markerPath, JSON.stringify(marker, null, 2), "utf8");
+}
+async function migrateLegacyStoreIfNeeded(scopedStorePath) {
+  if (await fileExists3(scopedStorePath)) {
+    return;
+  }
+  const context = await getActiveProfileContext();
+  const legacyPath = legacyStorePath();
+  if (!await fileExists3(legacyPath)) {
+    return;
+  }
+  const marker = await readLegacyMigrationMarker();
+  if (marker && marker.migratedToProfileKey && marker.migratedToProfileKey !== context.profileKey) {
+    return;
+  }
+  await import_promises3.default.mkdir(import_node_path12.default.dirname(scopedStorePath), { recursive: true });
+  await import_promises3.default.copyFile(legacyPath, scopedStorePath);
+  await writeLegacyMigrationMarker(context.profileKey);
+}
+async function storePath() {
+  const dir = await ensureStoreDir();
+  const scopedPath = import_node_path12.default.join(dir, STORE_FILE);
+  await migrateLegacyStoreIfNeeded(scopedPath);
+  return scopedPath;
+}
+function sanitizeWorkspace(entry) {
+  if (!entry || typeof entry !== "object") {
+    return null;
+  }
+  const id = typeof entry.id === "string" && entry.id.trim() ? entry.id.trim() : null;
+  const workspacePath = typeof entry.path === "string" && entry.path.trim() ? import_node_path12.default.resolve(entry.path) : null;
+  if (!id || !workspacePath) {
+    return null;
+  }
+  const name = typeof entry.name === "string" && entry.name.trim() ? entry.name.trim() : toWorkspaceName(workspacePath);
+  const branch = entry.worktree && typeof entry.worktree === "object" && typeof entry.worktree.branch === "string" ? entry.worktree.branch.trim() || "main" : "main";
+  return {
+    id,
+    name,
+    path: workspacePath,
+    connected: Boolean(entry.connected),
+    kind: entry.kind === "worktree" ? "worktree" : "main",
+    parentId: typeof entry.parentId === "string" && entry.parentId.trim() ? entry.parentId.trim() : null,
+    worktree: entry.kind === "worktree" ? { branch } : null,
+    settings: {
+      ...defaultSettings(),
+      ...entry.settings ?? {}
+    }
+  };
+}
+async function readStore() {
+  const filePath = await storePath();
+  try {
+    const raw = await import_promises3.default.readFile(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    const source = Array.isArray(parsed?.workspaces) ? parsed.workspaces : [];
+    const workspaces = source.map((entry) => sanitizeWorkspace(entry)).filter((entry) => Boolean(entry));
+    return {
+      version: 1,
+      workspaces
+    };
+  } catch {
+    return defaultStore();
+  }
+}
+async function writeStore(store) {
+  const filePath = await storePath();
+  await import_promises3.default.writeFile(filePath, JSON.stringify(store, null, 2), "utf8");
+}
+function dedupeByPath(workspaces) {
+  const seen = /* @__PURE__ */ new Set();
+  const ordered = [];
+  for (const workspace of workspaces) {
+    const key = workspace.path.toLowerCase();
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    ordered.push(workspace);
+  }
+  return ordered;
+}
+async function upsertStore(mutator) {
+  const current = await readStore();
+  const next = mutator(current);
+  await writeStore(next);
+  return next;
+}
+function isMainWorkspace(workspace) {
+  return (workspace.kind ?? "main") !== "worktree";
+}
+function pruneToFreeProjectLimit(workspaces) {
+  const mainWorkspaces = workspaces.filter((workspace) => isMainWorkspace(workspace));
+  if (mainWorkspaces.length <= FREE_PROFILE_LIMIT) {
+    return workspaces;
+  }
+  const keptMainIds = new Set(mainWorkspaces.slice(0, FREE_PROFILE_LIMIT).map((workspace) => workspace.id));
+  return workspaces.filter((workspace) => {
+    if (isMainWorkspace(workspace)) {
+      return keptMainIds.has(workspace.id);
+    }
+    return typeof workspace.parentId === "string" && keptMainIds.has(workspace.parentId);
+  });
+}
+async function enforceFreeProjectLimitIfNeeded(workspaces) {
+  const license = await licenseService.getStatus().catch(() => null);
+  if (!license || !shouldEnforceProfileLimit(license)) {
+    return workspaces;
+  }
+  const pruned = pruneToFreeProjectLimit(workspaces);
+  if (pruned.length === workspaces.length) {
+    return workspaces;
+  }
+  await writeStore({
+    version: 1,
+    workspaces: pruned
+  });
+  return pruned;
+}
+async function listParityWorkspaces() {
+  const store = await readStore();
+  const deduped = dedupeByPath(store.workspaces);
+  return enforceFreeProjectLimitIfNeeded(deduped);
+}
+async function getParityWorkspaceById(id) {
+  const workspaces = await listParityWorkspaces();
+  return workspaces.find((entry) => entry.id === id) ?? null;
+}
+async function addParityWorkspace(targetPath) {
+  const resolved = import_node_path12.default.resolve(targetPath);
+  const name = toWorkspaceName(resolved);
+  await import_promises3.default.mkdir(resolved, { recursive: true });
+  const nextWorkspace = {
+    id: (0, import_node_crypto3.randomUUID)(),
+    name,
+    path: resolved,
+    connected: true,
+    kind: "main",
+    parentId: null,
+    worktree: null,
+    settings: defaultSettings()
+  };
+  await upsertStore((store) => ({
+    version: 1,
+    workspaces: dedupeByPath([nextWorkspace, ...store.workspaces])
+  }));
+  return nextWorkspace;
+}
+async function connectParityWorkspace(id) {
+  let updated = null;
+  await upsertStore((store) => {
+    const next = store.workspaces.map((entry) => {
+      if (entry.id !== id) {
+        return entry;
+      }
+      updated = {
+        ...entry,
+        connected: true
+      };
+      return updated;
+    });
+    return {
+      version: 1,
+      workspaces: next
+    };
+  });
+  if (!updated) {
+    throw new Error(`Workspace '${id}' not found.`);
+  }
+  return updated;
+}
+
+// ../../electron/telegram-bridge.ts
+var import_node_crypto4 = require("crypto");
+var import_promises4 = __toESM(require("fs/promises"));
+var import_node_path13 = __toESM(require("path"));
+
+// ../../lib/retryable-turn-error.ts
+var RETRY_FLAG_KEYS = [
+  "willRetry",
+  "will_retry",
+  "retryable",
+  "retryable_error",
+  "shouldRetry",
+  "should_retry",
+  "retry"
+];
+var RETRY_PROGRESS_MESSAGE_RE = /(?:reconnecting|retrying)(?:\.\.\.)?(?:\s+\d+\s*\/\s*\d+)?/i;
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function asString5(value) {
+  return typeof value === "string" ? value : value != null ? String(value) : "";
+}
+function parseBooleanLike(value) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    if (value === 1) {
+      return true;
+    }
+    if (value === 0) {
+      return false;
+    }
+    return null;
+  }
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (!normalized) {
+      return null;
+    }
+    if (normalized === "true" || normalized === "1") {
+      return true;
+    }
+    if (normalized === "false" || normalized === "0") {
+      return false;
+    }
+  }
+  return null;
+}
+function extractRetryFlag(payload) {
+  const root = asRecord(payload);
+  const nestedCandidates = [
+    root,
+    asRecord(root.error),
+    asRecord(root.details),
+    asRecord(root.data),
+    asRecord(root.meta)
+  ];
+  for (const candidate of nestedCandidates) {
+    for (const key of RETRY_FLAG_KEYS) {
+      const parsed = parseBooleanLike(candidate[key]);
+      if (parsed !== null) {
+        return parsed;
+      }
+    }
+  }
+  return null;
+}
+function isRetryProgressMessage(message) {
+  const trimmed = message.trim();
+  if (!trimmed) {
+    return false;
+  }
+  return RETRY_PROGRESS_MESSAGE_RE.test(trimmed);
+}
+function extractErrorMessageCandidates(payload) {
+  const root = asRecord(payload);
+  const error = asRecord(root.error);
+  return [
+    asString5(root.message),
+    asString5(root.detail),
+    asString5(root.reason),
+    asString5(root.error),
+    asString5(error.message),
+    asString5(error.detail),
+    asString5(error.reason),
+    asString5(error.error)
+  ].map((value) => value.trim()).filter(Boolean);
+}
+function isRetryableTurnErrorPayload(payload) {
+  const retryFlag = extractRetryFlag(payload);
+  if (retryFlag !== null) {
+    return retryFlag;
+  }
+  return extractErrorMessageCandidates(payload).some(isRetryProgressMessage);
+}
+
+// ../../electron/telegram-bridge.ts
+var TELEGRAM_API_BASE = "https://api.telegram.org";
+var TELEGRAM_POLL_TIMEOUT_SECONDS = 30;
+var TELEGRAM_API_TIMEOUT_MS = 4e4;
+var TELEGRAM_STREAM_FLUSH_MS = 300;
+var TELEGRAM_MAX_MESSAGE_LENGTH = 4096;
+var TELEGRAM_PENDING_TTL_MS = 30 * 60 * 1e3;
+var TELEGRAM_RETRY_LIMIT_MS = 3e4;
+var TELEGRAM_MIN_SEND_INTERVAL_MS = 500;
+var TELEGRAM_FINAL_TEXT_DEDUPE_MS = 2500;
+var TELEGRAM_RECENT_FINALIZED_TURNS_MAX = 24;
+var TELEGRAM_FINAL_SIGNATURE_DEDUPE_MS = 2e4;
+var TELEGRAM_RECENT_FINAL_SIGNATURES_MAX = 40;
+var TELEGRAM_RECENT_INCOMING_MESSAGES_MAX = 32;
+var TELEGRAM_TYPING_HEARTBEAT_MS = 4e3;
+var TELEGRAM_BRIDGE_LOCK_FILE_PREFIX = "telegram-bridge";
+function asRecord2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function asString6(value) {
+  return typeof value === "string" ? value : value != null ? String(value) : "";
+}
+function asTrimmedString(value) {
+  return asString6(value).trim();
+}
+function asNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value.trim());
+    if (Number.isFinite(parsed)) {
+      return parsed;
+    }
+  }
+  return null;
+}
+function normalizeChatId(value) {
+  const trimmed = asTrimmedString(value);
+  if (!trimmed) {
+    return null;
+  }
+  if (!/^-?[0-9]+$/.test(trimmed)) {
+    return null;
+  }
+  return trimmed;
+}
+function extractThreadId(value) {
+  const params = asRecord2(value);
+  const turn = asRecord2(params.turn);
+  const thread = asRecord2(params.thread);
+  const item = asRecord2(params.item);
+  const msg = asRecord2(params.msg);
+  const msgItem = asRecord2(msg.item);
+  return asTrimmedString(
+    params.threadId ?? params.thread_id ?? params.conversationId ?? params.conversation_id ?? turn.threadId ?? turn.thread_id ?? thread.id ?? thread.threadId ?? thread.thread_id ?? item.threadId ?? item.thread_id ?? item.conversationId ?? item.conversation_id ?? msg.threadId ?? msg.thread_id ?? msg.conversationId ?? msg.conversation_id ?? msgItem.threadId ?? msgItem.thread_id ?? msgItem.conversationId ?? msgItem.conversation_id ?? ""
+  );
+}
+function extractTurnId(value) {
+  const params = asRecord2(value);
+  const turn = asRecord2(params.turn);
+  const msg = asRecord2(params.msg);
+  const msgTurn = asRecord2(msg.turn);
+  return asTrimmedString(
+    turn.id ?? turn.turnId ?? turn.turn_id ?? params.turnId ?? params.turn_id ?? msg.turnId ?? msg.turn_id ?? msgTurn.id ?? msgTurn.turnId ?? msgTurn.turn_id ?? ""
+  );
+}
+function extractText(value, depth = 0) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (depth > 4 || value == null) {
+    return "";
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => extractText(entry, depth + 1)).join("");
+  }
+  if (typeof value !== "object") {
+    return "";
+  }
+  const record = value;
+  return extractText(record.text, depth + 1) || extractText(record.delta, depth + 1) || extractText(record.message, depth + 1) || extractText(record.content, depth + 1) || extractText(record.value, depth + 1);
+}
+function extractDeltaFromNotification(params) {
+  const msg = asRecord2(params.msg);
+  return asString6(params.delta) || extractText(params.delta) || extractText(msg.delta ?? msg.message ?? msg.content ?? msg.value);
+}
+function looksLikeAssistantItem(item) {
+  const itemType = asTrimmedString(item.type).toLowerCase();
+  if (itemType === "agentmessage" || itemType === "agent_message" || itemType === "assistantmessage" || itemType === "assistant_message") {
+    return true;
+  }
+  const itemRole = asTrimmedString(
+    item.role ?? item.authorRole ?? item.author_role ?? item.senderRole ?? item.sender_role
+  ).toLowerCase();
+  if (itemRole === "assistant" || itemRole === "agent") {
+    return true;
+  }
+  const itemId = asTrimmedString(item.id);
+  return itemId.startsWith("msg_");
+}
+function extractAssistantTextFromItemCompleted(params) {
+  const item = asRecord2(params.item);
+  if (!looksLikeAssistantItem(item)) {
+    return "";
+  }
+  return asString6(item.text) || extractText(item.content) || extractText(params.msg) || "";
+}
+function extractCommandText(params) {
+  const command = params.command;
+  if (typeof command === "string") {
+    return command.trim();
+  }
+  if (Array.isArray(command)) {
+    const parts = command.map((entry) => asString6(entry).trim()).filter(Boolean);
+    if (parts.length > 0) {
+      return parts.join(" ");
+    }
+  }
+  const parsed = asRecord2(params.parsed_cmd ?? params.parsedCmd);
+  const parsedText = asTrimmedString(parsed.text ?? parsed.command);
+  if (parsedText) {
+    return parsedText;
+  }
+  return asTrimmedString(params.cmd ?? "");
+}
+function summarizePatchRequest(params) {
+  const fileChanges = params.file_changes ?? params.fileChanges;
+  if (Array.isArray(fileChanges)) {
+    const count = fileChanges.length;
+    return `${count} file ${count === 1 ? "change" : "changes"}`;
+  }
+  const summary = extractText(params);
+  return summary.trim() || "Apply patch request";
+}
+function splitMessage(text, maxLength = TELEGRAM_MAX_MESSAGE_LENGTH) {
+  const normalized = text.trim();
+  if (!normalized) {
+    return [];
+  }
+  if (normalized.length <= maxLength) {
+    return [normalized];
+  }
+  const parts = [];
+  let index = 0;
+  while (index < normalized.length) {
+    const remaining = normalized.slice(index);
+    if (remaining.length <= maxLength) {
+      parts.push(remaining);
+      break;
+    }
+    let cut = maxLength;
+    const newlineCut = remaining.lastIndexOf("\n", maxLength);
+    if (newlineCut >= Math.floor(maxLength * 0.5)) {
+      cut = newlineCut;
+    }
+    const chunk = remaining.slice(0, cut).trim();
+    parts.push(chunk || remaining.slice(0, maxLength));
+    index += cut;
+  }
+  return parts;
+}
+function mergeStreamDeltaBuffer(current, incoming) {
+  if (!incoming) {
+    return current;
+  }
+  if (!current) {
+    return incoming;
+  }
+  if (current.endsWith(incoming)) {
+    return current;
+  }
+  if (incoming.startsWith(current)) {
+    return incoming;
+  }
+  const maxProbe = Math.min(current.length, incoming.length, 2048);
+  for (let size = maxProbe; size > 0; size -= 1) {
+    if (current.slice(-size) === incoming.slice(0, size)) {
+      return current + incoming.slice(size);
+    }
+  }
+  return current + incoming;
+}
+function nowMs() {
+  return Date.now();
+}
+var TelegramBridge = class {
+  constructor(options) {
+    this.settings = {
+      enabled: false,
+      token: null
+    };
+    this.status = {
+      state: "stopped",
+      running: false,
+      botUsername: null,
+      allowedChats: 0,
+      activeChats: 0,
+      streamMode: "message",
+      lastError: null,
+      startedAtMs: null
+    };
+    this.running = false;
+    this.pollAbortController = null;
+    this.pollLoopPromise = null;
+    this.updateOffset = null;
+    this.draftStreamingEnabled = false;
+    this.messageStreamingEnabled = true;
+    this.sessionsByChatId = /* @__PURE__ */ new Map();
+    this.chatIdByThreadId = /* @__PURE__ */ new Map();
+    this.pendingApprovalById = /* @__PURE__ */ new Map();
+    this.pendingUserInputByRequestId = /* @__PURE__ */ new Map();
+    this.appServerListenersBound = false;
+    this.recentDeltaBySignature = /* @__PURE__ */ new Map();
+    this.lastSendAtByChatId = /* @__PURE__ */ new Map();
+    this.runtimeLockPath = null;
+    this.handleCodexNotification = (payload) => {
+      this.handleNotification(payload).catch((error) => {
+        logWarn("[telegram-bridge] notification handling failed", error);
+      });
+    };
+    this.handleCodexEvent = (payload) => {
+      this.handleEvent(payload).catch((error) => {
+        logWarn("[telegram-bridge] event handling failed", error);
+      });
+    };
+    this.handleExecApprovalRequest = (payload) => {
+      this.handleApprovalRequest("exec", payload.requestToken, payload.params).catch((error) => {
+        logWarn("[telegram-bridge] exec approval handling failed", error);
+      });
+    };
+    this.handlePatchApprovalRequest = (payload) => {
+      this.handleApprovalRequest("patch", payload.requestToken, payload.params).catch((error) => {
+        logWarn("[telegram-bridge] patch approval handling failed", error);
+      });
+    };
+    this.handleServerRequest = (payload) => {
+      this.handleUserInputRequest(payload).catch((error) => {
+        logWarn("[telegram-bridge] user-input request handling failed", error);
+      });
+    };
+    this.options = options;
+  }
+  getCurrentStreamMode() {
+    if (this.messageStreamingEnabled) {
+      return "message";
+    }
+    if (this.draftStreamingEnabled) {
+      return "draft";
+    }
+    return "none";
+  }
+  getStatus() {
+    return {
+      ...this.status,
+      allowedChats: 0,
+      activeChats: this.sessionsByChatId.size,
+      streamMode: this.getCurrentStreamMode()
+    };
+  }
+  async testToken(tokenInput) {
+    const token = asTrimmedString(tokenInput) || this.settings.token || "";
+    if (!token) {
+      return {
+        ok: false,
+        username: null,
+        error: "Telegram bot token is required."
+      };
+    }
+    try {
+      const response = await this.callTelegramApi(
+        token,
+        "getMe",
+        {},
+        { retry429: false }
+      );
+      const username = asTrimmedString(asRecord2(response).username);
+      return {
+        ok: true,
+        username: username || null,
+        error: null
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        username: null,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async applyRuntimeSettings(settings) {
+    const next = this.extractSettings(settings);
+    const tokenChanged = next.token !== this.settings.token;
+    const enabledChanged = next.enabled !== this.settings.enabled;
+    this.settings = next;
+    this.status.allowedChats = 0;
+    if (tokenChanged) {
+      this.status.botUsername = null;
+      this.draftStreamingEnabled = false;
+      this.messageStreamingEnabled = true;
+      this.status.streamMode = this.getCurrentStreamMode();
+    }
+    const shouldRestart = tokenChanged || enabledChanged;
+    await this.syncRuntimeState({ shouldRestart });
+  }
+  async dispose() {
+    await this.stop("Bridge disposed.");
+  }
+  async stop(reason) {
+    if (!this.running && !this.pollLoopPromise) {
+      await this.releaseRuntimeLock();
+      this.status.state = "stopped";
+      this.status.running = false;
+      this.status.startedAtMs = null;
+      if (reason) {
+        this.status.lastError = null;
+      }
+      return;
+    }
+    this.running = false;
+    this.status.running = false;
+    this.status.state = "stopped";
+    this.status.startedAtMs = null;
+    if (this.pollAbortController) {
+      this.pollAbortController.abort();
+      this.pollAbortController = null;
+    }
+    if (this.pollLoopPromise) {
+      try {
+        await this.pollLoopPromise;
+      } catch {
+      }
+      this.pollLoopPromise = null;
+    }
+    this.detachAppServerListeners();
+    await this.detachAllConversationListeners();
+    this.clearSessionState();
+    await this.releaseRuntimeLock();
+    if (reason) {
+      logInfo("[telegram-bridge] stopped", reason);
+    }
+  }
+  extractSettings(raw) {
+    return {
+      enabled: raw.telegramBridgeEnabled === true,
+      token: (() => {
+        const token = asTrimmedString(raw.telegramBotToken);
+        return token || null;
+      })()
+    };
+  }
+  async syncRuntimeState(options) {
+    const shouldRun = this.settings.enabled && Boolean(this.settings.token);
+    if (!shouldRun) {
+      await this.stop("Disabled or incomplete Telegram settings.");
+      this.status.state = "stopped";
+      this.status.lastError = null;
+      return;
+    }
+    const isPro = await this.options.isProEnabled().catch((error) => {
+      logWarn("[telegram-bridge] failed to verify Pro status", error);
+      return false;
+    });
+    if (!isPro) {
+      await this.stop("Telegram bridge requires Pro.");
+      this.status.state = "error";
+      this.status.lastError = "Telegram mobile access requires Pro.";
+      return;
+    }
+    if (this.running && options.shouldRestart) {
+      await this.stop("Restarting Telegram bridge after settings change.");
+    }
+    if (this.running) {
+      return;
+    }
+    await this.start();
+  }
+  async start() {
+    const token = this.settings.token;
+    if (!token) {
+      this.status.state = "error";
+      this.status.lastError = "Telegram bot token is missing.";
+      return;
+    }
+    const me = await this.testToken(token);
+    if (!me.ok) {
+      this.status.state = "error";
+      this.status.lastError = me.error;
+      this.status.botUsername = null;
+      return;
+    }
+    try {
+      await this.acquireRuntimeLock(token);
+    } catch (error) {
+      this.status.state = "error";
+      this.status.lastError = error instanceof Error ? error.message : String(error);
+      return;
+    }
+    this.status.botUsername = me.username;
+    this.status.lastError = null;
+    this.status.state = "running";
+    this.status.running = true;
+    this.status.startedAtMs = nowMs();
+    this.running = true;
+    this.attachAppServerListeners();
+    this.pollAbortController = new AbortController();
+    this.pollLoopPromise = this.runPolling(this.pollAbortController.signal).finally(() => {
+      this.pollLoopPromise = null;
+    });
+    logInfo("[telegram-bridge] started", {
+      allowedChats: "all-private-chats",
+      botUsername: this.status.botUsername
+    });
+  }
+  async runPolling(signal) {
+    const token = this.settings.token;
+    if (!token) {
+      return;
+    }
+    await this.callTelegramApi(token, "deleteWebhook", { drop_pending_updates: false }).catch(
+      (error) => {
+        logWarn("[telegram-bridge] deleteWebhook failed", error);
+      }
+    );
+    let backoffMs = 1e3;
+    while (!signal.aborted && this.running) {
+      try {
+        this.prunePendingActions();
+        const updates = await this.callTelegramApi(
+          token,
+          "getUpdates",
+          {
+            offset: this.updateOffset,
+            timeout: TELEGRAM_POLL_TIMEOUT_SECONDS,
+            allowed_updates: ["message", "callback_query", "my_chat_member"]
+          },
+          {
+            signal,
+            retry429: true
+          }
+        );
+        const list = Array.isArray(updates) ? updates : [];
+        for (const update of list) {
+          const updateId = asNumber(update.update_id);
+          if (updateId !== null) {
+            this.updateOffset = updateId + 1;
+          }
+          await this.handleUpdate(update);
+        }
+        backoffMs = 1e3;
+      } catch (error) {
+        if (signal.aborted || !this.running) {
+          break;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        this.status.state = "error";
+        this.status.lastError = message;
+        logWarn("[telegram-bridge] polling error", message);
+        await this.sleep(Math.min(backoffMs, TELEGRAM_RETRY_LIMIT_MS));
+        backoffMs = Math.min(backoffMs * 2, TELEGRAM_RETRY_LIMIT_MS);
+      }
+    }
+    if (!signal.aborted && this.running) {
+      this.status.state = "error";
+      this.status.lastError = "Telegram polling stopped unexpectedly.";
+    }
+  }
+  async handleUpdate(update) {
+    const record = asRecord2(update);
+    if (record.callback_query) {
+      await this.handleCallbackQuery(asRecord2(record.callback_query));
+      return;
+    }
+    if (record.message) {
+      await this.handleMessage(asRecord2(record.message));
+      return;
+    }
+    if (record.my_chat_member) {
+      this.handleMembershipUpdate(asRecord2(record.my_chat_member));
+      return;
+    }
+  }
+  handleMembershipUpdate(payload) {
+    const chat = asRecord2(payload.chat);
+    const chatId = normalizeChatId(chat.id);
+    if (!chatId) {
+      return;
+    }
+    const newMember = asRecord2(payload.new_chat_member);
+    const status = asTrimmedString(newMember.status).toLowerCase();
+    if (status === "kicked" || status === "left") {
+      void this.resetSession(chatId);
+    }
+  }
+  async handleMessage(message) {
+    const chat = asRecord2(message.chat);
+    const chatId = normalizeChatId(chat.id);
+    if (!chatId) {
+      return;
+    }
+    const session = this.getOrCreateSession(chatId);
+    const messageId = asNumber(message.message_id ?? message.messageId);
+    if (messageId !== null && this.isDuplicateIncomingMessage(session, messageId)) {
+      return;
+    }
+    const chatType = asTrimmedString(chat.type).toLowerCase();
+    if (chatType && chatType !== "private") {
+      await this.sendSimpleMessage(chatId, "Private chats only. Use me in a direct chat.");
+      return;
+    }
+    const text = asTrimmedString(message.text);
+    if (!text) {
+      return;
+    }
+    const parsedCommand = this.parseCommand(text);
+    if (parsedCommand) {
+      const handled = await this.handleCommand(chatId, parsedCommand.command, parsedCommand.args);
+      if (handled) {
+        return;
+      }
+    }
+    await this.handlePromptText(chatId, text);
+  }
+  async handleCallbackQuery(callbackQuery) {
+    const callbackId = asTrimmedString(callbackQuery.id);
+    const message = asRecord2(callbackQuery.message);
+    const chat = asRecord2(message.chat);
+    const chatId = normalizeChatId(chat.id);
+    const data = asTrimmedString(callbackQuery.data);
+    if (!callbackId || !chatId || !data) {
+      return;
+    }
+    const approvalMatch = /^cu:ap:([a-z0-9]+):(approved|approved_for_session|denied|abort)$/i.exec(
+      data
+    );
+    if (approvalMatch) {
+      const actionId = approvalMatch[1];
+      const decision = approvalMatch[2];
+      const action = this.pendingApprovalById.get(actionId);
+      if (!action || action.chatId !== chatId) {
+        await this.answerCallbackQuery(callbackId, "Action expired.");
+        return;
+      }
+      const appServer = this.options.getAppServer();
+      if (!appServer) {
+        await this.answerCallbackQuery(callbackId, "Backend unavailable.");
+        return;
+      }
+      try {
+        if (action.kind === "exec") {
+          await appServer.respondExecCommandRequest(action.requestToken, decision);
+        } else {
+          await appServer.respondApplyPatchRequest(action.requestToken, decision);
+        }
+        this.pendingApprovalById.delete(actionId);
+        await this.answerCallbackQuery(callbackId, `Recorded: ${decision}`);
+        await this.sendSimpleMessage(chatId, `Approval decision sent: ${decision}.`);
+      } catch (error) {
+        await this.answerCallbackQuery(callbackId, "Failed to submit decision.");
+        await this.sendSimpleMessage(
+          chatId,
+          `Failed to submit approval decision: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+      return;
+    }
+    await this.answerCallbackQuery(callbackId, "Unknown action.");
+  }
+  parseCommand(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith("/")) {
+      return null;
+    }
+    const [head, ...rest] = trimmed.split(/\s+/g);
+    const commandWithSlash = head.slice(1);
+    const command = commandWithSlash.split("@")[0]?.trim().toLowerCase();
+    if (!command) {
+      return null;
+    }
+    return {
+      command,
+      args: rest.join(" ").trim()
+    };
+  }
+  async handleCommand(chatId, command, args) {
+    switch (command) {
+      case "start":
+      case "help": {
+        await this.sendHelp(chatId);
+        return true;
+      }
+      case "status": {
+        await this.sendStatus(chatId);
+        return true;
+      }
+      case "projects":
+      case "workspaces": {
+        await this.sendProjects(chatId);
+        return true;
+      }
+      case "project":
+      case "workspace": {
+        await this.selectProject(chatId, args);
+        return true;
+      }
+      case "new": {
+        await this.createNewThread(chatId);
+        return true;
+      }
+      case "threads": {
+        await this.listThreads(chatId);
+        return true;
+      }
+      case "thread": {
+        await this.selectThread(chatId, args);
+        return true;
+      }
+      case "interrupt": {
+        await this.interruptTurn(chatId);
+        return true;
+      }
+      case "input": {
+        await this.submitUserInput(chatId, args);
+        return true;
+      }
+      default:
+        return false;
+    }
+  }
+  async sendHelp(chatId) {
+    const lines = [
+      "CodexUse Telegram bridge is connected.",
+      "",
+      "Commands:",
+      "/status - Show current status",
+      "/projects - List available projects",
+      "/project <index|id> - Select active project",
+      "/new - Start a new thread in active project",
+      "/threads - List recent threads in active project",
+      "/thread <index|id> - Switch active thread",
+      "/interrupt - Interrupt active turn",
+      "/input <request-id> qid=answer;... - Reply to request-user-input",
+      "",
+      "Send any normal text message to run it in the active thread."
+    ];
+    await this.sendSimpleMessage(chatId, lines.join("\n"));
+  }
+  async sendStatus(chatId) {
+    const session = this.getOrCreateSession(chatId);
+    const status = this.getStatus();
+    const lines = [
+      `Bridge: ${status.state}`,
+      `Streaming mode: ${status.streamMode}`,
+      "Allowed chats: all private chats",
+      `Bot: ${status.botUsername ? `@${status.botUsername}` : "(unknown)"}`,
+      `Active project: ${session.projectId ?? "(not selected)"}`,
+      `Active thread: ${session.threadId ?? "(none)"}`,
+      `Processing: ${session.processing ? "yes" : "no"}`
+    ];
+    if (status.lastError) {
+      lines.push(`Last error: ${status.lastError}`);
+    }
+    await this.sendSimpleMessage(chatId, lines.join("\n"));
+  }
+  async sendProjects(chatId) {
+    const projects = await this.options.listProjects();
+    const session = this.getOrCreateSession(chatId);
+    if (projects.length === 0) {
+      await this.sendSimpleMessage(chatId, "No projects found in this desktop app.");
+      return;
+    }
+    session.lastProjectOrder = projects.map((entry) => entry.id);
+    const lines = ["Projects:"];
+    projects.forEach((project, index) => {
+      const isActive = project.id === session.projectId;
+      lines.push(
+        `${index + 1}. ${project.name}${isActive ? " (active)" : ""} [${project.id}]`
+      );
+    });
+    await this.sendSimpleMessage(chatId, lines.join("\n"));
+  }
+  async selectProject(chatId, args) {
+    const session = this.getOrCreateSession(chatId);
+    const projects = await this.options.listProjects();
+    if (projects.length === 0) {
+      await this.sendSimpleMessage(chatId, "No projects available.");
+      return;
+    }
+    const selected = this.resolveProjectSelection(args, projects, session.lastProjectOrder);
+    if (!selected) {
+      await this.sendSimpleMessage(
+        chatId,
+        "Project not found. Use /projects, then /project <index|id>."
+      );
+      return;
+    }
+    if (session.projectId !== selected.id) {
+      await this.detachConversationListener(session);
+      session.projectId = selected.id;
+      session.threadId = null;
+      session.activeTurnId = null;
+      session.processing = false;
+      session.completedTextCandidate = null;
+      this.resetStream(session);
+    }
+    await this.sendSimpleMessage(chatId, `Active project set to: ${selected.name}.`);
+  }
+  resolveProjectSelection(args, projects, order) {
+    const input = args.trim();
+    if (!input) {
+      return null;
+    }
+    const numeric = Number(input);
+    if (Number.isInteger(numeric) && numeric >= 1) {
+      if (order.length > 0 && numeric <= order.length) {
+        const id = order[numeric - 1];
+        return projects.find((entry) => entry.id === id) ?? null;
+      }
+      if (numeric <= projects.length) {
+        return projects[numeric - 1] ?? null;
+      }
+    }
+    return projects.find((entry) => entry.id === input) ?? null;
+  }
+  async createNewThread(chatId) {
+    const session = this.getOrCreateSession(chatId);
+    const project = await this.ensureSessionProject(session, chatId);
+    if (!project) {
+      return;
+    }
+    const appServer = this.options.getAppServer();
+    if (!appServer) {
+      await this.sendSimpleMessage(chatId, "Backend unavailable.");
+      return;
+    }
+    try {
+      const response = await appServer.threadStart({
+        workspaceId: project.id,
+        workspace_id: project.id,
+        cwd: project.path
+      });
+      const threadId = this.extractThreadIdFromResponse(response);
+      if (!threadId) {
+        await this.sendSimpleMessage(chatId, "Thread started, but thread id was missing.");
+        return;
+      }
+      session.threadId = threadId;
+      session.activeTurnId = null;
+      session.processing = false;
+      session.completedTextCandidate = null;
+      this.resetStream(session);
+      await this.attachConversationListener(session, project.id, threadId);
+      await this.sendSimpleMessage(chatId, `Started new thread: ${threadId}`);
+    } catch (error) {
+      await this.sendSimpleMessage(
+        chatId,
+        `Failed to start a new thread: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  async listThreads(chatId) {
+    const session = this.getOrCreateSession(chatId);
+    const project = await this.ensureSessionProject(session, chatId);
+    if (!project) {
+      return;
+    }
+    const appServer = this.options.getAppServer();
+    if (!appServer) {
+      await this.sendSimpleMessage(chatId, "Backend unavailable.");
+      return;
+    }
+    try {
+      const response = await appServer.listConversations({
+        cwd: project.path,
+        limit: 20,
+        sortKey: "updated_at",
+        archived: false
+      });
+      const threads = this.extractThreadList(response);
+      if (threads.length === 0) {
+        await this.sendSimpleMessage(chatId, "No threads found for this project.");
+        return;
+      }
+      session.lastThreadOrder = threads.map((entry) => entry.id);
+      const lines = ["Threads:"];
+      threads.forEach((thread, index) => {
+        const isActive = thread.id === session.threadId;
+        const title = thread.title || "(untitled)";
+        lines.push(`${index + 1}. ${title}${isActive ? " (active)" : ""} [${thread.id}]`);
+      });
+      await this.sendSimpleMessage(chatId, lines.join("\n"));
+    } catch (error) {
+      await this.sendSimpleMessage(
+        chatId,
+        `Failed to list threads: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  async selectThread(chatId, args) {
+    const session = this.getOrCreateSession(chatId);
+    const project = await this.ensureSessionProject(session, chatId);
+    if (!project) {
+      return;
+    }
+    const appServer = this.options.getAppServer();
+    if (!appServer) {
+      await this.sendSimpleMessage(chatId, "Backend unavailable.");
+      return;
+    }
+    const input = args.trim();
+    if (!input) {
+      await this.sendSimpleMessage(chatId, "Usage: /thread <index|id>");
+      return;
+    }
+    let threadId = "";
+    const numeric = Number(input);
+    if (Number.isInteger(numeric) && numeric >= 1) {
+      if (session.lastThreadOrder.length > 0 && numeric <= session.lastThreadOrder.length) {
+        threadId = session.lastThreadOrder[numeric - 1] ?? "";
+      }
+    }
+    if (!threadId) {
+      threadId = input;
+    }
+    try {
+      await appServer.threadResume({
+        workspaceId: project.id,
+        workspace_id: project.id,
+        threadId
+      });
+      session.threadId = threadId;
+      session.activeTurnId = null;
+      session.processing = false;
+      session.completedTextCandidate = null;
+      this.resetStream(session);
+      await this.attachConversationListener(session, project.id, threadId);
+      await this.sendSimpleMessage(chatId, `Active thread set to: ${threadId}`);
+    } catch (error) {
+      await this.sendSimpleMessage(
+        chatId,
+        `Failed to switch thread: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  async interruptTurn(chatId) {
+    const session = this.getOrCreateSession(chatId);
+    const project = await this.ensureSessionProject(session, chatId);
+    if (!project || !session.threadId) {
+      await this.sendSimpleMessage(chatId, "No active thread to interrupt.");
+      return;
+    }
+    const appServer = this.options.getAppServer();
+    if (!appServer) {
+      await this.sendSimpleMessage(chatId, "Backend unavailable.");
+      return;
+    }
+    const turnId = session.activeTurnId || "pending";
+    try {
+      await appServer.interruptTurn({
+        workspaceId: project.id,
+        workspace_id: project.id,
+        threadId: session.threadId,
+        turnId
+      });
+      session.processing = false;
+      session.activeTurnId = null;
+      this.resetStream(session);
+      await this.sendSimpleMessage(chatId, "Interrupt requested.");
+    } catch (error) {
+      await this.sendSimpleMessage(
+        chatId,
+        `Failed to interrupt turn: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  async submitUserInput(chatId, args) {
+    const appServer = this.options.getAppServer();
+    if (!appServer) {
+      await this.sendSimpleMessage(chatId, "Backend unavailable.");
+      return;
+    }
+    const trimmed = args.trim();
+    if (!trimmed) {
+      await this.sendSimpleMessage(
+        chatId,
+        "Usage: /input <request-id> qid=answer; qid2=answer"
+      );
+      return;
+    }
+    const [requestTokenPart, ...restParts] = trimmed.split(/\s+/g);
+    let requestIdToken = requestTokenPart.trim();
+    let bodyText = restParts.join(" ").trim();
+    if (!requestIdToken || requestIdToken.includes("=")) {
+      const pendingForChat = Array.from(this.pendingUserInputByRequestId.values()).filter(
+        (entry) => entry.chatId === chatId
+      );
+      if (pendingForChat.length !== 1) {
+        await this.sendSimpleMessage(
+          chatId,
+          "Request id is required. Use /input <request-id> qid=answer;..."
+        );
+        return;
+      }
+      requestIdToken = String(pendingForChat[0].requestId);
+      bodyText = trimmed;
+    }
+    const pending = this.pendingUserInputByRequestId.get(requestIdToken);
+    if (!pending || pending.chatId !== chatId) {
+      await this.sendSimpleMessage(chatId, "Unknown or expired request id.");
+      return;
+    }
+    const answers = this.parseUserInputAnswers(bodyText, pending.params);
+    if (!answers) {
+      await this.sendSimpleMessage(
+        chatId,
+        "Could not parse answers. Format: /input <request-id> qid=answer; qid2=answer"
+      );
+      return;
+    }
+    try {
+      await appServer.respondToServerRequest(pending.requestId, {
+        answers
+      });
+      this.pendingUserInputByRequestId.delete(requestIdToken);
+      await this.sendSimpleMessage(chatId, "Input submitted.");
+    } catch (error) {
+      await this.sendSimpleMessage(
+        chatId,
+        `Failed to submit input: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  parseUserInputAnswers(bodyText, params) {
+    const questionsRaw = Array.isArray(params.questions) ? params.questions : [];
+    const questions = questionsRaw.map((entry) => asRecord2(entry)).filter((entry) => asTrimmedString(entry.id));
+    const questionIds = new Set(questions.map((entry) => asTrimmedString(entry.id)));
+    const answers = {};
+    const segments = bodyText.split(";").map((segment) => segment.trim()).filter(Boolean);
+    if (segments.length === 0) {
+      if (questions.length === 1 && bodyText.trim()) {
+        const id = asTrimmedString(questions[0].id);
+        answers[id] = { answers: [bodyText.trim()] };
+        return answers;
+      }
+      return null;
+    }
+    for (const segment of segments) {
+      const eqIndex = segment.indexOf("=");
+      if (eqIndex <= 0) {
+        if (questions.length === 1) {
+          const id = asTrimmedString(questions[0].id);
+          answers[id] = { answers: [segment.trim()] };
+          continue;
+        }
+        return null;
+      }
+      const key = segment.slice(0, eqIndex).trim();
+      const value = segment.slice(eqIndex + 1).trim();
+      if (!key || !value || !questionIds.has(key)) {
+        return null;
+      }
+      const splitValues = value.split(",").map((entry) => entry.trim()).filter(Boolean);
+      answers[key] = {
+        answers: splitValues.length > 0 ? splitValues : [value]
+      };
+    }
+    return Object.keys(answers).length > 0 ? answers : null;
+  }
+  async handlePromptText(chatId, text) {
+    const session = this.getOrCreateSession(chatId);
+    if (session.processing) {
+      await this.sendSimpleMessage(
+        chatId,
+        "A response is already in progress. Wait for completion or use /interrupt."
+      );
+      return;
+    }
+    const project = await this.ensureSessionProject(session, chatId);
+    if (!project) {
+      return;
+    }
+    const threadId = session.threadId || await this.startThreadForSession(chatId, session, project);
+    if (!threadId) {
+      return;
+    }
+    const appServer = this.options.getAppServer();
+    if (!appServer) {
+      await this.sendSimpleMessage(chatId, "Backend unavailable.");
+      return;
+    }
+    try {
+      session.completedTextCandidate = null;
+      this.resetStream(session);
+      const response = await appServer.sendUserMessage({
+        workspaceId: project.id,
+        workspace_id: project.id,
+        threadId,
+        thread_id: threadId,
+        conversationId: threadId,
+        conversation_id: threadId,
+        text
+      });
+      const turnId = this.extractTurnIdFromResponse(response);
+      session.processing = true;
+      session.activeTurnId = turnId || null;
+      this.ensureTypingIndicator(session);
+    } catch (error) {
+      await this.sendSimpleMessage(
+        chatId,
+        `Failed to send message: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  async startThreadForSession(chatId, session, project) {
+    const appServer = this.options.getAppServer();
+    if (!appServer) {
+      await this.sendSimpleMessage(chatId, "Backend unavailable.");
+      return null;
+    }
+    try {
+      const response = await appServer.threadStart({
+        workspaceId: project.id,
+        workspace_id: project.id,
+        cwd: project.path
+      });
+      const threadId = this.extractThreadIdFromResponse(response);
+      if (!threadId) {
+        await this.sendSimpleMessage(chatId, "Could not create thread (missing thread id).");
+        return null;
+      }
+      session.threadId = threadId;
+      await this.attachConversationListener(session, project.id, threadId);
+      return threadId;
+    } catch (error) {
+      await this.sendSimpleMessage(
+        chatId,
+        `Failed to create thread: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return null;
+    }
+  }
+  async ensureSessionProject(session, chatId) {
+    if (session.projectId) {
+      const existing = await this.options.getProjectById(session.projectId);
+      if (existing) {
+        return existing;
+      }
+      session.projectId = null;
+      session.threadId = null;
+    }
+    const defaultProjectId = await this.resolveDefaultProjectId();
+    if (defaultProjectId) {
+      const preferred = await this.options.getProjectById(defaultProjectId).catch(() => null);
+      if (preferred) {
+        session.projectId = preferred.id;
+        return preferred;
+      }
+    }
+    const projects = await this.options.listProjects();
+    if (projects.length === 0) {
+      await this.sendSimpleMessage(chatId, "No projects found. Add a project in desktop settings first.");
+      return null;
+    }
+    const connected = projects.find((entry) => entry.connected);
+    const selected = connected ?? projects[0];
+    session.projectId = selected.id;
+    session.lastProjectOrder = projects.map((entry) => entry.id);
+    return selected;
+  }
+  async resolveDefaultProjectId() {
+    const resolver = this.options.getDefaultProjectId;
+    if (!resolver) {
+      return null;
+    }
+    try {
+      const value = await resolver();
+      const normalized = asTrimmedString(value);
+      return normalized || null;
+    } catch {
+      return null;
+    }
+  }
+  extractThreadIdFromResponse(value) {
+    const record = asRecord2(value);
+    const result = asRecord2(record.result);
+    const thread = asRecord2(result.thread ?? record.thread);
+    return asTrimmedString(
+      thread.id ?? thread.threadId ?? thread.thread_id ?? result.threadId ?? result.thread_id ?? record.threadId ?? record.thread_id ?? result.conversationId ?? result.conversation_id ?? ""
+    );
+  }
+  extractTurnIdFromResponse(value) {
+    const record = asRecord2(value);
+    const result = asRecord2(record.result);
+    const turn = asRecord2(result.turn ?? record.turn);
+    return asTrimmedString(
+      turn.id ?? turn.turnId ?? turn.turn_id ?? result.turnId ?? result.turn_id ?? record.turnId ?? record.turn_id ?? ""
+    );
+  }
+  extractThreadList(value) {
+    const root = asRecord2(value);
+    const primary = Array.isArray(value) ? value : Array.isArray(root.data) ? root.data : Array.isArray(root.threads) ? root.threads : Array.isArray(root.items) ? root.items : [];
+    const result = [];
+    for (const entry of primary) {
+      const thread = asRecord2(entry);
+      const id = asTrimmedString(
+        thread.id ?? thread.threadId ?? thread.thread_id ?? thread.conversationId ?? thread.conversation_id ?? ""
+      );
+      if (!id) {
+        continue;
+      }
+      const title = asTrimmedString(
+        thread.name ?? thread.title ?? thread.preview ?? thread.summary ?? thread.path ?? ""
+      ) || "(untitled)";
+      result.push({ id, title });
+    }
+    return result;
+  }
+  getOrCreateSession(chatId) {
+    const existing = this.sessionsByChatId.get(chatId);
+    if (existing) {
+      return existing;
+    }
+    const session = {
+      chatId,
+      projectId: null,
+      threadId: null,
+      listenerSubscriptionId: null,
+      activeTurnId: null,
+      processing: false,
+      finalizeInFlight: false,
+      lastProjectOrder: [],
+      lastThreadOrder: [],
+      completedTextCandidate: null,
+      recentFinalizedTurnIds: [],
+      recentFinalSignatures: [],
+      recentIncomingMessageIds: [],
+      streamFlushPromise: null,
+      streamFlushPending: false,
+      lastDeliveredFinalText: null,
+      lastDeliveredFinalAtMs: 0,
+      typingTimer: null,
+      stream: null
+    };
+    this.sessionsByChatId.set(chatId, session);
+    this.status.activeChats = this.sessionsByChatId.size;
+    return session;
+  }
+  async resetSession(chatId) {
+    const session = this.sessionsByChatId.get(chatId);
+    if (!session) {
+      return;
+    }
+    await this.detachConversationListener(session);
+    this.stopTypingIndicator(session);
+    if (session.threadId) {
+      this.chatIdByThreadId.delete(session.threadId);
+    }
+    this.sessionsByChatId.delete(chatId);
+    this.status.activeChats = this.sessionsByChatId.size;
+  }
+  async attachConversationListener(session, projectId, threadId) {
+    const appServer = this.options.getAppServer();
+    if (!appServer) {
+      return;
+    }
+    await this.detachConversationListener(session);
+    try {
+      const response = await appServer.addConversationListener({
+        conversationId: threadId,
+        workspaceId: projectId,
+        workspace_id: projectId
+      });
+      const responseRecord = asRecord2(response);
+      const subscriptionId = asTrimmedString(responseRecord.subscriptionId);
+      session.listenerSubscriptionId = subscriptionId || null;
+      session.threadId = threadId;
+      this.chatIdByThreadId.set(threadId, session.chatId);
+    } catch (error) {
+      logWarn("[telegram-bridge] failed to attach conversation listener", error);
+    }
+  }
+  async detachConversationListener(session) {
+    const appServer = this.options.getAppServer();
+    if (!appServer) {
+      session.listenerSubscriptionId = null;
+      return;
+    }
+    const subscriptionId = session.listenerSubscriptionId;
+    session.listenerSubscriptionId = null;
+    if (!subscriptionId) {
+      return;
+    }
+    try {
+      await appServer.removeConversationListener({
+        subscriptionId
+      });
+    } catch (error) {
+      logWarn("[telegram-bridge] failed to remove conversation listener", error);
+    }
+  }
+  async detachAllConversationListeners() {
+    const sessions = Array.from(this.sessionsByChatId.values());
+    await Promise.all(sessions.map((session) => this.detachConversationListener(session)));
+  }
+  clearSessionState() {
+    for (const session of this.sessionsByChatId.values()) {
+      this.resetStream(session);
+    }
+    this.sessionsByChatId.clear();
+    this.chatIdByThreadId.clear();
+    this.pendingApprovalById.clear();
+    this.pendingUserInputByRequestId.clear();
+    this.recentDeltaBySignature.clear();
+    this.lastSendAtByChatId.clear();
+    this.status.activeChats = 0;
+  }
+  attachAppServerListeners() {
+    if (this.appServerListenersBound) {
+      return;
+    }
+    const appServer = this.options.getAppServer();
+    if (!appServer) {
+      this.status.state = "error";
+      this.status.lastError = "Codex app-server is unavailable.";
+      return;
+    }
+    appServer.on("codex:notification", this.handleCodexNotification);
+    appServer.on("codex:event", this.handleCodexEvent);
+    appServer.on("codex:exec-command-request", this.handleExecApprovalRequest);
+    appServer.on("codex:apply-patch-request", this.handlePatchApprovalRequest);
+    appServer.on("codex:server-request", this.handleServerRequest);
+    this.appServerListenersBound = true;
+  }
+  detachAppServerListeners() {
+    if (!this.appServerListenersBound) {
+      return;
+    }
+    const appServer = this.options.getAppServer();
+    if (!appServer) {
+      this.appServerListenersBound = false;
+      return;
+    }
+    appServer.off("codex:notification", this.handleCodexNotification);
+    appServer.off("codex:event", this.handleCodexEvent);
+    appServer.off("codex:exec-command-request", this.handleExecApprovalRequest);
+    appServer.off("codex:apply-patch-request", this.handlePatchApprovalRequest);
+    appServer.off("codex:server-request", this.handleServerRequest);
+    this.appServerListenersBound = false;
+  }
+  async handleNotification(payload) {
+    if (!this.running) {
+      return;
+    }
+    const method = asTrimmedString(payload.method);
+    if (!method) {
+      return;
+    }
+    const params = asRecord2(payload.params);
+    const threadId = extractThreadId(params);
+    if (!threadId) {
+      return;
+    }
+    const session = this.resolveSessionByThreadId(threadId);
+    if (!session) {
+      return;
+    }
+    if (method === "turn/started") {
+      const turnId = extractTurnId(params);
+      session.processing = true;
+      if (turnId) {
+        session.activeTurnId = turnId;
+      }
+      this.ensureTypingIndicator(session);
+      return;
+    }
+    if (method === "item/agentMessage/delta") {
+      const delta = extractDeltaFromNotification(params);
+      if (!delta) {
+        return;
+      }
+      if (this.isDuplicateDelta(`${threadId}|${delta}`)) {
+        return;
+      }
+      this.appendAssistantDelta(session, delta);
+      return;
+    }
+    if (method === "item/completed") {
+      const text = extractAssistantTextFromItemCompleted(params);
+      if (text.trim()) {
+        session.completedTextCandidate = text;
+      }
+      return;
+    }
+    if (method === "turn/completed") {
+      await this.finalizeTurn(session);
+      return;
+    }
+    if (method === "error") {
+      if (!isRetryableTurnErrorPayload(params)) {
+        const errorMessage = asTrimmedString(asRecord2(params.error).message) || asTrimmedString(params.message) || "Turn failed.";
+        await this.sendSimpleMessage(session.chatId, `Turn error: ${errorMessage}`);
+      }
+      await this.finalizeTurn(session);
+      return;
+    }
+  }
+  async handleEvent(payload) {
+    if (!this.running) {
+      return;
+    }
+    const method = asTrimmedString(payload.method);
+    if (!method.startsWith("codex/event/")) {
+      return;
+    }
+    const params = asRecord2(payload.params);
+    const threadId = extractThreadId(params);
+    if (!threadId) {
+      return;
+    }
+    const session = this.resolveSessionByThreadId(threadId);
+    if (!session) {
+      return;
+    }
+    const msg = asRecord2(params.msg);
+    const msgType = asTrimmedString(msg.type).toLowerCase();
+    if (msgType === "agent_message_delta" || msgType === "agent_message_content_delta") {
+      const delta = extractText(msg.delta ?? msg.message ?? msg.content ?? msg.value);
+      if (!delta) {
+        return;
+      }
+      if (this.isDuplicateDelta(`${threadId}|${delta}`)) {
+        return;
+      }
+      this.appendAssistantDelta(session, delta);
+      return;
+    }
+    if (msgType === "agent_message") {
+      const text = extractText(msg.message ?? msg.content ?? msg.text ?? msg.value);
+      if (text.trim()) {
+        session.completedTextCandidate = text;
+      }
+      return;
+    }
+    if (msgType === "task_started") {
+      session.processing = true;
+      const turnId = extractTurnId(params);
+      if (turnId) {
+        session.activeTurnId = turnId;
+      }
+      this.ensureTypingIndicator(session);
+      return;
+    }
+    if (msgType === "task_complete" || msgType === "turn_aborted") {
+      await this.finalizeTurn(session);
+      return;
+    }
+    if (msgType === "error" || msgType === "stream_error") {
+      if (!isRetryableTurnErrorPayload(msg)) {
+        const errorMessage = asTrimmedString(msg.message) || asTrimmedString(msg.error) || "Turn failed.";
+        await this.sendSimpleMessage(session.chatId, `Turn error: ${errorMessage}`);
+      }
+      await this.finalizeTurn(session);
+    }
+  }
+  resolveSessionByThreadId(threadId) {
+    const chatId = this.chatIdByThreadId.get(threadId);
+    if (!chatId) {
+      return null;
+    }
+    const session = this.sessionsByChatId.get(chatId);
+    if (!session || session.threadId !== threadId) {
+      return null;
+    }
+    return session;
+  }
+  appendAssistantDelta(session, delta) {
+    if (!session.stream) {
+      session.stream = {
+        draftId: (0, import_node_crypto4.randomUUID)().slice(0, 12),
+        buffer: "",
+        lastSent: "",
+        flushTimer: null,
+        messageId: null
+      };
+    }
+    const nextBuffer = mergeStreamDeltaBuffer(session.stream.buffer, delta);
+    if (nextBuffer === session.stream.buffer) {
+      return;
+    }
+    session.stream.buffer = nextBuffer;
+    session.processing = true;
+    this.ensureTypingIndicator(session);
+    this.scheduleDraftFlush(session, false);
+  }
+  scheduleDraftFlush(session, force) {
+    if (!session.stream) {
+      return;
+    }
+    if (force) {
+      if (session.stream.flushTimer) {
+        clearTimeout(session.stream.flushTimer);
+        session.stream.flushTimer = null;
+      }
+      if (session.streamFlushPromise) {
+        session.streamFlushPending = true;
+        return;
+      }
+      void this.flushDraft(session, true);
+      return;
+    }
+    if (session.streamFlushPromise) {
+      session.streamFlushPending = true;
+      return;
+    }
+    if (session.stream.flushTimer) {
+      return;
+    }
+    session.stream.flushTimer = setTimeout(() => {
+      if (session.stream) {
+        session.stream.flushTimer = null;
+      }
+      void this.flushDraft(session, false);
+    }, TELEGRAM_STREAM_FLUSH_MS);
+  }
+  async flushDraft(session, force) {
+    if (!this.running) {
+      return;
+    }
+    if (session.streamFlushPromise) {
+      if (force) {
+        session.streamFlushPending = true;
+      }
+      return;
+    }
+    const currentStream = session.stream;
+    if (!currentStream) {
+      return;
+    }
+    const draftId = currentStream.draftId;
+    const rawText = currentStream.buffer;
+    if (!rawText.trim()) {
+      return;
+    }
+    const draftText = rawText.length <= TELEGRAM_MAX_MESSAGE_LENGTH ? rawText : rawText.slice(rawText.length - TELEGRAM_MAX_MESSAGE_LENGTH);
+    if (!force && draftText === currentStream.lastSent) {
+      return;
+    }
+    const runFlush = async () => {
+      if (this.draftStreamingEnabled) {
+        try {
+          await this.sendDraftMessage(session.chatId, draftText, draftId);
+          const activeStream = this.getStreamByDraftId(session, draftId);
+          if (activeStream) {
+            activeStream.lastSent = draftText;
+          }
+          this.status.streamMode = this.getCurrentStreamMode();
+          return;
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          if (this.isDraftStreamingUnsupportedError(message)) {
+            this.draftStreamingEnabled = false;
+            this.status.streamMode = this.getCurrentStreamMode();
+            logWarn(
+              "[telegram-bridge] sendMessageDraft unavailable, falling back to message edit streaming",
+              message
+            );
+          } else {
+            logWarn("[telegram-bridge] failed to flush draft", message);
+            return;
+          }
+        }
+      }
+      if (!this.messageStreamingEnabled) {
+        return;
+      }
+      try {
+        await this.sendOrEditStreamMessage(session, draftText, draftId);
+        const activeStream = this.getStreamByDraftId(session, draftId);
+        if (activeStream) {
+          activeStream.lastSent = draftText;
+        }
+        this.status.streamMode = this.getCurrentStreamMode();
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (this.isMessageStreamingUnsupportedError(message)) {
+          this.messageStreamingEnabled = false;
+          this.status.streamMode = this.getCurrentStreamMode();
+          logWarn("[telegram-bridge] edit streaming unavailable, disabling streaming", message);
+          return;
+        }
+        logWarn("[telegram-bridge] failed to flush message-edit stream", message);
+      }
+    };
+    const flushPromise = runFlush();
+    session.streamFlushPromise = flushPromise;
+    try {
+      await flushPromise;
+    } finally {
+      if (session.streamFlushPromise === flushPromise) {
+        session.streamFlushPromise = null;
+      }
+      if (session.streamFlushPending && this.running && session.stream) {
+        session.streamFlushPending = false;
+        void this.flushDraft(session, false);
+      }
+    }
+  }
+  async finalizeTurn(session) {
+    if (session.finalizeInFlight) {
+      return;
+    }
+    if (!session.processing && !session.stream?.buffer && !session.completedTextCandidate) {
+      return;
+    }
+    session.finalizeInFlight = true;
+    try {
+      await this.flushDraft(session, true);
+      if (session.streamFlushPromise) {
+        await session.streamFlushPromise.catch(() => void 0);
+      }
+      if (session.streamFlushPending && session.stream) {
+        session.streamFlushPending = false;
+        await this.flushDraft(session, true);
+        if (session.streamFlushPromise) {
+          await session.streamFlushPromise.catch(() => void 0);
+        }
+      }
+      const finalText = (session.completedTextCandidate ?? session.stream?.buffer ?? "").trim();
+      const turnId = session.activeTurnId;
+      const alreadyFinalizedTurn = turnId ? session.recentFinalizedTurnIds.includes(turnId) : false;
+      const now = nowMs();
+      const duplicateByRecentText = finalText.length > 0 && session.lastDeliveredFinalText === finalText && now - session.lastDeliveredFinalAtMs <= TELEGRAM_FINAL_TEXT_DEDUPE_MS;
+      const duplicateByFinalSignature = this.isDuplicateFinalSignature(session, finalText, now);
+      if (finalText && !alreadyFinalizedTurn && !duplicateByRecentText && !duplicateByFinalSignature) {
+        const chunks = splitMessage(finalText, TELEGRAM_MAX_MESSAGE_LENGTH);
+        let chunkStartIndex = 0;
+        const streamMessageId = session.stream?.messageId ?? null;
+        if (streamMessageId !== null && chunks.length > 0) {
+          const reused = await this.tryFinalizeStreamMessage(session.chatId, streamMessageId, chunks[0]);
+          if (!reused) {
+            await this.sendSimpleMessage(session.chatId, chunks[0]);
+          }
+          chunkStartIndex = 1;
+        }
+        for (let index = chunkStartIndex; index < chunks.length; index += 1) {
+          await this.sendSimpleMessage(session.chatId, chunks[index]);
+        }
+        session.lastDeliveredFinalText = finalText;
+        session.lastDeliveredFinalAtMs = now;
+        this.recordFinalSignature(session, finalText, now);
+        if (turnId) {
+          session.recentFinalizedTurnIds.push(turnId);
+          if (session.recentFinalizedTurnIds.length > TELEGRAM_RECENT_FINALIZED_TURNS_MAX) {
+            session.recentFinalizedTurnIds.splice(
+              0,
+              session.recentFinalizedTurnIds.length - TELEGRAM_RECENT_FINALIZED_TURNS_MAX
+            );
+          }
+        }
+      }
+    } finally {
+      session.processing = false;
+      session.activeTurnId = null;
+      session.completedTextCandidate = null;
+      this.resetStream(session);
+      session.finalizeInFlight = false;
+    }
+  }
+  resetStream(session) {
+    this.stopTypingIndicator(session);
+    if (session.stream?.flushTimer) {
+      clearTimeout(session.stream.flushTimer);
+    }
+    session.streamFlushPending = false;
+    session.streamFlushPromise = null;
+    session.stream = null;
+  }
+  ensureTypingIndicator(session) {
+    if (!this.running || !session.processing) {
+      return;
+    }
+    if (session.typingTimer) {
+      return;
+    }
+    void this.sendTypingAction(session.chatId);
+    session.typingTimer = setInterval(() => {
+      if (!this.running || !session.processing) {
+        this.stopTypingIndicator(session);
+        return;
+      }
+      void this.sendTypingAction(session.chatId);
+    }, TELEGRAM_TYPING_HEARTBEAT_MS);
+  }
+  stopTypingIndicator(session) {
+    if (session.typingTimer) {
+      clearInterval(session.typingTimer);
+      session.typingTimer = null;
+    }
+  }
+  isDraftStreamingUnsupportedError(message) {
+    const lower = message.toLowerCase();
+    return lower.includes("sendmessagedraft") || lower.includes("method not found") || lower.includes("there is no method") || lower.includes("text must be non-empty") || lower.includes("random_id_invalid") || lower.includes("random id invalid") || lower.includes("not found");
+  }
+  isMessageStreamingUnsupportedError(message) {
+    const lower = message.toLowerCase();
+    return lower.includes("editmessagetext") && (lower.includes("method not found") || lower.includes("there is no method"));
+  }
+  async sendOrEditStreamMessage(session, text, draftId) {
+    const stream = this.getStreamByDraftId(session, draftId);
+    if (!stream) {
+      return;
+    }
+    const existingMessageId = stream.messageId;
+    if (existingMessageId !== null) {
+      const edited = await this.tryEditMessageText(session.chatId, existingMessageId, text);
+      if (edited) {
+        return;
+      }
+      const activeStream = this.getStreamByDraftId(session, draftId);
+      if (activeStream) {
+        activeStream.messageId = null;
+      }
+    }
+    const sent = await this.sendSimpleMessage(session.chatId, text);
+    const messageId = this.extractTelegramMessageId(sent);
+    if (messageId !== null) {
+      const activeStream = this.getStreamByDraftId(session, draftId);
+      if (activeStream) {
+        activeStream.messageId = messageId;
+      }
+    }
+  }
+  getStreamByDraftId(session, draftId) {
+    const stream = session.stream;
+    if (!stream || stream.draftId !== draftId) {
+      return null;
+    }
+    return stream;
+  }
+  async tryFinalizeStreamMessage(chatId, messageId, text) {
+    return this.tryEditMessageText(chatId, messageId, text);
+  }
+  async tryEditMessageText(chatId, messageId, text) {
+    try {
+      await this.editMessageText(chatId, messageId, text);
+      return true;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const lower = message.toLowerCase();
+      if (lower.includes("message is not modified")) {
+        return true;
+      }
+      if (lower.includes("message to edit not found") || lower.includes("message can't be edited") || lower.includes("message cant be edited")) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  isDuplicateIncomingMessage(session, messageId) {
+    if (session.recentIncomingMessageIds.includes(messageId)) {
+      return true;
+    }
+    session.recentIncomingMessageIds.push(messageId);
+    if (session.recentIncomingMessageIds.length > TELEGRAM_RECENT_INCOMING_MESSAGES_MAX) {
+      session.recentIncomingMessageIds.splice(
+        0,
+        session.recentIncomingMessageIds.length - TELEGRAM_RECENT_INCOMING_MESSAGES_MAX
+      );
+    }
+    return false;
+  }
+  buildFinalSignature(session, finalText) {
+    const normalized = finalText.trim();
+    if (!normalized) {
+      return "";
+    }
+    const threadKey = session.threadId ?? "no-thread";
+    const digest = (0, import_node_crypto4.createHash)("sha1").update(normalized).digest("hex");
+    return `${threadKey}|${digest}`;
+  }
+  isDuplicateFinalSignature(session, finalText, now) {
+    const signature = this.buildFinalSignature(session, finalText);
+    if (!signature) {
+      return false;
+    }
+    let duplicated = false;
+    const kept = [];
+    for (const entry of session.recentFinalSignatures) {
+      if (now - entry.at > TELEGRAM_FINAL_SIGNATURE_DEDUPE_MS) {
+        continue;
+      }
+      if (entry.signature === signature) {
+        duplicated = true;
+      }
+      kept.push(entry);
+    }
+    session.recentFinalSignatures = kept;
+    return duplicated;
+  }
+  recordFinalSignature(session, finalText, now) {
+    const signature = this.buildFinalSignature(session, finalText);
+    if (!signature) {
+      return;
+    }
+    const kept = session.recentFinalSignatures.filter(
+      (entry) => entry.signature !== signature && now - entry.at <= TELEGRAM_FINAL_SIGNATURE_DEDUPE_MS
+    );
+    kept.push({ signature, at: now });
+    if (kept.length > TELEGRAM_RECENT_FINAL_SIGNATURES_MAX) {
+      kept.splice(0, kept.length - TELEGRAM_RECENT_FINAL_SIGNATURES_MAX);
+    }
+    session.recentFinalSignatures = kept;
+  }
+  isDuplicateDelta(signature) {
+    const now = nowMs();
+    const previous = this.recentDeltaBySignature.get(signature) ?? 0;
+    this.recentDeltaBySignature.set(signature, now);
+    if (this.recentDeltaBySignature.size > 2048) {
+      for (const [key, at] of this.recentDeltaBySignature) {
+        if (now - at > 5e3) {
+          this.recentDeltaBySignature.delete(key);
+        }
+      }
+    }
+    return previous > 0 && now - previous <= 500;
+  }
+  async handleApprovalRequest(kind, requestToken, params) {
+    if (!this.running) {
+      return;
+    }
+    const chatId = this.resolveChatIdForRequest(params);
+    if (!chatId) {
+      return;
+    }
+    const actionId = (0, import_node_crypto4.randomUUID)().replace(/-/g, "").slice(0, 10);
+    this.pendingApprovalById.set(actionId, {
+      id: actionId,
+      kind,
+      chatId,
+      requestToken,
+      createdAtMs: nowMs()
+    });
+    const threadId = extractThreadId(params);
+    const title = kind === "exec" ? "Command approval required" : "Patch approval required";
+    const detail = kind === "exec" ? extractCommandText(params) : summarizePatchRequest(params);
+    const lines = [title];
+    if (threadId) {
+      lines.push(`Thread: ${threadId}`);
+    }
+    if (detail) {
+      lines.push(`Detail: ${detail}`);
+    }
+    await this.sendSimpleMessage(chatId, lines.join("\n"), {
+      reply_markup: {
+        inline_keyboard: [
+          [
+            { text: "Approve", callback_data: `cu:ap:${actionId}:approved` },
+            { text: "Approve session", callback_data: `cu:ap:${actionId}:approved_for_session` }
+          ],
+          [
+            { text: "Deny", callback_data: `cu:ap:${actionId}:denied` },
+            { text: "Abort", callback_data: `cu:ap:${actionId}:abort` }
+          ]
+        ]
+      }
+    });
+  }
+  async handleUserInputRequest(payload) {
+    if (!this.running) {
+      return;
+    }
+    const method = asTrimmedString(payload.method).toLowerCase();
+    if (!method.includes("requestuserinput")) {
+      return;
+    }
+    const params = asRecord2(payload.params);
+    const chatId = this.resolveChatIdForRequest(params);
+    if (!chatId) {
+      return;
+    }
+    const token = String(payload.requestId);
+    this.pendingUserInputByRequestId.set(token, {
+      chatId,
+      requestId: payload.requestId,
+      method: payload.method,
+      params,
+      createdAtMs: nowMs()
+    });
+    const questions = Array.isArray(params.questions) ? params.questions.map((entry) => asRecord2(entry)).filter((entry) => asTrimmedString(entry.id)) : [];
+    const lines = [
+      "Input required.",
+      `Request ID: ${token}`,
+      "Reply with: /input <request-id> qid=answer; qid2=answer"
+    ];
+    if (questions.length > 0) {
+      lines.push("");
+      for (const question of questions) {
+        const qid = asTrimmedString(question.id);
+        const qtext = asTrimmedString(question.question) || asTrimmedString(question.header) || "Question";
+        lines.push(`${qid}: ${qtext}`);
+        const options = Array.isArray(question.options) ? question.options.map((entry) => asRecord2(entry)).map((entry) => asTrimmedString(entry.label)).filter(Boolean) : [];
+        if (options.length > 0) {
+          lines.push(`Options: ${options.join(", ")}`);
+        }
+      }
+    }
+    await this.sendSimpleMessage(chatId, lines.join("\n"));
+  }
+  resolveChatIdForRequest(params) {
+    const threadId = extractThreadId(params);
+    if (threadId) {
+      const mapped = this.chatIdByThreadId.get(threadId);
+      if (mapped) {
+        return mapped;
+      }
+    }
+    const sessions = Array.from(this.sessionsByChatId.values());
+    if (sessions.length === 1) {
+      return sessions[0].chatId;
+    }
+    return null;
+  }
+  prunePendingActions() {
+    const threshold = nowMs() - TELEGRAM_PENDING_TTL_MS;
+    for (const [id, entry] of this.pendingApprovalById) {
+      if (entry.createdAtMs < threshold) {
+        this.pendingApprovalById.delete(id);
+      }
+    }
+    for (const [requestId, entry] of this.pendingUserInputByRequestId) {
+      if (entry.createdAtMs < threshold) {
+        this.pendingUserInputByRequestId.delete(requestId);
+      }
+    }
+  }
+  async answerCallbackQuery(callbackQueryId, text) {
+    const token = this.settings.token;
+    if (!token) {
+      return;
+    }
+    await this.callTelegramApi(
+      token,
+      "answerCallbackQuery",
+      {
+        callback_query_id: callbackQueryId,
+        text: text || void 0
+      },
+      {
+        retry429: false
+      }
+    ).catch(() => void 0);
+  }
+  async sendTypingAction(chatId) {
+    const token = this.settings.token;
+    if (!token) {
+      return;
+    }
+    await this.callTelegramApi(
+      token,
+      "sendChatAction",
+      {
+        chat_id: chatId,
+        action: "typing"
+      },
+      {
+        retry429: false
+      }
+    ).catch(() => void 0);
+  }
+  async sendDraftMessage(chatId, text, draftId) {
+    const token = this.settings.token;
+    if (!token) {
+      return;
+    }
+    await this.sendWithRateLimit(chatId);
+    await this.callTelegramApi(
+      token,
+      "sendMessageDraft",
+      {
+        chat_id: chatId,
+        text,
+        message_text: text,
+        draft_id: draftId
+      },
+      {
+        retry429: true
+      }
+    );
+  }
+  async sendSimpleMessage(chatId, text, extra) {
+    const token = this.settings.token;
+    if (!token) {
+      return null;
+    }
+    const payload = {
+      chat_id: chatId,
+      text,
+      ...extra
+    };
+    await this.sendWithRateLimit(chatId);
+    const result = await this.callTelegramApi(token, "sendMessage", payload, {
+      retry429: true
+    });
+    return asRecord2(result);
+  }
+  async editMessageText(chatId, messageId, text) {
+    const token = this.settings.token;
+    if (!token) {
+      return;
+    }
+    await this.sendWithRateLimit(chatId);
+    await this.callTelegramApi(
+      token,
+      "editMessageText",
+      {
+        chat_id: chatId,
+        message_id: messageId,
+        text
+      },
+      {
+        retry429: true
+      }
+    );
+  }
+  extractTelegramMessageId(value) {
+    const record = asRecord2(value);
+    return asNumber(record.message_id ?? record.messageId);
+  }
+  async sendWithRateLimit(chatId) {
+    const lastSend = this.lastSendAtByChatId.get(chatId) ?? 0;
+    const now = nowMs();
+    const waitMs = TELEGRAM_MIN_SEND_INTERVAL_MS - (now - lastSend);
+    if (waitMs > 0) {
+      await this.sleep(waitMs);
+    }
+    this.lastSendAtByChatId.set(chatId, nowMs());
+  }
+  async callTelegramApi(token, method, payload, options) {
+    const url = `${TELEGRAM_API_BASE}/bot${token}/${method}`;
+    const execute = async () => {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => {
+        controller.abort();
+      }, TELEGRAM_API_TIMEOUT_MS);
+      const signal = options?.signal;
+      let externalAbortListener = null;
+      if (signal) {
+        if (signal.aborted) {
+          clearTimeout(timeoutId);
+          controller.abort();
+        } else {
+          externalAbortListener = () => controller.abort();
+          signal.addEventListener("abort", externalAbortListener, { once: true });
+        }
+      }
+      try {
+        const response2 = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(payload),
+          signal: controller.signal
+        });
+        const json = await response2.json();
+        return json;
+      } finally {
+        clearTimeout(timeoutId);
+        if (signal && externalAbortListener) {
+          signal.removeEventListener("abort", externalAbortListener);
+        }
+      }
+    };
+    const response = await execute();
+    if (response.ok) {
+      return response.result;
+    }
+    const retryAfterSeconds = response.parameters?.retry_after;
+    if (options?.retry429 && response.error_code === 429 && typeof retryAfterSeconds === "number" && retryAfterSeconds > 0) {
+      await this.sleep(retryAfterSeconds * 1e3);
+      const retried = await execute();
+      if (retried.ok) {
+        return retried.result;
+      }
+      throw new Error(retried.description || `${method} failed (code ${retried.error_code ?? "unknown"})`);
+    }
+    throw new Error(response.description || `${method} failed (code ${response.error_code ?? "unknown"})`);
+  }
+  sleep(ms) {
+    return new Promise((resolve) => {
+      setTimeout(resolve, Math.max(0, Math.floor(ms)));
+    });
+  }
+  buildRuntimeLockPath(token) {
+    const tokenHash = (0, import_node_crypto4.createHash)("sha1").update(token).digest("hex").slice(0, 16);
+    return import_node_path13.default.join(getUserDataDir(), `${TELEGRAM_BRIDGE_LOCK_FILE_PREFIX}-${tokenHash}.lock`);
+  }
+  async acquireRuntimeLock(token) {
+    if (this.runtimeLockPath) {
+      return;
+    }
+    const lockPath = this.buildRuntimeLockPath(token);
+    await import_promises4.default.mkdir(import_node_path13.default.dirname(lockPath), { recursive: true });
+    const payload = JSON.stringify(
+      {
+        pid: process.pid,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      null,
+      2
+    );
+    try {
+      await import_promises4.default.writeFile(lockPath, payload, { encoding: "utf8", flag: "wx" });
+      this.runtimeLockPath = lockPath;
+      return;
+    } catch (error) {
+      const code = error.code;
+      if (code !== "EEXIST") {
+        throw error;
+      }
+    }
+    const existingPid = await this.readLockPid(lockPath);
+    if (existingPid && existingPid !== process.pid && this.isProcessAlive(existingPid)) {
+      throw new Error(
+        `Telegram bridge already running in another process (pid ${existingPid}). Stop the other instance to avoid duplicate replies.`
+      );
+    }
+    await import_promises4.default.unlink(lockPath).catch(() => void 0);
+    await import_promises4.default.writeFile(lockPath, payload, { encoding: "utf8", flag: "wx" });
+    this.runtimeLockPath = lockPath;
+  }
+  async releaseRuntimeLock() {
+    const lockPath = this.runtimeLockPath;
+    this.runtimeLockPath = null;
+    if (!lockPath) {
+      return;
+    }
+    await import_promises4.default.unlink(lockPath).catch(() => void 0);
+  }
+  async readLockPid(lockPath) {
+    try {
+      const raw = await import_promises4.default.readFile(lockPath, "utf8");
+      const parsed = JSON.parse(raw);
+      const pid = asNumber(parsed.pid);
+      if (pid === null || pid <= 0) {
+        return null;
+      }
+      return Math.trunc(pid);
+    } catch {
+      return null;
+    }
+  }
+  isProcessAlive(pid) {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (error) {
+      const code = error.code;
+      return code === "EPERM";
+    }
+  }
+};
+function createTelegramBridge(options) {
+  return new TelegramBridge(options);
+}
+
+// src/daemon.ts
+function hasFlag(args, flag) {
+  return args.includes(flag);
+}
+function stripFlags(args) {
+  return args.filter((arg) => !arg.startsWith("-"));
+}
+function parseStringFlag(flags, name) {
+  const explicit = flags.find((flag) => flag.startsWith(`${name}=`));
+  if (!explicit) {
+    return null;
+  }
+  const value = explicit.slice(`${name}=`.length).trim();
+  return value.length > 0 ? value : "";
+}
+function printDaemonHelp(version) {
+  console.log(`CodexUse CLI v${version}
+
+Usage:
+  codexuse daemon start --telegram-bot-token=<token> [--project-path=/abs/path]
+
+Environment:
+  CODEXUSE_TELEGRAM_BOT_TOKEN   Telegram bot token fallback
+
+Notes:
+  - Runs Codex app-server + Telegram bridge in headless mode (no desktop app).
+  - --project-path auto-registers that path and makes it the default project for new chats.
+  - Use on VPS/Linux with a process manager (systemd, pm2, supervisord).
+  - Stop with Ctrl+C or SIGTERM.
+`);
+}
+async function ensureProjectRegistered(projectPath) {
+  const resolvedPath = import_node_path14.default.resolve(projectPath);
+  const projects = await listParityWorkspaces();
+  const existing = projects.find((entry) => import_node_path14.default.resolve(entry.path) === resolvedPath) ?? null;
+  if (!existing) {
+    await assertProjectCreationAllowed(projects);
+    const added = await addParityWorkspace(resolvedPath);
+    console.log(`Added project: ${added.name} (${added.path})`);
+    return added;
+  }
+  if (!existing.connected) {
+    const connected = await connectParityWorkspace(existing.id);
+    console.log(`Connected project: ${connected.name} (${connected.path})`);
+    return connected;
+  }
+  return existing;
+}
+async function resolveProEnabled() {
+  const cached = await licenseService.getCachedStatus().catch(() => null);
+  if (cached?.isPro) {
+    return true;
+  }
+  const refreshed = await licenseService.getStatus().catch(() => cached);
+  return Boolean(refreshed?.isPro);
+}
+function parseProcessExitPayload(payload) {
+  if (!payload || typeof payload !== "object") {
+    return "";
+  }
+  const record = payload;
+  const code = typeof record.code === "number" ? record.code : null;
+  const signal = typeof record.signal === "string" ? record.signal : null;
+  if (code !== null && signal) {
+    return `code=${code}, signal=${signal}`;
+  }
+  if (code !== null) {
+    return `code=${code}`;
+  }
+  if (signal) {
+    return `signal=${signal}`;
+  }
+  return "";
+}
+async function runDaemonStart(options) {
+  if (!options.telegramBotToken) {
+    throw new Error(
+      "Telegram bot token is required. Pass --telegram-bot-token=<token> or set CODEXUSE_TELEGRAM_BOT_TOKEN."
+    );
+  }
+  let preferredProject = null;
+  if (options.projectPath) {
+    preferredProject = await ensureProjectRegistered(options.projectPath);
+  }
+  const appServer = new CodexAppServer();
+  await appServer.initialize({
+    name: "codexuse-cli-daemon",
+    title: "CodexUse CLI Daemon",
+    version: options.version
+  });
+  const bridge = createTelegramBridge({
+    getAppServer: () => appServer,
+    listProjects: () => listParityWorkspaces(),
+    getProjectById: (id) => getParityWorkspaceById(id),
+    isProEnabled: () => resolveProEnabled(),
+    getDefaultProjectId: () => preferredProject?.id ?? null
+  });
+  await bridge.applyRuntimeSettings({
+    telegramBridgeEnabled: true,
+    telegramBotToken: options.telegramBotToken
+  });
+  const status = bridge.getStatus();
+  if (!status.running) {
+    await bridge.dispose().catch(() => void 0);
+    await appServer.stop().catch(() => void 0);
+    throw new Error(status.lastError || "Telegram bridge failed to start.");
+  }
+  const botLabel = status.botUsername ? `@${status.botUsername}` : "(unknown)";
+  const projects = await listParityWorkspaces().catch(() => []);
+  console.log(`Daemon started. Telegram bot: ${botLabel}`);
+  console.log(`Streaming mode: ${status.streamMode}`);
+  if (preferredProject) {
+    console.log(`Default project: ${preferredProject.name} [${preferredProject.id}]`);
+  }
+  console.log(`Projects available: ${projects.length}`);
+  console.log("Running until SIGINT/SIGTERM...");
+  let stopping = false;
+  let resolveWait = null;
+  const stop = async (reason, exitCode) => {
+    if (stopping) {
+      return;
+    }
+    stopping = true;
+    process.exitCode = exitCode;
+    console.log(`Stopping daemon (${reason})...`);
+    await bridge.dispose().catch((error) => {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`Failed to stop Telegram bridge cleanly: ${message}`);
+    });
+    await appServer.stop().catch((error) => {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`Failed to stop app-server cleanly: ${message}`);
+    });
+    resolveWait?.();
+  };
+  const onSigInt = () => {
+    void stop("SIGINT", 0);
+  };
+  const onSigTerm = () => {
+    void stop("SIGTERM", 0);
+  };
+  const onProcessExited = (payload) => {
+    const suffix = parseProcessExitPayload(payload);
+    const detail = suffix ? ` (${suffix})` : "";
+    console.error(`Codex app-server exited unexpectedly${detail}.`);
+    void stop("app-server-exited", 1);
+  };
+  process.once("SIGINT", onSigInt);
+  process.once("SIGTERM", onSigTerm);
+  appServer.once("codex:process-exited", onProcessExited);
+  try {
+    await new Promise((resolve) => {
+      resolveWait = resolve;
+    });
+  } finally {
+    process.off("SIGINT", onSigInt);
+    process.off("SIGTERM", onSigTerm);
+    appServer.off("codex:process-exited", onProcessExited);
+  }
+}
+async function handleDaemonCommand(args, version) {
+  const flags = args.filter((arg) => arg.startsWith("-"));
+  const params = stripFlags(args);
+  const sub = params[0];
+  if (!sub || hasFlag(flags, "--help") || hasFlag(flags, "-h")) {
+    printDaemonHelp(version);
+    return;
+  }
+  switch (sub) {
+    case "start": {
+      const tokenFlag = parseStringFlag(flags, "--telegram-bot-token") ?? parseStringFlag(flags, "--bot-token");
+      const tokenEnv = process.env.CODEXUSE_TELEGRAM_BOT_TOKEN?.trim() || null;
+      const telegramBotToken = tokenFlag && tokenFlag.trim() || tokenEnv || "";
+      const projectPath = parseStringFlag(flags, "--project-path") ?? parseStringFlag(flags, "--project") ?? null;
+      await runDaemonStart({
+        telegramBotToken,
+        projectPath,
+        version
+      });
+      return;
+    }
+    default:
+      printDaemonHelp(version);
+      return;
+  }
+}
+
+// src/index.ts
+var VERSION = true ? "2.5.8" : "0.0.0";
+var cliStorageReadyPromise = null;
+async function ensureCliStorageReady() {
+  if (cliStorageReadyPromise) {
+    return cliStorageReadyPromise;
+  }
+  cliStorageReadyPromise = (async () => {
+    await initializeAppState(getUserDataDir());
+    const migrated = await runStorageMigrationV1();
+    if (migrated.migration.status === "pending_local_storage") {
+      await importLegacyLocalStorageOnce({});
+    }
+    const state = await getAppState();
+    if (state.migration.status !== "complete") {
+      throw new Error(
+        `Storage migration is not complete (status: ${state.migration.status}). CLI cannot continue until migration succeeds.`
+      );
+    }
+  })().catch((error) => {
+    cliStorageReadyPromise = null;
+    throw error;
+  });
+  return cliStorageReadyPromise;
+}
+function printHelp() {
+  console.log(`CodexUse CLI v${VERSION}
+
+Usage:
+  codexuse profile list [--no-usage] [--compact]
+  codexuse profile current
+  codexuse profile add <name> [--skip-login] [--device-auth] [--login=browser|device]
+  codexuse profile refresh <name> [--skip-login] [--device-auth] [--login=browser|device]
+  codexuse profile switch <name>
+  codexuse profile autoroll [--threshold=50-100] [--dry-run] [--watch] [--interval=seconds]
+  codexuse profile delete <name>
+  codexuse profile rename <old> <new>
+
+  codexuse license status [--refresh]
+  codexuse license activate <license-key>
+
+  codexuse sync status
+  codexuse sync pull
+  codexuse sync push
+
+  codexuse daemon start --telegram-bot-token=<token> [--project-path=/abs/path]
+
+Flags:
+  -h, --help       Show help
+  -v, --version    Show version
+  --no-usage       Skip rate-limit usage fetch
+  --compact        Names only
+  --device-auth    Use device auth for Codex login
+  --login=MODE     Login mode: browser | device
+  --threshold=NN   Auto-roll switch threshold percent (50-100)
+  --watch          Keep checking and auto-switch when threshold is reached
+  --interval=SEC   Watch interval in seconds (default: 30)
+  --dry-run        Print planned switch without changing active profile
+  --telegram-bot-token=TOKEN   Telegram bot token for daemon mode
+  --project-path=PATH          Optional path to auto-register and set as default project in daemon mode
+`);
+}
+function hasFlag2(args, flag) {
+  return args.includes(flag);
+}
+function stripFlags2(args) {
+  return args.filter((arg) => !arg.startsWith("-"));
+}
+function parseLoginMode(flags) {
+  if (flags.includes("--device-auth")) return "device";
+  const explicit = flags.find((flag) => flag.startsWith("--login="));
+  if (!explicit) return null;
+  const value = explicit.split("=")[1];
+  if (value === "browser" || value === "device") {
+    return value;
+  }
+  return null;
+}
+var DEFAULT_AUTOROLL_INTERVAL_SECONDS = 30;
+var DEFAULT_AUTOROLL_THRESHOLD = 95;
+function parseNumericFlag(flags, name) {
+  const explicit = flags.find((flag) => flag.startsWith(`${name}=`));
+  if (!explicit) {
+    return null;
+  }
+  const raw = explicit.slice(`${name}=`.length);
+  const value = Number.parseFloat(raw);
+  return Number.isFinite(value) ? value : Number.NaN;
+}
+function parseIntegerFlag(flags, name) {
+  const explicit = flags.find((flag) => flag.startsWith(`${name}=`));
+  if (!explicit) {
+    return null;
+  }
+  const raw = explicit.slice(`${name}=`.length);
+  const value = Number.parseInt(raw, 10);
+  return Number.isFinite(value) ? value : Number.NaN;
+}
+function formatProfileLabel(name, displayName) {
+  if (displayName && displayName.trim() && displayName !== name) {
+    return `${displayName} (${name})`;
   }
   return name;
 }
@@ -5602,9 +9549,9 @@ function delay(ms) {
 }
 async function handleProfile(args) {
   const flags = args.filter((arg) => arg.startsWith("-"));
-  const params = stripFlags(args);
+  const params = stripFlags2(args);
   const sub = params[0];
-  if (!sub || hasFlag(flags, "--help") || hasFlag(flags, "-h")) {
+  if (!sub || hasFlag2(flags, "--help") || hasFlag2(flags, "-h")) {
     printHelp();
     return;
   }
@@ -5617,8 +9564,8 @@ async function handleProfile(args) {
         console.log("No profiles found.");
         return;
       }
-      const compact = hasFlag(flags, "--compact");
-      const withUsage = !hasFlag(flags, "--no-usage");
+      const compact = hasFlag2(flags, "--compact");
+      const withUsage = !hasFlag2(flags, "--no-usage");
       let usageMap = null;
       if (withUsage) {
         const codexPath = resolveCodexBinary();
@@ -5664,7 +9611,7 @@ async function handleProfile(args) {
         throw new Error("Profile name is required.");
       }
       await assertProfileCreationAllowed(manager);
-      if (!hasFlag(flags, "--skip-login")) {
+      if (!hasFlag2(flags, "--skip-login")) {
         const loginMode = resolveLoginMode(parseLoginMode(flags));
         await runCodexLogin(loginMode);
       }
@@ -5678,7 +9625,7 @@ async function handleProfile(args) {
       if (!name) {
         throw new Error("Profile name is required.");
       }
-      if (!hasFlag(flags, "--skip-login")) {
+      if (!hasFlag2(flags, "--skip-login")) {
         const loginMode = resolveLoginMode(parseLoginMode(flags));
         await runCodexLogin(loginMode);
       }
@@ -5698,8 +9645,8 @@ async function handleProfile(args) {
     }
     case "autoroll":
     case "auto-roll": {
-      const watch = hasFlag(flags, "--watch");
-      const dryRun = hasFlag(flags, "--dry-run");
+      const watch = hasFlag2(flags, "--watch");
+      const dryRun = hasFlag2(flags, "--dry-run");
       const settings = await getStoredAutoRollSettings().catch(() => null);
       const fallbackThreshold = typeof settings?.switchThreshold === "number" && Number.isFinite(settings.switchThreshold) ? Math.round(settings.switchThreshold) : DEFAULT_AUTOROLL_THRESHOLD;
       const threshold = parseAutoRollThreshold(flags, fallbackThreshold);
@@ -5754,15 +9701,15 @@ async function handleProfile(args) {
 }
 async function handleLicense(args) {
   const flags = args.filter((arg) => arg.startsWith("-"));
-  const params = stripFlags(args);
+  const params = stripFlags2(args);
   const sub = params[0];
-  if (!sub || hasFlag(flags, "--help") || hasFlag(flags, "-h")) {
+  if (!sub || hasFlag2(flags, "--help") || hasFlag2(flags, "-h")) {
     printHelp();
     return;
   }
   switch (sub) {
     case "status": {
-      const forceRefresh = hasFlag(flags, "--refresh");
+      const forceRefresh = hasFlag2(flags, "--refresh");
       const status = await licenseService.getStatus({ forceRefresh });
       console.log(`Tier: ${status.tier}`);
       console.log(`State: ${status.state}`);
@@ -5811,9 +9758,9 @@ function printSyncResult(result) {
 }
 async function handleSync(args) {
   const flags = args.filter((arg) => arg.startsWith("-"));
-  const params = stripFlags(args);
+  const params = stripFlags2(args);
   const sub = params[0];
-  if (!sub || hasFlag(flags, "--help") || hasFlag(flags, "-h")) {
+  if (!sub || hasFlag2(flags, "--help") || hasFlag2(flags, "-h")) {
     printHelp();
     return;
   }
@@ -5866,11 +9813,15 @@ async function handleSync(args) {
 }
 async function main() {
   const args = process.argv.slice(2);
-  if (args.length === 0 || hasFlag(args, "--help") || hasFlag(args, "-h")) {
+  if (args.length === 0) {
+    printHelp();
+    return;
+  }
+  if (args[0]?.startsWith("-") && (hasFlag2(args, "--help") || hasFlag2(args, "-h"))) {
     printHelp();
     return;
   }
-  if (hasFlag(args, "--version") || hasFlag(args, "-v")) {
+  if (args[0]?.startsWith("-") && (hasFlag2(args, "--version") || hasFlag2(args, "-v"))) {
     console.log(VERSION);
     return;
   }
@@ -5889,6 +9840,10 @@ async function main() {
       await ensureCliStorageReady();
       await handleSync(rest);
       return;
+    case "daemon":
+      await ensureCliStorageReady();
+      await handleDaemonCommand(rest, VERSION);
+      return;
     default:
       printHelp();
       return;