codexapp 0.1.26 → 0.1.27

package/dist-cli/index.js

@@ -21,11 +21,12 @@ import express from "express";
 
 // src/server/codexAppServerBridge.ts
 import { spawn } from "child_process";
+import { randomBytes } from "crypto";
 import { mkdtemp, readFile, readdir, rm, mkdir, stat } from "fs/promises";
 import { request as httpsRequest } from "https";
 import { homedir } from "os";
 import { tmpdir } from "os";
-import { isAbsolute, join, resolve } from "path";
+import { basename, isAbsolute, join, resolve } from "path";
 import { writeFile } from "fs/promises";
 function asRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -49,6 +50,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();
@@ -122,6 +163,55 @@ async function runCommand(command, args, options = {}) {
     });
   });
 }
+function isMissingHeadError(error) {
+  const message = getErrorMessage(error, "").toLowerCase();
+  return message.includes("not a valid object name: 'head'") || message.includes("not a valid object name: head");
+}
+function isNotGitRepositoryError(error) {
+  const message = getErrorMessage(error, "").toLowerCase();
+  return message.includes("not a git repository") || message.includes("fatal: not a git repository");
+}
+async function ensureRepoHasInitialCommit(repoRoot) {
+  const agentsPath = join(repoRoot, "AGENTS.md");
+  try {
+    await stat(agentsPath);
+  } catch {
+    await writeFile(agentsPath, "", "utf8");
+  }
+  await runCommand("git", ["add", "AGENTS.md"], { cwd: repoRoot });
+  await runCommand(
+    "git",
+    ["-c", "user.name=Codex", "-c", "user.email=codex@local", "commit", "-m", "Initialize repository for worktree support"],
+    { cwd: repoRoot }
+  );
+}
+async function runCommandCapture(command, args, options = {}) {
+  return await new Promise((resolveOutput, reject) => {
+    const proc = spawn(command, args, {
+      cwd: options.cwd,
+      env: process.env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    proc.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    proc.on("error", reject);
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolveOutput(stdout.trim());
+        return;
+      }
+      const details = [stderr.trim(), stdout.trim()].filter(Boolean).join("\n");
+      const suffix = details.length > 0 ? `: ${details}` : "";
+      reject(new Error(`Command failed (${command} ${args.join(" ")})${suffix}`));
+    });
+  });
+}
 async function detectUserSkillsDir(appServer) {
   try {
     const result = await appServer.rpc("skills/list", {});
@@ -842,8 +932,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) {
@@ -909,6 +1073,76 @@ function createCodexBridgeMiddleware() {
         setJson(res, 200, { data: { path: homedir() } });
         return;
       }
+      if (req.method === "POST" && url.pathname === "/codex-api/worktree/create") {
+        const payload = asRecord(await readJsonBody(req));
+        const rawSourceCwd = typeof payload?.sourceCwd === "string" ? payload.sourceCwd.trim() : "";
+        if (!rawSourceCwd) {
+          setJson(res, 400, { error: "Missing sourceCwd" });
+          return;
+        }
+        const sourceCwd = isAbsolute(rawSourceCwd) ? rawSourceCwd : resolve(rawSourceCwd);
+        try {
+          const sourceInfo = await stat(sourceCwd);
+          if (!sourceInfo.isDirectory()) {
+            setJson(res, 400, { error: "sourceCwd is not a directory" });
+            return;
+          }
+        } catch {
+          setJson(res, 404, { error: "sourceCwd does not exist" });
+          return;
+        }
+        try {
+          let gitRoot = "";
+          try {
+            gitRoot = await runCommandCapture("git", ["rev-parse", "--show-toplevel"], { cwd: sourceCwd });
+          } catch (error) {
+            if (!isNotGitRepositoryError(error)) throw error;
+            await runCommand("git", ["init"], { cwd: sourceCwd });
+            gitRoot = await runCommandCapture("git", ["rev-parse", "--show-toplevel"], { cwd: sourceCwd });
+          }
+          const repoName = basename(gitRoot) || "repo";
+          const worktreesRoot = join(getCodexHomeDir(), "worktrees");
+          await mkdir(worktreesRoot, { recursive: true });
+          let worktreeId = "";
+          let worktreeParent = "";
+          let worktreeCwd = "";
+          for (let attempt = 0; attempt < 12; attempt += 1) {
+            const candidate = randomBytes(2).toString("hex");
+            const parent = join(worktreesRoot, candidate);
+            try {
+              await stat(parent);
+              continue;
+            } catch {
+              worktreeId = candidate;
+              worktreeParent = parent;
+              worktreeCwd = join(parent, repoName);
+              break;
+            }
+          }
+          if (!worktreeId || !worktreeParent || !worktreeCwd) {
+            throw new Error("Failed to allocate a unique worktree id");
+          }
+          const branch = `codex/${worktreeId}`;
+          await mkdir(worktreeParent, { recursive: true });
+          try {
+            await runCommand("git", ["worktree", "add", "-b", branch, worktreeCwd, "HEAD"], { cwd: gitRoot });
+          } catch (error) {
+            if (!isMissingHeadError(error)) throw error;
+            await ensureRepoHasInitialCommit(gitRoot);
+            await runCommand("git", ["worktree", "add", "-b", branch, worktreeCwd, "HEAD"], { cwd: gitRoot });
+          }
+          setJson(res, 200, {
+            data: {
+              cwd: worktreeCwd,
+              branch,
+              gitRoot
+            }
+          });
+        } catch (error) {
+          setJson(res, 500, { error: getErrorMessage(error, "Failed to create worktree") });
+        }
+        return;
+      }
       if (req.method === "PUT" && url.pathname === "/codex-api/workspace-roots-state") {
         const payload = await readJsonBody(req);
         const record = asRecord(payload);
@@ -1034,6 +1268,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 : "";
@@ -1197,6 +1445,7 @@ data: ${JSON.stringify({ ok: true })}
     }
   };
   middleware.dispose = () => {
+    threadSearchIndex = null;
     appServer.dispose();
   };
   middleware.subscribeNotifications = (listener) => {
@@ -1211,7 +1460,7 @@ data: ${JSON.stringify({ ok: true })}
 }
 
 // src/server/authMiddleware.ts
-import { randomBytes, timingSafeEqual } from "crypto";
+import { randomBytes as randomBytes2, timingSafeEqual } from "crypto";
 var TOKEN_COOKIE = "codex_web_local_token";
 function constantTimeCompare(a, b) {
   const bufA = Buffer.from(a);
@@ -1309,7 +1558,7 @@ function createAuthSession(password) {
             res.status(401).json({ error: "Invalid password" });
             return;
           }
-          const token = randomBytes(32).toString("hex");
+          const token = randomBytes2(32).toString("hex");
           validTokens.add(token);
           res.setHeader("Set-Cookie", `${TOKEN_COOKIE}=${token}; Path=/; HttpOnly; SameSite=Strict`);
           res.json({ ok: true });