codexui-android 0.1.108 → 0.1.109

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,11 +4264,6 @@ 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;
 }
@@ -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}"}
 
@@ -5196,6 +5236,7 @@ function shellQuote(value) {
 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 +5739,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)
     }
   };
 }
@@ -5770,6 +5813,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 +7272,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;
@@ -8463,6 +8575,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 +8689,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 +8736,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 +9431,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 +9447,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 +9545,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 +9697,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,
@@ -9729,6 +9857,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 +10201,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 +10518,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 +10532,7 @@ function createCodexBridgeMiddleware(options = {}) {
           setJson4(res, 200, {
             data: {
               ...state,
-              options: options2
+              options
             }
           });
         } catch (error) {
@@ -10602,6 +10778,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;
@@ -10913,7 +11101,6 @@ data: ${JSON.stringify({ ok: true })}
     backendQueueProcessor.dispose();
     appServer.dispose();
   };
-  middleware.startBackgroundServices = startBackgroundServices;
   middleware.subscribeNotifications = (listener) => {
     const unsubscribeAppServer = appServer.onNotification((notification) => {
       listener({
@@ -11615,9 +11802,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 +11948,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 +12427,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) {