codexapp 0.1.23 → 0.1.25

package/dist-cli/index.js

@@ -2,13 +2,14 @@
 
 // src/cli/index.ts
 import { createServer as createServer2 } from "http";
-import { existsSync as existsSync2 } from "fs";
+import { chmodSync, createWriteStream, existsSync as existsSync2, mkdirSync } from "fs";
 import { readFile as readFile2 } from "fs/promises";
 import { homedir as homedir2 } from "os";
 import { join as join3 } from "path";
 import { spawn as spawn2, spawnSync } from "child_process";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { dirname as dirname2 } from "path";
+import { get as httpsGet } from "https";
 import { Command } from "commander";
 import qrcode from "qrcode-terminal";
 
@@ -50,6 +51,46 @@ function setJson(res, statusCode, payload) {
   res.setHeader("Content-Type", "application/json; charset=utf-8");
   res.end(JSON.stringify(payload));
 }
+function extractThreadMessageText(threadReadPayload) {
+  const payload = asRecord(threadReadPayload);
+  const thread = asRecord(payload?.thread);
+  const turns = Array.isArray(thread?.turns) ? thread.turns : [];
+  const parts = [];
+  for (const turn of turns) {
+    const turnRecord = asRecord(turn);
+    const items = Array.isArray(turnRecord?.items) ? turnRecord.items : [];
+    for (const item of items) {
+      const itemRecord = asRecord(item);
+      const type = typeof itemRecord?.type === "string" ? itemRecord.type : "";
+      if (type === "agentMessage" && typeof itemRecord?.text === "string" && itemRecord.text.trim().length > 0) {
+        parts.push(itemRecord.text.trim());
+        continue;
+      }
+      if (type === "userMessage") {
+        const content = Array.isArray(itemRecord?.content) ? itemRecord.content : [];
+        for (const block of content) {
+          const blockRecord = asRecord(block);
+          if (blockRecord?.type === "text" && typeof blockRecord.text === "string" && blockRecord.text.trim().length > 0) {
+            parts.push(blockRecord.text.trim());
+          }
+        }
+        continue;
+      }
+      if (type === "commandExecution") {
+        const command = typeof itemRecord?.command === "string" ? itemRecord.command.trim() : "";
+        const output = typeof itemRecord?.aggregatedOutput === "string" ? itemRecord.aggregatedOutput.trim() : "";
+        if (command) parts.push(command);
+        if (output) parts.push(output);
+      }
+    }
+  }
+  return parts.join("\n").trim();
+}
+function isExactPhraseMatch(query, doc) {
+  const q = query.trim().toLowerCase();
+  if (!q) return false;
+  return doc.title.toLowerCase().includes(q) || doc.preview.toLowerCase().includes(q) || doc.messageText.toLowerCase().includes(q);
+}
 function scoreFileCandidate(path, query) {
   if (!query) return 0;
   const lowerPath = path.toLowerCase();
@@ -892,8 +933,82 @@ function getSharedBridgeState() {
   globalScope[SHARED_BRIDGE_KEY] = created;
   return created;
 }
+async function loadAllThreadsForSearch(appServer) {
+  const threads = [];
+  let cursor = null;
+  do {
+    const response = asRecord(await appServer.rpc("thread/list", {
+      archived: false,
+      limit: 100,
+      sortKey: "updated_at",
+      cursor
+    }));
+    const data = Array.isArray(response?.data) ? response.data : [];
+    for (const row of data) {
+      const record = asRecord(row);
+      const id = typeof record?.id === "string" ? record.id : "";
+      if (!id) continue;
+      const title = typeof record?.name === "string" && record.name.trim().length > 0 ? record.name.trim() : typeof record?.preview === "string" && record.preview.trim().length > 0 ? record.preview.trim() : "Untitled thread";
+      const preview = typeof record?.preview === "string" ? record.preview : "";
+      threads.push({ id, title, preview });
+    }
+    cursor = typeof response?.nextCursor === "string" && response.nextCursor.length > 0 ? response.nextCursor : null;
+  } while (cursor);
+  const docs = [];
+  const concurrency = 4;
+  for (let offset = 0; offset < threads.length; offset += concurrency) {
+    const batch = threads.slice(offset, offset + concurrency);
+    const loaded = await Promise.all(batch.map(async (thread) => {
+      try {
+        const readResponse = await appServer.rpc("thread/read", {
+          threadId: thread.id,
+          includeTurns: true
+        });
+        const messageText = extractThreadMessageText(readResponse);
+        const searchableText = [thread.title, thread.preview, messageText].filter(Boolean).join("\n");
+        return {
+          id: thread.id,
+          title: thread.title,
+          preview: thread.preview,
+          messageText,
+          searchableText
+        };
+      } catch {
+        const searchableText = [thread.title, thread.preview].filter(Boolean).join("\n");
+        return {
+          id: thread.id,
+          title: thread.title,
+          preview: thread.preview,
+          messageText: "",
+          searchableText
+        };
+      }
+    }));
+    docs.push(...loaded);
+  }
+  return docs;
+}
+async function buildThreadSearchIndex(appServer) {
+  const docs = await loadAllThreadsForSearch(appServer);
+  const docsById = new Map(docs.map((doc) => [doc.id, doc]));
+  return { docsById };
+}
 function createCodexBridgeMiddleware() {
   const { appServer, methodCatalog } = getSharedBridgeState();
+  let threadSearchIndex = null;
+  let threadSearchIndexPromise = null;
+  async function getThreadSearchIndex() {
+    if (threadSearchIndex) return threadSearchIndex;
+    if (!threadSearchIndexPromise) {
+      threadSearchIndexPromise = buildThreadSearchIndex(appServer).then((index) => {
+        threadSearchIndex = index;
+        return index;
+      }).finally(() => {
+        threadSearchIndexPromise = null;
+      });
+    }
+    return threadSearchIndexPromise;
+  }
   const middleware = async (req, res, next) => {
     try {
       if (!req.url) {
@@ -1154,6 +1269,20 @@ function createCodexBridgeMiddleware() {
         setJson(res, 200, { data: cache });
         return;
       }
+      if (req.method === "POST" && url.pathname === "/codex-api/thread-search") {
+        const payload = asRecord(await readJsonBody(req));
+        const query = typeof payload?.query === "string" ? payload.query.trim() : "";
+        const limitRaw = typeof payload?.limit === "number" ? payload.limit : 200;
+        const limit = Math.max(1, Math.min(1e3, Math.floor(limitRaw)));
+        if (!query) {
+          setJson(res, 200, { data: { threadIds: [], indexedThreadCount: 0 } });
+          return;
+        }
+        const index = await getThreadSearchIndex();
+        const matchedIds = Array.from(index.docsById.entries()).filter(([, doc]) => isExactPhraseMatch(query, doc)).slice(0, limit).map(([id]) => id);
+        setJson(res, 200, { data: { threadIds: matchedIds, indexedThreadCount: index.docsById.size } });
+        return;
+      }
       if (req.method === "PUT" && url.pathname === "/codex-api/thread-titles") {
         const payload = asRecord(await readJsonBody(req));
         const id = typeof payload?.id === "string" ? payload.id : "";
@@ -1317,6 +1446,7 @@ data: ${JSON.stringify({ ok: true })}
     }
   };
   middleware.dispose = () => {
+    threadSearchIndex = null;
     appServer.dispose();
   };
   middleware.subscribeNotifications = (listener) => {
@@ -1721,6 +1851,79 @@ function resolveCodexCommand() {
   }
   return null;
 }
+function resolveCloudflaredCommand() {
+  if (canRun("cloudflared", ["--version"])) {
+    return "cloudflared";
+  }
+  const localCandidate = join3(homedir2(), ".local", "bin", "cloudflared");
+  if (existsSync2(localCandidate) && canRun(localCandidate, ["--version"])) {
+    return localCandidate;
+  }
+  return null;
+}
+function mapCloudflaredLinuxArch(arch) {
+  if (arch === "x64") {
+    return "amd64";
+  }
+  if (arch === "arm64") {
+    return "arm64";
+  }
+  return null;
+}
+function downloadFile(url, destination) {
+  return new Promise((resolve2, reject) => {
+    const request = (currentUrl) => {
+      httpsGet(currentUrl, (response) => {
+        const code = response.statusCode ?? 0;
+        if (code >= 300 && code < 400 && response.headers.location) {
+          response.resume();
+          request(response.headers.location);
+          return;
+        }
+        if (code !== 200) {
+          response.resume();
+          reject(new Error(`Download failed with HTTP status ${String(code)}`));
+          return;
+        }
+        const file = createWriteStream(destination, { mode: 493 });
+        response.pipe(file);
+        file.on("finish", () => {
+          file.close();
+          resolve2();
+        });
+        file.on("error", reject);
+      }).on("error", reject);
+    };
+    request(url);
+  });
+}
+async function ensureCloudflaredInstalledLinux() {
+  const current = resolveCloudflaredCommand();
+  if (current) {
+    return current;
+  }
+  if (process.platform !== "linux") {
+    return null;
+  }
+  const mappedArch = mapCloudflaredLinuxArch(process.arch);
+  if (!mappedArch) {
+    throw new Error(`cloudflared auto-install is not supported for Linux architecture: ${process.arch}`);
+  }
+  const userBinDir = join3(homedir2(), ".local", "bin");
+  mkdirSync(userBinDir, { recursive: true });
+  const destination = join3(userBinDir, "cloudflared");
+  const downloadUrl = `https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-${mappedArch}`;
+  console.log("\ncloudflared not found. Installing to ~/.local/bin...\n");
+  await downloadFile(downloadUrl, destination);
+  chmodSync(destination, 493);
+  process.env.PATH = `${userBinDir}:${process.env.PATH ?? ""}`;
+  const installed = resolveCloudflaredCommand();
+  if (!installed) {
+    throw new Error("cloudflared download completed but executable is still not available");
+  }
+  console.log("\ncloudflared installed.\n");
+  return installed;
+}
 function hasCodexAuth() {
   const codexHome = process.env.CODEX_HOME?.trim() || join3(homedir2(), ".codex");
   return existsSync2(join3(codexHome, "auth.json"));
@@ -1802,9 +2005,9 @@ function parseCloudflaredUrl(chunk) {
   }
   return urlMatch[urlMatch.length - 1] ?? null;
 }
-async function startCloudflaredTunnel(localPort) {
+async function startCloudflaredTunnel(command, localPort) {
   return new Promise((resolve2, reject) => {
-    const child = spawn2("cloudflared", ["tunnel", "--url", `http://localhost:${String(localPort)}`], {
+    const child = spawn2(command, ["tunnel", "--url", `http://localhost:${String(localPort)}`], {
       stdio: ["ignore", "pipe", "pipe"]
     });
     const timeout = setTimeout(() => {
@@ -1877,7 +2080,8 @@ async function startServer(options) {
   let tunnelUrl = null;
   if (options.tunnel) {
     try {
-      const tunnel = await startCloudflaredTunnel(port);
+      const cloudflaredCommand = await ensureCloudflaredInstalledLinux() ?? "cloudflared";
+      const tunnel = await startCloudflaredTunnel(cloudflaredCommand, port);
       tunnelChild = tunnel.process;
       tunnelUrl = tunnel.url;
     } catch (error) {