codexapp 0.1.52 → 0.1.56

package/dist-cli/index.js

@@ -9,14 +9,156 @@ import { isAbsolute as isAbsolute3, join as join6, resolve as resolve2 } from "p
 import { spawn as spawn3 } from "child_process";
 import { createInterface as createInterface2 } from "readline/promises";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname3 } from "path";
+import { dirname as dirname4 } from "path";
 import { get as httpsGet } from "https";
 import { Command } from "commander";
 import qrcode from "qrcode-terminal";
 
+// src/commandResolution.ts
+import { spawnSync } from "child_process";
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { delimiter, join } from "path";
+function uniqueStrings(values) {
+  const unique = [];
+  for (const value of values) {
+    const normalized = value?.trim();
+    if (!normalized || unique.includes(normalized)) continue;
+    unique.push(normalized);
+  }
+  return unique;
+}
+function isPathLike(command) {
+  return command.includes("/") || command.includes("\\") || /^[a-zA-Z]:/.test(command);
+}
+function isRunnableCommand(command, args = []) {
+  if (isPathLike(command) && !existsSync(command)) {
+    return false;
+  }
+  return canRunCommand(command, args);
+}
+function getWindowsAppDataNpmPrefix() {
+  const appData = process.env.APPDATA?.trim();
+  return appData ? join(appData, "npm") : null;
+}
+function getPotentialNpmPrefixes() {
+  return uniqueStrings([
+    process.env.npm_config_prefix,
+    process.env.PREFIX,
+    getUserNpmPrefix(),
+    process.platform === "win32" ? getWindowsAppDataNpmPrefix() : null
+  ]);
+}
+function getPotentialCodexPackageDirs(prefix) {
+  const dirs = [join(prefix, "node_modules", "@openai", "codex")];
+  if (process.platform !== "win32") {
+    dirs.push(join(prefix, "lib", "node_modules", "@openai", "codex"));
+  }
+  return dirs;
+}
+function getPotentialCodexExecutables(prefix) {
+  return getPotentialCodexPackageDirs(prefix).map((packageDir) => process.platform === "win32" ? join(
+    packageDir,
+    "node_modules",
+    "@openai",
+    "codex-win32-x64",
+    "vendor",
+    "x86_64-pc-windows-msvc",
+    "codex",
+    "codex.exe"
+  ) : join(packageDir, "bin", "codex"));
+}
+function getPotentialRipgrepExecutables(prefix) {
+  return getPotentialCodexPackageDirs(prefix).map((packageDir) => process.platform === "win32" ? join(
+    packageDir,
+    "node_modules",
+    "@openai",
+    "codex-win32-x64",
+    "vendor",
+    "x86_64-pc-windows-msvc",
+    "path",
+    "rg.exe"
+  ) : join(packageDir, "bin", "rg"));
+}
+function canRunCommand(command, args = []) {
+  const result = spawnSync(command, args, {
+    stdio: "ignore",
+    windowsHide: true
+  });
+  return !result.error && result.status === 0;
+}
+function getUserNpmPrefix() {
+  return join(homedir(), ".npm-global");
+}
+function getNpmGlobalBinDir(prefix) {
+  return process.platform === "win32" ? prefix : join(prefix, "bin");
+}
+function prependPathEntry(existingPath, entry) {
+  const normalizedEntry = entry.trim();
+  if (!normalizedEntry) return existingPath;
+  const parts = existingPath.split(delimiter).map((value) => value.trim()).filter(Boolean);
+  if (parts.includes(normalizedEntry)) {
+    return existingPath;
+  }
+  return existingPath ? `${normalizedEntry}${delimiter}${existingPath}` : normalizedEntry;
+}
+function resolveCodexCommand() {
+  const explicit = process.env.CODEXUI_CODEX_COMMAND?.trim();
+  const packageCandidates = getPotentialNpmPrefixes().flatMap(getPotentialCodexExecutables);
+  const fallbackCandidates = process.platform === "win32" ? [...packageCandidates, "codex"] : ["codex", ...packageCandidates];
+  for (const candidate of uniqueStrings([explicit, ...fallbackCandidates])) {
+    if (isRunnableCommand(candidate, ["--version"])) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function resolveRipgrepCommand() {
+  const explicit = process.env.CODEXUI_RG_COMMAND?.trim();
+  const packageCandidates = getPotentialNpmPrefixes().flatMap(getPotentialRipgrepExecutables);
+  const fallbackCandidates = process.platform === "win32" ? [...packageCandidates, "rg"] : ["rg", ...packageCandidates];
+  for (const candidate of uniqueStrings([explicit, ...fallbackCandidates])) {
+    if (isRunnableCommand(candidate, ["--version"])) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function resolvePythonCommand() {
+  const candidates = process.platform === "win32" ? [
+    { command: "python", args: [] },
+    { command: "py", args: ["-3"] },
+    { command: "python3", args: [] }
+  ] : [
+    { command: "python3", args: [] },
+    { command: "python", args: [] }
+  ];
+  for (const candidate of candidates) {
+    if (isRunnableCommand(candidate.command, [...candidate.args, "--version"])) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function resolveSkillInstallerScriptPath(codexHome) {
+  const normalizedCodexHome = codexHome?.trim();
+  const candidates = uniqueStrings([
+    normalizedCodexHome ? join(normalizedCodexHome, "skills", ".system", "skill-installer", "scripts", "install-skill-from-github.py") : null,
+    process.env.CODEX_HOME?.trim() ? join(process.env.CODEX_HOME.trim(), "skills", ".system", "skill-installer", "scripts", "install-skill-from-github.py") : null,
+    join(homedir(), ".codex", "skills", ".system", "skill-installer", "scripts", "install-skill-from-github.py"),
+    join(homedir(), ".cursor", "skills", ".system", "skill-installer", "scripts", "install-skill-from-github.py")
+  ]);
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
 // src/server/httpServer.ts
 import { fileURLToPath } from "url";
-import { dirname as dirname2, extname as extname3, isAbsolute as isAbsolute2, join as join5 } from "path";
+import { dirname as dirname3, extname as extname3, isAbsolute as isAbsolute2, join as join5 } from "path";
 import { existsSync as existsSync4 } from "fs";
 import { writeFile as writeFile3, stat as stat4 } from "fs/promises";
 import express from "express";
@@ -30,16 +172,16 @@ import { request as httpRequest } from "http";
 import { request as httpsRequest } from "https";
 import { homedir as homedir3 } from "os";
 import { tmpdir as tmpdir2 } from "os";
-import { basename as basename3, isAbsolute, join as join3, resolve } from "path";
+import { basename as basename3, dirname, isAbsolute, join as join3, resolve } from "path";
 import { createInterface } from "readline";
 import { writeFile as writeFile2 } from "fs/promises";
 
 // src/server/skillsRoutes.ts
 import { spawn } from "child_process";
 import { mkdtemp, readFile, readdir, rm, mkdir, stat, lstat, readlink, symlink } from "fs/promises";
-import { existsSync } from "fs";
-import { homedir, tmpdir } from "os";
-import { join } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { homedir as homedir2, tmpdir } from "os";
+import { join as join2 } from "path";
 import { writeFile } from "fs/promises";
 function asRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -65,39 +207,45 @@ function setJson(res, statusCode, payload) {
 }
 function getCodexHomeDir() {
   const codexHome = process.env.CODEX_HOME?.trim();
-  return codexHome && codexHome.length > 0 ? codexHome : join(homedir(), ".codex");
+  return codexHome && codexHome.length > 0 ? codexHome : join2(homedir2(), ".codex");
 }
 function getSkillsInstallDir() {
-  return join(getCodexHomeDir(), "skills");
-}
-function resolveSkillInstallerScriptPath() {
-  const candidates = [
-    join(getCodexHomeDir(), "skills", ".system", "skill-installer", "scripts", "install-skill-from-github.py"),
-    join(homedir(), ".codex", "skills", ".system", "skill-installer", "scripts", "install-skill-from-github.py"),
-    join(homedir(), ".cursor", "skills", ".system", "skill-installer", "scripts", "install-skill-from-github.py")
-  ];
-  for (const candidate of candidates) {
-    if (existsSync(candidate)) return candidate;
-  }
-  throw new Error(`Skill installer script not found. Checked: ${candidates.join(", ")}`);
+  return join2(getCodexHomeDir(), "skills");
 }
+var DEFAULT_COMMAND_TIMEOUT_MS = 12e4;
 async function runCommand(command, args, options = {}) {
+  const timeout = options.timeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS;
   await new Promise((resolve3, reject) => {
     const proc = spawn(command, args, {
       cwd: options.cwd,
       env: process.env,
       stdio: ["ignore", "pipe", "pipe"]
     });
+    let settled = false;
     let stdout = "";
     let stderr = "";
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      proc.kill("SIGKILL");
+      reject(new Error(`Command timed out after ${timeout}ms (${command} ${args.join(" ")})`));
+    }, timeout);
     proc.stdout.on("data", (chunk) => {
       stdout += chunk.toString();
     });
     proc.stderr.on("data", (chunk) => {
       stderr += chunk.toString();
     });
-    proc.on("error", reject);
+    proc.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(err);
+    });
     proc.on("close", (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
       if (code === 0) {
         resolve3();
         return;
@@ -109,22 +257,38 @@ async function runCommand(command, args, options = {}) {
   });
 }
 async function runCommandWithOutput(command, args, options = {}) {
+  const timeout = options.timeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS;
   return await new Promise((resolve3, reject) => {
     const proc = spawn(command, args, {
       cwd: options.cwd,
       env: process.env,
       stdio: ["ignore", "pipe", "pipe"]
     });
+    let settled = false;
     let stdout = "";
     let stderr = "";
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      proc.kill("SIGKILL");
+      reject(new Error(`Command timed out after ${timeout}ms (${command} ${args.join(" ")})`));
+    }, timeout);
     proc.stdout.on("data", (chunk) => {
       stdout += chunk.toString();
     });
     proc.stderr.on("data", (chunk) => {
       stderr += chunk.toString();
     });
-    proc.on("error", reject);
+    proc.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(err);
+    });
     proc.on("close", (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
       if (code === 0) {
         resolve3(stdout.trim());
         return;
@@ -135,6 +299,21 @@ async function runCommandWithOutput(command, args, options = {}) {
     });
   });
 }
+function withTimeout(promise, ms, label) {
+  return new Promise((resolve3, reject) => {
+    const timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
+    promise.then(
+      (val) => {
+        clearTimeout(timer);
+        resolve3(val);
+      },
+      (err) => {
+        clearTimeout(timer);
+        reject(err);
+      }
+    );
+  });
+}
 async function detectUserSkillsDir(appServer) {
   try {
     const result = await appServer.rpc("skills/list", {});
@@ -250,13 +429,14 @@ var DEFAULT_SKILLS_SYNC_REPO_NAME = "codexskills";
 var SKILLS_SYNC_MANIFEST_PATH = "installed-skills.json";
 var SYNC_UPSTREAM_SKILLS_OWNER = "OpenClawAndroid";
 var SYNC_UPSTREAM_SKILLS_REPO = "skills";
+var PRIVATE_SYNC_BRANCH = "main";
 var HUB_SKILLS_OWNER = "openclaw";
 var HUB_SKILLS_REPO = "skills";
 var startupSkillsSyncInitialized = false;
 var startupSyncStatus = {
   inProgress: false,
   mode: "idle",
-  branch: getPreferredSyncBranch(),
+  branch: PRIVATE_SYNC_BRANCH,
   lastAction: "not-started",
   lastRunAtIso: "",
   lastSuccessAtIso: "",
@@ -269,7 +449,7 @@ async function scanInstalledSkillsFromDisk() {
     const entries = await readdir(skillsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const skillMd = join(skillsDir, entry.name, "SKILL.md");
+      const skillMd = join2(skillsDir, entry.name, "SKILL.md");
       try {
         await stat(skillMd);
         map.set(entry.name, { name: entry.name, path: skillMd, enabled: true });
@@ -298,7 +478,7 @@ function extractSkillDescriptionFromMarkdown(markdown) {
   return "";
 }
 function getSkillsSyncStatePath() {
-  return join(getCodexHomeDir(), "skills-sync.json");
+  return join2(getCodexHomeDir(), "skills-sync.json");
 }
 async function readSkillsSyncState() {
   try {
@@ -371,14 +551,14 @@ async function completeGithubDeviceLogin(deviceCode) {
 }
 function isAndroidLikeRuntime() {
   if (process.platform === "android") return true;
-  if (existsSync("/data/data/com.termux")) return true;
+  if (existsSync2("/data/data/com.termux")) return true;
   if (process.env.TERMUX_VERSION) return true;
   const prefix = process.env.PREFIX?.toLowerCase() ?? "";
   if (prefix.includes("/com.termux/")) return true;
   const proot = process.env.PROOT_TMP_DIR?.toLowerCase() ?? "";
   return proot.length > 0;
 }
-function getPreferredSyncBranch() {
+function getPreferredPublicUpstreamBranch() {
   return isAndroidLikeRuntime() ? "android" : "main";
 }
 function isUpstreamSkillsRepo(repoOwner, repoName) {
@@ -433,10 +613,10 @@ async function ensurePrivateForkFromUpstream(token, username, repoName) {
   }
   if (!ready) throw new Error("Private mirror repo was created but is not available yet");
   if (!created) return;
-  const tmp = await mkdtemp(join(tmpdir(), "codex-skills-seed-"));
+  const tmp = await mkdtemp(join2(tmpdir(), "codex-skills-seed-"));
   try {
     const upstreamUrl = `https://github.com/${SYNC_UPSTREAM_SKILLS_OWNER}/${SYNC_UPSTREAM_SKILLS_REPO}.git`;
-    const branch = getPreferredSyncBranch();
+    const branch = PRIVATE_SYNC_BRANCH;
     try {
       await runCommand("git", ["clone", "--depth", "1", "--single-branch", "--branch", branch, upstreamUrl, tmp]);
     } catch {
@@ -507,7 +687,7 @@ function toGitHubTokenRemote(repoOwner, repoName, token) {
 async function ensureSkillsWorkingTreeRepo(repoUrl, branch) {
   const localDir = getSkillsInstallDir();
   await mkdir(localDir, { recursive: true });
-  const gitDir = join(localDir, ".git");
+  const gitDir = join2(localDir, ".git");
   let hasGitDir = false;
   try {
     hasGitDir = (await stat(gitDir)).isDirectory();
@@ -553,7 +733,7 @@ async function ensureSkillsWorkingTreeRepo(repoUrl, branch) {
   }
   let pulledMtimes = /* @__PURE__ */ new Map();
   try {
-    await runCommand("git", ["pull", "--no-rebase", "origin", branch], { cwd: localDir });
+    await runCommand("git", ["pull", "--no-rebase", "--no-ff", "origin", branch], { cwd: localDir });
     pulledMtimes = await snapshotFileMtimes(localDir);
   } catch {
     await resolveMergeConflictsByNewerCommit(localDir, branch);
@@ -622,7 +802,7 @@ async function walkFileMtimes(rootDir, currentDir, out) {
   for (const entry of entries) {
     const entryName = String(entry.name);
     if (entryName === ".git") continue;
-    const absolutePath = join(currentDir, entryName);
+    const absolutePath = join2(currentDir, entryName);
     const relativePath = absolutePath.slice(rootDir.length + 1);
     if (entry.isDirectory()) {
       await walkFileMtimes(rootDir, absolutePath, out);
@@ -637,8 +817,37 @@ async function walkFileMtimes(rootDir, currentDir, out) {
   }
 }
 async function syncInstalledSkillsFolderToRepo(token, repoOwner, repoName, _installedMap) {
+  function isNonFastForwardPushError(error) {
+    const text = getErrorMessage(error, "").toLowerCase();
+    return text.includes("non-fast-forward") || text.includes("fetch first") || text.includes("rejected") && text.includes("push");
+  }
+  async function pushWithNonFastForwardRetry(repoDir2, branch2) {
+    const maxAttempts = 3;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        await runCommand("git", ["push", "origin", `HEAD:${branch2}`], { cwd: repoDir2 });
+        return;
+      } catch (error) {
+        if (!isNonFastForwardPushError(error) || attempt >= maxAttempts) {
+          throw error;
+        }
+      }
+      await runCommand("git", ["fetch", "origin"], { cwd: repoDir2 });
+      try {
+        await runCommand("git", ["pull", "--no-rebase", "--no-ff", "origin", branch2], { cwd: repoDir2 });
+      } catch {
+        await resolveMergeConflictsByNewerCommit(repoDir2, branch2);
+      }
+      await runCommand("git", ["add", "."], { cwd: repoDir2 });
+      const statusAfterReconcile = (await runCommandWithOutput("git", ["status", "--porcelain"], { cwd: repoDir2 })).trim();
+      if (statusAfterReconcile) {
+        await runCommand("git", ["commit", "-m", "Reconcile skills sync before push retry"], { cwd: repoDir2 });
+      }
+    }
+    throw new Error("Failed to push after non-fast-forward retries");
+  }
   const remoteUrl = toGitHubTokenRemote(repoOwner, repoName, token);
-  const branch = getPreferredSyncBranch();
+  const branch = PRIVATE_SYNC_BRANCH;
   const repoDir = await ensureSkillsWorkingTreeRepo(remoteUrl, branch);
   void _installedMap;
   await runCommand("git", ["config", "user.email", "skills-sync@local"], { cwd: repoDir });
@@ -647,16 +856,16 @@ async function syncInstalledSkillsFolderToRepo(token, repoOwner, repoName, _inst
   const status = (await runCommandWithOutput("git", ["status", "--porcelain"], { cwd: repoDir })).trim();
   if (!status) return;
   await runCommand("git", ["commit", "-m", "Sync installed skills folder and manifest"], { cwd: repoDir });
-  await runCommand("git", ["push", "origin", `HEAD:${branch}`], { cwd: repoDir });
+  await pushWithNonFastForwardRetry(repoDir, branch);
 }
 async function pullInstalledSkillsFolderFromRepo(token, repoOwner, repoName) {
   const remoteUrl = toGitHubTokenRemote(repoOwner, repoName, token);
-  const branch = getPreferredSyncBranch();
+  const branch = PRIVATE_SYNC_BRANCH;
   await ensureSkillsWorkingTreeRepo(remoteUrl, branch);
 }
 async function bootstrapSkillsFromUpstreamIntoLocal() {
   const repoUrl = `https://github.com/${SYNC_UPSTREAM_SKILLS_OWNER}/${SYNC_UPSTREAM_SKILLS_REPO}.git`;
-  const branch = getPreferredSyncBranch();
+  const branch = getPreferredPublicUpstreamBranch();
   await ensureSkillsWorkingTreeRepo(repoUrl, branch);
 }
 async function collectLocalSyncedSkills(appServer) {
@@ -716,9 +925,9 @@ async function autoPushSyncedSkills(appServer) {
 }
 async function ensureCodexAgentsSymlinkToSkillsAgents() {
   const codexHomeDir = getCodexHomeDir();
-  const skillsAgentsPath = join(codexHomeDir, "skills", "AGENTS.md");
-  const codexAgentsPath = join(codexHomeDir, "AGENTS.md");
-  await mkdir(join(codexHomeDir, "skills"), { recursive: true });
+  const skillsAgentsPath = join2(codexHomeDir, "skills", "AGENTS.md");
+  const codexAgentsPath = join2(codexHomeDir, "AGENTS.md");
+  await mkdir(join2(codexHomeDir, "skills"), { recursive: true });
   let copiedFromCodex = false;
   try {
     const codexAgentsStat = await lstat(codexAgentsPath);
@@ -742,7 +951,7 @@ async function ensureCodexAgentsSymlinkToSkillsAgents() {
       await writeFile(skillsAgentsPath, "", "utf8");
     }
   }
-  const relativeTarget = join("skills", "AGENTS.md");
+  const relativeTarget = join2("skills", "AGENTS.md");
   try {
     const current = await lstat(codexAgentsPath);
     if (current.isSymbolicLink()) {
@@ -760,7 +969,7 @@ async function initializeSkillsSyncOnStartup(appServer) {
   startupSyncStatus.inProgress = true;
   startupSyncStatus.lastRunAtIso = (/* @__PURE__ */ new Date()).toISOString();
   startupSyncStatus.lastError = "";
-  startupSyncStatus.branch = getPreferredSyncBranch();
+  startupSyncStatus.branch = PRIVATE_SYNC_BRANCH;
   try {
     const state = await readSkillsSyncState();
     if (!state.githubToken) {
@@ -772,6 +981,7 @@ async function initializeSkillsSyncOnStartup(appServer) {
         return;
       }
       startupSyncStatus.mode = "unauthenticated-bootstrap";
+      startupSyncStatus.branch = getPreferredPublicUpstreamBranch();
       startupSyncStatus.lastAction = "pull-upstream";
       await bootstrapSkillsFromUpstreamIntoLocal();
       try {
@@ -783,6 +993,7 @@ async function initializeSkillsSyncOnStartup(appServer) {
       return;
     }
     startupSyncStatus.mode = "authenticated-fork-sync";
+    startupSyncStatus.branch = PRIVATE_SYNC_BRANCH;
     startupSyncStatus.lastAction = "ensure-private-fork";
     const username = state.githubUsername || await resolveGithubUsername(state.githubToken);
     const repoName = DEFAULT_SKILLS_SYNC_REPO_NAME;
@@ -1022,13 +1233,21 @@ async function handleSkillsRoutes(req, res, url, context) {
       }
       const localDir = await detectUserSkillsDir(appServer);
       await pullInstalledSkillsFolderFromRepo(state.githubToken, state.repoOwner, state.repoName);
-      const installerScript = resolveSkillInstallerScriptPath();
+      const installerScript = resolveSkillInstallerScriptPath(getCodexHomeDir());
+      if (!installerScript) {
+        throw new Error("Skill installer script not found");
+      }
+      const pythonCommand = resolvePythonCommand();
+      if (!pythonCommand) {
+        throw new Error("Python 3 is required to install skills");
+      }
       const localSkills = await scanInstalledSkillsFromDisk();
       for (const skill of remote) {
         const owner = skill.owner || uniqueOwnerByName.get(skill.name) || "";
         if (!owner) continue;
         if (!localSkills.has(skill.name)) {
-          await runCommand("python3", [
+          await runCommand(pythonCommand.command, [
+            ...pythonCommand.args,
             installerScript,
             "--repo",
             `${HUB_SKILLS_OWNER}/${HUB_SKILLS_REPO}`,
@@ -1040,7 +1259,7 @@ async function handleSkillsRoutes(req, res, url, context) {
             "git"
           ]);
         }
-        const skillPath = join(localDir, skill.name);
+        const skillPath = join2(localDir, skill.name);
         await appServer.rpc("skills/config/write", { path: skillPath, enabled: skill.enabled });
       }
       const remoteNames = new Set(remote.map((row) => row.name));
@@ -1106,9 +1325,25 @@ async function handleSkillsRoutes(req, res, url, context) {
         setJson(res, 400, { error: "Missing owner or name" });
         return true;
       }
-      const installerScript = resolveSkillInstallerScriptPath();
-      const installDest = await detectUserSkillsDir(appServer);
-      await runCommand("python3", [
+      const installerScript = resolveSkillInstallerScriptPath(getCodexHomeDir());
+      if (!installerScript) {
+        throw new Error("Skill installer script not found");
+      }
+      const pythonCommand = resolvePythonCommand();
+      if (!pythonCommand) {
+        throw new Error("Python 3 is required to install skills");
+      }
+      const installDest = await withTimeout(
+        detectUserSkillsDir(appServer),
+        1e4,
+        "detectUserSkillsDir"
+      ).catch(() => getSkillsInstallDir());
+      const skillDir = join2(installDest, name);
+      if (existsSync2(skillDir)) {
+        await rm(skillDir, { recursive: true, force: true });
+      }
+      await runCommand(pythonCommand.command, [
+        ...pythonCommand.args,
         installerScript,
         "--repo",
         `${HUB_SKILLS_OWNER}/${HUB_SKILLS_REPO}`,
@@ -1118,13 +1353,16 @@ async function handleSkillsRoutes(req, res, url, context) {
         installDest,
         "--method",
         "git"
-      ]);
-      const skillDir = join(installDest, name);
-      await ensureInstalledSkillIsValid(appServer, skillDir);
+      ], { timeoutMs: 9e4 });
+      try {
+        await withTimeout(ensureInstalledSkillIsValid(appServer, skillDir), 1e4, "ensureInstalledSkillIsValid");
+      } catch {
+      }
       const syncState = await readSkillsSyncState();
       const nextOwners = { ...syncState.installedOwners ?? {}, [name]: owner };
       await writeSkillsSyncState({ ...syncState, installedOwners: nextOwners });
-      await autoPushSyncedSkills(appServer);
+      autoPushSyncedSkills(appServer).catch(() => {
+      });
       setJson(res, 200, { ok: true, path: skillDir });
     } catch (error) {
       setJson(res, 502, { error: getErrorMessage(error, "Failed to install skill") });
@@ -1136,7 +1374,7 @@ async function handleSkillsRoutes(req, res, url, context) {
       const payload = asRecord(await readJsonBody2(req));
       const name = typeof payload?.name === "string" ? payload.name : "";
       const path = typeof payload?.path === "string" ? payload.path : "";
-      const target = path || (name ? join(getSkillsInstallDir(), name) : "");
+      const target = path || (name ? join2(getSkillsInstallDir(), name) : "");
       if (!target) {
         setJson(res, 400, { error: "Missing name or path" });
         return true;
@@ -1148,9 +1386,10 @@ async function handleSkillsRoutes(req, res, url, context) {
         delete nextOwners[name];
         await writeSkillsSyncState({ ...syncState, installedOwners: nextOwners });
       }
-      await autoPushSyncedSkills(appServer);
+      autoPushSyncedSkills(appServer).catch(() => {
+      });
       try {
-        await appServer.rpc("skills/list", { forceReload: true });
+        await withTimeout(appServer.rpc("skills/list", { forceReload: true }), 1e4, "skills/list reload");
       } catch {
       }
       setJson(res, 200, { ok: true, deletedPath: target });
@@ -1529,10 +1768,8 @@ ${summary}`;
 };
 
 // src/utils/commandInvocation.ts
-import { spawnSync } from "child_process";
-import { existsSync as existsSync2 } from "fs";
-import { homedir as homedir2 } from "os";
-import { basename as basename2, extname, join as join2 } from "path";
+import { spawnSync as spawnSync2 } from "child_process";
+import { basename as basename2, extname } from "path";
 var WINDOWS_CMD_NAMES = /* @__PURE__ */ new Set(["codex", "npm", "npx"]);
 function quoteCmdExeArg(value) {
   const normalized = value.replace(/"/g, '""');
@@ -1566,44 +1803,7 @@ function getSpawnInvocation(command, args = []) {
 }
 function spawnSyncCommand(command, args = [], options = {}) {
   const invocation = getSpawnInvocation(command, args);
-  return spawnSync(invocation.command, invocation.args, options);
-}
-function canRunCommand(command, args = []) {
-  const result = spawnSyncCommand(command, args, { stdio: "ignore" });
-  return result.status === 0;
-}
-function getUserNpmPrefix() {
-  return join2(homedir2(), ".npm-global");
-}
-function resolveCodexCommand() {
-  if (canRunCommand("codex", ["--version"])) {
-    return "codex";
-  }
-  if (process.platform === "win32") {
-    const windowsCandidates = [
-      process.env.APPDATA ? join2(process.env.APPDATA, "npm", "codex.cmd") : "",
-      join2(homedir2(), ".local", "bin", "codex.cmd"),
-      join2(getUserNpmPrefix(), "bin", "codex.cmd")
-    ].filter(Boolean);
-    for (const candidate2 of windowsCandidates) {
-      if (existsSync2(candidate2) && canRunCommand(candidate2, ["--version"])) {
-        return candidate2;
-      }
-    }
-  }
-  const userCandidate = join2(getUserNpmPrefix(), "bin", "codex");
-  if (existsSync2(userCandidate) && canRunCommand(userCandidate, ["--version"])) {
-    return userCandidate;
-  }
-  const prefix = process.env.PREFIX?.trim();
-  if (!prefix) {
-    return null;
-  }
-  const candidate = join2(prefix, "bin", "codex");
-  if (existsSync2(candidate) && canRunCommand(candidate, ["--version"])) {
-    return candidate;
-  }
-  return null;
+  return spawnSync2(invocation.command, invocation.args, options);
 }
 
 // src/server/codexAppServerBridge.ts
@@ -1681,9 +1881,62 @@ 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 repoBlockMatch = row.match(/<h2[\s\S]*?<\/h2>/);
+    const hrefMatch = repoBlockMatch?.[0]?.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[^>]*class="[^"]*col-9[^"]*"[^>]*>([\s\S]*?)<\/p>/) ?? row.match(/<p[^>]*class="[^"]*color-fg-muted[^"]*"[^>]*>([\s\S]*?)<\/p>/) ?? 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"], {
+    const ripgrepCommand = resolveRipgrepCommand();
+    if (!ripgrepCommand) {
+      reject(new Error("ripgrep (rg) is not available"));
+      return;
+    }
+    const proc = spawn2(ripgrepCommand, ["--files", "--hidden", "-g", "!.git", "-g", "!node_modules"], {
       cwd,
       env: process.env,
       stdio: ["ignore", "pipe", "pipe"]
@@ -1840,14 +2093,70 @@ function normalizeCommitMessage(value) {
   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 });
+function getRollbackGitDirForCwd(cwd) {
+  return join3(cwd, ".codex", "rollbacks", ".git");
+}
+async function ensureLocalCodexGitignoreHasRollbacks(cwd) {
+  const localCodexDir = join3(cwd, ".codex");
+  const gitignorePath = join3(localCodexDir, ".gitignore");
+  await mkdir2(localCodexDir, { recursive: true });
+  let current = "";
+  try {
+    current = await readFile2(gitignorePath, "utf8");
+  } catch {
+    current = "";
+  }
+  const rows = current.split(/\r?\n/).map((line) => line.trim());
+  if (rows.includes("rollbacks/")) return;
+  const prefix = current.length > 0 && !current.endsWith("\n") ? `${current}
+` : current;
+  await writeFile2(gitignorePath, `${prefix}rollbacks/
+`, "utf8");
+}
+async function ensureRollbackGitRepo(cwd) {
+  const gitDir = getRollbackGitDirForCwd(cwd);
+  try {
+    const headInfo = await stat2(join3(gitDir, "HEAD"));
+    if (!headInfo.isFile()) {
+      throw new Error("Invalid rollback git repository");
+    }
+  } catch {
+    await mkdir2(dirname(gitDir), { recursive: true });
+    await runCommand2("git", ["--git-dir", gitDir, "--work-tree", cwd, "init"]);
+  }
+  await runCommand2("git", ["--git-dir", gitDir, "config", "user.email", "codex@local"]);
+  await runCommand2("git", ["--git-dir", gitDir, "config", "user.name", "Codex Rollback"]);
+  try {
+    await runCommandCapture("git", ["--git-dir", gitDir, "--work-tree", cwd, "rev-parse", "--verify", "HEAD"]);
+  } catch {
+    await runCommand2(
+      "git",
+      ["--git-dir", gitDir, "--work-tree", cwd, "commit", "--allow-empty", "-m", "Initialize rollback history"]
+    );
+  }
+  await ensureLocalCodexGitignoreHasRollbacks(cwd);
+  return gitDir;
+}
+async function runRollbackGit(cwd, args) {
+  const gitDir = await ensureRollbackGitRepo(cwd);
+  await runCommand2("git", ["--git-dir", gitDir, "--work-tree", cwd, ...args]);
+}
+async function runRollbackGitCapture(cwd, args) {
+  const gitDir = await ensureRollbackGitRepo(cwd);
+  return await runCommandCapture("git", ["--git-dir", gitDir, "--work-tree", cwd, ...args]);
+}
+async function runRollbackGitWithOutput(cwd, args) {
+  const gitDir = await ensureRollbackGitRepo(cwd);
+  return await runCommandWithOutput2("git", ["--git-dir", gitDir, "--work-tree", cwd, ...args]);
+}
+async function hasRollbackGitWorkingTreeChanges(cwd) {
+  const status = await runRollbackGitWithOutput(cwd, ["status", "--porcelain"]);
   return status.trim().length > 0;
 }
-async function findCommitByExactMessage(cwd, message) {
+async function findRollbackCommitByExactMessage(cwd, message) {
   const normalizedTarget = normalizeCommitMessage(message);
   if (!normalizedTarget) return "";
-  const raw = await runCommandWithOutput2("git", ["log", "--format=%H%x1f%B%x1e"], { cwd });
+  const raw = await runRollbackGitWithOutput(cwd, ["log", "--format=%H%x1f%B%x1e"]);
   const entries = raw.split("");
   for (const entry of entries) {
     if (!entry.trim()) continue;
@@ -2273,10 +2582,17 @@ var AppServerProcess = class {
       'sandbox_mode="danger-full-access"'
     ];
   }
+  getCodexCommand() {
+    const codexCommand = resolveCodexCommand();
+    if (!codexCommand) {
+      throw new Error("Codex CLI is not available. Install @openai/codex or set CODEXUI_CODEX_COMMAND.");
+    }
+    return codexCommand;
+  }
   start() {
     if (this.process) return;
     this.stopping = false;
-    const invocation = getSpawnInvocation(resolveCodexCommand() ?? "codex", this.appServerArgs);
+    const invocation = getSpawnInvocation(this.getCodexCommand(), this.appServerArgs);
     const proc = spawn2(invocation.command, invocation.args, { stdio: ["pipe", "pipe", "pipe"] });
     this.process = proc;
     proc.stdout.setEncoding("utf8");
@@ -2503,7 +2819,12 @@ var MethodCatalog = class {
   }
   async runGenerateSchemaCommand(outDir) {
     await new Promise((resolve3, reject) => {
-      const invocation = getSpawnInvocation(resolveCodexCommand() ?? "codex", ["app-server", "generate-json-schema", "--out", outDir]);
+      const codexCommand = resolveCodexCommand();
+      if (!codexCommand) {
+        reject(new Error("Codex CLI is not available. Install @openai/codex or set CODEXUI_CODEX_COMMAND."));
+        return;
+      }
+      const invocation = getSpawnInvocation(codexCommand, ["app-server", "generate-json-schema", "--out", outDir]);
       const process2 = spawn2(invocation.command, invocation.args, {
         stdio: ["ignore", "ignore", "pipe"]
       });
@@ -2748,6 +3069,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: getErrorMessage3(error, "Failed to fetch GitHub trending") });
+        }
+        return;
+      }
       if (req.method === "POST" && url.pathname === "/codex-api/worktree/create") {
         const payload = asRecord3(await readJsonBody(req));
         const rawSourceCwd = typeof payload?.sourceCwd === "string" ? payload.sourceCwd.trim() : "";
@@ -2842,22 +3176,22 @@ function createCodexBridgeMiddleware() {
           return;
         }
         try {
-          await runCommandCapture("git", ["rev-parse", "--is-inside-work-tree"], { cwd });
-          const beforeStatus = await runCommandWithOutput2("git", ["status", "--porcelain"], { cwd });
+          await ensureRollbackGitRepo(cwd);
+          const beforeStatus = await runRollbackGitWithOutput(cwd, ["status", "--porcelain"]);
           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 });
+          await runRollbackGit(cwd, ["add", "-A"]);
+          const stagedStatus = await runRollbackGitWithOutput(cwd, ["diff", "--cached", "--name-only"]);
           if (!stagedStatus.trim()) {
             setJson2(res, 200, { data: { committed: false } });
             return;
           }
-          await runCommand2("git", ["commit", "-m", commitMessage], { cwd });
+          await runRollbackGit(cwd, ["commit", "-m", commitMessage]);
           setJson2(res, 200, { data: { committed: true } });
         } catch (error) {
-          setJson2(res, 500, { error: getErrorMessage3(error, "Failed to auto-commit worktree changes") });
+          setJson2(res, 500, { error: getErrorMessage3(error, "Failed to auto-commit rollback changes") });
         }
         return;
       }
@@ -2885,29 +3219,29 @@ function createCodexBridgeMiddleware() {
           return;
         }
         try {
-          await runCommandCapture("git", ["rev-parse", "--is-inside-work-tree"], { cwd });
-          const commitSha = await findCommitByExactMessage(cwd, commitMessage);
+          await ensureRollbackGitRepo(cwd);
+          const commitSha = await findRollbackCommitByExactMessage(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 });
+            resetTargetSha = await runRollbackGitCapture(cwd, ["rev-parse", `${commitSha}^`]);
           } catch {
             setJson2(res, 409, { error: "Cannot rollback: matched commit has no parent commit" });
             return;
           }
           let stashed = false;
-          if (await hasGitWorkingTreeChanges(cwd)) {
+          if (await hasRollbackGitWorkingTreeChanges(cwd)) {
             const stashMessage = `codex-auto-stash-before-rollback-${Date.now()}`;
-            await runCommand2("git", ["stash", "push", "-u", "-m", stashMessage], { cwd });
+            await runRollbackGit(cwd, ["stash", "push", "-u", "-m", stashMessage]);
             stashed = true;
           }
-          await runCommand2("git", ["reset", "--hard", resetTargetSha], { cwd });
+          await runRollbackGit(cwd, ["reset", "--hard", resetTargetSha]);
           setJson2(res, 200, { data: { reset: true, commitSha, resetTargetSha, stashed } });
         } catch (error) {
-          setJson2(res, 500, { error: getErrorMessage3(error, "Failed to rollback worktree to user message commit") });
+          setJson2(res, 500, { error: getErrorMessage3(error, "Failed to rollback project to user message commit") });
         }
         return;
       }
@@ -3252,7 +3586,7 @@ function createAuthSession(password) {
 }
 
 // src/server/localBrowseUi.ts
-import { dirname, extname as extname2, join as join4 } from "path";
+import { dirname as dirname2, extname as extname2, join as join4 } from "path";
 import { open, readFile as readFile3, readdir as readdir3, stat as stat3 } from "fs/promises";
 var TEXT_EDITABLE_EXTENSIONS = /* @__PURE__ */ new Set([
   ".txt",
@@ -3410,7 +3744,7 @@ async function getDirectoryItems(localPath) {
 }
 async function createDirectoryListingHtml(localPath) {
   const items = await getDirectoryItems(localPath);
-  const parentPath = dirname(localPath);
+  const parentPath = dirname2(localPath);
   const rows = items.map((item) => {
     const suffix = item.isDirectory ? "/" : "";
     const editAction = item.editable ? ` <a class="icon-btn" aria-label="Edit ${escapeHtml(item.name)}" href="${escapeHtml(toEditHref(item.path))}" title="Edit">\u270F\uFE0F</a>` : "";
@@ -3507,7 +3841,7 @@ async function createDirectoryListingHtml(localPath) {
 }
 async function createTextEditorHtml(localPath) {
   const content = await readFile3(localPath, "utf8");
-  const parentPath = dirname(localPath);
+  const parentPath = dirname2(localPath);
   const language = languageForPath(localPath);
   const safeContentLiteral = escapeForInlineScriptString(content);
   return `<!doctype html>
@@ -3576,7 +3910,7 @@ async function createTextEditorHtml(localPath) {
 
 // src/server/httpServer.ts
 import { WebSocketServer } from "ws";
-var __dirname = dirname2(fileURLToPath(import.meta.url));
+var __dirname = dirname3(fileURLToPath(import.meta.url));
 var distDir = join5(__dirname, "..", "dist");
 var spaEntryFile = join5(distDir, "index.html");
 var IMAGE_CONTENT_TYPES = {
@@ -3792,7 +4126,7 @@ 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 __dirname2 = dirname4(fileURLToPath2(import.meta.url));
 var hasPromptedCloudflaredInstall = false;
 function getCodexHomePath() {
   return process.env.CODEX_HOME?.trim() || join6(homedir4(), ".codex");
@@ -3822,10 +4156,6 @@ async function readCliVersion() {
 function isTermuxRuntime() {
   return Boolean(process.env.TERMUX_VERSION || process.env.PREFIX?.includes("/com.termux/"));
 }
-function canRun(command, args = []) {
-  const result = canRunCommand(command, args);
-  return result;
-}
 function runOrFail(command, args, label) {
   const result = spawnSyncCommand(command, args, { stdio: "inherit" });
   if (result.status !== 0) {
@@ -3837,11 +4167,11 @@ function runWithStatus(command, args) {
   return result.status ?? -1;
 }
 function resolveCloudflaredCommand() {
-  if (canRun("cloudflared", ["--version"])) {
+  if (canRunCommand("cloudflared", ["--version"])) {
     return "cloudflared";
   }
   const localCandidate = join6(homedir4(), ".local", "bin", "cloudflared");
-  if (existsSync5(localCandidate) && canRun(localCandidate, ["--version"])) {
+  if (existsSync5(localCandidate) && canRunCommand(localCandidate, ["--version"])) {
     return localCandidate;
   }
   return null;
@@ -3901,7 +4231,7 @@ async function ensureCloudflaredInstalledLinux() {
   console.log("\ncloudflared not found. Installing to ~/.local/bin...\n");
   await downloadFile(downloadUrl, destination);
   chmodSync(destination, 493);
-  process.env.PATH = `${userBinDir}:${process.env.PATH ?? ""}`;
+  process.env.PATH = prependPathEntry(process.env.PATH ?? "", userBinDir);
   const installed = resolveCloudflaredCommand();
   if (!installed) {
     throw new Error("cloudflared download completed but executable is still not available");
@@ -3965,7 +4295,7 @@ function ensureCodexInstalled() {
 Global npm install requires elevated permissions. Retrying with --prefix ${userPrefix}...
 `);
       runOrFail("npm", ["install", "-g", "--prefix", userPrefix, pkg], `${label} (user prefix)`);
-      process.env.PATH = `${join6(userPrefix, "bin")}:${process.env.PATH ?? ""}`;
+      process.env.PATH = prependPathEntry(process.env.PATH ?? "", getNpmGlobalBinDir(userPrefix));
     };
     if (isTermuxRuntime()) {
       console.log("\nCodex CLI not found. Installing Termux-compatible Codex CLI from npm...\n");
@@ -4172,6 +4502,9 @@ async function startServer(options) {
     }
   }
   const codexCommand = ensureCodexInstalled() ?? resolveCodexCommand();
+  if (codexCommand) {
+    process.env.CODEXUI_CODEX_COMMAND = codexCommand;
+  }
   if (!hasCodexAuth() && codexCommand) {
     console.log("\nCodex is not logged in. Starting `codex login`...\n");
     runOrFail(codexCommand, ["login"], "Codex login");
@@ -4251,6 +4584,7 @@ async function startServer(options) {
 }
 async function runLogin() {
   const codexCommand = ensureCodexInstalled() ?? "codex";
+  process.env.CODEXUI_CODEX_COMMAND = codexCommand;
   console.log("\nStarting `codex login`...\n");
   runOrFail(codexCommand, ["login"], "Codex login");
 }