codexapp 0.1.44 → 0.1.46

package/dist-cli/index.js

@@ -2,12 +2,12 @@
 
 // src/cli/index.ts
 import { createServer as createServer2 } from "http";
-import { chmodSync, createWriteStream, existsSync as existsSync3, mkdirSync } from "fs";
-import { readFile as readFile4 } from "fs/promises";
+import { chmodSync, createWriteStream, existsSync as existsSync4, mkdirSync } from "fs";
+import { readFile as readFile4, stat as stat5, writeFile as writeFile4 } from "fs/promises";
 import { homedir as homedir3, networkInterfaces } from "os";
-import { join as join5 } from "path";
+import { isAbsolute as isAbsolute3, join as join5, resolve as resolve2 } from "path";
 import { spawn as spawn3, spawnSync } from "child_process";
-import { createInterface } from "readline/promises";
+import { createInterface as createInterface2 } from "readline/promises";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { dirname as dirname3 } from "path";
 import { get as httpsGet } from "https";
@@ -17,7 +17,7 @@ import qrcode from "qrcode-terminal";
 // src/server/httpServer.ts
 import { fileURLToPath } from "url";
 import { dirname as dirname2, extname as extname2, isAbsolute as isAbsolute2, join as join4 } from "path";
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 import { writeFile as writeFile3, stat as stat4 } from "fs/promises";
 import express from "express";
 
@@ -25,10 +25,13 @@ import express from "express";
 import { spawn as spawn2 } from "child_process";
 import { randomBytes } from "crypto";
 import { mkdtemp as mkdtemp2, readFile as readFile2, mkdir as mkdir2, stat as stat2 } from "fs/promises";
+import { createReadStream } from "fs";
+import { request as httpRequest } from "http";
 import { request as httpsRequest } from "https";
 import { homedir as homedir2 } from "os";
 import { tmpdir as tmpdir2 } from "os";
 import { basename, isAbsolute, join as join2, resolve } from "path";
+import { createInterface } from "readline";
 import { writeFile as writeFile2 } from "fs/promises";
 
 // src/server/skillsRoutes.ts
