codexapp 0.1.33 → 0.1.35

package/dist-cli/index.js

@@ -1,33 +1,42 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
-import "dotenv/config";
 import { createServer as createServer2 } from "http";
-import { existsSync as existsSync3 } from "fs";
-import { readFile as readFile2 } from "fs/promises";
-import { homedir as homedir2 } from "os";
-import { join as join3 } from "path";
-import { spawn as spawn2, spawnSync } from "child_process";
+import { chmodSync, createWriteStream, existsSync as existsSync3, mkdirSync } from "fs";
+import { readFile as readFile4 } from "fs/promises";
+import { homedir as homedir3, networkInterfaces } from "os";
+import { join as join5 } from "path";
+import { spawn as spawn3, spawnSync } from "child_process";
+import { createInterface } from "readline/promises";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname2 } from "path";
+import { dirname as dirname3 } from "path";
+import { get as httpsGet } from "https";
 import { Command } from "commander";
 import qrcode from "qrcode-terminal";
 
 // src/server/httpServer.ts
 import { fileURLToPath } from "url";
-import { dirname, extname, isAbsolute as isAbsolute2, join as join2 } from "path";
+import { dirname as dirname2, extname as extname2, isAbsolute as isAbsolute2, join as join4 } from "path";
 import { existsSync as existsSync2 } from "fs";
+import { writeFile as writeFile3, stat as stat4 } from "fs/promises";
 import express from "express";
 
 // src/server/codexAppServerBridge.ts
