codexui-android 0.1.108 → 0.1.110

package/dist-cli/index.js

@@ -2047,6 +2047,9 @@ function deriveSkillPathInfo(skillPath, knownPaths = /* @__PURE__ */ new Set())
 function getSkillsInstallDir() {
   return join4(getCodexHomeDir2(), "skills");
 }
+function getSharedSkillsInstallDir() {
+  return join4(getSkillsInstallDir(), "shared_skills");
+}
 var DEFAULT_COMMAND_TIMEOUT_MS = 12e4;
 var SKILL_SEARCH_METADATA_LIMIT = 20;
 var SKILL_SEARCH_METADATA_CONCURRENCY = 4;
@@ -2421,9 +2424,8 @@ var startupSyncStatus = {
   lastSuccessAtIso: "",
   lastError: ""
 };
-async function scanInstalledSkillsFromDisk() {
+async function scanInstalledSkillsFromDir(skillsDir) {
   const map = /* @__PURE__ */ new Map();
-  const skillsDir = getSkillsInstallDir();
   try {
     const entries = await readdir(skillsDir, { withFileTypes: true });
     for (const entry of entries) {
@@ -2439,6 +2441,9 @@ async function scanInstalledSkillsFromDisk() {
   }
   return map;
 }
+async function scanInstalledSkillsFromDisk() {
+  return await scanInstalledSkillsFromDir(getSkillsInstallDir());
+}
 async function collectInstalledSkillsMap(appServer) {
   const installedMap = await scanInstalledSkillsFromDisk();
   try {
@@ -2700,13 +2705,14 @@ async function writeRemoteSkillsManifest(token, repoOwner, repoName, skills) {
 function toGitHubTokenRemote(repoOwner, repoName, token) {
   return `https://x-access-token:${encodeURIComponent(token)}@github.com/${repoOwner}/${repoName}.git`;
 }
-async function ensureSkillsWorkingTreeRepo(repoUrl, branch) {
-  const localDir = getSkillsInstallDir();
+async function ensureSkillsWorkingTreeRepo(repoUrl, branch, options = {}) {
+  const localDir = options.localDir ?? getSkillsInstallDir();
   await mkdir3(localDir, { recursive: true });
   const gitDir = join4(localDir, ".git");
   let hasGitDir = false;
   try {
-    hasGitDir = (await stat3(gitDir)).isDirectory();
+    const gitDirStat = await lstat(gitDir);
+    hasGitDir = gitDirStat.isDirectory() || gitDirStat.isFile();
   } catch {
     hasGitDir = false;
   }
@@ -2726,6 +2732,14 @@ async function ensureSkillsWorkingTreeRepo(repoUrl, branch) {
       await runCommand2("git", ["remote", "set-url", "origin", repoUrl], { cwd: localDir });
     }
     await runGitFetchWithRefLockRetry(localDir);
+    if (options.overwriteLocalFiles) {
+      await runCommand2("git", ["reset", "--hard"], { cwd: localDir });
+      await runCommand2("git", ["clean", "-fd"], { cwd: localDir });
+      await runCommand2("git", ["checkout", "-B", branch, `origin/${branch}`], { cwd: localDir });
+      await runCommand2("git", ["reset", "--hard", `origin/${branch}`], { cwd: localDir });
+      await runCommand2("git", ["clean", "-fd"], { cwd: localDir });
+      return localDir;
+    }
     try {
       await runCommand2("git", ["merge", "--allow-unrelated-histories", "--no-edit", `origin/${branch}`], { cwd: localDir });
     } catch {
@@ -2734,6 +2748,17 @@ async function ensureSkillsWorkingTreeRepo(repoUrl, branch) {
   }
   await runCommand2("git", ["remote", "set-url", "origin", repoUrl], { cwd: localDir });
   await runGitFetchWithRefLockRetry(localDir);
+  if (options.overwriteLocalFiles) {
+    try {
+      await runCommand2("git", ["reset", "--hard"], { cwd: localDir });
+    } catch {
+    }
+    await runCommand2("git", ["clean", "-fd"], { cwd: localDir });
+    await runCommand2("git", ["checkout", "-B", branch, `origin/${branch}`], { cwd: localDir });
+    await runCommand2("git", ["reset", "--hard", `origin/${branch}`], { cwd: localDir });
+    await runCommand2("git", ["clean", "-fd"], { cwd: localDir });
+    return localDir;
+  }
   const hasLocalChangesBeforeSync = await hasLocalUncommittedChanges(localDir);
   const localMtimesBeforeSync = hasLocalChangesBeforeSync ? await snapshotFileMtimes(localDir) : /* @__PURE__ */ new Map();
   await resolveMergeConflictsByNewerCommit(localDir, branch, localMtimesBeforeSync);
@@ -2994,13 +3019,19 @@ async function syncInstalledSkillsFolderToRepo(token, repoOwner, repoName, _inst
 }
 async function pullInstalledSkillsFolderFromRepo(token, repoOwner, repoName) {
   const remoteUrl = toGitHubTokenRemote(repoOwner, repoName, token);
-  const branch = PRIVATE_SYNC_BRANCH;
-  await ensureSkillsWorkingTreeRepo(remoteUrl, branch);
+  const isUpstream = isUpstreamSkillsRepo(repoOwner, repoName);
+  const branch = isUpstream ? PUBLIC_UPSTREAM_BRANCH_ANDROID : PRIVATE_SYNC_BRANCH;
+  return await ensureSkillsWorkingTreeRepo(remoteUrl, branch, {
+    ...isUpstream ? { localDir: getSharedSkillsInstallDir() } : {},
+    overwriteLocalFiles: isUpstream
+  });
 }
 async function bootstrapSkillsFromUpstreamIntoLocal() {
   const repoUrl = `https://github.com/${SYNC_UPSTREAM_SKILLS_OWNER}/${SYNC_UPSTREAM_SKILLS_REPO}.git`;
-  const branch = getPreferredPublicUpstreamBranch();
-  await ensureSkillsWorkingTreeRepo(repoUrl, branch);
+  return await ensureSkillsWorkingTreeRepo(repoUrl, PUBLIC_UPSTREAM_BRANCH_ANDROID, {
+    localDir: getSharedSkillsInstallDir(),
+    overwriteLocalFiles: true
+  });
 }
 async function collectLocalSyncedSkills(appServer) {
   const state = await readSkillsSyncState();
@@ -3305,12 +3336,31 @@ async function handleSkillsRoutes(req, res, url, context) {
     try {
       const state = await readSkillsSyncState();
       if (!state.githubToken || !state.repoOwner || !state.repoName) {
-        await bootstrapSkillsFromUpstreamIntoLocal();
+        const repoDir = await bootstrapSkillsFromUpstreamIntoLocal();
+        const localSkills2 = await scanInstalledSkillsFromDir(repoDir);
+        try {
+          await appServer.rpc("skills/list", { forceReload: true });
+        } catch {
+        }
+        setJson3(res, 200, { ok: true, data: { synced: localSkills2.size, source: "upstream" } });
+        return true;
+      }
+      if (isUpstreamSkillsRepo(state.repoOwner, state.repoName)) {
+        const repoDir = await pullInstalledSkillsFolderFromRepo(state.githubToken, state.repoOwner, state.repoName);
+        const localSkills2 = await scanInstalledSkillsFromDir(repoDir);
+        const pulledHead2 = await runCommandWithOutput("git", ["rev-parse", "HEAD"], { cwd: repoDir }).catch(() => "");
+        await writeSkillsSyncState({
+          ...state,
+          lastPullCommitSha: pulledHead2.trim(),
+          lastSyncAttemptCount: 1,
+          lastSyncError: "",
+          lastSyncAtIso: (/* @__PURE__ */ new Date()).toISOString()
+        });
         try {
           await appServer.rpc("skills/list", { forceReload: true });
         } catch {
         }
-        setJson3(res, 200, { ok: true, data: { synced: 0, source: "upstream" } });
+        setJson3(res, 200, { ok: true, data: { synced: localSkills2.size, source: "upstream" } });
         return true;
       }
       const remote = await readRemoteSkillsManifest(state.githubToken, state.repoOwner, state.repoName);
@@ -4203,13 +4253,6 @@ var CUSTOM_PROVIDER_ID = "custom-endpoint";
 var OPENCODE_ZEN_PROVIDER_ID = "opencode-zen";
 var OPENCODE_ZEN_BASE_URL = "https://opencode.ai/zen/v1";
 var OPENCODE_ZEN_DEFAULT_MODEL = "big-pickle";
-var OPENCODE_ZEN_FALLBACK_FREE_MODELS = [
-  OPENCODE_ZEN_DEFAULT_MODEL,
-  "minimax-m2.5-free",
-  "hy3-preview-free",
-  "nemotron-3-super-free",
-  "trinity-large-preview-free"
-];
 function createDefaultOpenCodeZenFreeModeState() {
   return {
     enabled: true,
@@ -4221,13 +4264,8 @@ function createDefaultOpenCodeZenFreeModeState() {
     providerKeys: {}
   };
 }
-function getOpenCodeZenFreeModelIds(modelIds) {
-  const uniqueIds = modelIds.map((id) => id.trim()).filter((id, index, ids) => id.length > 0 && ids.indexOf(id) === index);
-  const freeIds = uniqueIds.filter((id) => id.endsWith("-free") || id === OPENCODE_ZEN_DEFAULT_MODEL);
-  return freeIds.length > 0 ? freeIds : OPENCODE_ZEN_FALLBACK_FREE_MODELS;
-}
-function shouldCreateDefaultFreeModeStateForMissingAuth(current, hasUsableCodexAuth) {
-  return current == null && !hasUsableCodexAuth;
+function shouldCreateDefaultFreeModeStateForMissingAuth(current, hasUsableCodexAuth2) {
+  return current == null && !hasUsableCodexAuth2;
 }
 function getFreeModeEnvVars(state) {
   if (!state.enabled) return {};
@@ -4358,14 +4396,6 @@ function extractTextParts(value) {
   if (!Array.isArray(value)) return "";
   return value.map((part) => part && typeof part === "object" && typeof part.text === "string" ? part.text : "").filter((part) => part.length > 0).join("\n");
 }
-function buildReasoningOutputItem(reasoningContent) {
-  return {
-    type: "reasoning",
-    id: `rs_${Date.now()}`,
-    summary: [{ type: "summary_text", text: reasoningContent }],
-    content: []
-  };
-}
 function responsesInputToMessages(input, instructions) {
   const messages = [];
   let pendingReasoningContent = "";
@@ -4487,7 +4517,12 @@ function chatCompletionToResponsesFormat(chatResponse, model) {
       });
     }
     if (message.reasoning_content) {
-      output.push(buildReasoningOutputItem(message.reasoning_content));
+      output.push({
+        type: "reasoning",
+        id: `rs_${Date.now()}`,
+        summary: [],
+        content: [{ type: "reasoning_text", text: message.reasoning_content }]
+      });
     }
   }
   const usage = chatResponse.usage;
@@ -4553,7 +4588,12 @@ function forwardStreamingTextResponse(upstreamRes, res, model) {
     const messageItem = { type: "message", role: "assistant", content: [{ type: "output_text", text: fullText }], status: "completed" };
     const output = [messageItem];
     if (fullReasoningText) {
-      output.push(buildReasoningOutputItem(fullReasoningText));
+      output.push({
+        type: "reasoning",
+        id: `rs_${Date.now()}`,
+        summary: [],
+        content: [{ type: "reasoning_text", text: fullReasoningText }]
+      });
     }
     res.write(`data: {"type":"response.output_text.done","output_index":0,"content_index":0,"text":"${escapedFull}"}
 
@@ -5192,10 +5232,34 @@ function shellQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 
+// src/pathUtils.ts
+function stripWindowsDevicePathPrefix(value) {
+  const trimmed = value.trim();
+  if (!trimmed) return "";
+  if (trimmed.startsWith("\\\\?\\UNC\\")) {
+    return `\\\\${trimmed.slice("\\\\?\\UNC\\".length)}`;
+  }
+  if (trimmed.startsWith("\\\\?\\")) {
+    return trimmed.slice("\\\\?\\".length);
+  }
+  return trimmed;
+}
+function normalizePathForUi(value) {
+  return stripWindowsDevicePathPrefix(value);
+}
+function isWindowsLikePath(value) {
+  return /^[a-z]:[\\/]/iu.test(value) || value.startsWith("\\\\");
+}
+function isAbsoluteLikePath(value) {
+  const normalized = normalizePathForUi(value);
+  return normalized.startsWith("/") || isWindowsLikePath(normalized);
+}
+
 // src/server/codexAppServerBridge.ts
 var COMPOSIO_CONNECTORS_PAGE_LIMIT_MAX = 1e3;
 var PROVIDER_MODELS_FETCH_TIMEOUT_MS = 5e3;
 var THREAD_RESPONSE_TURN_LIMIT = 10;
+var THREAD_TURN_PAGE_READ_CACHE_TTL_MS = 3e4;
 var THREAD_METHODS_WITH_TURNS = /* @__PURE__ */ new Set(["thread/read", "thread/resume", "thread/fork", "thread/rollback"]);
 var THREAD_SEARCH_FULL_TEXT_THREAD_LIMIT = 100;
 var PROJECTLESS_THREAD_DIRECTORY_MAX_ATTEMPTS = 100;
@@ -5698,11 +5762,13 @@ function trimThreadTurnsInRpcResult(method, result) {
   const thread = asRecord5(record?.thread);
   const turns = Array.isArray(thread?.turns) ? thread.turns : null;
   if (!record || !thread || !turns || turns.length <= THREAD_RESPONSE_TURN_LIMIT) return result;
+  const startTurnIndex = Math.max(0, turns.length - THREAD_RESPONSE_TURN_LIMIT);
   return {
     ...record,
+    threadTurnStartIndex: startTurnIndex,
     thread: {
       ...thread,
-      turns: turns.slice(-THREAD_RESPONSE_TURN_LIMIT)
+      turns: turns.slice(startTurnIndex)
     }
   };
 }
@@ -5720,6 +5786,37 @@ function getErrorMessage5(payload, fallback) {
   }
   return fallback;
 }
+function isUnauthenticatedRateLimitError(error) {
+  const message = getErrorMessage5(error, "").toLowerCase();
+  return message.includes("authentication required") && message.includes("rate limits");
+}
+var warnedCodexAuthReadFailures = /* @__PURE__ */ new Set();
+function getErrorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error ? String(error.code ?? "") : null;
+}
+function getCodexAuthReadErrorMessage(error) {
+  return error instanceof Error && error.message.trim().length > 0 ? error.message : String(error);
+}
+function warnCodexAuthReadFailure(authPath, error) {
+  const message = getCodexAuthReadErrorMessage(error);
+  const warningKey = `${authPath}:${message}`;
+  if (warnedCodexAuthReadFailures.has(warningKey)) return;
+  warnedCodexAuthReadFailures.add(warningKey);
+  console.warn("[codex-auth] Unable to read Codex auth state", { path: authPath, error: message });
+}
+async function hasUsableCodexAuth() {
+  const authPath = getCodexAuthPath();
+  try {
+    const raw = await readFile3(authPath, "utf8");
+    const auth = JSON.parse(raw);
+    return Boolean(auth.tokens?.access_token?.trim() || auth.tokens?.refresh_token?.trim());
+  } catch (error) {
+    if (getErrorCode(error) !== "ENOENT") {
+      warnCodexAuthReadFailure(authPath, error);
+    }
+    return false;
+  }
+}
 function setJson4(res, statusCode, payload) {
   res.statusCode = statusCode;
   res.setHeader("Content-Type", "application/json; charset=utf-8");
@@ -5770,6 +5867,56 @@ async function createProjectlessThreadDirectory(prompt) {
   }
   throw new Error("Unable to create a unique new chat folder");
 }
+function normalizeGithubCloneUrl(rawUrl) {
+  const trimmedUrl = rawUrl.trim();
+  if (!trimmedUrl) throw new Error("Missing GitHub repository URL");
+  const sshMatch = trimmedUrl.match(/^git@github\.com:([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+?)(?:\.git)?$/u);
+  if (sshMatch) {
+    const repoName2 = sshMatch[2];
+    return { url: `git@github.com:${sshMatch[1]}/${repoName2}.git`, repoName: repoName2 };
+  }
+  let parsed;
+  try {
+    parsed = new URL(trimmedUrl);
+  } catch {
+    throw new Error("Enter a valid GitHub repository URL");
+  }
+  if (parsed.hostname.toLowerCase() !== "github.com") {
+    throw new Error("Only github.com repository URLs are supported");
+  }
+  const segments = parsed.pathname.split("/").filter(Boolean);
+  if (segments.length < 2) {
+    throw new Error("Enter a GitHub repository URL with owner and repository name");
+  }
+  const owner = segments[0];
+  const repoName = segments[1].replace(/\.git$/iu, "");
+  if (!/^[A-Za-z0-9_.-]+$/u.test(owner) || !/^[A-Za-z0-9_.-]+$/u.test(repoName)) {
+    throw new Error("GitHub repository owner or name contains unsupported characters");
+  }
+  return { url: `https://github.com/${owner}/${repoName}.git`, repoName };
+}
+async function cloneGithubRepositoryIntoBase(rawUrl, rawBasePath) {
+  const basePath = rawBasePath.trim();
+  if (!basePath) throw new Error("Missing clone destination folder");
+  const normalizedBasePath = isAbsolute2(basePath) ? basePath : resolve2(basePath);
+  await ensureRealDirectory(normalizedBasePath, "Clone destination folder");
+  const { url, repoName } = normalizeGithubCloneUrl(rawUrl);
+  const targetPath = join6(normalizedBasePath, repoName);
+  try {
+    await stat4(targetPath);
+    throw new Error(`Destination already exists: ${targetPath}`);
+  } catch (error) {
+    if (error?.code !== "ENOENT") throw error;
+  }
+  try {
+    await runCommand3("git", ["clone", url, targetPath], { cwd: normalizedBasePath, timeoutMs: 5 * 6e4 });
+  } catch (error) {
+    await rm4(targetPath, { recursive: true, force: true }).catch(() => void 0);
+    throw error;
+  }
+  await persistWorkspaceRoot(targetPath, "");
+  return targetPath;
+}
 function normalizeHeaderValue(value) {
   if (typeof value === "string") {
     const trimmed = value.trim();
@@ -7179,14 +7326,33 @@ async function runCommand3(command, args, options = {}) {
     });
     let stdout = "";
     let stderr = "";
+    let timedOut = false;
+    let closed = false;
+    const timeout = typeof options.timeoutMs === "number" && Number.isFinite(options.timeoutMs) && options.timeoutMs > 0 ? setTimeout(() => {
+      timedOut = true;
+      proc.kill("SIGTERM");
+      setTimeout(() => {
+        if (!closed) proc.kill("SIGKILL");
+      }, 5e3).unref();
+    }, options.timeoutMs) : null;
+    timeout?.unref();
     proc.stdout.on("data", (chunk) => {
       stdout += chunk.toString();
     });
     proc.stderr.on("data", (chunk) => {
       stderr += chunk.toString();
     });
-    proc.on("error", reject);
+    proc.on("error", (error) => {
+      if (timeout) clearTimeout(timeout);
+      reject(error);
+    });
     proc.on("close", (code) => {
+      closed = true;
+      if (timeout) clearTimeout(timeout);
+      if (timedOut) {
+        reject(new Error(`Command timed out after ${options.timeoutMs}ms (${command} ${args.join(" ")})`));
+        return;
+      }
       if (code === 0) {
         resolve4();
         return;
@@ -7562,23 +7728,70 @@ function readTomlString(value) {
 function serializeTomlString(value) {
   return JSON.stringify(value);
 }
+function parseTomlStringArray(value) {
+  const trimmed = value.trim();
+  if (!trimmed.startsWith("[") || !trimmed.endsWith("]")) return [];
+  try {
+    const parsed = JSON.parse(trimmed);
+    return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string" && item.trim().length > 0) : [];
+  } catch {
+    return [];
+  }
+}
+function serializeTomlStringArray(values) {
+  return `[${values.map((value) => serializeTomlString(value)).join(", ")}]`;
+}
 function parseAutomationToml(raw) {
   const values = {};
+  const extraTomlLines = [];
+  const knownKeys = /* @__PURE__ */ new Set([
+    "version",
+    "id",
+    "kind",
+    "name",
+    "prompt",
+    "status",
+    "rrule",
+    "target_thread_id",
+    "cwds",
+    "created_at",
+    "updated_at"
+  ]);
+  let isInsideExtraTable = false;
   for (const line of raw.split(/\r?\n/u)) {
     const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#") || !trimmed.includes("=")) continue;
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+      isInsideExtraTable = true;
+      extraTomlLines.push(trimmed);
+      continue;
+    }
+    if (isInsideExtraTable) {
+      extraTomlLines.push(trimmed);
+      continue;
+    }
+    if (!trimmed.includes("=")) {
+      extraTomlLines.push(trimmed);
+      continue;
+    }
     const separatorIndex = trimmed.indexOf("=");
     const key = trimmed.slice(0, separatorIndex).trim();
     const value = trimmed.slice(separatorIndex + 1).trim();
-    if (key) values[key] = value;
+    if (!key) continue;
+    if (knownKeys.has(key)) {
+      values[key] = value;
+    } else {
+      extraTomlLines.push(trimmed);
+    }
   }
   const id = readTomlString(values.id ?? "");
-  const kindValue = readTomlString(values.kind ?? "heartbeat");
+  const kindValue = readTomlString(values.kind ?? (values.cwds ? "cron" : "heartbeat"));
   const name = readTomlString(values.name ?? "");
   const prompt = readTomlString(values.prompt ?? "");
   const rrule = readTomlString(values.rrule ?? "");
   const statusValue = readTomlString(values.status ?? "ACTIVE");
   const targetThreadId = readTomlString(values.target_thread_id ?? "") || null;
+  const cwds = parseTomlStringArray(values.cwds ?? "");
   const createdAtMs = Number.parseInt(values.created_at ?? "", 10);
   const updatedAtMs = Number.parseInt(values.updated_at ?? "", 10);
   if (!id || !name || !prompt || !rrule) return null;
@@ -7592,6 +7805,8 @@ function parseAutomationToml(raw) {
     rrule,
     status: statusValue,
     targetThreadId,
+    cwds,
+    extraTomlLines,
     createdAtMs: Number.isFinite(createdAtMs) ? createdAtMs : null,
     updatedAtMs: Number.isFinite(updatedAtMs) ? updatedAtMs : null,
     nextRunAtMs: null
@@ -7605,11 +7820,19 @@ function serializeAutomationToml(record) {
     `name = ${serializeTomlString(record.name)}`,
     `prompt = ${serializeTomlString(record.prompt)}`,
     `status = ${serializeTomlString(record.status)}`,
-    `rrule = ${serializeTomlString(record.rrule)}`,
-    `target_thread_id = ${serializeTomlString(record.targetThreadId ?? "")}`,
+    `rrule = ${serializeTomlString(record.rrule)}`
+  ];
+  if (record.targetThreadId) {
+    lines.push(`target_thread_id = ${serializeTomlString(record.targetThreadId)}`);
+  }
+  if (record.cwds.length > 0) {
+    lines.push(`cwds = ${serializeTomlStringArray(record.cwds)}`);
+  }
+  lines.push(
     `created_at = ${String(record.createdAtMs ?? Date.now())}`,
     `updated_at = ${String(record.updatedAtMs ?? Date.now())}`
-  ];
+  );
+  lines.push(...record.extraTomlLines);
   return `${lines.join("\n")}
 `;
 }
@@ -7693,6 +7916,8 @@ async function writeThreadHeartbeatAutomation(input) {
     rrule,
     status: input.status,
     targetThreadId: threadId,
+    cwds: [],
+    extraTomlLines: existing?.extraTomlLines ?? [],
     createdAtMs: existing?.createdAtMs ?? now,
     updatedAtMs: now,
     nextRunAtMs: null
@@ -7721,6 +7946,114 @@ async function deleteThreadHeartbeatAutomation(threadId, automationId = "") {
   await Promise.all(automations.map((automation) => rm4(join6(getCodexAutomationsDir(), automation.id), { recursive: true, force: true })));
   return true;
 }
+async function listProjectCronAutomations() {
+  const automationRoot = getCodexAutomationsDir();
+  const next = {};
+  let entries;
+  try {
+    entries = await readdir2(automationRoot, { withFileTypes: true });
+  } catch {
+    return next;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const automation = await readAutomationRecordFromFile(join6(automationRoot, entry.name, "automation.toml"));
+    if (!automation || automation.kind !== "cron" || automation.cwds.length === 0) continue;
+    for (const cwd of automation.cwds) {
+      next[cwd] = [...next[cwd] ?? [], automation];
+    }
+  }
+  for (const automations of Object.values(next)) {
+    automations.sort((first, second) => {
+      const firstCreatedAt = first.createdAtMs ?? 0;
+      const secondCreatedAt = second.createdAtMs ?? 0;
+      if (firstCreatedAt !== secondCreatedAt) return firstCreatedAt - secondCreatedAt;
+      return first.id.localeCompare(second.id);
+    });
+  }
+  return next;
+}
+async function readProjectCronAutomations(projectName) {
+  const all = await listProjectCronAutomations();
+  return all[projectName] ?? [];
+}
+async function readProjectCronAutomation(projectName, automationId = "") {
+  const automations = await readProjectCronAutomations(projectName);
+  if (automationId) return automations.find((automation) => automation.id === automationId) ?? null;
+  return automations[0] ?? null;
+}
+async function writeProjectCronAutomation(input) {
+  const projectName = input.projectName.trim();
+  const name = input.name.trim();
+  const prompt = input.prompt.trim();
+  const rrule = input.rrule.trim();
+  if (!projectName || !name || !prompt || !rrule) {
+    throw new Error("projectName, name, prompt, and rrule are required");
+  }
+  if (!isAbsoluteLikePath(projectName)) {
+    throw new Error("Project automation cwd must be an absolute path");
+  }
+  const automationRoot = getCodexAutomationsDir();
+  await mkdir4(automationRoot, { recursive: true });
+  const existing = input.id ? await readProjectCronAutomation(projectName, input.id.trim()) : null;
+  const entries = await readdir2(automationRoot, { withFileTypes: true }).catch(() => []);
+  const existingIds = new Set(entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name));
+  const id = existing?.id ?? resolveUniqueAutomationId(existingIds, projectName, name);
+  const automationDir = join6(automationRoot, id);
+  const now = Date.now();
+  const record = {
+    id,
+    kind: "cron",
+    name,
+    prompt,
+    rrule,
+    status: input.status,
+    targetThreadId: null,
+    cwds: Array.from(/* @__PURE__ */ new Set([...existing?.cwds ?? [], projectName])),
+    extraTomlLines: existing?.extraTomlLines ?? [],
+    createdAtMs: existing?.createdAtMs ?? now,
+    updatedAtMs: now,
+    nextRunAtMs: null
+  };
+  await mkdir4(automationDir, { recursive: true });
+  await writeFile4(join6(automationDir, "automation.toml"), serializeAutomationToml(record), "utf8");
+  const memoryPath = join6(automationDir, "memory.md");
+  try {
+    await stat4(memoryPath);
+  } catch {
+    await writeFile4(memoryPath, "", "utf8");
+  }
+  return record;
+}
+async function deleteProjectCronAutomation(projectName, automationId = "") {
+  const normalizedProjectName = projectName.trim();
+  const normalizedAutomationId = automationId.trim();
+  if (!normalizedProjectName || !isAbsoluteLikePath(normalizedProjectName)) return false;
+  if (normalizedAutomationId) {
+    const automation = await readProjectCronAutomation(normalizedProjectName, normalizedAutomationId);
+    if (!automation) return false;
+    const remainingCwds = automation.cwds.filter((cwd) => cwd !== normalizedProjectName);
+    if (remainingCwds.length > 0) {
+      const record = { ...automation, cwds: remainingCwds, updatedAtMs: Date.now() };
+      await writeFile4(join6(getCodexAutomationsDir(), automation.id, "automation.toml"), serializeAutomationToml(record), "utf8");
+    } else {
+      await rm4(join6(getCodexAutomationsDir(), automation.id), { recursive: true, force: true });
+    }
+    return true;
+  }
+  const automations = await readProjectCronAutomations(normalizedProjectName);
+  if (automations.length === 0) return false;
+  await Promise.all(automations.map(async (automation) => {
+    const remainingCwds = automation.cwds.filter((cwd) => cwd !== normalizedProjectName);
+    if (remainingCwds.length > 0) {
+      const record = { ...automation, cwds: remainingCwds, updatedAtMs: Date.now() };
+      await writeFile4(join6(getCodexAutomationsDir(), automation.id, "automation.toml"), serializeAutomationToml(record), "utf8");
+      return;
+    }
+    await rm4(join6(getCodexAutomationsDir(), automation.id), { recursive: true, force: true });
+  }));
+  return true;
+}
 var MAX_THREAD_TITLES = 500;
 var EMPTY_THREAD_TITLE_CACHE = { titles: {}, order: [] };
 var PINNED_THREAD_IDS_KEY = "pinned-thread-ids";
@@ -8463,6 +8796,8 @@ var AppServerProcess = class {
     this.appServerArgs = buildAppServerArgs();
     this.streamEventsByThreadId = /* @__PURE__ */ new Map();
     this.lastThreadReadSnapshotByThreadId = /* @__PURE__ */ new Map();
+    this.threadTurnPageReadCacheByThreadId = /* @__PURE__ */ new Map();
+    this.threadTurnPageReadPromiseByThreadId = /* @__PURE__ */ new Map();
     this.capturedItemsByThreadId = /* @__PURE__ */ new Map();
     this.liveStateCache = /* @__PURE__ */ new Map();
     this.chatgptAuthRefreshPromise = null;
@@ -8575,7 +8910,10 @@ var AppServerProcess = class {
     this.recordStreamEvent(notification);
     this.captureItemFromNotification(notification);
     const nThreadId = this.extractThreadIdFromParams(notification.params);
-    if (nThreadId) this.invalidateLiveStateCache(nThreadId);
+    if (nThreadId) {
+      this.invalidateLiveStateCache(nThreadId);
+      this.threadTurnPageReadCacheByThreadId.delete(nThreadId);
+    }
     for (const listener of this.notificationListeners) {
       listener(notification);
     }
@@ -8619,10 +8957,33 @@ var AppServerProcess = class {
   }
   storeThreadReadSnapshot(threadId, snapshot) {
     this.lastThreadReadSnapshotByThreadId.set(threadId, snapshot);
+    this.threadTurnPageReadCacheByThreadId.delete(threadId);
   }
   getLastThreadReadSnapshot(threadId) {
     return this.lastThreadReadSnapshotByThreadId.get(threadId) ?? null;
   }
+  async readThreadForTurnPage(threadId) {
+    const now = Date.now();
+    const cached = this.threadTurnPageReadCacheByThreadId.get(threadId);
+    if (cached && cached.expiresAt > now) return cached.result;
+    if (cached) this.threadTurnPageReadCacheByThreadId.delete(threadId);
+    const pending = this.threadTurnPageReadPromiseByThreadId.get(threadId);
+    if (pending) return pending;
+    const promise = this.rpc("thread/read", {
+      threadId,
+      includeTurns: true
+    }).then((result) => {
+      this.threadTurnPageReadCacheByThreadId.set(threadId, {
+        result,
+        expiresAt: Date.now() + THREAD_TURN_PAGE_READ_CACHE_TTL_MS
+      });
+      return result;
+    }).finally(() => {
+      this.threadTurnPageReadPromiseByThreadId.delete(threadId);
+    });
+    this.threadTurnPageReadPromiseByThreadId.set(threadId, promise);
+    return promise;
+  }
   cacheLiveState(threadId, data, turnCount, sessionSize) {
     this.liveStateCache.set(threadId, { data, turnCount, sessionSize });
   }
@@ -9291,11 +9652,10 @@ async function buildThreadSearchIndex(appServer) {
   const docsById = new Map(docs.map((doc) => [doc.id, doc]));
   return { docsById };
 }
-function createCodexBridgeMiddleware(options = {}) {
+function createCodexBridgeMiddleware() {
   const { appServer, terminalManager, methodCatalog, telegramBridge, backendQueueProcessor } = getSharedBridgeState();
   let threadSearchIndex = null;
   let threadSearchIndexPromise = null;
-  let backgroundServicesStarted = false;
   async function getThreadSearchIndex() {
     if (threadSearchIndex) return threadSearchIndex;
     if (!threadSearchIndexPromise) {
@@ -9308,21 +9668,14 @@ function createCodexBridgeMiddleware(options = {}) {
     }
     return threadSearchIndexPromise;
   }
-  function startBackgroundServices() {
-    if (backgroundServicesStarted) return;
-    backgroundServicesStarted = true;
-    void initializeSkillsSyncOnStartup(appServer);
-    void readTelegramBridgeConfig().then((config) => {
-      if (!config.botToken) return;
-      telegramBridge.configureToken(config.botToken);
-      telegramBridge.configureAllowedUserIds(config.allowedUserIds);
-      telegramBridge.start();
-    }).catch(() => {
-    });
-  }
-  if (options.startBackgroundServices !== false) {
-    startBackgroundServices();
-  }
+  void initializeSkillsSyncOnStartup(appServer);
+  void readTelegramBridgeConfig().then((config) => {
+    if (!config.botToken) return;
+    telegramBridge.configureToken(config.botToken);
+    telegramBridge.configureAllowedUserIds(config.allowedUserIds);
+    telegramBridge.start();
+  }).catch(() => {
+  });
   const middleware = async (req, res, next) => {
     const requestStartNs = process.hrtime.bigint();
     const rawUrl = req.url ?? "";
@@ -9413,11 +9766,7 @@ function createCodexBridgeMiddleware(options = {}) {
       }
       if (url.pathname.startsWith("/codex-api/free-mode")) {
         let readFreeModeState2 = function() {
-          const state = ensureDefaultFreeModeStateForMissingAuthSync(statePath) ?? { enabled: false, apiKey: null, model: FREE_MODE_DEFAULT_MODEL };
-          if (state.provider === "opencode-zen" && !state.model?.trim()) {
-            return { ...state, model: OPENCODE_ZEN_DEFAULT_MODEL };
-          }
-          return state;
+          return ensureDefaultFreeModeStateForMissingAuthSync(statePath) ?? { enabled: false, apiKey: null, model: FREE_MODE_DEFAULT_MODEL };
         };
         var readFreeModeState = readFreeModeState2;
         const statePath = join6(getCodexHomeDir3(), FREE_MODE_STATE_FILE);
@@ -9569,7 +9918,7 @@ function createCodexBridgeMiddleware(options = {}) {
             if (resolvedKey) {
               prevKeys[providerType] = resolvedKey;
             }
-            const resolvedModel = providerType === "openrouter" ? current.model || FREE_MODE_DEFAULT_MODEL : providerType === "custom" ? await fetchCustomEndpointDefaultModel(baseUrl, resolvedKey) : OPENCODE_ZEN_DEFAULT_MODEL;
+            const resolvedModel = providerType === "openrouter" ? current.model || FREE_MODE_DEFAULT_MODEL : providerType === "custom" ? await fetchCustomEndpointDefaultModel(baseUrl, resolvedKey) : "";
             const state = {
               enabled: true,
               apiKey: resolvedKey,
@@ -9714,7 +10063,20 @@ function createCodexBridgeMiddleware(options = {}) {
           setJson4(res, 400, { error: "Invalid body: expected { method, params? }" });
           return;
         }
-        const rpcResult = await callRpcWithArchiveRecovery(appServer, body.method, body.params ?? null);
+        if (body.method === "account/rateLimits/read" && !await hasUsableCodexAuth()) {
+          setJson4(res, 200, { result: null });
+          return;
+        }
+        let rpcResult;
+        try {
+          rpcResult = await callRpcWithArchiveRecovery(appServer, body.method, body.params ?? null);
+        } catch (error) {
+          if (body.method === "account/rateLimits/read" && isUnauthenticatedRateLimitError(error)) {
+            setJson4(res, 200, { result: null });
+            return;
+          }
+          throw error;
+        }
         const trimmedResult = trimThreadTurnsInRpcResult(body.method, rpcResult);
         const sanitizedResult = await sanitizeThreadTurnsInlinePayloads(body.method, trimmedResult);
         const result = THREAD_METHODS_WITH_TURNS.has(body.method) ? await mergeSessionSkillInputsIntoThreadResult(sanitizedResult) : sanitizedResult;
@@ -9729,6 +10091,61 @@ function createCodexBridgeMiddleware(options = {}) {
         setJson4(res, 200, { result });
         return;
       }
+      if (req.method === "GET" && url.pathname === "/codex-api/thread-turn-page") {
+        try {
+          const threadId = url.searchParams.get("threadId")?.trim() ?? "";
+          const beforeTurnId = url.searchParams.get("beforeTurnId")?.trim() ?? "";
+          const limitRaw = url.searchParams.get("limit")?.trim() ?? String(THREAD_RESPONSE_TURN_LIMIT);
+          const limit = Math.max(1, Math.min(50, Number.parseInt(limitRaw, 10) || THREAD_RESPONSE_TURN_LIMIT));
+          if (!threadId) {
+            setJson4(res, 400, { error: "Missing threadId" });
+            return;
+          }
+          const threadReadResult = await appServer.readThreadForTurnPage(threadId);
+          const record = asRecord5(threadReadResult);
+          const thread = asRecord5(record?.thread);
+          if (!record || !thread) {
+            setJson4(res, 502, { error: "thread/read returned an invalid thread response" });
+            return;
+          }
+          const turns = Array.isArray(thread.turns) ? thread.turns : [];
+          const beforeIndex = beforeTurnId ? turns.findIndex((turn) => asRecord5(turn)?.id === beforeTurnId) : turns.length;
+          if (beforeTurnId && beforeIndex < 0) {
+            setJson4(res, 200, {
+              result: {
+                ...record,
+                thread: {
+                  ...thread,
+                  turns: []
+                }
+              },
+              startTurnIndex: 0,
+              hasMoreOlder: false
+            });
+            return;
+          }
+          const endIndex = beforeIndex;
+          const startIndex = Math.max(0, endIndex - limit);
+          const pageTurns = turns.slice(startIndex, endIndex);
+          const pagedResult = {
+            ...record,
+            thread: {
+              ...thread,
+              turns: pageTurns
+            }
+          };
+          const sanitized = await sanitizeThreadTurnsInlinePayloads("thread/read", pagedResult);
+          const result = await mergeSessionSkillInputsIntoThreadResult(sanitized);
+          setJson4(res, 200, {
+            result,
+            startTurnIndex: startIndex,
+            hasMoreOlder: startIndex > 0
+          });
+        } catch (error) {
+          setJson4(res, 500, { error: getErrorMessage5(error, "Failed to load earlier thread messages") });
+        }
+        return;
+      }
       if (req.method === "GET" && url.pathname === "/codex-api/thread-file-change-fallback") {
         const threadId = url.searchParams.get("threadId")?.trim() ?? "";
         if (!threadId) {
@@ -10018,28 +10435,21 @@ function createCodexBridgeMiddleware(options = {}) {
               try {
                 const modelsUrl = "https://opencode.ai/zen/v1/models";
                 const headers = {};
-                const hasZenApiKey = Boolean(fmState.apiKey && fmState.apiKey !== "dummy");
-                if (hasZenApiKey) {
+                if (fmState.apiKey && fmState.apiKey !== "dummy") {
                   headers["Authorization"] = `Bearer ${fmState.apiKey}`;
                 }
                 const resp = await fetch(modelsUrl, { headers, signal: AbortSignal.timeout(8e3) });
                 if (resp.ok) {
                   const json = await resp.json();
                   const allIds = (json.data ?? []).map((m) => m.id).filter(Boolean);
-                  setJson4(res, 200, {
-                    data: getOpenCodeZenFreeModelIds(allIds),
-                    exclusive: true,
-                    source: "opencode-zen"
-                  });
+                  const freeIds = allIds.filter((id) => id.endsWith("-free") || id === "big-pickle");
+                  const paidIds = allIds.filter((id) => !id.endsWith("-free") && id !== "big-pickle");
+                  setJson4(res, 200, { data: [...freeIds, ...paidIds], exclusive: true, source: "opencode-zen" });
                   return;
                 }
               } catch {
               }
-              setJson4(res, 200, {
-                data: getOpenCodeZenFreeModelIds([]),
-                exclusive: true,
-                source: "opencode-zen"
-              });
+              setJson4(res, 200, { data: ["big-pickle", "minimax-m2.5-free", "nemotron-3-super-free", "trinity-large-preview-free"], exclusive: true, source: "opencode-zen" });
               return;
             }
             if (fmState.provider === "custom" && fmState.customBaseUrl) {
@@ -10342,7 +10752,7 @@ function createCodexBridgeMiddleware(options = {}) {
           if (currentBranch && !branchActivityByName.has(currentBranch)) {
             branchActivityByName.set(currentBranch, { timestamp: Number.MAX_SAFE_INTEGER, isRemote: false });
           }
-          const options2 = Array.from(branchActivityByName.entries()).map(([value, metadata]) => ({
+          const options = Array.from(branchActivityByName.entries()).map(([value, metadata]) => ({
             value,
             label: value,
             isCurrent: value === currentBranch,
@@ -10356,7 +10766,7 @@ function createCodexBridgeMiddleware(options = {}) {
           setJson4(res, 200, {
             data: {
               ...state,
-              options: options2
+              options
             }
           });
         } catch (error) {
@@ -10602,6 +11012,18 @@ function createCodexBridgeMiddleware(options = {}) {
         setJson4(res, 200, { data: { path: normalizedPath } });
         return;
       }
+      if (req.method === "POST" && url.pathname === "/codex-api/github-clone") {
+        const payload = asRecord5(await readJsonBody2(req));
+        const repoUrl = typeof payload?.url === "string" ? payload.url.trim() : "";
+        const basePath = typeof payload?.basePath === "string" ? payload.basePath.trim() : "";
+        try {
+          const clonedPath = await cloneGithubRepositoryIntoBase(repoUrl, basePath);
+          setJson4(res, 200, { data: { path: clonedPath } });
+        } catch (error) {
+          setJson4(res, 400, { error: error instanceof Error ? error.message : "Failed to clone GitHub repository" });
+        }
+        return;
+      }
       if (req.method === "POST" && url.pathname === "/codex-api/projectless-thread-cwd") {
         const payload = asRecord5(await readJsonBody2(req));
         const prompt = typeof payload?.prompt === "string" ? payload.prompt : null;
@@ -10730,6 +11152,11 @@ function createCodexBridgeMiddleware(options = {}) {
         setJson4(res, 200, { data: automationsByThreadId });
         return;
       }
+      if (req.method === "GET" && url.pathname === "/codex-api/project-automations") {
+        const automationsByProjectName = await listProjectCronAutomations();
+        setJson4(res, 200, { data: automationsByProjectName });
+        return;
+      }
       if (req.method === "GET" && url.pathname === "/codex-api/thread-automation") {
         const threadId = url.searchParams.get("threadId")?.trim() ?? "";
         const automationId = url.searchParams.get("automationId")?.trim() ?? "";
@@ -10741,6 +11168,17 @@ function createCodexBridgeMiddleware(options = {}) {
         setJson4(res, 200, { data: automation });
         return;
       }
+      if (req.method === "GET" && url.pathname === "/codex-api/project-automation") {
+        const projectName = url.searchParams.get("projectName")?.trim() ?? "";
+        const automationId = url.searchParams.get("automationId")?.trim() ?? "";
+        if (!projectName) {
+          setJson4(res, 400, { error: "Missing projectName" });
+          return;
+        }
+        const automation = automationId ? await readProjectCronAutomation(projectName, automationId) : await readProjectCronAutomations(projectName);
+        setJson4(res, 200, { data: automation });
+        return;
+      }
       if (req.method === "POST" && url.pathname === "/codex-api/thread-search") {
         const payload = asRecord5(await readJsonBody2(req));
         const query = typeof payload?.query === "string" ? payload.query.trim() : "";
@@ -10799,6 +11237,26 @@ function createCodexBridgeMiddleware(options = {}) {
         setJson4(res, 200, { data: automation });
         return;
       }
+      if (req.method === "PUT" && url.pathname === "/codex-api/project-automation") {
+        const payload = asRecord5(await readJsonBody2(req));
+        const projectName = typeof payload?.projectName === "string" ? payload.projectName.trim() : "";
+        const id = typeof payload?.id === "string" ? payload.id.trim() : "";
+        const name = typeof payload?.name === "string" ? payload.name.trim() : "";
+        const prompt = typeof payload?.prompt === "string" ? payload.prompt.trim() : "";
+        const rrule = typeof payload?.rrule === "string" ? payload.rrule.trim() : "";
+        const status = payload?.status === "PAUSED" ? "PAUSED" : "ACTIVE";
+        if (!projectName || !name || !prompt || !rrule) {
+          setJson4(res, 400, { error: "projectName, name, prompt, and rrule are required" });
+          return;
+        }
+        if (!isAbsoluteLikePath(projectName)) {
+          setJson4(res, 400, { error: "Project automation cwd must be an absolute path" });
+          return;
+        }
+        const automation = await writeProjectCronAutomation({ projectName, id, name, prompt, rrule, status });
+        setJson4(res, 200, { data: automation });
+        return;
+      }
       if (req.method === "POST" && url.pathname === "/codex-api/thread-automation/run") {
         const payload = asRecord5(await readJsonBody2(req));
         const threadId = typeof payload?.threadId === "string" ? payload.threadId.trim() : "";
@@ -10828,6 +11286,17 @@ function createCodexBridgeMiddleware(options = {}) {
         setJson4(res, 200, { data: { removed } });
         return;
       }
+      if (req.method === "DELETE" && url.pathname === "/codex-api/project-automation") {
+        const projectName = url.searchParams.get("projectName")?.trim() ?? "";
+        const automationId = url.searchParams.get("automationId")?.trim() ?? "";
+        if (!projectName) {
+          setJson4(res, 400, { error: "Missing projectName" });
+          return;
+        }
+        const removed = await deleteProjectCronAutomation(projectName, automationId);
+        setJson4(res, 200, { data: { removed } });
+        return;
+      }
       if (req.method === "POST" && url.pathname === "/codex-api/telegram/configure-bot") {
         const payload = asRecord5(await readJsonBody2(req));
         const botToken = typeof payload?.botToken === "string" ? payload.botToken.trim() : "";
@@ -10913,7 +11382,6 @@ data: ${JSON.stringify({ ok: true })}
     backendQueueProcessor.dispose();
     appServer.dispose();
   };
-  middleware.startBackgroundServices = startBackgroundServices;
   middleware.subscribeNotifications = (listener) => {
     const unsubscribeAppServer = appServer.onNotification((notification) => {
       listener({
@@ -11615,9 +12083,7 @@ function readWildcardPathParam(value) {
 }
 function createServer(options = {}) {
   const app = express();
-  const bridge = createCodexBridgeMiddleware({
-    startBackgroundServices: options.deferBridgeBackgroundServices !== true
-  });
+  const bridge = createCodexBridgeMiddleware();
   const authSession = options.password ? createAuthSession(options.password) : null;
   if (authSession) {
     app.use(authSession.middleware);
@@ -11763,7 +12229,6 @@ function createServer(options = {}) {
   return {
     app,
     dispose: () => bridge.dispose(),
-    startBridgeBackgroundServices: () => bridge.startBackgroundServices(),
     attachWebSocket: (server) => {
       const wss = new WebSocketServer({ noServer: true });
       server.on("upgrade", (req, socket, head) => {
@@ -12243,15 +12708,10 @@ async function startServer(options) {
   const passwordResolution = resolvePassword(options.password);
   const password = passwordResolution.password;
   const generatedPasswordPath = password && passwordResolution.generated ? await persistGeneratedPassword(password) : null;
-  const { app, dispose, attachWebSocket, startBridgeBackgroundServices } = createServer({
-    password,
-    deferBridgeBackgroundServices: true
-  });
+  const { app, dispose, attachWebSocket } = createServer({ password });
   const server = createServer2(app);
   attachWebSocket(server);
   const port = await listenWithFallback(server, requestedPort);
-  process.env.CODEXUI_SERVER_PORT = String(port);
-  startBridgeBackgroundServices();
   let tunnelChild = null;
   let tunnelUrl = null;
   if (options.tunnel) {