codexapp 0.1.48 → 0.1.49

package/dist-cli/index.js

@@ -1273,6 +1273,53 @@ function scoreFileCandidate(path, query) {
   if (lowerPath.includes(lowerQuery)) return 4;
   return 10;
 }
+function decodeHtmlEntities(value) {
+  return value.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&#x2F;/gi, "/");
+}
+function stripHtml(value) {
+  return decodeHtmlEntities(value.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim());
+}
+function parseGithubTrendingHtml(html, limit) {
+  const rows = html.match(/<article[\s\S]*?<\/article>/g) ?? [];
+  const items = [];
+  let seq = Date.now();
+  for (const row of rows) {
+    const hrefMatch = row.match(/href="\/([A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+)"/);
+    if (!hrefMatch) continue;
+    const fullName = hrefMatch[1] ?? "";
+    if (!fullName || items.some((item) => item.fullName === fullName)) continue;
+    const descriptionMatch = row.match(/<p[^>]*>([\s\S]*?)<\/p>/);
+    const languageMatch = row.match(/programmingLanguage[^>]*>\s*([\s\S]*?)\s*<\/span>/);
+    const starsMatch = row.match(/href="\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+\/stargazers"[\s\S]*?>([\s\S]*?)<\/a>/);
+    const starsText = stripHtml(starsMatch?.[1] ?? "").replace(/,/g, "");
+    const stars = Number.parseInt(starsText, 10);
+    items.push({
+      id: seq,
+      fullName,
+      url: `https://github.com/${fullName}`,
+      description: stripHtml(descriptionMatch?.[1] ?? ""),
+      language: stripHtml(languageMatch?.[1] ?? ""),
+      stars: Number.isFinite(stars) ? stars : 0
+    });
+    seq += 1;
+    if (items.length >= limit) break;
+  }
+  return items;
+}
+async function fetchGithubTrending(since, limit) {
+  const endpoint = `https://github.com/trending?since=${since}`;
+  const response = await fetch(endpoint, {
+    headers: {
+      "User-Agent": "codex-web-local",
+      Accept: "text/html"
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`GitHub trending fetch failed (${response.status})`);
+  }
+  const html = await response.text();
+  return parseGithubTrendingHtml(html, limit);
+}
 async function listFilesWithRipgrep(cwd) {
   return await new Promise((resolve3, reject) => {
     const proc = spawn2("rg", ["--files", "--hidden", "-g", "!.git", "-g", "!node_modules"], {
@@ -1380,6 +1427,33 @@ async function runCommandCapture(command, args, options = {}) {
     });
   });
 }
+async function runCommandWithOutput2(command, args, options = {}) {
+  return await new Promise((resolve3, reject) => {
+    const proc = spawn2(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) {
+        resolve3(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}`));
+    });
+  });
+}
 function normalizeStringArray(value) {
   if (!Array.isArray(value)) return [];
   const normalized = [];
@@ -1400,6 +1474,30 @@ function normalizeStringRecord(value) {
   }
   return next;
 }
+function normalizeCommitMessage(value) {
+  if (typeof value !== "string") return "";
+  const normalized = value.replace(/\r\n?/gu, "\n").split("\n").map((line) => line.trim()).filter((line) => line.length > 0).join("\n").trim();
+  return normalized.slice(0, 2e3);
+}
+async function hasGitWorkingTreeChanges(cwd) {
+  const status = await runCommandWithOutput2("git", ["status", "--porcelain"], { cwd });
+  return status.trim().length > 0;
+}
+async function findCommitByExactMessage(cwd, message) {
+  const normalizedTarget = normalizeCommitMessage(message);
+  if (!normalizedTarget) return "";
+  const raw = await runCommandWithOutput2("git", ["log", "--format=%H%x1f%B%x1e"], { cwd });
+  const entries = raw.split("");
+  for (const entry of entries) {
+    if (!entry.trim()) continue;
+    const [shaRaw, bodyRaw] = entry.split("");
+    const sha = (shaRaw ?? "").trim();
+    const body = normalizeCommitMessage(bodyRaw ?? "");
+    if (!sha) continue;
+    if (body === normalizedTarget) return sha;
+  }
+  return "";
+}
 function getCodexAuthPath() {
   return join3(getCodexHomeDir2(), "auth.json");
 }
@@ -2251,6 +2349,19 @@ function createCodexBridgeMiddleware() {
         setJson2(res, 200, { data: { path: homedir3() } });
         return;
       }
+      if (req.method === "GET" && url.pathname === "/codex-api/github-trending") {
+        const sinceRaw = (url.searchParams.get("since") ?? "").trim().toLowerCase();
+        const since = sinceRaw === "weekly" ? "weekly" : sinceRaw === "monthly" ? "monthly" : "daily";
+        const limitRaw = Number.parseInt((url.searchParams.get("limit") ?? "6").trim(), 10);
+        const limit = Number.isFinite(limitRaw) ? Math.max(1, Math.min(10, limitRaw)) : 6;
+        try {
+          const data = await fetchGithubTrending(since, limit);
+          setJson2(res, 200, { data });
+        } catch (error) {
+          setJson2(res, 502, { error: getErrorMessage2(error, "Failed to fetch GitHub trending") });
+        }
+        return;
+      }
       if (req.method === "POST" && url.pathname === "/codex-api/worktree/create") {
         const payload = asRecord2(await readJsonBody(req));
         const rawSourceCwd = typeof payload?.sourceCwd === "string" ? payload.sourceCwd.trim() : "";
@@ -2321,6 +2432,99 @@ function createCodexBridgeMiddleware() {
         }
         return;
       }
+      if (req.method === "POST" && url.pathname === "/codex-api/worktree/auto-commit") {
+        const payload = asRecord2(await readJsonBody(req));
+        const rawCwd = typeof payload?.cwd === "string" ? payload.cwd.trim() : "";
+        const commitMessage = normalizeCommitMessage(payload?.message);
+        if (!rawCwd) {
+          setJson2(res, 400, { error: "Missing cwd" });
+          return;
+        }
+        if (!commitMessage) {
+          setJson2(res, 400, { error: "Missing message" });
+          return;
+        }
+        const cwd = isAbsolute(rawCwd) ? rawCwd : resolve(rawCwd);
+        try {
+          const cwdInfo = await stat2(cwd);
+          if (!cwdInfo.isDirectory()) {
+            setJson2(res, 400, { error: "cwd is not a directory" });
+            return;
+          }
+        } catch {
+          setJson2(res, 404, { error: "cwd does not exist" });
+          return;
+        }
+        try {
+          await runCommandCapture("git", ["rev-parse", "--is-inside-work-tree"], { cwd });
+          const beforeStatus = await runCommandWithOutput2("git", ["status", "--porcelain"], { cwd });
+          if (!beforeStatus.trim()) {
+            setJson2(res, 200, { data: { committed: false } });
+            return;
+          }
+          await runCommand2("git", ["add", "-A"], { cwd });
+          const stagedStatus = await runCommandWithOutput2("git", ["diff", "--cached", "--name-only"], { cwd });
+          if (!stagedStatus.trim()) {
+            setJson2(res, 200, { data: { committed: false } });
+            return;
+          }
+          await runCommand2("git", ["commit", "-m", commitMessage], { cwd });
+          setJson2(res, 200, { data: { committed: true } });
+        } catch (error) {
+          setJson2(res, 500, { error: getErrorMessage2(error, "Failed to auto-commit worktree changes") });
+        }
+        return;
+      }
+      if (req.method === "POST" && url.pathname === "/codex-api/worktree/rollback-to-message") {
+        const payload = asRecord2(await readJsonBody(req));
+        const rawCwd = typeof payload?.cwd === "string" ? payload.cwd.trim() : "";
+        const commitMessage = normalizeCommitMessage(payload?.message);
+        if (!rawCwd) {
+          setJson2(res, 400, { error: "Missing cwd" });
+          return;
+        }
+        if (!commitMessage) {
+          setJson2(res, 400, { error: "Missing message" });
+          return;
+        }
+        const cwd = isAbsolute(rawCwd) ? rawCwd : resolve(rawCwd);
+        try {
+          const cwdInfo = await stat2(cwd);
+          if (!cwdInfo.isDirectory()) {
+            setJson2(res, 400, { error: "cwd is not a directory" });
+            return;
+          }
+        } catch {
+          setJson2(res, 404, { error: "cwd does not exist" });
+          return;
+        }
+        try {
+          await runCommandCapture("git", ["rev-parse", "--is-inside-work-tree"], { cwd });
+          const commitSha = await findCommitByExactMessage(cwd, commitMessage);
+          if (!commitSha) {
+            setJson2(res, 404, { error: "No matching commit found for this user message" });
+            return;
+          }
+          let resetTargetSha = "";
+          try {
+            resetTargetSha = await runCommandCapture("git", ["rev-parse", `${commitSha}^`], { cwd });
+          } catch {
+            setJson2(res, 409, { error: "Cannot rollback: matched commit has no parent commit" });
+            return;
+          }
+          let stashed = false;
+          if (await hasGitWorkingTreeChanges(cwd)) {
+            const stashMessage = `codex-auto-stash-before-rollback-${Date.now()}`;
+            await runCommand2("git", ["stash", "push", "-u", "-m", stashMessage], { cwd });
+            stashed = true;
+          }
+          await runCommand2("git", ["reset", "--hard", resetTargetSha], { cwd });
+          setJson2(res, 200, { data: { reset: true, commitSha, resetTargetSha, stashed } });
+        } catch (error) {
+          setJson2(res, 500, { error: getErrorMessage2(error, "Failed to rollback worktree to user message commit") });
+        }
+        return;
+      }
       if (req.method === "PUT" && url.pathname === "/codex-api/workspace-roots-state") {
         const payload = await readJsonBody(req);
         const record = asRecord2(payload);
@@ -3185,6 +3389,22 @@ function generatePassword() {
 // src/cli/index.ts
 var program = new Command().name("codexui").description("Web interface for Codex app-server");
 var __dirname2 = dirname3(fileURLToPath2(import.meta.url));
+var hasPromptedCloudflaredInstall = false;
+function getCodexHomePath() {
+  return process.env.CODEX_HOME?.trim() || join6(homedir4(), ".codex");
+}
+function getCloudflaredPromptMarkerPath() {
+  return join6(getCodexHomePath(), ".cloudflared-install-prompted");
+}
+function hasPromptedCloudflaredInstallPersisted() {
+  return existsSync5(getCloudflaredPromptMarkerPath());
+}
+async function persistCloudflaredInstallPrompted() {
+  const codexHome = getCodexHomePath();
+  mkdirSync(codexHome, { recursive: true });
+  await writeFile4(getCloudflaredPromptMarkerPath(), `${Date.now()}
+`, "utf8");
+}
 async function readCliVersion() {
   try {
     const packageJsonPath = join6(__dirname2, "..", "package.json");
@@ -3286,6 +3506,14 @@ async function ensureCloudflaredInstalledLinux() {
   return installed;
 }
 async function shouldInstallCloudflaredInteractively() {
+  if (hasPromptedCloudflaredInstall || hasPromptedCloudflaredInstallPersisted()) {
+    return false;
+  }
+  hasPromptedCloudflaredInstall = true;
+  await persistCloudflaredInstallPrompted();
+  if (process.platform === "win32") {
+    return false;
+  }
   if (!process.stdin.isTTY || !process.stdout.isTTY) {
     console.warn("\n[cloudflared] cloudflared is missing and terminal is non-interactive, skipping install.");
     return false;
@@ -3304,6 +3532,9 @@ async function resolveCloudflaredForTunnel() {
   if (current) {
     return current;
   }
+  if (process.platform === "win32") {
+    return null;
+  }
   const installApproved = await shouldInstallCloudflaredInteractively();
   if (!installApproved) {
     return null;
@@ -3311,7 +3542,7 @@ async function resolveCloudflaredForTunnel() {
   return ensureCloudflaredInstalledLinux();
 }
 function hasCodexAuth() {
-  const codexHome = process.env.CODEX_HOME?.trim() || join6(homedir4(), ".codex");
+  const codexHome = getCodexHomePath();
   return existsSync5(join6(codexHome, "auth.json"));
 }
 function ensureCodexInstalled() {
@@ -3471,7 +3702,7 @@ function listenWithFallback(server, startPort) {
   });
 }
 function getCodexGlobalStatePath2() {
-  const codexHome = process.env.CODEX_HOME?.trim() || join6(homedir4(), ".codex");
+  const codexHome = getCodexHomePath();
   return join6(codexHome, ".codex-global-state.json");
 }
 function normalizeUniqueStrings(value) {