-import "dotenv/config";
+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 { 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 { 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 { request as httpsRequest } from "https";
-import { homedir } from "os";
-import { tmpdir } from "os";
-import { isAbsolute, join, resolve } from "path";
+import { homedir, tmpdir } from "os";
+import { join } from "path";
 import { writeFile } from "fs/promises";
 function asRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -51,45 +60,6 @@ function setJson(res, statusCode, payload) {
   res.setHeader("Content-Type", "application/json; charset=utf-8");
   res.end(JSON.stringify(payload));
 }
-function scoreFileCandidate(path, query) {
-  if (!query) return 0;
-  const lowerPath = path.toLowerCase();
-  const lowerQuery = query.toLowerCase();
-  const baseName = lowerPath.slice(lowerPath.lastIndexOf("/") + 1);
-  if (baseName === lowerQuery) return 0;
-  if (baseName.startsWith(lowerQuery)) return 1;
-  if (baseName.includes(lowerQuery)) return 2;
-  if (lowerPath.includes(`/${lowerQuery}`)) return 3;
-  if (lowerPath.includes(lowerQuery)) return 4;
-  return 10;
-}
-async function listFilesWithRipgrep(cwd) {
-  return await new Promise((resolve2, reject) => {
-    const proc = spawn("rg", ["--files", "--hidden", "-g", "!.git", "-g", "!node_modules"], {
-      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) {
-        const rows = stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-        resolve2(rows);
-        return;
-      }
-      const details = [stderr.trim(), stdout.trim()].filter(Boolean).join("\n");
-      reject(new Error(details || "rg --files failed"));
-    });
-  });
-}
 function getCodexHomeDir() {
   const codexHome = process.env.CODEX_HOME?.trim();
   return codexHome && codexHome.length > 0 ? codexHome : join(homedir(), ".codex");
@@ -142,7 +112,7 @@ async function runCommandWithOutput(command, args, options = {}) {
     proc.on("error", reject);
     proc.on("close", (code) => {
       if (code === 0) {
-        resolve2(stdout);
+        resolve2(stdout.trim());
         return;
       }
       const details = [stderr.trim(), stdout.trim()].filter(Boolean).join("\n");
@@ -234,7 +204,7 @@ async function fetchMetaBatch(entries) {
   const toFetch = entries.filter((e) => !metaCache.has(`${e.owner}/${e.name}`));
   if (toFetch.length === 0) return;
   const batch = toFetch.slice(0, 50);
-  const results = await Promise.allSettled(
+  await Promise.allSettled(
     batch.map(async (e) => {
       const rawUrl = `https://raw.githubusercontent.com/${HUB_SKILLS_OWNER}/${HUB_SKILLS_REPO}/main/skills/${e.owner}/${e.name}/_meta.json`;
       const resp = await fetch(rawUrl);
@@ -247,7 +217,6 @@ async function fetchMetaBatch(entries) {
       });
     })
   );
-  void results;
 }
 function buildHubEntry(e) {
   const cached = metaCache.get(`${e.owner}/${e.name}`);
@@ -376,8 +345,7 @@ function isAndroidLikeRuntime() {
   const prefix = process.env.PREFIX?.toLowerCase() ?? "";
   if (prefix.includes("/com.termux/")) return true;
   const proot = process.env.PROOT_TMP_DIR?.toLowerCase() ?? "";
-  if (proot.length > 0) return true;
-  return false;
+  return proot.length > 0;
 }
 function getPreferredSyncBranch() {
   return isAndroidLikeRuntime() ? "android" : "main";
@@ -641,23 +609,21 @@ async function syncInstalledSkillsFolderToRepo(token, repoOwner, repoName, _inst
   const remoteUrl = toGitHubTokenRemote(repoOwner, repoName, token);
   const branch = getPreferredSyncBranch();
   const repoDir = await ensureSkillsWorkingTreeRepo(remoteUrl, branch);
-  const addPaths = ["."];
   void _installedMap;
   await runCommand("git", ["config", "user.email", "skills-sync@local"], { cwd: repoDir });
   await runCommand("git", ["config", "user.name", "Skills Sync"], { cwd: repoDir });
-  await runCommand("git", ["add", ...addPaths], { cwd: repoDir });
+  await runCommand("git", ["add", "."], { cwd: repoDir });
   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 });
 }
-async function pullInstalledSkillsFolderFromRepo(token, repoOwner, repoName, _localSkillsDir) {
+async function pullInstalledSkillsFolderFromRepo(token, repoOwner, repoName) {
   const remoteUrl = toGitHubTokenRemote(repoOwner, repoName, token);
   const branch = getPreferredSyncBranch();
   await ensureSkillsWorkingTreeRepo(remoteUrl, branch);
 }
-async function bootstrapSkillsFromUpstreamIntoLocal(_localSkillsDir) {
-  void _localSkillsDir;
+async function bootstrapSkillsFromUpstreamIntoLocal() {
   const repoUrl = `https://github.com/${SYNC_UPSTREAM_SKILLS_OWNER}/${SYNC_UPSTREAM_SKILLS_REPO}.git`;
   const branch = getPreferredSyncBranch();
   await ensureSkillsWorkingTreeRepo(repoUrl, branch);
@@ -721,11 +687,29 @@ 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 });
+  let copiedFromCodex = false;
   try {
-    const skillsAgentsStat = await stat(skillsAgentsPath);
-    if (!skillsAgentsStat.isFile()) return;
+    const codexAgentsStat = await lstat(codexAgentsPath);
+    if (codexAgentsStat.isFile() || codexAgentsStat.isSymbolicLink()) {
+      const content = await readFile(codexAgentsPath, "utf8");
+      await writeFile(skillsAgentsPath, content, "utf8");
+      copiedFromCodex = true;
+    } else {
+      await rm(codexAgentsPath, { force: true, recursive: true });
+    }
   } catch {
-    return;
+  }
+  if (!copiedFromCodex) {
+    try {
+      const skillsAgentsStat = await stat(skillsAgentsPath);
+      if (!skillsAgentsStat.isFile()) {
+        await rm(skillsAgentsPath, { force: true, recursive: true });
+        await writeFile(skillsAgentsPath, "", "utf8");
+      }
+    } catch {
+      await writeFile(skillsAgentsPath, "", "utf8");
+    }
   }
   const relativeTarget = join("skills", "AGENTS.md");
   try {
@@ -748,7 +732,6 @@ async function initializeSkillsSyncOnStartup(appServer) {
   startupSyncStatus.branch = getPreferredSyncBranch();
   try {
     const state = await readSkillsSyncState();
-    const localSkillsDir = getSkillsInstallDir();
     if (!state.githubToken) {
       await ensureCodexAgentsSymlinkToSkillsAgents();
       if (!isAndroidLikeRuntime()) {
@@ -759,7 +742,7 @@ async function initializeSkillsSyncOnStartup(appServer) {
       }
       startupSyncStatus.mode = "unauthenticated-bootstrap";
       startupSyncStatus.lastAction = "pull-upstream";
-      await bootstrapSkillsFromUpstreamIntoLocal(localSkillsDir);
+      await bootstrapSkillsFromUpstreamIntoLocal();
       try {
         await appServer.rpc("skills/list", { forceReload: true });
       } catch {
@@ -773,10 +756,9 @@ async function initializeSkillsSyncOnStartup(appServer) {
     const username = state.githubUsername || await resolveGithubUsername(state.githubToken);
     const repoName = DEFAULT_SKILLS_SYNC_REPO_NAME;
     await ensurePrivateForkFromUpstream(state.githubToken, username, repoName);
-    const nextState = { ...state, githubUsername: username, repoOwner: username, repoName };
-    await writeSkillsSyncState(nextState);
+    await writeSkillsSyncState({ ...state, githubUsername: username, repoOwner: username, repoName });
     startupSyncStatus.lastAction = "pull-private-fork";
-    await pullInstalledSkillsFolderFromRepo(state.githubToken, username, repoName, localSkillsDir);
+    await pullInstalledSkillsFolderFromRepo(state.githubToken, username, repoName);
     try {
       await appServer.rpc("skills/list", { forceReload: true });
     } catch {
@@ -796,15 +778,8 @@ async function finalizeGithubLoginAndSync(token, username, appServer) {
   const repoName = DEFAULT_SKILLS_SYNC_REPO_NAME;
   await ensurePrivateForkFromUpstream(token, username, repoName);
   const current = await readSkillsSyncState();
-  await writeSkillsSyncState({
-    ...current,
-    githubToken: token,
-    githubUsername: username,
-    repoOwner: username,
-    repoName
-  });
-  const localDir = getSkillsInstallDir();
-  await pullInstalledSkillsFolderFromRepo(token, username, repoName, localDir);
+  await writeSkillsSyncState({ ...current, githubToken: token, githubUsername: username, repoOwner: username, repoName });
+  await pullInstalledSkillsFolderFromRepo(token, username, repoName);
   try {
     await appServer.rpc("skills/list", { forceReload: true });
   } catch {
@@ -813,11 +788,10 @@ async function finalizeGithubLoginAndSync(token, username, appServer) {
 }
 async function searchSkillsHub(allEntries, query, limit, sort, installedMap) {
   const q = query.toLowerCase().trim();
-  let filtered = q ? allEntries.filter((s) => {
+  const filtered = q ? allEntries.filter((s) => {
     if (s.name.toLowerCase().includes(q) || s.owner.toLowerCase().includes(q)) return true;
     const cached = metaCache.get(`${s.owner}/${s.name}`);
-    if (cached?.displayName?.toLowerCase().includes(q)) return true;
-    return false;
+    return Boolean(cached?.displayName?.toLowerCase().includes(q));
   }) : allEntries;
   const page = filtered.slice(0, Math.min(limit * 2, 200));
   await fetchMetaBatch(page);
@@ -837,204 +811,692 @@ async function searchSkillsHub(allEntries, query, limit, sort, installedMap) {
     return local ? { ...s, installed: true, path: local.path, enabled: local.enabled } : s;
   });
 }
-function normalizeStringArray(value) {
-  if (!Array.isArray(value)) return [];
-  const normalized = [];
-  for (const item of value) {
-    if (typeof item === "string" && item.length > 0 && !normalized.includes(item)) {
-      normalized.push(item);
-    }
-  }
-  return normalized;
-}
-function normalizeStringRecord(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
-  const next = {};
-  for (const [key, item] of Object.entries(value)) {
-    if (typeof key === "string" && key.length > 0 && typeof item === "string") {
-      next[key] = item;
+async function handleSkillsRoutes(req, res, url, context) {
+  const { appServer, readJsonBody: readJsonBody2 } = context;
+  if (req.method === "GET" && url.pathname === "/codex-api/skills-hub") {
+    try {
+      const q = url.searchParams.get("q") || "";
+      const limit = Math.min(Math.max(parseInt(url.searchParams.get("limit") || "50", 10) || 50, 1), 200);
+      const sort = url.searchParams.get("sort") || "date";
+      const allEntries = await fetchSkillsTree();
+      const installedMap = await scanInstalledSkillsFromDisk();
+      try {
+        const result = await appServer.rpc("skills/list", {});
+        for (const entry of result.data ?? []) {
+          for (const skill of entry.skills ?? []) {
+            if (skill.name) {
+              installedMap.set(skill.name, { name: skill.name, path: skill.path ?? "", enabled: skill.enabled !== false });
+            }
+          }
+        }
+      } catch {
+      }
+      const installedHubEntries = allEntries.filter((e) => installedMap.has(e.name));
+      await fetchMetaBatch(installedHubEntries);
+      const installed = [];
+      for (const [, info] of installedMap) {
+        const hubEntry = allEntries.find((e) => e.name === info.name);
+        const base = hubEntry ? buildHubEntry(hubEntry) : {
+          name: info.name,
+          owner: "local",
+          description: "",
+          displayName: "",
+          publishedAt: 0,
+          avatarUrl: "",
+          url: "",
+          installed: false
+        };
+        installed.push({ ...base, installed: true, path: info.path, enabled: info.enabled });
+      }
+      const results = await searchSkillsHub(allEntries, q, limit, sort, installedMap);
+      setJson(res, 200, { data: results, installed, total: allEntries.length });
+    } catch (error) {
+      setJson(res, 502, { error: getErrorMessage(error, "Failed to fetch skills hub") });
     }
+    return true;
   }
-  return next;
-}
-function getCodexAuthPath() {
-  return join(getCodexHomeDir(), "auth.json");
-}
-async function readCodexAuth() {
-  try {
-    const raw = await readFile(getCodexAuthPath(), "utf8");
-    const auth = JSON.parse(raw);
-    const token = auth.tokens?.access_token;
-    if (!token) return null;
-    return { accessToken: token, accountId: auth.tokens?.account_id ?? void 0 };
-  } catch {
-    return null;
+  if (req.method === "GET" && url.pathname === "/codex-api/skills-sync/status") {
+    const state = await readSkillsSyncState();
+    setJson(res, 200, {
+      data: {
+        loggedIn: Boolean(state.githubToken),
+        githubUsername: state.githubUsername ?? "",
+        repoOwner: state.repoOwner ?? "",
+        repoName: state.repoName ?? "",
+        configured: Boolean(state.githubToken && state.repoOwner && state.repoName),
+        startup: {
+          inProgress: startupSyncStatus.inProgress,
+          mode: startupSyncStatus.mode,
+          branch: startupSyncStatus.branch,
+          lastAction: startupSyncStatus.lastAction,
+          lastRunAtIso: startupSyncStatus.lastRunAtIso,
+          lastSuccessAtIso: startupSyncStatus.lastSuccessAtIso,
+          lastError: startupSyncStatus.lastError
+        }
+      }
+    });
+    return true;
   }
-}
-function getCodexGlobalStatePath() {
-  return join(getCodexHomeDir(), ".codex-global-state.json");
-}
-var MAX_THREAD_TITLES = 500;
-function normalizeThreadTitleCache(value) {
-  const record = asRecord(value);
-  if (!record) return { titles: {}, order: [] };
-  const rawTitles = asRecord(record.titles);
-  const titles = {};
-  if (rawTitles) {
-    for (const [k, v] of Object.entries(rawTitles)) {
-      if (typeof v === "string" && v.length > 0) titles[k] = v;
+  if (req.method === "POST" && url.pathname === "/codex-api/skills-sync/github/start-login") {
+    try {
+      const started = await startGithubDeviceLogin();
+      setJson(res, 200, { data: started });
+    } catch (error) {
+      setJson(res, 502, { error: getErrorMessage(error, "Failed to start GitHub login") });
     }
+    return true;
   }
-  const order = normalizeStringArray(record.order);
-  return { titles, order };
-}
-function updateThreadTitleCache(cache, id, title) {
-  const titles = { ...cache.titles, [id]: title };
-  const order = [id, ...cache.order.filter((o) => o !== id)];
-  while (order.length > MAX_THREAD_TITLES) {
-    const removed = order.pop();
-    if (removed) delete titles[removed];
-  }
-  return { titles, order };
-}
-function removeFromThreadTitleCache(cache, id) {
-  const { [id]: _, ...titles } = cache.titles;
-  return { titles, order: cache.order.filter((o) => o !== id) };
-}
-async function readThreadTitleCache() {
-  const statePath = getCodexGlobalStatePath();
-  try {
-    const raw = await readFile(statePath, "utf8");
-    const payload = asRecord(JSON.parse(raw)) ?? {};
-    return normalizeThreadTitleCache(payload["thread-titles"]);
-  } catch {
-    return { titles: {}, order: [] };
-  }
-}
-async function writeThreadTitleCache(cache) {
-  const statePath = getCodexGlobalStatePath();
-  let payload = {};
-  try {
-    const raw = await readFile(statePath, "utf8");
-    payload = asRecord(JSON.parse(raw)) ?? {};
-  } catch {
-    payload = {};
-  }
-  payload["thread-titles"] = cache;
-  await writeFile(statePath, JSON.stringify(payload), "utf8");
-}
-async function readWorkspaceRootsState() {
-  const statePath = getCodexGlobalStatePath();
-  let payload = {};
-  try {
-    const raw = await readFile(statePath, "utf8");
-    const parsed = JSON.parse(raw);
-    payload = asRecord(parsed) ?? {};
-  } catch {
-    payload = {};
-  }
-  return {
-    order: normalizeStringArray(payload["electron-saved-workspace-roots"]),
-    labels: normalizeStringRecord(payload["electron-workspace-root-labels"]),
-    active: normalizeStringArray(payload["active-workspace-roots"])
-  };
-}
-async function writeWorkspaceRootsState(nextState) {
-  const statePath = getCodexGlobalStatePath();
-  let payload = {};
-  try {
-    const raw = await readFile(statePath, "utf8");
-    payload = asRecord(JSON.parse(raw)) ?? {};
-  } catch {
-    payload = {};
+  if (req.method === "POST" && url.pathname === "/codex-api/skills-sync/github/token-login") {
+    try {
+      const payload = asRecord(await readJsonBody2(req));
+      const token = typeof payload?.token === "string" ? payload.token.trim() : "";
+      if (!token) {
+        setJson(res, 400, { error: "Missing GitHub token" });
+        return true;
+      }
+      const username = await resolveGithubUsername(token);
+      await finalizeGithubLoginAndSync(token, username, appServer);
+      setJson(res, 200, { ok: true, data: { githubUsername: username } });
+    } catch (error) {
+      setJson(res, 502, { error: getErrorMessage(error, "Failed to login with GitHub token") });
+    }
+    return true;
   }
-  payload["electron-saved-workspace-roots"] = normalizeStringArray(nextState.order);
-  payload["electron-workspace-root-labels"] = normalizeStringRecord(nextState.labels);
-  payload["active-workspace-roots"] = normalizeStringArray(nextState.active);
-  await writeFile(statePath, JSON.stringify(payload), "utf8");
-}
-async function readJsonBody(req) {
-  const raw = await readRawBody(req);
-  if (raw.length === 0) return null;
-  const text = raw.toString("utf8").trim();
-  if (text.length === 0) return null;
-  return JSON.parse(text);
-}
-async function readRawBody(req) {
-  const chunks = [];
-  for await (const chunk of req) {
-    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  if (req.method === "POST" && url.pathname === "/codex-api/skills-sync/github/logout") {
+    try {
+      const state = await readSkillsSyncState();
+      await writeSkillsSyncState({
+        ...state,
+        githubToken: void 0,
+        githubUsername: void 0,
+        repoOwner: void 0,
+        repoName: void 0
+      });
+      setJson(res, 200, { ok: true });
+    } catch (error) {
+      setJson(res, 500, { error: getErrorMessage(error, "Failed to logout GitHub") });
+    }
+    return true;
   }
-  return Buffer.concat(chunks);
-}
-function bufferIndexOf(buf, needle, start = 0) {
-  for (let i = start; i <= buf.length - needle.length; i++) {
-    let match = true;
-    for (let j = 0; j < needle.length; j++) {
-      if (buf[i + j] !== needle[j]) {
-        match = false;
-        break;
+  if (req.method === "POST" && url.pathname === "/codex-api/skills-sync/github/complete-login") {
+    try {
+      const payload = asRecord(await readJsonBody2(req));
+      const deviceCode = typeof payload?.deviceCode === "string" ? payload.deviceCode : "";
+      if (!deviceCode) {
+        setJson(res, 400, { error: "Missing deviceCode" });
+        return true;
       }
+      const result = await completeGithubDeviceLogin(deviceCode);
+      if (!result.token) {
+        setJson(res, 200, { ok: false, pending: result.error === "authorization_pending", error: result.error || "login_failed" });
+        return true;
+      }
+      const token = result.token;
+      const username = await resolveGithubUsername(token);
+      await finalizeGithubLoginAndSync(token, username, appServer);
+      setJson(res, 200, { ok: true, data: { githubUsername: username } });
+    } catch (error) {
+      setJson(res, 502, { error: getErrorMessage(error, "Failed to complete GitHub login") });
     }
-    if (match) return i;
+    return true;
   }
-  return -1;
-}
-function handleFileUpload(req, res) {
-  const chunks = [];
-  req.on("data", (chunk) => chunks.push(chunk));
-  req.on("end", async () => {
+  if (req.method === "POST" && url.pathname === "/codex-api/skills-sync/push") {
     try {
-      const body = Buffer.concat(chunks);
-      const contentType = req.headers["content-type"] ?? "";
-      const boundaryMatch = contentType.match(/boundary=(.+)/i);
-      if (!boundaryMatch) {
-        setJson(res, 400, { error: "Missing multipart boundary" });
-        return;
+      const state = await readSkillsSyncState();
+      if (!state.githubToken || !state.repoOwner || !state.repoName) {
+        setJson(res, 400, { error: "Skills sync is not configured yet" });
+        return true;
       }
-      const boundary = boundaryMatch[1];
-      const boundaryBuf = Buffer.from(`--${boundary}`);
-      const parts = [];
-      let searchStart = 0;
-      while (searchStart < body.length) {
-        const idx = body.indexOf(boundaryBuf, searchStart);
-        if (idx < 0) break;
-        if (searchStart > 0) parts.push(body.subarray(searchStart, idx));
-        searchStart = idx + boundaryBuf.length;
-        if (body[searchStart] === 13 && body[searchStart + 1] === 10) searchStart += 2;
+      if (isUpstreamSkillsRepo(state.repoOwner, state.repoName)) {
+        setJson(res, 400, { error: "Refusing to push to upstream repository" });
+        return true;
       }
-      let fileName = "uploaded-file";
-      let fileData = null;
-      const headerSep = Buffer.from("\r\n\r\n");
-      for (const part of parts) {
-        const headerEnd = bufferIndexOf(part, headerSep);
-        if (headerEnd < 0) continue;
-        const headers = part.subarray(0, headerEnd).toString("utf8");
-        const fnMatch = headers.match(/filename="([^"]+)"/i);
-        if (!fnMatch) continue;
-        fileName = fnMatch[1].replace(/[/\\]/g, "_");
-        let end = part.length;
-        if (end >= 2 && part[end - 2] === 13 && part[end - 1] === 10) end -= 2;
-        fileData = part.subarray(headerEnd + 4, end);
-        break;
+      const local = await collectLocalSyncedSkills(appServer);
+      const installedMap = await scanInstalledSkillsFromDisk();
+      await writeRemoteSkillsManifest(state.githubToken, state.repoOwner, state.repoName, local);
+      await syncInstalledSkillsFolderToRepo(state.githubToken, state.repoOwner, state.repoName, installedMap);
+      setJson(res, 200, { ok: true, data: { synced: local.length } });
+    } catch (error) {
+      setJson(res, 502, { error: getErrorMessage(error, "Failed to push synced skills") });
+    }
+    return true;
+  }
+  if (req.method === "POST" && url.pathname === "/codex-api/skills-sync/pull") {
+    try {
+      const state = await readSkillsSyncState();
+      if (!state.githubToken || !state.repoOwner || !state.repoName) {
+        await bootstrapSkillsFromUpstreamIntoLocal();
+        try {
+          await appServer.rpc("skills/list", { forceReload: true });
+        } catch {
+        }
+        setJson(res, 200, { ok: true, data: { synced: 0, source: "upstream" } });
+        return true;
       }
-      if (!fileData) {
-        setJson(res, 400, { error: "No file in request" });
-        return;
+      const remote = await readRemoteSkillsManifest(state.githubToken, state.repoOwner, state.repoName);
+      const tree = await fetchSkillsTree();
+      const uniqueOwnerByName = /* @__PURE__ */ new Map();
+      const ambiguousNames = /* @__PURE__ */ new Set();
+      for (const entry of tree) {
+        if (ambiguousNames.has(entry.name)) continue;
+        const existingOwner = uniqueOwnerByName.get(entry.name);
+        if (!existingOwner) {
+          uniqueOwnerByName.set(entry.name, entry.owner);
+          continue;
+        }
+        if (existingOwner !== entry.owner) {
+          uniqueOwnerByName.delete(entry.name);
+          ambiguousNames.add(entry.name);
+        }
       }
-      const uploadDir = join(tmpdir(), "codex-web-uploads");
-      await mkdir(uploadDir, { recursive: true });
-      const destDir = await mkdtemp(join(uploadDir, "f-"));
-      const destPath = join(destDir, fileName);
-      await writeFile(destPath, fileData);
-      setJson(res, 200, { path: destPath });
-    } catch (err) {
-      setJson(res, 500, { error: getErrorMessage(err, "Upload failed") });
-    }
-  });
-  req.on("error", (err) => {
-    setJson(res, 500, { error: getErrorMessage(err, "Upload stream error") });
-  });
+      const localDir = await detectUserSkillsDir(appServer);
+      await pullInstalledSkillsFolderFromRepo(state.githubToken, state.repoOwner, state.repoName);
+      const installerScript = "/Users/igor/.cursor/skills/.system/skill-installer/scripts/install-skill-from-github.py";
+      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", [
+            installerScript,
+            "--repo",
+            `${HUB_SKILLS_OWNER}/${HUB_SKILLS_REPO}`,
+            "--path",
+            `skills/${owner}/${skill.name}`,
+            "--dest",
+            localDir,
+            "--method",
+            "git"
+          ]);
+        }
+        const skillPath = join(localDir, skill.name);
+        await appServer.rpc("skills/config/write", { path: skillPath, enabled: skill.enabled });
+      }
+      const remoteNames = new Set(remote.map((row) => row.name));
+      for (const [name, localInfo] of localSkills.entries()) {
+        if (!remoteNames.has(name)) {
+          await rm(localInfo.path.replace(/\/SKILL\.md$/, ""), { recursive: true, force: true });
+        }
+      }
+      const nextOwners = {};
+      for (const item of remote) {
+        const owner = item.owner || uniqueOwnerByName.get(item.name) || "";
+        if (owner) nextOwners[item.name] = owner;
+      }
+      await writeSkillsSyncState({ ...state, installedOwners: nextOwners });
+      try {
+        await appServer.rpc("skills/list", { forceReload: true });
+      } catch {
+      }
+      setJson(res, 200, { ok: true, data: { synced: remote.length } });
+    } catch (error) {
+      setJson(res, 502, { error: getErrorMessage(error, "Failed to pull synced skills") });
+    }
+    return true;
+  }
+  if (req.method === "GET" && url.pathname === "/codex-api/skills-hub/readme") {
+    try {
+      const owner = url.searchParams.get("owner") || "";
+      const name = url.searchParams.get("name") || "";
+      if (!owner || !name) {
+        setJson(res, 400, { error: "Missing owner or name" });
+        return true;
+      }
+      const rawUrl = `https://raw.githubusercontent.com/${HUB_SKILLS_OWNER}/${HUB_SKILLS_REPO}/main/skills/${owner}/${name}/SKILL.md`;
+      const resp = await fetch(rawUrl);
+      if (!resp.ok) throw new Error(`Failed to fetch SKILL.md: ${resp.status}`);
+      const content = await resp.text();
+      setJson(res, 200, { content });
+    } catch (error) {
+      setJson(res, 502, { error: getErrorMessage(error, "Failed to fetch SKILL.md") });
+    }
+    return true;
+  }
+  if (req.method === "POST" && url.pathname === "/codex-api/skills-hub/install") {
+    try {
+      const payload = asRecord(await readJsonBody2(req));
+      const owner = typeof payload?.owner === "string" ? payload.owner : "";
+      const name = typeof payload?.name === "string" ? payload.name : "";
+      if (!owner || !name) {
+        setJson(res, 400, { error: "Missing owner or name" });
+        return true;
+      }
+      const installerScript = "/Users/igor/.cursor/skills/.system/skill-installer/scripts/install-skill-from-github.py";
+      const installDest = await detectUserSkillsDir(appServer);
+      await runCommand("python3", [
+        installerScript,
+        "--repo",
+        `${HUB_SKILLS_OWNER}/${HUB_SKILLS_REPO}`,
+        "--path",
+        `skills/${owner}/${name}`,
+        "--dest",
+        installDest,
+        "--method",
+        "git"
+      ]);
+      const skillDir = join(installDest, name);
+      await ensureInstalledSkillIsValid(appServer, skillDir);
+      const syncState = await readSkillsSyncState();
+      const nextOwners = { ...syncState.installedOwners ?? {}, [name]: owner };
+      await writeSkillsSyncState({ ...syncState, installedOwners: nextOwners });
+      await autoPushSyncedSkills(appServer);
+      setJson(res, 200, { ok: true, path: skillDir });
+    } catch (error) {
+      setJson(res, 502, { error: getErrorMessage(error, "Failed to install skill") });
+    }
+    return true;
+  }
+  if (req.method === "POST" && url.pathname === "/codex-api/skills-hub/uninstall") {
+    try {
+      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) : "");
+      if (!target) {
+        setJson(res, 400, { error: "Missing name or path" });
+        return true;
+      }
+      await rm(target, { recursive: true, force: true });
+      if (name) {
+        const syncState = await readSkillsSyncState();
+        const nextOwners = { ...syncState.installedOwners ?? {} };
+        delete nextOwners[name];
+        await writeSkillsSyncState({ ...syncState, installedOwners: nextOwners });
+      }
+      await autoPushSyncedSkills(appServer);
+      try {
+        await appServer.rpc("skills/list", { forceReload: true });
+      } catch {
+      }
+      setJson(res, 200, { ok: true, deletedPath: target });
+    } catch (error) {
+      setJson(res, 502, { error: getErrorMessage(error, "Failed to uninstall skill") });
+    }
+    return true;
+  }
+  return false;
+}
+
+// src/server/codexAppServerBridge.ts
+function asRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function getErrorMessage2(payload, fallback) {
+  if (payload instanceof Error && payload.message.trim().length > 0) {
+    return payload.message;
+  }
+  const record = asRecord2(payload);
+  if (!record) return fallback;
+  const error = record.error;
+  if (typeof error === "string" && error.length > 0) return error;
+  const nestedError = asRecord2(error);
+  if (nestedError && typeof nestedError.message === "string" && nestedError.message.length > 0) {
+    return nestedError.message;
+  }
+  return fallback;
+}
+function setJson2(res, statusCode, payload) {
+  res.statusCode = statusCode;
+  res.setHeader("Content-Type", "application/json; charset=utf-8");
+  res.end(JSON.stringify(payload));
+}
+function extractThreadMessageText(threadReadPayload) {
+  const payload = asRecord2(threadReadPayload);
+  const thread = asRecord2(payload?.thread);
+  const turns = Array.isArray(thread?.turns) ? thread.turns : [];
+  const parts = [];
+  for (const turn of turns) {
+    const turnRecord = asRecord2(turn);
+    const items = Array.isArray(turnRecord?.items) ? turnRecord.items : [];
+    for (const item of items) {
+      const itemRecord = asRecord2(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 = asRecord2(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();
+  const lowerQuery = query.toLowerCase();
+  const baseName = lowerPath.slice(lowerPath.lastIndexOf("/") + 1);
+  if (baseName === lowerQuery) return 0;
+  if (baseName.startsWith(lowerQuery)) return 1;
+  if (baseName.includes(lowerQuery)) return 2;
+  if (lowerPath.includes(`/${lowerQuery}`)) return 3;
+  if (lowerPath.includes(lowerQuery)) return 4;
+  return 10;
+}
+async function listFilesWithRipgrep(cwd) {
+  return await new Promise((resolve2, reject) => {
+    const proc = spawn2("rg", ["--files", "--hidden", "-g", "!.git", "-g", "!node_modules"], {
+      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) {
+        const rows = stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+        resolve2(rows);
+        return;
+      }
+      const details = [stderr.trim(), stdout.trim()].filter(Boolean).join("\n");
+      reject(new Error(details || "rg --files failed"));
+    });
+  });
+}
+function getCodexHomeDir2() {
+  const codexHome = process.env.CODEX_HOME?.trim();
+  return codexHome && codexHome.length > 0 ? codexHome : join2(homedir2(), ".codex");
+}
+async function runCommand2(command, args, options = {}) {
+  await new Promise((resolve2, 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) {
+        resolve2();
+        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 isMissingHeadError(error) {
+  const message = getErrorMessage2(error, "").toLowerCase();
+  return message.includes("not a valid object name: 'head'") || message.includes("not a valid object name: head") || message.includes("invalid reference: head");
+}
+function isNotGitRepositoryError(error) {
+  const message = getErrorMessage2(error, "").toLowerCase();
+  return message.includes("not a git repository") || message.includes("fatal: not a git repository");
+}
+async function ensureRepoHasInitialCommit(repoRoot) {
+  const agentsPath = join2(repoRoot, "AGENTS.md");
+  try {
+    await stat2(agentsPath);
+  } catch {
+    await writeFile2(agentsPath, "", "utf8");
+  }
+  await runCommand2("git", ["add", "AGENTS.md"], { cwd: repoRoot });
+  await runCommand2(
+    "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((resolve2, 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) {
+        resolve2(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 = [];
+  for (const item of value) {
+    if (typeof item === "string" && item.length > 0 && !normalized.includes(item)) {
+      normalized.push(item);
+    }
+  }
+  return normalized;
+}
+function normalizeStringRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const next = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (typeof key === "string" && key.length > 0 && typeof item === "string") {
+      next[key] = item;
+    }
+  }
+  return next;
+}
+function getCodexAuthPath() {
+  return join2(getCodexHomeDir2(), "auth.json");
+}
+async function readCodexAuth() {
+  try {
+    const raw = await readFile2(getCodexAuthPath(), "utf8");
+    const auth = JSON.parse(raw);
+    const token = auth.tokens?.access_token;
+    if (!token) return null;
+    return { accessToken: token, accountId: auth.tokens?.account_id ?? void 0 };
+  } catch {
+    return null;
+  }
+}
+function getCodexGlobalStatePath() {
+  return join2(getCodexHomeDir2(), ".codex-global-state.json");
+}
+var MAX_THREAD_TITLES = 500;
+function normalizeThreadTitleCache(value) {
+  const record = asRecord2(value);
+  if (!record) return { titles: {}, order: [] };
+  const rawTitles = asRecord2(record.titles);
+  const titles = {};
+  if (rawTitles) {
+    for (const [k, v] of Object.entries(rawTitles)) {
+      if (typeof v === "string" && v.length > 0) titles[k] = v;
+    }
+  }
+  const order = normalizeStringArray(record.order);
+  return { titles, order };
+}
+function updateThreadTitleCache(cache, id, title) {
+  const titles = { ...cache.titles, [id]: title };
+  const order = [id, ...cache.order.filter((o) => o !== id)];
+  while (order.length > MAX_THREAD_TITLES) {
+    const removed = order.pop();
+    if (removed) delete titles[removed];
+  }
+  return { titles, order };
+}
+function removeFromThreadTitleCache(cache, id) {
+  const { [id]: _, ...titles } = cache.titles;
+  return { titles, order: cache.order.filter((o) => o !== id) };
+}
+async function readThreadTitleCache() {
+  const statePath = getCodexGlobalStatePath();
+  try {
+    const raw = await readFile2(statePath, "utf8");
+    const payload = asRecord2(JSON.parse(raw)) ?? {};
+    return normalizeThreadTitleCache(payload["thread-titles"]);
+  } catch {
+    return { titles: {}, order: [] };
+  }
+}
+async function writeThreadTitleCache(cache) {
+  const statePath = getCodexGlobalStatePath();
+  let payload = {};
+  try {
+    const raw = await readFile2(statePath, "utf8");
+    payload = asRecord2(JSON.parse(raw)) ?? {};
+  } catch {
+    payload = {};
+  }
+  payload["thread-titles"] = cache;
+  await writeFile2(statePath, JSON.stringify(payload), "utf8");
+}
+async function readWorkspaceRootsState() {
+  const statePath = getCodexGlobalStatePath();
+  let payload = {};
+  try {
+    const raw = await readFile2(statePath, "utf8");
+    const parsed = JSON.parse(raw);
+    payload = asRecord2(parsed) ?? {};
+  } catch {
+    payload = {};
+  }
+  return {
+    order: normalizeStringArray(payload["electron-saved-workspace-roots"]),
+    labels: normalizeStringRecord(payload["electron-workspace-root-labels"]),
+    active: normalizeStringArray(payload["active-workspace-roots"])
+  };
+}
+async function writeWorkspaceRootsState(nextState) {
+  const statePath = getCodexGlobalStatePath();
+  let payload = {};
+  try {
+    const raw = await readFile2(statePath, "utf8");
+    payload = asRecord2(JSON.parse(raw)) ?? {};
+  } catch {
+    payload = {};
+  }
+  payload["electron-saved-workspace-roots"] = normalizeStringArray(nextState.order);
+  payload["electron-workspace-root-labels"] = normalizeStringRecord(nextState.labels);
+  payload["active-workspace-roots"] = normalizeStringArray(nextState.active);
+  await writeFile2(statePath, JSON.stringify(payload), "utf8");
+}
+async function readJsonBody(req) {
+  const raw = await readRawBody(req);
+  if (raw.length === 0) return null;
+  const text = raw.toString("utf8").trim();
+  if (text.length === 0) return null;
+  return JSON.parse(text);
+}
+async function readRawBody(req) {
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  return Buffer.concat(chunks);
+}
+function bufferIndexOf(buf, needle, start = 0) {
+  for (let i = start; i <= buf.length - needle.length; i++) {
+    let match = true;
+    for (let j = 0; j < needle.length; j++) {
+      if (buf[i + j] !== needle[j]) {
+        match = false;
+        break;
+      }
+    }
+    if (match) return i;
+  }
+  return -1;
+}
+function handleFileUpload(req, res) {
+  const chunks = [];
+  req.on("data", (chunk) => chunks.push(chunk));
+  req.on("end", async () => {
+    try {
+      const body = Buffer.concat(chunks);
+      const contentType = req.headers["content-type"] ?? "";
+      const boundaryMatch = contentType.match(/boundary=(.+)/i);
+      if (!boundaryMatch) {
+        setJson2(res, 400, { error: "Missing multipart boundary" });
+        return;
+      }
+      const boundary = boundaryMatch[1];
+      const boundaryBuf = Buffer.from(`--${boundary}`);
+      const parts = [];
+      let searchStart = 0;
+      while (searchStart < body.length) {
+        const idx = body.indexOf(boundaryBuf, searchStart);
+        if (idx < 0) break;
+        if (searchStart > 0) parts.push(body.subarray(searchStart, idx));
+        searchStart = idx + boundaryBuf.length;
+        if (body[searchStart] === 13 && body[searchStart + 1] === 10) searchStart += 2;
+      }
+      let fileName = "uploaded-file";
+      let fileData = null;
+      const headerSep = Buffer.from("\r\n\r\n");
+      for (const part of parts) {
+        const headerEnd = bufferIndexOf(part, headerSep);
+        if (headerEnd < 0) continue;
+        const headers = part.subarray(0, headerEnd).toString("utf8");
+        const fnMatch = headers.match(/filename="([^"]+)"/i);
+        if (!fnMatch) continue;
+        fileName = fnMatch[1].replace(/[/\\]/g, "_");
+        let end = part.length;
+        if (end >= 2 && part[end - 2] === 13 && part[end - 1] === 10) end -= 2;
+        fileData = part.subarray(headerEnd + 4, end);
+        break;
+      }
+      if (!fileData) {
+        setJson2(res, 400, { error: "No file in request" });
+        return;
+      }
+      const uploadDir = join2(tmpdir2(), "codex-web-uploads");
+      await mkdir2(uploadDir, { recursive: true });
+      const destDir = await mkdtemp2(join2(uploadDir, "f-"));
+      const destPath = join2(destDir, fileName);
+      await writeFile2(destPath, fileData);
+      setJson2(res, 200, { path: destPath });
+    } catch (err) {
+      setJson2(res, 500, { error: getErrorMessage2(err, "Upload failed") });
+    }
+  });
+  req.on("error", (err) => {
+    setJson2(res, 500, { error: getErrorMessage2(err, "Upload stream error") });
+  });
 }
 async function proxyTranscribe(body, contentType, authToken, accountId) {
   const headers = {
@@ -1085,7 +1547,7 @@ var AppServerProcess = class {
   start() {
     if (this.process) return;
     this.stopping = false;
-    const proc = spawn("codex", this.appServerArgs, { stdio: ["pipe", "pipe", "pipe"] });
+    const proc = spawn2("codex", this.appServerArgs, { stdio: ["pipe", "pipe", "pipe"] });
     this.process = proc;
     proc.stdout.setEncoding("utf8");
     proc.stdout.on("data", (chunk) => {
@@ -1179,7 +1641,7 @@ var AppServerProcess = class {
     }
     this.pendingServerRequests.delete(requestId);
     this.sendServerRequestReply(requestId, reply);
-    const requestParams = asRecord(pendingRequest.params);
+    const requestParams = asRecord2(pendingRequest.params);
     const threadId = typeof requestParams?.threadId === "string" && requestParams.threadId.length > 0 ? requestParams.threadId : "";
     this.emitNotification({
       method: "server/request/resolved",
@@ -1248,7 +1710,7 @@ var AppServerProcess = class {
   }
   async respondToServerRequest(payload) {
     await this.ensureInitialized();
-    const body = asRecord(payload);
+    const body = asRecord2(payload);
     if (!body) {
       throw new Error("Invalid response payload: expected object");
     }
@@ -1256,7 +1718,7 @@ var AppServerProcess = class {
     if (typeof id !== "number" || !Number.isInteger(id)) {
       throw new Error('Invalid response payload: "id" must be an integer');
     }
-    const rawError = asRecord(body.error);
+    const rawError = asRecord2(body.error);
     if (rawError) {
       const message = typeof rawError.message === "string" && rawError.message.trim().length > 0 ? rawError.message.trim() : "Server request rejected by client";
       const code = typeof rawError.code === "number" && Number.isFinite(rawError.code) ? Math.trunc(rawError.code) : -32e3;
@@ -1311,7 +1773,7 @@ var MethodCatalog = class {
   }
   async runGenerateSchemaCommand(outDir) {
     await new Promise((resolve2, reject) => {
-      const process2 = spawn("codex", ["app-server", "generate-json-schema", "--out", outDir], {
+      const process2 = spawn2("codex", ["app-server", "generate-json-schema", "--out", outDir], {
         stdio: ["ignore", "ignore", "pipe"]
       });
       let stderr = "";
@@ -1330,13 +1792,13 @@ var MethodCatalog = class {
     });
   }
   extractMethodsFromClientRequest(payload) {
-    const root = asRecord(payload);
+    const root = asRecord2(payload);
     const oneOf = Array.isArray(root?.oneOf) ? root.oneOf : [];
     const methods = /* @__PURE__ */ new Set();
     for (const entry of oneOf) {
-      const row = asRecord(entry);
-      const properties = asRecord(row?.properties);
-      const methodDef = asRecord(properties?.method);
+      const row = asRecord2(entry);
+      const properties = asRecord2(row?.properties);
+      const methodDef = asRecord2(properties?.method);
       const methodEnum = Array.isArray(methodDef?.enum) ? methodDef.enum : [];
       for (const item of methodEnum) {
         if (typeof item === "string" && item.length > 0) {
@@ -1347,13 +1809,13 @@ var MethodCatalog = class {
     return Array.from(methods).sort((a, b) => a.localeCompare(b));
   }
   extractMethodsFromServerNotification(payload) {
-    const root = asRecord(payload);
+    const root = asRecord2(payload);
     const oneOf = Array.isArray(root?.oneOf) ? root.oneOf : [];
     const methods = /* @__PURE__ */ new Set();
     for (const entry of oneOf) {
-      const row = asRecord(entry);
-      const properties = asRecord(row?.properties);
-      const methodDef = asRecord(properties?.method);
+      const row = asRecord2(entry);
+      const properties = asRecord2(row?.properties);
+      const methodDef = asRecord2(properties?.method);
       const methodEnum = Array.isArray(methodDef?.enum) ? methodDef.enum : [];
       for (const item of methodEnum) {
         if (typeof item === "string" && item.length > 0) {
@@ -1367,10 +1829,10 @@ var MethodCatalog = class {
     if (this.methodCache) {
       return this.methodCache;
     }
-    const outDir = await mkdtemp(join(tmpdir(), "codex-web-local-schema-"));
+    const outDir = await mkdtemp2(join2(tmpdir2(), "codex-web-local-schema-"));
     await this.runGenerateSchemaCommand(outDir);
-    const clientRequestPath = join(outDir, "ClientRequest.json");
-    const raw = await readFile(clientRequestPath, "utf8");
+    const clientRequestPath = join2(outDir, "ClientRequest.json");
+    const raw = await readFile2(clientRequestPath, "utf8");
     const parsed = JSON.parse(raw);
     const methods = this.extractMethodsFromClientRequest(parsed);
     this.methodCache = methods;
@@ -1380,10 +1842,10 @@ var MethodCatalog = class {
     if (this.notificationCache) {
       return this.notificationCache;
     }
-    const outDir = await mkdtemp(join(tmpdir(), "codex-web-local-schema-"));
+    const outDir = await mkdtemp2(join2(tmpdir2(), "codex-web-local-schema-"));
     await this.runGenerateSchemaCommand(outDir);
-    const serverNotificationPath = join(outDir, "ServerNotification.json");
-    const raw = await readFile(serverNotificationPath, "utf8");
+    const serverNotificationPath = join2(outDir, "ServerNotification.json");
+    const raw = await readFile2(serverNotificationPath, "utf8");
     const parsed = JSON.parse(raw);
     const methods = this.extractMethodsFromServerNotification(parsed);
     this.notificationCache = methods;
@@ -1402,8 +1864,82 @@ function getSharedBridgeState() {
   globalScope[SHARED_BRIDGE_KEY] = created;
   return created;
 }
+async function loadAllThreadsForSearch(appServer) {
+  const threads = [];
+  let cursor = null;
+  do {
+    const response = asRecord2(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 = asRecord2(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;
+  }
   void initializeSkillsSyncOnStartup(appServer);
   const middleware = async (req, res, next) => {
     try {
@@ -1412,25 +1948,28 @@ function createCodexBridgeMiddleware() {
         return;
       }
       const url = new URL(req.url, "http://localhost");
+      if (await handleSkillsRoutes(req, res, url, { appServer, readJsonBody })) {
+        return;
+      }
       if (req.method === "POST" && url.pathname === "/codex-api/upload-file") {
         handleFileUpload(req, res);
         return;
       }
       if (req.method === "POST" && url.pathname === "/codex-api/rpc") {
         const payload = await readJsonBody(req);
-        const body = asRecord(payload);
+        const body = asRecord2(payload);
         if (!body || typeof body.method !== "string" || body.method.length === 0) {
-          setJson(res, 400, { error: "Invalid body: expected { method, params? }" });
+          setJson2(res, 400, { error: "Invalid body: expected { method, params? }" });
           return;
         }
         const result = await appServer.rpc(body.method, body.params ?? null);
-        setJson(res, 200, { result });
+        setJson2(res, 200, { result });
         return;
       }
       if (req.method === "POST" && url.pathname === "/codex-api/transcribe") {
         const auth = await readCodexAuth();
         if (!auth) {
-          setJson(res, 401, { error: "No auth token available for transcription" });
+          setJson2(res, 401, { error: "No auth token available for transcription" });
           return;
         }
         const rawBody = await readRawBody(req);
@@ -1444,37 +1983,107 @@ function createCodexBridgeMiddleware() {
       if (req.method === "POST" && url.pathname === "/codex-api/server-requests/respond") {
         const payload = await readJsonBody(req);
         await appServer.respondToServerRequest(payload);
-        setJson(res, 200, { ok: true });
+        setJson2(res, 200, { ok: true });
         return;
       }
       if (req.method === "GET" && url.pathname === "/codex-api/server-requests/pending") {
-        setJson(res, 200, { data: appServer.listPendingServerRequests() });
+        setJson2(res, 200, { data: appServer.listPendingServerRequests() });
         return;
       }
       if (req.method === "GET" && url.pathname === "/codex-api/meta/methods") {
         const methods = await methodCatalog.listMethods();
-        setJson(res, 200, { data: methods });
+        setJson2(res, 200, { data: methods });
         return;
       }
       if (req.method === "GET" && url.pathname === "/codex-api/meta/notifications") {
         const methods = await methodCatalog.listNotificationMethods();
-        setJson(res, 200, { data: methods });
+        setJson2(res, 200, { data: methods });
         return;
       }
       if (req.method === "GET" && url.pathname === "/codex-api/workspace-roots-state") {
         const state = await readWorkspaceRootsState();
-        setJson(res, 200, { data: state });
+        setJson2(res, 200, { data: state });
         return;
       }
       if (req.method === "GET" && url.pathname === "/codex-api/home-directory") {
-        setJson(res, 200, { data: { path: homedir() } });
+        setJson2(res, 200, { data: { path: homedir2() } });
+        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() : "";
+        if (!rawSourceCwd) {
+          setJson2(res, 400, { error: "Missing sourceCwd" });
+          return;
+        }
+        const sourceCwd = isAbsolute(rawSourceCwd) ? rawSourceCwd : resolve(rawSourceCwd);
+        try {
+          const sourceInfo = await stat2(sourceCwd);
+          if (!sourceInfo.isDirectory()) {
+            setJson2(res, 400, { error: "sourceCwd is not a directory" });
+            return;
+          }
+        } catch {
+          setJson2(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 runCommand2("git", ["init"], { cwd: sourceCwd });
+            gitRoot = await runCommandCapture("git", ["rev-parse", "--show-toplevel"], { cwd: sourceCwd });
+          }
+          const repoName = basename(gitRoot) || "repo";
+          const worktreesRoot = join2(getCodexHomeDir2(), "worktrees");
+          await mkdir2(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 = join2(worktreesRoot, candidate);
+            try {
+              await stat2(parent);
+              continue;
+            } catch {
+              worktreeId = candidate;
+              worktreeParent = parent;
+              worktreeCwd = join2(parent, repoName);
+              break;
+            }
+          }
+          if (!worktreeId || !worktreeParent || !worktreeCwd) {
+            throw new Error("Failed to allocate a unique worktree id");
+          }
+          const branch = `codex/${worktreeId}`;
+          await mkdir2(worktreeParent, { recursive: true });
+          try {
+            await runCommand2("git", ["worktree", "add", "-b", branch, worktreeCwd, "HEAD"], { cwd: gitRoot });
+          } catch (error) {
+            if (!isMissingHeadError(error)) throw error;
+            await ensureRepoHasInitialCommit(gitRoot);
+            await runCommand2("git", ["worktree", "add", "-b", branch, worktreeCwd, "HEAD"], { cwd: gitRoot });
+          }
+          setJson2(res, 200, {
+            data: {
+              cwd: worktreeCwd,
+              branch,
+              gitRoot
+            }
+          });
+        } catch (error) {
+          setJson2(res, 500, { error: getErrorMessage2(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);
+        const record = asRecord2(payload);
         if (!record) {
-          setJson(res, 400, { error: "Invalid body: expected object" });
+          setJson2(res, 400, { error: "Invalid body: expected object" });
           return;
         }
         const nextState = {
@@ -1483,33 +2092,33 @@ function createCodexBridgeMiddleware() {
           active: normalizeStringArray(record.active)
         };
         await writeWorkspaceRootsState(nextState);
-        setJson(res, 200, { ok: true });
+        setJson2(res, 200, { ok: true });
         return;
       }
       if (req.method === "POST" && url.pathname === "/codex-api/project-root") {
-        const payload = asRecord(await readJsonBody(req));
+        const payload = asRecord2(await readJsonBody(req));
         const rawPath = typeof payload?.path === "string" ? payload.path.trim() : "";
         const createIfMissing = payload?.createIfMissing === true;
         const label = typeof payload?.label === "string" ? payload.label : "";
         if (!rawPath) {
-          setJson(res, 400, { error: "Missing path" });
+          setJson2(res, 400, { error: "Missing path" });
           return;
         }
         const normalizedPath = isAbsolute(rawPath) ? rawPath : resolve(rawPath);
         let pathExists = true;
         try {
-          const info = await stat(normalizedPath);
+          const info = await stat2(normalizedPath);
           if (!info.isDirectory()) {
-            setJson(res, 400, { error: "Path exists but is not a directory" });
+            setJson2(res, 400, { error: "Path exists but is not a directory" });
             return;
           }
         } catch {
           pathExists = false;
         }
         if (!pathExists && createIfMissing) {
-          await mkdir(normalizedPath, { recursive: true });
+          await mkdir2(normalizedPath, { recursive: true });
         } else if (!pathExists) {
-          setJson(res, 404, { error: "Directory does not exist" });
+          setJson2(res, 404, { error: "Directory does not exist" });
           return;
         }
         const existingState = await readWorkspaceRootsState();
@@ -1524,388 +2133,103 @@ function createCodexBridgeMiddleware() {
           labels: nextLabels,
           active: nextActive
         });
-        setJson(res, 200, { data: { path: normalizedPath } });
+        setJson2(res, 200, { data: { path: normalizedPath } });
         return;
       }
       if (req.method === "GET" && url.pathname === "/codex-api/project-root-suggestion") {
         const basePath = url.searchParams.get("basePath")?.trim() ?? "";
         if (!basePath) {
-          setJson(res, 400, { error: "Missing basePath" });
+          setJson2(res, 400, { error: "Missing basePath" });
           return;
         }
         const normalizedBasePath = isAbsolute(basePath) ? basePath : resolve(basePath);
         try {
-          const baseInfo = await stat(normalizedBasePath);
+          const baseInfo = await stat2(normalizedBasePath);
           if (!baseInfo.isDirectory()) {
-            setJson(res, 400, { error: "basePath is not a directory" });
+            setJson2(res, 400, { error: "basePath is not a directory" });
             return;
           }
         } catch {
-          setJson(res, 404, { error: "basePath does not exist" });
+          setJson2(res, 404, { error: "basePath does not exist" });
           return;
         }
         let index = 1;
         while (index < 1e5) {
           const candidateName = `New Project (${String(index)})`;
-          const candidatePath = join(normalizedBasePath, candidateName);
+          const candidatePath = join2(normalizedBasePath, candidateName);
           try {
-            await stat(candidatePath);
+            await stat2(candidatePath);
             index += 1;
             continue;
           } catch {
-            setJson(res, 200, { data: { name: candidateName, path: candidatePath } });
+            setJson2(res, 200, { data: { name: candidateName, path: candidatePath } });
             return;
           }
         }
-        setJson(res, 500, { error: "Failed to compute project name suggestion" });
+        setJson2(res, 500, { error: "Failed to compute project name suggestion" });
         return;
       }
       if (req.method === "POST" && url.pathname === "/codex-api/composer-file-search") {
-        const payload = asRecord(await readJsonBody(req));
+        const payload = asRecord2(await readJsonBody(req));
         const rawCwd = typeof payload?.cwd === "string" ? payload.cwd.trim() : "";
         const query = typeof payload?.query === "string" ? payload.query.trim() : "";
         const limitRaw = typeof payload?.limit === "number" ? payload.limit : 20;
         const limit = Math.max(1, Math.min(100, Math.floor(limitRaw)));
         if (!rawCwd) {
-          setJson(res, 400, { error: "Missing cwd" });
+          setJson2(res, 400, { error: "Missing cwd" });
           return;
         }
         const cwd = isAbsolute(rawCwd) ? rawCwd : resolve(rawCwd);
         try {
-          const info = await stat(cwd);
+          const info = await stat2(cwd);
           if (!info.isDirectory()) {
-            setJson(res, 400, { error: "cwd is not a directory" });
+            setJson2(res, 400, { error: "cwd is not a directory" });
             return;
           }
         } catch {
-          setJson(res, 404, { error: "cwd does not exist" });
+          setJson2(res, 404, { error: "cwd does not exist" });
           return;
         }
         try {
           const files = await listFilesWithRipgrep(cwd);
           const scored = files.map((path) => ({ path, score: scoreFileCandidate(path, query) })).filter((row) => query.length === 0 || row.score < 10).sort((a, b) => a.score - b.score || a.path.localeCompare(b.path)).slice(0, limit).map((row) => ({ path: row.path }));
-          setJson(res, 200, { data: scored });
+          setJson2(res, 200, { data: scored });
         } catch (error) {
-          setJson(res, 500, { error: getErrorMessage(error, "Failed to search files") });
+          setJson2(res, 500, { error: getErrorMessage2(error, "Failed to search files") });
         }
         return;
       }
       if (req.method === "GET" && url.pathname === "/codex-api/thread-titles") {
         const cache = await readThreadTitleCache();
-        setJson(res, 200, { data: cache });
+        setJson2(res, 200, { data: cache });
+        return;
+      }
+      if (req.method === "POST" && url.pathname === "/codex-api/thread-search") {
+        const payload = asRecord2(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) {
+          setJson2(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);
+        setJson2(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 payload = asRecord2(await readJsonBody(req));
         const id = typeof payload?.id === "string" ? payload.id : "";
         const title = typeof payload?.title === "string" ? payload.title : "";
         if (!id) {
-          setJson(res, 400, { error: "Missing id" });
+          setJson2(res, 400, { error: "Missing id" });
           return;
         }
         const cache = await readThreadTitleCache();
         const next2 = title ? updateThreadTitleCache(cache, id, title) : removeFromThreadTitleCache(cache, id);
         await writeThreadTitleCache(next2);
-        setJson(res, 200, { ok: true });
-        return;
-      }
-      if (req.method === "GET" && url.pathname === "/codex-api/skills-hub") {
-        try {
-          const q = url.searchParams.get("q") || "";
-          const limit = Math.min(Math.max(parseInt(url.searchParams.get("limit") || "50", 10) || 50, 1), 200);
-          const sort = url.searchParams.get("sort") || "date";
-          const allEntries = await fetchSkillsTree();
-          const installedMap = await scanInstalledSkillsFromDisk();
-          try {
-            const result = await appServer.rpc("skills/list", {});
-            for (const entry of result.data ?? []) {
-              for (const skill of entry.skills ?? []) {
-                if (skill.name) {
-                  installedMap.set(skill.name, { name: skill.name, path: skill.path ?? "", enabled: skill.enabled !== false });
-                }
-              }
-            }
-          } catch {
-          }
-          const installedHubEntries = allEntries.filter((e) => installedMap.has(e.name));
-          await fetchMetaBatch(installedHubEntries);
-          const installed = [];
-          for (const [, info] of installedMap) {
-            const hubEntry = allEntries.find((e) => e.name === info.name);
-            const base = hubEntry ? buildHubEntry(hubEntry) : {
-              name: info.name,
-              owner: "local",
-              description: "",
-              displayName: "",
-              publishedAt: 0,
-              avatarUrl: "",
-              url: "",
-              installed: false
-            };
-            installed.push({ ...base, installed: true, path: info.path, enabled: info.enabled });
-          }
-          const results = await searchSkillsHub(allEntries, q, limit, sort, installedMap);
-          setJson(res, 200, { data: results, installed, total: allEntries.length });
-        } catch (error) {
-          setJson(res, 502, { error: getErrorMessage(error, "Failed to fetch skills hub") });
-        }
-        return;
-      }
-      if (req.method === "GET" && url.pathname === "/codex-api/skills-sync/status") {
-        const state = await readSkillsSyncState();
-        setJson(res, 200, {
-          data: {
-            loggedIn: Boolean(state.githubToken),
-            githubUsername: state.githubUsername ?? "",
-            repoOwner: state.repoOwner ?? "",
-            repoName: state.repoName ?? "",
-            configured: Boolean(state.githubToken && state.repoOwner && state.repoName),
-            startup: {
-              inProgress: startupSyncStatus.inProgress,
-              mode: startupSyncStatus.mode,
-              branch: startupSyncStatus.branch,
-              lastAction: startupSyncStatus.lastAction,
-              lastRunAtIso: startupSyncStatus.lastRunAtIso,
-              lastSuccessAtIso: startupSyncStatus.lastSuccessAtIso,
-              lastError: startupSyncStatus.lastError
-            }
-          }
-        });
-        return;
-      }
-      if (req.method === "POST" && url.pathname === "/codex-api/skills-sync/github/start-login") {
-        try {
-          const started = await startGithubDeviceLogin();
-          setJson(res, 200, { data: started });
-        } catch (error) {
-          setJson(res, 502, { error: getErrorMessage(error, "Failed to start GitHub login") });
-        }
-        return;
-      }
-      if (req.method === "POST" && url.pathname === "/codex-api/skills-sync/github/token-login") {
-        try {
-          const payload = asRecord(await readJsonBody(req));
-          const token = typeof payload?.token === "string" ? payload.token.trim() : "";
-          if (!token) {
-            setJson(res, 400, { error: "Missing GitHub token" });
-            return;
-          }
-          const username = await resolveGithubUsername(token);
-          await finalizeGithubLoginAndSync(token, username, appServer);
-          setJson(res, 200, { ok: true, data: { githubUsername: username } });
-        } catch (error) {
-          setJson(res, 502, { error: getErrorMessage(error, "Failed to login with GitHub token") });
-        }
-        return;
-      }
-      if (req.method === "POST" && url.pathname === "/codex-api/skills-sync/github/logout") {
-        try {
-          const state = await readSkillsSyncState();
-          await writeSkillsSyncState({
-            ...state,
-            githubToken: void 0,
-            githubUsername: void 0,
-            repoOwner: void 0,
-            repoName: void 0
-          });
-          setJson(res, 200, { ok: true });
-        } catch (error) {
-          setJson(res, 500, { error: getErrorMessage(error, "Failed to logout GitHub") });
-        }
-        return;
-      }
-      if (req.method === "POST" && url.pathname === "/codex-api/skills-sync/github/complete-login") {
-        try {
-          const payload = asRecord(await readJsonBody(req));
-          const deviceCode = typeof payload?.deviceCode === "string" ? payload.deviceCode : "";
-          if (!deviceCode) {
-            setJson(res, 400, { error: "Missing deviceCode" });
-            return;
-          }
-          const result = await completeGithubDeviceLogin(deviceCode);
-          if (!result.token) {
-            setJson(res, 200, { ok: false, pending: result.error === "authorization_pending", error: result.error || "login_failed" });
-            return;
-          }
-          const token = result.token;
-          const username = await resolveGithubUsername(token);
-          await finalizeGithubLoginAndSync(token, username, appServer);
-          setJson(res, 200, { ok: true, data: { githubUsername: username } });
-        } catch (error) {
-          setJson(res, 502, { error: getErrorMessage(error, "Failed to complete GitHub login") });
-        }
-        return;
-      }
-      if (req.method === "POST" && url.pathname === "/codex-api/skills-sync/push") {
-        try {
-          const state = await readSkillsSyncState();
-          if (!state.githubToken || !state.repoOwner || !state.repoName) {
-            setJson(res, 400, { error: "Skills sync is not configured yet" });
-            return;
-          }
-          if (isUpstreamSkillsRepo(state.repoOwner, state.repoName)) {
-            setJson(res, 400, { error: "Refusing to push to upstream repository" });
-            return;
-          }
-          const local = await collectLocalSyncedSkills(appServer);
-          const installedMap = await scanInstalledSkillsFromDisk();
-          await writeRemoteSkillsManifest(state.githubToken, state.repoOwner, state.repoName, local);
-          await syncInstalledSkillsFolderToRepo(state.githubToken, state.repoOwner, state.repoName, installedMap);
-          setJson(res, 200, { ok: true, data: { synced: local.length } });
-        } catch (error) {
-          setJson(res, 502, { error: getErrorMessage(error, "Failed to push synced skills") });
-        }
-        return;
-      }
-      if (req.method === "POST" && url.pathname === "/codex-api/skills-sync/pull") {
-        try {
-          const state = await readSkillsSyncState();
-          if (!state.githubToken || !state.repoOwner || !state.repoName) {
-            setJson(res, 400, { error: "Skills sync is not configured yet" });
-            return;
-          }
-          const remote = await readRemoteSkillsManifest(state.githubToken, state.repoOwner, state.repoName);
-          const tree = await fetchSkillsTree();
-          const uniqueOwnerByName = /* @__PURE__ */ new Map();
-          const ambiguousNames = /* @__PURE__ */ new Set();
-          for (const entry of tree) {
-            if (ambiguousNames.has(entry.name)) continue;
-            const existingOwner = uniqueOwnerByName.get(entry.name);
-            if (!existingOwner) {
-              uniqueOwnerByName.set(entry.name, entry.owner);
-              continue;
-            }
-            if (existingOwner !== entry.owner) {
-              uniqueOwnerByName.delete(entry.name);
-              ambiguousNames.add(entry.name);
-            }
-          }
-          const localDir = await detectUserSkillsDir(appServer);
-          await pullInstalledSkillsFolderFromRepo(state.githubToken, state.repoOwner, state.repoName, localDir);
-          const installerScript = "/Users/igor/.cursor/skills/.system/skill-installer/scripts/install-skill-from-github.py";
-          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", [
-                installerScript,
-                "--repo",
-                `${HUB_SKILLS_OWNER}/${HUB_SKILLS_REPO}`,
-                "--path",
-                `skills/${owner}/${skill.name}`,
-                "--dest",
-                localDir,
-                "--method",
-                "git"
-              ]);
-            }
-            const skillPath = join(localDir, skill.name);
-            await appServer.rpc("skills/config/write", { path: skillPath, enabled: skill.enabled });
-          }
-          const remoteNames = new Set(remote.map((row) => row.name));
-          for (const [name, localInfo] of localSkills.entries()) {
-            if (!remoteNames.has(name)) {
-              await rm(localInfo.path.replace(/\/SKILL\.md$/, ""), { recursive: true, force: true });
-            }
-          }
-          const nextOwners = {};
-          for (const item of remote) {
-            const owner = item.owner || uniqueOwnerByName.get(item.name) || "";
-            if (owner) nextOwners[item.name] = owner;
-          }
-          await writeSkillsSyncState({ ...state, installedOwners: nextOwners });
-          try {
-            await appServer.rpc("skills/list", { forceReload: true });
-          } catch {
-          }
-          setJson(res, 200, { ok: true, data: { synced: remote.length } });
-        } catch (error) {
-          setJson(res, 502, { error: getErrorMessage(error, "Failed to pull synced skills") });
-        }
-        return;
-      }
-      if (req.method === "GET" && url.pathname === "/codex-api/skills-hub/readme") {
-        try {
-          const owner = url.searchParams.get("owner") || "";
-          const name = url.searchParams.get("name") || "";
-          if (!owner || !name) {
-            setJson(res, 400, { error: "Missing owner or name" });
-            return;
-          }
-          const rawUrl = `https://raw.githubusercontent.com/${HUB_SKILLS_OWNER}/${HUB_SKILLS_REPO}/main/skills/${owner}/${name}/SKILL.md`;
-          const resp = await fetch(rawUrl);
-          if (!resp.ok) throw new Error(`Failed to fetch SKILL.md: ${resp.status}`);
-          const content = await resp.text();
-          setJson(res, 200, { content });
-        } catch (error) {
-          setJson(res, 502, { error: getErrorMessage(error, "Failed to fetch SKILL.md") });
-        }
-        return;
-      }
-      if (req.method === "POST" && url.pathname === "/codex-api/skills-hub/install") {
-        try {
-          const payload = asRecord(await readJsonBody(req));
-          const owner = typeof payload?.owner === "string" ? payload.owner : "";
-          const name = typeof payload?.name === "string" ? payload.name : "";
-          if (!owner || !name) {
-            setJson(res, 400, { error: "Missing owner or name" });
-            return;
-          }
-          const installerScript = "/Users/igor/.cursor/skills/.system/skill-installer/scripts/install-skill-from-github.py";
-          const installDest = await detectUserSkillsDir(appServer);
-          const skillPathInRepo = `skills/${owner}/${name}`;
-          await runCommand("python3", [
-            installerScript,
-            "--repo",
-            `${HUB_SKILLS_OWNER}/${HUB_SKILLS_REPO}`,
-            "--path",
-            skillPathInRepo,
-            "--dest",
-            installDest,
-            "--method",
-            "git"
-          ]);
-          const skillDir = join(installDest, name);
-          await ensureInstalledSkillIsValid(appServer, skillDir);
-          const syncState = await readSkillsSyncState();
-          const nextOwners = { ...syncState.installedOwners ?? {}, [name]: owner };
-          await writeSkillsSyncState({ ...syncState, installedOwners: nextOwners });
-          await autoPushSyncedSkills(appServer);
-          setJson(res, 200, { ok: true, path: skillDir });
-        } catch (error) {
-          setJson(res, 502, { error: getErrorMessage(error, "Failed to install skill") });
-        }
-        return;
-      }
-      if (req.method === "POST" && url.pathname === "/codex-api/skills-hub/uninstall") {
-        try {
-          const payload = asRecord(await readJsonBody(req));
-          const name = typeof payload?.name === "string" ? payload.name : "";
-          const path = typeof payload?.path === "string" ? payload.path : "";
-          const target = path || (name ? join(getSkillsInstallDir(), name) : "");
-          if (!target) {
-            setJson(res, 400, { error: "Missing name or path" });
-            return;
-          }
-          await rm(target, { recursive: true, force: true });
-          if (name) {
-            const syncState = await readSkillsSyncState();
-            const nextOwners = { ...syncState.installedOwners ?? {} };
-            delete nextOwners[name];
-            await writeSkillsSyncState({ ...syncState, installedOwners: nextOwners });
-          }
-          await autoPushSyncedSkills(appServer);
-          try {
-            await appServer.rpc("skills/list", { forceReload: true });
-          } catch {
-          }
-          setJson(res, 200, { ok: true, deletedPath: target });
-        } catch (error) {
-          setJson(res, 502, { error: getErrorMessage(error, "Failed to uninstall skill") });
-        }
+        setJson2(res, 200, { ok: true });
         return;
       }
       if (req.method === "GET" && url.pathname === "/codex-api/events") {
@@ -1940,11 +2264,12 @@ data: ${JSON.stringify({ ok: true })}
       }
       next();
     } catch (error) {
-      const message = getErrorMessage(error, "Unknown bridge error");
-      setJson(res, 502, { error: message });
+      const message = getErrorMessage2(error, "Unknown bridge error");
+      setJson2(res, 502, { error: message });
     }
   };
   middleware.dispose = () => {
+    threadSearchIndex = null;
     appServer.dispose();
   };
   middleware.subscribeNotifications = (listener) => {
@@ -1959,7 +2284,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);
@@ -2057,7 +2382,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 });
@@ -2076,11 +2401,277 @@ function createAuthSession(password) {
   };
 }
 
+// src/server/localBrowseUi.ts
+import { dirname, extname, join as join3 } from "path";
+import { open, readFile as readFile3, readdir as readdir3, stat as stat3 } from "fs/promises";
+var TEXT_EDITABLE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".txt",
+  ".md",
+  ".json",
+  ".js",
+  ".ts",
+  ".tsx",
+  ".jsx",
+  ".css",
+  ".scss",
+  ".html",
+  ".htm",
+  ".xml",
+  ".yml",
+  ".yaml",
+  ".log",
+  ".csv",
+  ".env",
+  ".py",
+  ".sh",
+  ".toml",
+  ".ini",
+  ".conf",
+  ".sql",
+  ".bat",
+  ".cmd",
+  ".ps1"
+]);
+function languageForPath(pathValue) {
+  const extension = extname(pathValue).toLowerCase();
+  switch (extension) {
+    case ".js":
+      return "javascript";
+    case ".ts":
+      return "typescript";
+    case ".jsx":
+      return "javascript";
+    case ".tsx":
+      return "typescript";
+    case ".py":
+      return "python";
+    case ".sh":
+      return "sh";
+    case ".css":
+    case ".scss":
+      return "css";
+    case ".html":
+    case ".htm":
+      return "html";
+    case ".json":
+      return "json";
+    case ".md":
+      return "markdown";
+    case ".yaml":
+    case ".yml":
+      return "yaml";
+    case ".xml":
+      return "xml";
+    case ".sql":
+      return "sql";
+    case ".toml":
+      return "ini";
+    case ".ini":
+    case ".conf":
+      return "ini";
+    default:
+      return "plaintext";
+  }
+}
+function normalizeLocalPath(rawPath) {
+  const trimmed = rawPath.trim();
+  if (!trimmed) return "";
+  if (trimmed.startsWith("file://")) {
+    try {
+      return decodeURIComponent(trimmed.replace(/^file:\/\//u, ""));
+    } catch {
+      return trimmed.replace(/^file:\/\//u, "");
+    }
+  }
+  return trimmed;
+}
+function decodeBrowsePath(rawPath) {
+  if (!rawPath) return "";
+  try {
+    return decodeURIComponent(rawPath);
+  } catch {
+    return rawPath;
+  }
+}
+function isTextEditablePath(pathValue) {
+  return TEXT_EDITABLE_EXTENSIONS.has(extname(pathValue).toLowerCase());
+}
+function looksLikeTextBuffer(buffer) {
+  if (buffer.length === 0) return true;
+  for (const byte of buffer) {
+    if (byte === 0) return false;
+  }
+  const decoded = buffer.toString("utf8");
+  const replacementCount = (decoded.match(/\uFFFD/gu) ?? []).length;
+  return replacementCount / decoded.length < 0.05;
+}
+async function probeFileIsText(localPath) {
+  const handle = await open(localPath, "r");
+  try {
+    const sample = Buffer.allocUnsafe(4096);
+    const { bytesRead } = await handle.read(sample, 0, sample.length, 0);
+    return looksLikeTextBuffer(sample.subarray(0, bytesRead));
+  } finally {
+    await handle.close();
+  }
+}
+async function isTextEditableFile(localPath) {
+  if (isTextEditablePath(localPath)) return true;
+  try {
+    const fileStat = await stat3(localPath);
+    if (!fileStat.isFile()) return false;
+    return await probeFileIsText(localPath);
+  } catch {
+    return false;
+  }
+}
+function escapeHtml(value) {
+  return value.replace(/&/gu, "&amp;").replace(/</gu, "&lt;").replace(/>/gu, "&gt;").replace(/"/gu, "&quot;").replace(/'/gu, "&#39;");
+}
+function toBrowseHref(pathValue) {
+  return `/codex-local-browse${encodeURI(pathValue)}`;
+}
+function toEditHref(pathValue) {
+  return `/codex-local-edit${encodeURI(pathValue)}`;
+}
+function escapeForInlineScriptString(value) {
+  return JSON.stringify(value).replace(/<\//gu, "<\\/").replace(/<!--/gu, "<\\!--").replace(/\u2028/gu, "\\u2028").replace(/\u2029/gu, "\\u2029");
+}
+async function getDirectoryItems(localPath) {
+  const entries = await readdir3(localPath, { withFileTypes: true });
+  const withMeta = await Promise.all(entries.map(async (entry) => {
+    const entryPath = join3(localPath, entry.name);
+    const entryStat = await stat3(entryPath);
+    const editable = !entry.isDirectory() && await isTextEditableFile(entryPath);
+    return {
+      name: entry.name,
+      path: entryPath,
+      isDirectory: entry.isDirectory(),
+      editable,
+      mtimeMs: entryStat.mtimeMs
+    };
+  }));
+  return withMeta.sort((a, b) => {
+    if (b.mtimeMs !== a.mtimeMs) return b.mtimeMs - a.mtimeMs;
+    if (a.isDirectory && !b.isDirectory) return -1;
+    if (!a.isDirectory && b.isDirectory) return 1;
+    return a.name.localeCompare(b.name);
+  });
+}
+async function createDirectoryListingHtml(localPath) {
+  const items = await getDirectoryItems(localPath);
+  const parentPath = dirname(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>` : "";
+    return `<li class="file-row"><a class="file-link" href="${escapeHtml(toBrowseHref(item.path))}">${escapeHtml(item.name)}${suffix}</a>${editAction}</li>`;
+  }).join("\n");
+  const parentLink = localPath !== parentPath ? `<p><a href="${escapeHtml(toBrowseHref(parentPath))}">..</a></p>` : "";
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Index of ${escapeHtml(localPath)}</title>
+  <style>
+    body { font-family: ui-monospace, Menlo, Monaco, monospace; margin: 16px; background: #0b1020; color: #dbe6ff; }
+    a { color: #8cc2ff; text-decoration: none; }
+    a:hover { text-decoration: underline; }
+    ul { list-style: none; padding: 0; margin: 12px 0 0; display: flex; flex-direction: column; gap: 8px; }
+    .file-row { display: grid; grid-template-columns: minmax(0,1fr) auto; align-items: center; gap: 10px; }
+    .file-link { display: block; padding: 10px 12px; border: 1px solid #28405f; border-radius: 10px; background: #0f1b33; overflow-wrap: anywhere; }
+    .icon-btn { display: inline-flex; align-items: center; justify-content: center; width: 42px; height: 42px; border: 1px solid #36557a; border-radius: 10px; background: #162643; text-decoration: none; }
+    .icon-btn:hover { filter: brightness(1.08); text-decoration: none; }
+    h1 { font-size: 18px; margin: 0; word-break: break-all; }
+    @media (max-width: 640px) {
+      body { margin: 12px; }
+      .file-row { gap: 8px; }
+      .file-link { font-size: 15px; padding: 12px; }
+      .icon-btn { width: 44px; height: 44px; }
+    }
+  </style>
+</head>
+<body>
+  <h1>Index of ${escapeHtml(localPath)}</h1>
+  ${parentLink}
+  <ul>${rows}</ul>
+</body>
+</html>`;
+}
+async function createTextEditorHtml(localPath) {
+  const content = await readFile3(localPath, "utf8");
+  const parentPath = dirname(localPath);
+  const language = languageForPath(localPath);
+  const safeContentLiteral = escapeForInlineScriptString(content);
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Edit ${escapeHtml(localPath)}</title>
+  <style>
+    html, body { width: 100%; height: 100%; margin: 0; }
+    body { font-family: ui-monospace, Menlo, Monaco, monospace; background: #0b1020; color: #dbe6ff; display: flex; flex-direction: column; overflow: hidden; }
+    .toolbar { position: sticky; top: 0; z-index: 10; display: flex; flex-direction: column; gap: 8px; padding: 10px 12px; background: #0b1020; border-bottom: 1px solid #243a5a; }
+    .row { display: flex; gap: 8px; align-items: center; flex-wrap: wrap; }
+    button, a { background: #1b2a4a; color: #dbe6ff; border: 1px solid #345; padding: 6px 10px; border-radius: 6px; text-decoration: none; cursor: pointer; }
+    button:hover, a:hover { filter: brightness(1.08); }
+    #editor { flex: 1 1 auto; min-height: 0; width: 100%; border: none; overflow: hidden; }
+    #status { margin-left: 8px; color: #8cc2ff; }
+    .ace_editor { background: #07101f !important; color: #dbe6ff !important; width: 100% !important; height: 100% !important; }
+    .ace_gutter { background: #07101f !important; color: #6f8eb5 !important; }
+    .ace_marker-layer .ace_active-line { background: #10213c !important; }
+    .ace_marker-layer .ace_selection { background: rgba(140, 194, 255, 0.3) !important; }
+    .meta { opacity: 0.9; font-size: 12px; overflow-wrap: anywhere; }
+  </style>
+</head>
+<body>
+  <div class="toolbar">
+    <div class="row">
+      <a href="${escapeHtml(toBrowseHref(parentPath))}">Back</a>
+      <button id="saveBtn" type="button">Save</button>
+      <span id="status"></span>
+    </div>
+    <div class="meta">${escapeHtml(localPath)} \xB7 ${escapeHtml(language)}</div>
+  </div>
+  <div id="editor"></div>
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/ace/1.36.2/ace.js"></script>
+  <script>
+    const saveBtn = document.getElementById('saveBtn');
+    const status = document.getElementById('status');
+    const editor = ace.edit('editor');
+    editor.setTheme('ace/theme/tomorrow_night');
+    editor.session.setMode('ace/mode/${escapeHtml(language)}');
+    editor.setValue(${safeContentLiteral}, -1);
+    editor.setOptions({
+      fontSize: '13px',
+      wrap: true,
+      showPrintMargin: false,
+      useSoftTabs: true,
+      tabSize: 2,
+      behavioursEnabled: true,
+    });
+    editor.resize();
+
+    saveBtn.addEventListener('click', async () => {
+      status.textContent = 'Saving...';
+      const response = await fetch(location.pathname, {
+        method: 'PUT',
+        headers: { 'Content-Type': 'text/plain; charset=utf-8' },
+        body: editor.getValue(),
+      });
+      status.textContent = response.ok ? 'Saved' : 'Save failed';
+    });
+  </script>
+</body>
+</html>`;
+}
+
 // src/server/httpServer.ts
 import { WebSocketServer } from "ws";
-var __dirname = dirname(fileURLToPath(import.meta.url));
-var distDir = join2(__dirname, "..", "dist");
-var spaEntryFile = join2(distDir, "index.html");
+var __dirname = dirname2(fileURLToPath(import.meta.url));
+var distDir = join4(__dirname, "..", "dist");
+var spaEntryFile = join4(distDir, "index.html");
 var IMAGE_CONTENT_TYPES = {
   ".avif": "image/avif",
   ".bmp": "image/bmp",
@@ -2103,6 +2694,11 @@ function normalizeLocalImagePath(rawPath) {
   }
   return trimmed;
 }
+function readWildcardPathParam(value) {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) return value.join("/");
+  return "";
+}
 function createServer(options = {}) {
   const app = express();
   const bridge = createCodexBridgeMiddleware();
@@ -2118,7 +2714,7 @@ function createServer(options = {}) {
       res.status(400).json({ error: "Expected absolute local file path." });
       return;
     }
-    const contentType = IMAGE_CONTENT_TYPES[extname(localPath).toLowerCase()];
+    const contentType = IMAGE_CONTENT_TYPES[extname2(localPath).toLowerCase()];
     if (!contentType) {
       res.status(415).json({ error: "Unsupported image type." });
       return;
@@ -2130,6 +2726,81 @@ function createServer(options = {}) {
       if (!res.headersSent) res.status(404).json({ error: "Image file not found." });
     });
   });
+  app.get("/codex-local-file", (req, res) => {
+    const rawPath = typeof req.query.path === "string" ? req.query.path : "";
+    const localPath = normalizeLocalPath(rawPath);
+    if (!localPath || !isAbsolute2(localPath)) {
+      res.status(400).json({ error: "Expected absolute local file path." });
+      return;
+    }
+    res.setHeader("Cache-Control", "private, no-store");
+    res.setHeader("Content-Disposition", "inline");
+    res.sendFile(localPath, { dotfiles: "allow" }, (error) => {
+      if (!error) return;
+      if (!res.headersSent) res.status(404).json({ error: "File not found." });
+    });
+  });
+  app.get("/codex-local-browse/*path", async (req, res) => {
+    const rawPath = readWildcardPathParam(req.params.path);
+    const localPath = decodeBrowsePath(`/${rawPath}`);
+    if (!localPath || !isAbsolute2(localPath)) {
+      res.status(400).json({ error: "Expected absolute local file path." });
+      return;
+    }
+    try {
+      const fileStat = await stat4(localPath);
+      res.setHeader("Cache-Control", "private, no-store");
+      if (fileStat.isDirectory()) {
+        const html = await createDirectoryListingHtml(localPath);
+        res.status(200).type("text/html; charset=utf-8").send(html);
+        return;
+      }
+      res.sendFile(localPath, { dotfiles: "allow" }, (error) => {
+        if (!error) return;
+        if (!res.headersSent) res.status(404).json({ error: "File not found." });
+      });
+    } catch {
+      res.status(404).json({ error: "File not found." });
+    }
+  });
+  app.get("/codex-local-edit/*path", async (req, res) => {
+    const rawPath = readWildcardPathParam(req.params.path);
+    const localPath = decodeBrowsePath(`/${rawPath}`);
+    if (!localPath || !isAbsolute2(localPath)) {
+      res.status(400).json({ error: "Expected absolute local file path." });
+      return;
+    }
+    try {
+      const fileStat = await stat4(localPath);
+      if (!fileStat.isFile()) {
+        res.status(400).json({ error: "Expected file path." });
+        return;
+      }
+      const html = await createTextEditorHtml(localPath);
+      res.status(200).type("text/html; charset=utf-8").send(html);
+    } catch {
+      res.status(404).json({ error: "File not found." });
+    }
+  });
+  app.put("/codex-local-edit/*path", express.text({ type: "*/*", limit: "10mb" }), async (req, res) => {
+    const rawPath = readWildcardPathParam(req.params.path);
+    const localPath = decodeBrowsePath(`/${rawPath}`);
+    if (!localPath || !isAbsolute2(localPath)) {
+      res.status(400).json({ error: "Expected absolute local file path." });
+      return;
+    }
+    if (!await isTextEditableFile(localPath)) {
+      res.status(415).json({ error: "Only text-like files are editable." });
+      return;
+    }
+    const body = typeof req.body === "string" ? req.body : "";
+    try {
+      await writeFile3(localPath, body, "utf8");
+      res.status(200).json({ ok: true });
+    } catch {
+      res.status(404).json({ error: "File not found." });
+    }
+  });
   const hasFrontendAssets = existsSync2(spaEntryFile);
   if (hasFrontendAssets) {
     app.use(express.static(distDir));
@@ -2201,11 +2872,11 @@ function generatePassword() {
 
 // src/cli/index.ts
 var program = new Command().name("codexui").description("Web interface for Codex app-server");
-var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
+var __dirname2 = dirname3(fileURLToPath2(import.meta.url));
 async function readCliVersion() {
   try {
-    const packageJsonPath = join3(__dirname2, "..", "package.json");
-    const raw = await readFile2(packageJsonPath, "utf8");
+    const packageJsonPath = join5(__dirname2, "..", "package.json");
+    const raw = await readFile4(packageJsonPath, "utf8");
     const parsed = JSON.parse(raw);
     return typeof parsed.version === "string" ? parsed.version : "unknown";
   } catch {
@@ -2230,13 +2901,13 @@ function runWithStatus(command, args) {
   return result.status ?? -1;
 }
 function getUserNpmPrefix() {
-  return join3(homedir2(), ".npm-global");
+  return join5(homedir3(), ".npm-global");
 }
 function resolveCodexCommand() {
   if (canRun("codex", ["--version"])) {
     return "codex";
   }
-  const userCandidate = join3(getUserNpmPrefix(), "bin", "codex");
+  const userCandidate = join5(getUserNpmPrefix(), "bin", "codex");
   if (existsSync3(userCandidate) && canRun(userCandidate, ["--version"])) {
     return userCandidate;
   }
@@ -2244,15 +2915,113 @@ function resolveCodexCommand() {
   if (!prefix) {
     return null;
   }
-  const candidate = join3(prefix, "bin", "codex");
+  const candidate = join5(prefix, "bin", "codex");
   if (existsSync3(candidate) && canRun(candidate, ["--version"])) {
     return candidate;
   }
   return null;
 }
+function resolveCloudflaredCommand() {
+  if (canRun("cloudflared", ["--version"])) {
+    return "cloudflared";
+  }
+  const localCandidate = join5(homedir3(), ".local", "bin", "cloudflared");
+  if (existsSync3(localCandidate) && canRun(localCandidate, ["--version"])) {
+    return localCandidate;
+  }
+  return null;
+}
+function mapCloudflaredLinuxArch(arch) {
+  if (arch === "x64") {
+    return "amd64";
+  }
+  if (arch === "arm64") {
+    return "arm64";
+  }
+  return null;
+}
+function downloadFile(url, destination) {
+  return new Promise((resolve2, reject) => {
+    const request = (currentUrl) => {
+      httpsGet(currentUrl, (response) => {
+        const code = response.statusCode ?? 0;
+        if (code >= 300 && code < 400 && response.headers.location) {
+          response.resume();
+          request(response.headers.location);
+          return;
+        }
+        if (code !== 200) {
+          response.resume();
+          reject(new Error(`Download failed with HTTP status ${String(code)}`));
+          return;
+        }
+        const file = createWriteStream(destination, { mode: 493 });
+        response.pipe(file);
+        file.on("finish", () => {
+          file.close();
+          resolve2();
+        });
+        file.on("error", reject);
+      }).on("error", reject);
+    };
+    request(url);
+  });
+}
+async function ensureCloudflaredInstalledLinux() {
+  const current = resolveCloudflaredCommand();
+  if (current) {
+    return current;
+  }
+  if (process.platform !== "linux") {
+    return null;
+  }
+  const mappedArch = mapCloudflaredLinuxArch(process.arch);
+  if (!mappedArch) {
+    throw new Error(`cloudflared auto-install is not supported for Linux architecture: ${process.arch}`);
+  }
+  const userBinDir = join5(homedir3(), ".local", "bin");
+  mkdirSync(userBinDir, { recursive: true });
+  const destination = join5(userBinDir, "cloudflared");
+  const downloadUrl = `https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-${mappedArch}`;
+  console.log("\ncloudflared not found. Installing to ~/.local/bin...\n");
+  await downloadFile(downloadUrl, destination);
+  chmodSync(destination, 493);
+  process.env.PATH = `${userBinDir}:${process.env.PATH ?? ""}`;
+  const installed = resolveCloudflaredCommand();
+  if (!installed) {
+    throw new Error("cloudflared download completed but executable is still not available");
+  }
+  console.log("\ncloudflared installed.\n");
+  return installed;
+}
+async function shouldInstallCloudflaredInteractively() {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    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 });
+  try {
+    const answer = await prompt.question("cloudflared is not installed. Install it now to ~/.local/bin? [y/N] ");
+    const normalized = answer.trim().toLowerCase();
+    return normalized === "y" || normalized === "yes";
+  } finally {
+    prompt.close();
+  }
+}
+async function resolveCloudflaredForTunnel() {
+  const current = resolveCloudflaredCommand();
+  if (current) {
+    return current;
+  }
+  const installApproved = await shouldInstallCloudflaredInteractively();
+  if (!installApproved) {
+    return null;
+  }
+  return ensureCloudflaredInstalledLinux();
+}
 function hasCodexAuth() {
-  const codexHome = process.env.CODEX_HOME?.trim() || join3(homedir2(), ".codex");
-  return existsSync3(join3(codexHome, "auth.json"));
+  const codexHome = process.env.CODEX_HOME?.trim() || join5(homedir3(), ".codex");
+  return existsSync3(join5(codexHome, "auth.json"));
 }
 function ensureCodexInstalled() {
   let codexCommand = resolveCodexCommand();
@@ -2270,7 +3039,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 = `${join3(userPrefix, "bin")}:${process.env.PATH ?? ""}`;
+      process.env.PATH = `${join5(userPrefix, "bin")}:${process.env.PATH ?? ""}`;
     };
     if (isTermuxRuntime()) {
       console.log("\nCodex CLI not found. Installing Termux-compatible Codex CLI from npm...\n");
@@ -2319,7 +3088,7 @@ function printTermuxKeepAlive(lines) {
 }
 function openBrowser(url) {
   const command = process.platform === "darwin" ? { cmd: "open", args: [url] } : process.platform === "win32" ? { cmd: "cmd", args: ["/c", "start", "", url] } : { cmd: "xdg-open", args: [url] };
-  const child = spawn2(command.cmd, command.args, { detached: true, stdio: "ignore" });
+  const child = spawn3(command.cmd, command.args, { detached: true, stdio: "ignore" });
   child.on("error", () => {
   });
   child.unref();
@@ -2331,9 +3100,27 @@ function parseCloudflaredUrl(chunk) {
   }
   return urlMatch[urlMatch.length - 1] ?? null;
 }
-async function startCloudflaredTunnel(localPort) {
+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) {
+        continue;
+      }
+      if (entry.family === "IPv4") {
+        urls.add(`http://${entry.address}:${String(port)}`);
+      }
+    }
+  }
+  return Array.from(urls);
+}
+async function startCloudflaredTunnel(command, localPort) {
   return new Promise((resolve2, reject) => {
-    const child = spawn2("cloudflared", ["tunnel", "--url", `http://localhost:${String(localPort)}`], {
+    const child = spawn3(command, ["tunnel", "--url", `http://localhost:${String(localPort)}`], {
       stdio: ["ignore", "pipe", "pipe"]
     });
     const timeout = setTimeout(() => {
@@ -2384,7 +3171,7 @@ function listenWithFallback(server, startPort) {
       };
       server.once("error", onError);
       server.once("listening", onListening);
-      server.listen(port);
+      server.listen(port, "0.0.0.0");
     };
     attempt(startPort);
   });
@@ -2406,7 +3193,11 @@ async function startServer(options) {
   let tunnelUrl = null;
   if (options.tunnel) {
     try {
-      const tunnel = await startCloudflaredTunnel(port);
+      const cloudflaredCommand = await resolveCloudflaredForTunnel();
+      if (!cloudflaredCommand) {
+        throw new Error("cloudflared is not installed");
+      }
+      const tunnel = await startCloudflaredTunnel(cloudflaredCommand, port);
       tunnelChild = tunnel.process;
       tunnelUrl = tunnel.url;
     } catch (error) {
@@ -2421,8 +3212,15 @@ async function startServer(options) {
     `  Version:  ${version}`,
     "  GitHub:   https://github.com/friuns2/codexui",
     "",
-    `  Local:    http://localhost:${String(port)}`
+    `  Bind:     http://0.0.0.0:${String(port)}`
   ];
+  const accessUrls = getAccessibleUrls(port);
+  if (accessUrls.length > 0) {
+    lines.push(`  Local:    ${accessUrls[0]}`);
+    for (const accessUrl of accessUrls.slice(1)) {
+      lines.push(`  Network:  ${accessUrl}`);
+    }
+  }
   if (port !== requestedPort) {
     lines.push(`  Requested port ${String(requestedPort)} was unavailable; using ${String(port)}.`);
   }
@@ -2431,9 +3229,7 @@ async function startServer(options) {
   }
   if (tunnelUrl) {
     lines.push(`  Tunnel:   ${tunnelUrl}`);
-    lines.push("");
-    lines.push("  Tunnel QR code:");
-    lines.push(`  URL:      ${tunnelUrl}`);
+    lines.push("  Tunnel QR code below");
   }
   printTermuxKeepAlive(lines);
   lines.push("");