@@ -68,7 +71,7 @@ function getSkillsInstallDir() {
   return join(getCodexHomeDir(), "skills");
 }
 async function runCommand(command, args, options = {}) {
-  await new Promise((resolve2, reject) => {
+  await new Promise((resolve3, reject) => {
     const proc = spawn(command, args, {
       cwd: options.cwd,
       env: process.env,
@@ -85,7 +88,7 @@ async function runCommand(command, args, options = {}) {
     proc.on("error", reject);
     proc.on("close", (code) => {
       if (code === 0) {
-        resolve2();
+        resolve3();
         return;
       }
       const details = [stderr.trim(), stdout.trim()].filter(Boolean).join("\n");
@@ -95,7 +98,7 @@ async function runCommand(command, args, options = {}) {
   });
 }
 async function runCommandWithOutput(command, args, options = {}) {
-  return await new Promise((resolve2, reject) => {
+  return await new Promise((resolve3, reject) => {
     const proc = spawn(command, args, {
       cwd: options.cwd,
       env: process.env,
@@ -112,7 +115,7 @@ async function runCommandWithOutput(command, args, options = {}) {
     proc.on("error", reject);
     proc.on("close", (code) => {
       if (code === 0) {
-        resolve2(stdout.trim());
+        resolve3(stdout.trim());
         return;
       }
       const details = [stderr.trim(), stdout.trim()].filter(Boolean).join("\n");
@@ -157,9 +160,9 @@ async function getGhToken() {
     proc.stdout.on("data", (d) => {
       out += d.toString();
     });
-    return new Promise((resolve2) => {
-      proc.on("close", (code) => resolve2(code === 0 ? out.trim() : null));
-      proc.on("error", () => resolve2(null));
+    return new Promise((resolve3) => {
+      proc.on("close", (code) => resolve3(code === 0 ? out.trim() : null));
+      proc.on("error", () => resolve3(null));
     });
   } catch {
     return null;
@@ -398,7 +401,7 @@ async function ensurePrivateForkFromUpstream(token, username, repoName) {
       ready = true;
       break;
     }
-    await new Promise((resolve2) => setTimeout(resolve2, 1e3));
+    await new Promise((resolve3) => setTimeout(resolve3, 1e3));
   }
   if (!ready) throw new Error("Private mirror repo was created but is not available yet");
   if (!created) return;
@@ -1193,7 +1196,7 @@ function scoreFileCandidate(path, query) {
   return 10;
 }
 async function listFilesWithRipgrep(cwd) {
-  return await new Promise((resolve2, reject) => {
+  return await new Promise((resolve3, reject) => {
     const proc = spawn2("rg", ["--files", "--hidden", "-g", "!.git", "-g", "!node_modules"], {
       cwd,
       env: process.env,
@@ -1211,7 +1214,7 @@ async function listFilesWithRipgrep(cwd) {
     proc.on("close", (code) => {
       if (code === 0) {
         const rows = stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-        resolve2(rows);
+        resolve3(rows);
         return;
       }
       const details = [stderr.trim(), stdout.trim()].filter(Boolean).join("\n");
@@ -1224,7 +1227,7 @@ function getCodexHomeDir2() {
   return codexHome && codexHome.length > 0 ? codexHome : join2(homedir2(), ".codex");
 }
 async function runCommand2(command, args, options = {}) {
-  await new Promise((resolve2, reject) => {
+  await new Promise((resolve3, reject) => {
     const proc = spawn2(command, args, {
       cwd: options.cwd,
       env: process.env,
@@ -1241,7 +1244,7 @@ async function runCommand2(command, args, options = {}) {
     proc.on("error", reject);
     proc.on("close", (code) => {
       if (code === 0) {
-        resolve2();
+        resolve3();
         return;
       }
       const details = [stderr.trim(), stdout.trim()].filter(Boolean).join("\n");
@@ -1273,7 +1276,7 @@ async function ensureRepoHasInitialCommit(repoRoot) {
   );
 }
 async function runCommandCapture(command, args, options = {}) {
-  return await new Promise((resolve2, reject) => {
+  return await new Promise((resolve3, reject) => {
     const proc = spawn2(command, args, {
       cwd: options.cwd,
       env: process.env,
@@ -1290,7 +1293,7 @@ async function runCommandCapture(command, args, options = {}) {
     proc.on("error", reject);
     proc.on("close", (code) => {
       if (code === 0) {
-        resolve2(stdout.trim());
+        resolve3(stdout.trim());
         return;
       }
       const details = [stderr.trim(), stdout.trim()].filter(Boolean).join("\n");
@@ -1326,9 +1329,10 @@ async function readCodexAuth() {
   try {
     const raw = await readFile2(getCodexAuthPath(), "utf8");
     const auth = JSON.parse(raw);
+    const apiKey = auth.OPENAI_API_KEY || process.env.OPENAI_API_KEY || void 0;
     const token = auth.tokens?.access_token;
-    if (!token) return null;
-    return { accessToken: token, accountId: auth.tokens?.account_id ?? void 0 };
+    if (!token && !apiKey) return null;
+    return { accessToken: token ?? "", accountId: auth.tokens?.account_id ?? void 0, apiKey };
   } catch {
     return null;
   }
@@ -1336,10 +1340,18 @@ async function readCodexAuth() {
 function getCodexGlobalStatePath() {
   return join2(getCodexHomeDir2(), ".codex-global-state.json");
 }
+function getCodexSessionIndexPath() {
+  return join2(getCodexHomeDir2(), "session_index.jsonl");
+}
 var MAX_THREAD_TITLES = 500;
+var EMPTY_THREAD_TITLE_CACHE = { titles: {}, order: [] };
+var sessionIndexThreadTitleCacheState = {
+  fileSignature: null,
+  cache: EMPTY_THREAD_TITLE_CACHE
+};
 function normalizeThreadTitleCache(value) {
   const record = asRecord2(value);
-  if (!record) return { titles: {}, order: [] };
+  if (!record) return EMPTY_THREAD_TITLE_CACHE;
   const rawTitles = asRecord2(record.titles);
   const titles = {};
   if (rawTitles) {
@@ -1363,6 +1375,47 @@ function removeFromThreadTitleCache(cache, id) {
   const { [id]: _, ...titles } = cache.titles;
   return { titles, order: cache.order.filter((o) => o !== id) };
 }
+function normalizeSessionIndexThreadTitle(value) {
+  const record = asRecord2(value);
+  if (!record) return null;
+  const id = typeof record.id === "string" ? record.id.trim() : "";
+  const title = typeof record.thread_name === "string" ? record.thread_name.trim() : "";
+  const updatedAtIso = typeof record.updated_at === "string" ? record.updated_at.trim() : "";
+  const updatedAtMs = updatedAtIso ? Date.parse(updatedAtIso) : Number.NaN;
+  if (!id || !title) return null;
+  return {
+    id,
+    title,
+    updatedAtMs: Number.isFinite(updatedAtMs) ? updatedAtMs : 0
+  };
+}
+function trimThreadTitleCache(cache) {
+  const titles = { ...cache.titles };
+  const order = cache.order.filter((id) => {
+    if (!titles[id]) return false;
+    return true;
+  }).slice(0, MAX_THREAD_TITLES);
+  for (const id of Object.keys(titles)) {
+    if (!order.includes(id)) {
+      delete titles[id];
+    }
+  }
+  return { titles, order };
+}
+function mergeThreadTitleCaches(base, overlay) {
+  const titles = { ...base.titles, ...overlay.titles };
+  const order = [];
+  for (const id of [...overlay.order, ...base.order]) {
+    if (!titles[id] || order.includes(id)) continue;
+    order.push(id);
+  }
+  for (const id of Object.keys(titles)) {
+    if (!order.includes(id)) {
+      order.push(id);
+    }
+  }
+  return trimThreadTitleCache({ titles, order });
+}
 async function readThreadTitleCache() {
   const statePath = getCodexGlobalStatePath();
   try {
@@ -1370,7 +1423,7 @@ async function readThreadTitleCache() {
     const payload = asRecord2(JSON.parse(raw)) ?? {};
     return normalizeThreadTitleCache(payload["thread-titles"]);
   } catch {
-    return { titles: {}, order: [] };
+    return EMPTY_THREAD_TITLE_CACHE;
   }
 }
 async function writeThreadTitleCache(cache) {
@@ -1385,6 +1438,69 @@ async function writeThreadTitleCache(cache) {
   payload["thread-titles"] = cache;
   await writeFile2(statePath, JSON.stringify(payload), "utf8");
 }
+function getSessionIndexFileSignature(stats) {
+  return `${String(stats.mtimeMs)}:${String(stats.size)}`;
+}
+async function parseThreadTitlesFromSessionIndex(sessionIndexPath) {
+  const latestById = /* @__PURE__ */ new Map();
+  const input = createReadStream(sessionIndexPath, { encoding: "utf8" });
+  const lines = createInterface({
+    input,
+    crlfDelay: Infinity
+  });
+  try {
+    for await (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const entry = normalizeSessionIndexThreadTitle(JSON.parse(trimmed));
+        if (!entry) continue;
+        const previous = latestById.get(entry.id);
+        if (!previous || entry.updatedAtMs >= previous.updatedAtMs) {
+          latestById.set(entry.id, entry);
+        }
+      } catch {
+      }
+    }
+  } finally {
+    lines.close();
+    input.close();
+  }
+  const entries = Array.from(latestById.values()).sort((first, second) => second.updatedAtMs - first.updatedAtMs);
+  const titles = {};
+  const order = [];
+  for (const entry of entries) {
+    titles[entry.id] = entry.title;
+    order.push(entry.id);
+  }
+  return trimThreadTitleCache({ titles, order });
+}
+async function readThreadTitlesFromSessionIndex() {
+  const sessionIndexPath = getCodexSessionIndexPath();
+  try {
+    const stats = await stat2(sessionIndexPath);
+    const fileSignature = getSessionIndexFileSignature(stats);
+    if (sessionIndexThreadTitleCacheState.fileSignature === fileSignature) {
+      return sessionIndexThreadTitleCacheState.cache;
+    }
+    const cache = await parseThreadTitlesFromSessionIndex(sessionIndexPath);
+    sessionIndexThreadTitleCacheState = { fileSignature, cache };
+    return cache;
+  } catch {
+    sessionIndexThreadTitleCacheState = {
+      fileSignature: "missing",
+      cache: EMPTY_THREAD_TITLE_CACHE
+    };
+    return sessionIndexThreadTitleCacheState.cache;
+  }
+}
+async function readMergedThreadTitleCache() {
+  const [sessionIndexCache, persistedCache] = await Promise.all([
+    readThreadTitlesFromSessionIndex(),
+    readThreadTitleCache()
+  ]);
+  return mergeThreadTitleCaches(persistedCache, sessionIndexCache);
+}
 async function readWorkspaceRootsState() {
   const statePath = getCodexGlobalStatePath();
   let payload = {};
@@ -1498,32 +1614,93 @@ function handleFileUpload(req, res) {
     setJson2(res, 500, { error: getErrorMessage2(err, "Upload stream error") });
   });
 }
-async function proxyTranscribe(body, contentType, authToken, accountId) {
-  const headers = {
+function httpPost(url, headers, body) {
+  const doRequest = url.startsWith("http://") ? httpRequest : httpsRequest;
+  return new Promise((resolve3, reject) => {
+    const req = doRequest(url, { method: "POST", headers }, (res) => {
+      const chunks = [];
+      res.on("data", (c) => chunks.push(c));
+      res.on("end", () => resolve3({ status: res.statusCode ?? 500, body: Buffer.concat(chunks).toString("utf8") }));
+      res.on("error", reject);
+    });
+    req.on("error", reject);
+    req.write(body);
+    req.end();
+  });
+}
+var curlImpersonateAvailable = null;
+function curlImpersonatePost(url, headers, body) {
+  return new Promise((resolve3, reject) => {
+    const args = ["-s", "-w", "\n%{http_code}", "-X", "POST", url];
+    for (const [k, v] of Object.entries(headers)) {
+      if (k.toLowerCase() === "content-length") continue;
+      args.push("-H", `${k}: ${String(v)}`);
+    }
+    args.push("--data-binary", "@-");
+    const proc = spawn2("curl-impersonate-chrome", args, {
+      env: { ...process.env, CURL_IMPERSONATE: "chrome116" },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const chunks = [];
+    proc.stdout.on("data", (c) => chunks.push(c));
+    proc.on("error", (e) => {
+      curlImpersonateAvailable = false;
+      reject(e);
+    });
+    proc.on("close", (code) => {
+      const raw = Buffer.concat(chunks).toString("utf8");
+      const lastNewline = raw.lastIndexOf("\n");
+      const statusStr = lastNewline >= 0 ? raw.slice(lastNewline + 1).trim() : "";
+      const responseBody = lastNewline >= 0 ? raw.slice(0, lastNewline) : raw;
+      const status = parseInt(statusStr, 10) || (code === 0 ? 200 : 500);
+      curlImpersonateAvailable = true;
+      resolve3({ status, body: responseBody });
+    });
+    proc.stdin.write(body);
+    proc.stdin.end();
+  });
+}
+var TRANSCRIBE_RELAY_URL = process.env.TRANSCRIBE_RELAY_URL || "http://127.0.0.1:1090/relay-transcribe";
+async function tryRelay(headers, body) {
+  try {
+    const resp = await httpPost(TRANSCRIBE_RELAY_URL, headers, body);
+    if (resp.status !== 0) return resp;
+  } catch {
+  }
+  return null;
+}
+async function proxyTranscribe(body, contentType, authToken, accountId, apiKey) {
+  const chatgptHeaders = {
     "Content-Type": contentType,
     "Content-Length": body.length,
-    Authorization: `Bearer ${authToken}`,
+    Authorization: `Bearer ${authToken || apiKey || ""}`,
     originator: "Codex Desktop",
     "User-Agent": `Codex Desktop/0.1.0 (${process.platform}; ${process.arch})`
   };
-  if (accountId) {
-    headers["ChatGPT-Account-Id"] = accountId;
-  }
-  return new Promise((resolve2, reject) => {
-    const req = httpsRequest(
-      "https://chatgpt.com/backend-api/transcribe",
-      { method: "POST", headers },
-      (res) => {
-        const chunks = [];
-        res.on("data", (c) => chunks.push(c));
-        res.on("end", () => resolve2({ status: res.statusCode ?? 500, body: Buffer.concat(chunks).toString("utf8") }));
-        res.on("error", reject);
-      }
-    );
-    req.on("error", reject);
-    req.write(body);
-    req.end();
-  });
+  if (accountId) chatgptHeaders["ChatGPT-Account-Id"] = accountId;
+  const postFn = curlImpersonateAvailable !== false ? curlImpersonatePost : httpPost;
+  let result;
+  try {
+    result = await postFn("https://chatgpt.com/backend-api/transcribe", chatgptHeaders, body);
+  } catch {
+    result = await httpPost("https://chatgpt.com/backend-api/transcribe", chatgptHeaders, body);
+  }
+  if (result.status === 403 && result.body.includes("cf_chl")) {
+    if (curlImpersonateAvailable !== false && postFn !== curlImpersonatePost) {
+      try {
+        const ciResult = await curlImpersonatePost("https://chatgpt.com/backend-api/transcribe", chatgptHeaders, body);
+        if (ciResult.status !== 403) return ciResult;
+      } catch {
+      }
+    }
+    const relayed = await tryRelay(chatgptHeaders, body);
+    if (relayed && relayed.status !== 403) return relayed;
+    if (apiKey) {
+      return httpPost("https://api.openai.com/v1/audio/transcriptions", { ...chatgptHeaders, Authorization: `Bearer ${apiKey}` }, body);
+    }
+    return { status: 503, body: JSON.stringify({ error: "Transcription blocked by Cloudflare. Install curl-impersonate-chrome, start relay, or set OPENAI_API_KEY." }) };
+  }
+  return result;
 }
 var AppServerProcess = class {
   constructor() {
@@ -1670,8 +1847,8 @@ var AppServerProcess = class {
   async call(method, params) {
     this.start();
     const id = this.nextId++;
-    return new Promise((resolve2, reject) => {
-      this.pending.set(id, { resolve: resolve2, reject });
+    return new Promise((resolve3, reject) => {
+      this.pending.set(id, { resolve: resolve3, reject });
       this.sendLine({
         jsonrpc: "2.0",
         id,
@@ -1772,7 +1949,7 @@ var MethodCatalog = class {
     this.notificationCache = null;
   }
   async runGenerateSchemaCommand(outDir) {
-    await new Promise((resolve2, reject) => {
+    await new Promise((resolve3, reject) => {
       const process2 = spawn2("codex", ["app-server", "generate-json-schema", "--out", outDir], {
         stdio: ["ignore", "ignore", "pipe"]
       });
@@ -1784,7 +1961,7 @@ var MethodCatalog = class {
       process2.on("error", reject);
       process2.on("exit", (code) => {
         if (code === 0) {
-          resolve2();
+          resolve3();
           return;
         }
         reject(new Error(stderr.trim() || `generate-json-schema exited with code ${String(code)}`));
@@ -1974,7 +2151,7 @@ function createCodexBridgeMiddleware() {
         }
         const rawBody = await readRawBody(req);
         const incomingCt = req.headers["content-type"] ?? "application/octet-stream";
-        const upstream = await proxyTranscribe(rawBody, incomingCt, auth.accessToken, auth.accountId);
+        const upstream = await proxyTranscribe(rawBody, incomingCt, auth.accessToken, auth.accountId, auth.apiKey);
         res.statusCode = upstream.status;
         res.setHeader("Content-Type", "application/json; charset=utf-8");
         res.end(upstream.body);
@@ -2200,7 +2377,7 @@ function createCodexBridgeMiddleware() {
         return;
       }
       if (req.method === "GET" && url.pathname === "/codex-api/thread-titles") {
-        const cache = await readThreadTitleCache();
+        const cache = await readMergedThreadTitleCache();
         setJson2(res, 200, { data: cache });
         return;
       }
@@ -2815,7 +2992,7 @@ function createServer(options = {}) {
       res.status(404).json({ error: "File not found." });
     }
   });
-  const hasFrontendAssets = existsSync2(spaEntryFile);
+  const hasFrontendAssets = existsSync3(spaEntryFile);
   if (hasFrontendAssets) {
     app.use(express.static(distDir));
   }
@@ -2921,7 +3098,7 @@ function resolveCodexCommand() {
     return "codex";
   }
   const userCandidate = join5(getUserNpmPrefix(), "bin", "codex");
-  if (existsSync3(userCandidate) && canRun(userCandidate, ["--version"])) {
+  if (existsSync4(userCandidate) && canRun(userCandidate, ["--version"])) {
     return userCandidate;
   }
   const prefix = process.env.PREFIX?.trim();
@@ -2929,7 +3106,7 @@ function resolveCodexCommand() {
     return null;
   }
   const candidate = join5(prefix, "bin", "codex");
-  if (existsSync3(candidate) && canRun(candidate, ["--version"])) {
+  if (existsSync4(candidate) && canRun(candidate, ["--version"])) {
     return candidate;
   }
   return null;
@@ -2939,7 +3116,7 @@ function resolveCloudflaredCommand() {
     return "cloudflared";
   }
   const localCandidate = join5(homedir3(), ".local", "bin", "cloudflared");
-  if (existsSync3(localCandidate) && canRun(localCandidate, ["--version"])) {
+  if (existsSync4(localCandidate) && canRun(localCandidate, ["--version"])) {
     return localCandidate;
   }
   return null;
@@ -2954,7 +3131,7 @@ function mapCloudflaredLinuxArch(arch) {
   return null;
 }
 function downloadFile(url, destination) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const request = (currentUrl) => {
       httpsGet(currentUrl, (response) => {
         const code = response.statusCode ?? 0;
@@ -2972,7 +3149,7 @@ function downloadFile(url, destination) {
         response.pipe(file);
         file.on("finish", () => {
           file.close();
-          resolve2();
+          resolve3();
         });
         file.on("error", reject);
       }).on("error", reject);
@@ -3012,7 +3189,7 @@ async function shouldInstallCloudflaredInteractively() {
     console.warn("\n[cloudflared] cloudflared is missing and terminal is non-interactive, skipping install.");
     return false;
   }
-  const prompt = createInterface({ input: process.stdin, output: process.stdout });
+  const prompt = createInterface2({ input: process.stdin, output: process.stdout });
   try {
     const answer = await prompt.question("cloudflared is not installed. Install it now to ~/.local/bin? [y/N] ");
     const normalized = answer.trim().toLowerCase();
@@ -3034,7 +3211,7 @@ async function resolveCloudflaredForTunnel() {
 }
 function hasCodexAuth() {
   const codexHome = process.env.CODEX_HOME?.trim() || join5(homedir3(), ".codex");
-  return existsSync3(join5(codexHome, "auth.json"));
+  return existsSync4(join5(codexHome, "auth.json"));
 }
 function ensureCodexInstalled() {
   let codexCommand = resolveCodexCommand();
@@ -3115,24 +3292,27 @@ function parseCloudflaredUrl(chunk) {
 }
 function getAccessibleUrls(port) {
   const urls = /* @__PURE__ */ new Set([`http://localhost:${String(port)}`]);
-  const interfaces = networkInterfaces();
-  for (const entries of Object.values(interfaces)) {
-    if (!entries) {
-      continue;
-    }
-    for (const entry of entries) {
-      if (entry.internal) {
+  try {
+    const interfaces = networkInterfaces();
+    for (const entries of Object.values(interfaces)) {
+      if (!entries) {
         continue;
       }
-      if (entry.family === "IPv4") {
-        urls.add(`http://${entry.address}:${String(port)}`);
+      for (const entry of entries) {
+        if (entry.internal) {
+          continue;
+        }
+        if (entry.family === "IPv4") {
+          urls.add(`http://${entry.address}:${String(port)}`);
+        }
       }
     }
+  } catch {
   }
   return Array.from(urls);
 }
 async function startCloudflaredTunnel(command, localPort) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const child = spawn3(command, ["tunnel", "--url", `http://localhost:${String(localPort)}`], {
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -3149,7 +3329,7 @@ async function startCloudflaredTunnel(command, localPort) {
       clearTimeout(timeout);
       child.stdout?.off("data", handleData);
       child.stderr?.off("data", handleData);
-      resolve2({ process: child, url: parsedUrl });
+      resolve3({ process: child, url: parsedUrl });
     };
     const onError = (error) => {
       clearTimeout(timeout);
@@ -3168,7 +3348,7 @@ async function startCloudflaredTunnel(command, localPort) {
   });
 }
 function listenWithFallback(server, startPort) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const attempt = (port) => {
       const onError = (error) => {
         server.off("listening", onListening);
@@ -3180,7 +3360,7 @@ function listenWithFallback(server, startPort) {
       };
       const onListening = () => {
         server.off("error", onError);
-        resolve2(port);
+        resolve3(port);
       };
       server.once("error", onError);
       server.once("listening", onListening);
@@ -3189,8 +3369,72 @@ function listenWithFallback(server, startPort) {
     attempt(startPort);
   });
 }
+function getCodexGlobalStatePath2() {
+  const codexHome = process.env.CODEX_HOME?.trim() || join5(homedir3(), ".codex");
+  return join5(codexHome, ".codex-global-state.json");
+}
+function normalizeUniqueStrings(value) {
+  if (!Array.isArray(value)) return [];
+  const next = [];
+  for (const item of value) {
+    if (typeof item !== "string") continue;
+    const trimmed = item.trim();
+    if (!trimmed || next.includes(trimmed)) continue;
+    next.push(trimmed);
+  }
+  return next;
+}
+async function persistLaunchProject(projectPath) {
+  const trimmed = projectPath.trim();
+  if (!trimmed) return;
+  const normalizedPath = isAbsolute3(trimmed) ? trimmed : resolve2(trimmed);
+  const directoryInfo = await stat5(normalizedPath);
+  if (!directoryInfo.isDirectory()) {
+    throw new Error(`Not a directory: ${normalizedPath}`);
+  }
+  const statePath = getCodexGlobalStatePath2();
+  let payload = {};
+  try {
+    const raw = await readFile4(statePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      payload = parsed;
+    }
+  } catch {
+    payload = {};
+  }
+  const roots = normalizeUniqueStrings(payload["electron-saved-workspace-roots"]);
+  const activeRoots = normalizeUniqueStrings(payload["active-workspace-roots"]);
+  payload["electron-saved-workspace-roots"] = [
+    normalizedPath,
+    ...roots.filter((value) => value !== normalizedPath)
+  ];
+  payload["active-workspace-roots"] = [
+    normalizedPath,
+    ...activeRoots.filter((value) => value !== normalizedPath)
+  ];
+  await writeFile4(statePath, JSON.stringify(payload), "utf8");
+}
+async function addProjectOnly(projectPath) {
+  const trimmed = projectPath.trim();
+  if (!trimmed) {
+    throw new Error("Missing project path");
+  }
+  await persistLaunchProject(trimmed);
+}
 async function startServer(options) {
   const version = await readCliVersion();
+  const projectPath = options.projectPath?.trim() ?? "";
+  if (projectPath.length > 0) {
+    try {
+      await persistLaunchProject(projectPath);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(`
+[project] Could not open launch project: ${message}
+`);
+    }
+  }
   const codexCommand = ensureCodexInstalled() ?? resolveCodexCommand();
   if (!hasCodexAuth() && codexCommand) {
     console.log("\nCodex is not logged in. Starting `codex login`...\n");
@@ -3251,7 +3495,7 @@ async function startServer(options) {
     qrcode.generate(tunnelUrl, { small: true });
     console.log("");
   }
-  openBrowser(`http://localhost:${String(port)}`);
+  if (options.open) openBrowser(`http://localhost:${String(port)}`);
   function shutdown() {
     console.log("\nShutting down...");
     if (tunnelChild && !tunnelChild.killed) {
@@ -3274,8 +3518,20 @@ async function runLogin() {
   console.log("\nStarting `codex login`...\n");
   runOrFail(codexCommand, ["login"], "Codex login");
 }
-program.option("-p, --port <port>", "port to listen on", "5999").option("--password <pass>", "set a specific password").option("--no-password", "disable password protection").option("--tunnel", "start cloudflared tunnel", true).option("--no-tunnel", "disable cloudflared tunnel startup").action(async (opts) => {
-  await startServer(opts);
+program.argument("[projectPath]", "project directory to open on launch").option("--open-project <path>", "open project directory on launch (Codex desktop parity)").option("-p, --port <port>", "port to listen on", "5999").option("--password <pass>", "set a specific password").option("--no-password", "disable password protection").option("--tunnel", "start cloudflared tunnel", true).option("--no-tunnel", "disable cloudflared tunnel startup").option("--open", "open browser on startup", true).option("--no-open", "do not open browser on startup").action(async (projectPath, opts) => {
+  const rawArgv = process.argv.slice(2);
+  const openProjectFlagIndex = rawArgv.findIndex((arg) => arg === "--open-project" || arg.startsWith("--open-project="));
+  let openProjectOnly = (opts.openProject ?? "").trim();
+  if (!openProjectOnly && openProjectFlagIndex >= 0 && projectPath?.trim()) {
+    openProjectOnly = projectPath.trim();
+  }
+  if (openProjectOnly.length > 0) {
+    await addProjectOnly(openProjectOnly);
+    console.log(`Added project: ${openProjectOnly}`);
+    return;
+  }
+  const launchProject = (projectPath ?? "").trim();
+  await startServer({ ...opts, projectPath: launchProject });
 });
 program.command("login").description("Install/check Codex CLI and run `codex login`").action(runLogin);
 program.command("help").description("Show codexui command help").action(() => {