codexapp 0.1.4

package/dist-cli/index.js

@@ -0,0 +1,1414 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { createServer as createServer2 } from "http";
+import { existsSync } 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 { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname2 } from "path";
+import { Command } from "commander";
+
+// src/server/httpServer.ts
+import { fileURLToPath } from "url";
+import { dirname, extname, isAbsolute as isAbsolute2, join as join2 } from "path";
+import express from "express";
+
+// src/server/codexAppServerBridge.ts
+import { spawn } from "child_process";
+import { mkdtemp, readFile, readdir, rm, mkdir, stat } from "fs/promises";
+import { request as httpsRequest } from "https";
+import { homedir } from "os";
+import { tmpdir } from "os";
+import { isAbsolute, join, resolve } from "path";
+import { writeFile } from "fs/promises";
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function getErrorMessage(payload, fallback) {
+  if (payload instanceof Error && payload.message.trim().length > 0) {
+    return payload.message;
+  }
+  const record = asRecord(payload);
+  if (!record) return fallback;
+  const error = record.error;
+  if (typeof error === "string" && error.length > 0) return error;
+  const nestedError = asRecord(error);
+  if (nestedError && typeof nestedError.message === "string" && nestedError.message.length > 0) {
+    return nestedError.message;
+  }
+  return fallback;
+}
+function setJson(res, statusCode, payload) {
+  res.statusCode = statusCode;
+  res.setHeader("Content-Type", "application/json; charset=utf-8");
+  res.end(JSON.stringify(payload));
+}
+function getCodexHomeDir() {
+  const codexHome = process.env.CODEX_HOME?.trim();
+  return codexHome && codexHome.length > 0 ? codexHome : join(homedir(), ".codex");
+}
+function getSkillsInstallDir() {
+  return join(getCodexHomeDir(), "skills");
+}
+async function runCommand(command, args, options = {}) {
+  await new Promise((resolve2, reject) => {
+    const proc = spawn(command, args, {
+      cwd: options.cwd,
+      env: process.env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    proc.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    proc.on("error", reject);
+    proc.on("close", (code) => {
+      if (code === 0) {
+        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}`));
+    });
+  });
+}
+async function detectUserSkillsDir(appServer) {
+  try {
+    const result = await appServer.rpc("skills/list", {});
+    for (const entry of result.data ?? []) {
+      for (const skill of entry.skills ?? []) {
+        if (skill.scope !== "user" || !skill.path) continue;
+        const parts = skill.path.split("/").filter(Boolean);
+        if (parts.length < 2) continue;
+        return `/${parts.slice(0, -2).join("/")}`;
+      }
+    }
+  } catch {
+  }
+  return getSkillsInstallDir();
+}
+async function ensureInstalledSkillIsValid(appServer, skillPath) {
+  const result = await appServer.rpc("skills/list", { forceReload: true });
+  const normalized = skillPath.endsWith("/SKILL.md") ? skillPath : `${skillPath}/SKILL.md`;
+  for (const entry of result.data ?? []) {
+    for (const error of entry.errors ?? []) {
+      if (error.path === normalized) {
+        throw new Error(error.message || "Installed skill is invalid");
+      }
+    }
+  }
+}
+var TREE_CACHE_TTL_MS = 5 * 60 * 1e3;
+var skillsTreeCache = null;
+var metaCache = /* @__PURE__ */ new Map();
+async function getGhToken() {
+  try {
+    const proc = spawn("gh", ["auth", "token"], { stdio: ["ignore", "pipe", "ignore"] });
+    let out = "";
+    proc.stdout.on("data", (d) => {
+      out += d.toString();
+    });
+    return new Promise((resolve2) => {
+      proc.on("close", (code) => resolve2(code === 0 ? out.trim() : null));
+      proc.on("error", () => resolve2(null));
+    });
+  } catch {
+    return null;
+  }
+}
+async function ghFetch(url) {
+  const token = await getGhToken();
+  const headers = {
+    Accept: "application/vnd.github+json",
+    "User-Agent": "codex-web-local"
+  };
+  if (token) headers.Authorization = `Bearer ${token}`;
+  return fetch(url, { headers });
+}
+async function fetchSkillsTree() {
+  if (skillsTreeCache && Date.now() - skillsTreeCache.fetchedAt < TREE_CACHE_TTL_MS) {
+    return skillsTreeCache.entries;
+  }
+  const resp = await ghFetch("https://api.github.com/repos/openclaw/skills/git/trees/main?recursive=1");
+  if (!resp.ok) throw new Error(`GitHub tree API returned ${resp.status}`);
+  const data = await resp.json();
+  const metaPattern = /^skills\/([^/]+)\/([^/]+)\/_meta\.json$/;
+  const seen = /* @__PURE__ */ new Set();
+  const entries = [];
+  for (const node of data.tree ?? []) {
+    const match = metaPattern.exec(node.path);
+    if (!match) continue;
+    const [, owner, skillName] = match;
+    const key = `${owner}/${skillName}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    entries.push({
+      name: skillName,
+      owner,
+      url: `https://github.com/openclaw/skills/tree/main/skills/${owner}/${skillName}`
+    });
+  }
+  skillsTreeCache = { entries, fetchedAt: Date.now() };
+  return entries;
+}
+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(
+    batch.map(async (e) => {
+      const rawUrl = `https://raw.githubusercontent.com/openclaw/skills/main/skills/${e.owner}/${e.name}/_meta.json`;
+      const resp = await fetch(rawUrl);
+      if (!resp.ok) return;
+      const meta = await resp.json();
+      metaCache.set(`${e.owner}/${e.name}`, {
+        displayName: typeof meta.displayName === "string" ? meta.displayName : "",
+        description: typeof meta.displayName === "string" ? meta.displayName : "",
+        publishedAt: meta.latest?.publishedAt ?? 0
+      });
+    })
+  );
+  void results;
+}
+function buildHubEntry(e) {
+  const cached = metaCache.get(`${e.owner}/${e.name}`);
+  return {
+    name: e.name,
+    owner: e.owner,
+    description: cached?.description ?? "",
+    displayName: cached?.displayName ?? "",
+    publishedAt: cached?.publishedAt ?? 0,
+    avatarUrl: `https://github.com/${e.owner}.png?size=40`,
+    url: e.url,
+    installed: false
+  };
+}
+async function scanInstalledSkillsFromDisk() {
+  const map = /* @__PURE__ */ new Map();
+  const skillsDir = getSkillsInstallDir();
+  try {
+    const entries = await readdir(skillsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+      const skillMd = join(skillsDir, entry.name, "SKILL.md");
+      try {
+        await stat(skillMd);
+        map.set(entry.name, { name: entry.name, path: skillMd, enabled: true });
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return map;
+}
+async function searchSkillsHub(allEntries, query, limit, sort, installedMap) {
+  const q = query.toLowerCase().trim();
+  let 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;
+  }) : allEntries;
+  const page = filtered.slice(0, Math.min(limit * 2, 200));
+  await fetchMetaBatch(page);
+  let results = page.map(buildHubEntry);
+  if (sort === "date") {
+    results.sort((a, b) => b.publishedAt - a.publishedAt);
+  } else if (q) {
+    results.sort((a, b) => {
+      const aExact = a.name.toLowerCase() === q ? 1 : 0;
+      const bExact = b.name.toLowerCase() === q ? 1 : 0;
+      if (aExact !== bExact) return bExact - aExact;
+      return b.publishedAt - a.publishedAt;
+    });
+  }
+  return results.slice(0, limit).map((s) => {
+    const local = installedMap.get(s.name);
+    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;
+    }
+  }
+  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;
+  }
+}
+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;
+    }
+  }
+  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 = {};
+  }
+  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);
+  }
+  return Buffer.concat(chunks);
+}
+async function proxyTranscribe(body, contentType, authToken, accountId) {
+  const headers = {
+    "Content-Type": contentType,
+    "Content-Length": body.length,
+    Authorization: `Bearer ${authToken}`,
+    originator: "Codex Desktop",
+    "User-Agent": `Codex Desktop/0.1.0 (${process.platform}; ${process.arch})`
+  };
+  if (accountId) {
+    headers["ChatGPT-Account-Id"] = accountId;
+  }
+  return new Promise((resolve2, reject) => {
+    const req = httpsRequest(
+      "https://chatgpt.com/backend-api/transcribe",
+      { method: "POST", headers },
+      (res) => {
+        const chunks = [];
+        res.on("data", (c) => chunks.push(c));
+        res.on("end", () => resolve2({ status: res.statusCode ?? 500, body: Buffer.concat(chunks).toString("utf8") }));
+        res.on("error", reject);
+      }
+    );
+    req.on("error", reject);
+    req.write(body);
+    req.end();
+  });
+}
+var AppServerProcess = class {
+  constructor() {
+    this.process = null;
+    this.initialized = false;
+    this.initializePromise = null;
+    this.readBuffer = "";
+    this.nextId = 1;
+    this.stopping = false;
+    this.pending = /* @__PURE__ */ new Map();
+    this.notificationListeners = /* @__PURE__ */ new Set();
+    this.pendingServerRequests = /* @__PURE__ */ new Map();
+  }
+  start() {
+    if (this.process) return;
+    this.stopping = false;
+    const proc = spawn("codex", ["app-server"], { stdio: ["pipe", "pipe", "pipe"] });
+    this.process = proc;
+    proc.stdout.setEncoding("utf8");
+    proc.stdout.on("data", (chunk) => {
+      this.readBuffer += chunk;
+      let lineEnd = this.readBuffer.indexOf("\n");
+      while (lineEnd !== -1) {
+        const line = this.readBuffer.slice(0, lineEnd).trim();
+        this.readBuffer = this.readBuffer.slice(lineEnd + 1);
+        if (line.length > 0) {
+          this.handleLine(line);
+        }
+        lineEnd = this.readBuffer.indexOf("\n");
+      }
+    });
+    proc.stderr.setEncoding("utf8");
+    proc.stderr.on("data", () => {
+    });
+    proc.on("exit", () => {
+      const failure = new Error(this.stopping ? "codex app-server stopped" : "codex app-server exited unexpectedly");
+      for (const request of this.pending.values()) {
+        request.reject(failure);
+      }
+      this.pending.clear();
+      this.pendingServerRequests.clear();
+      this.process = null;
+      this.initialized = false;
+      this.initializePromise = null;
+      this.readBuffer = "";
+    });
+  }
+  sendLine(payload) {
+    if (!this.process) {
+      throw new Error("codex app-server is not running");
+    }
+    this.process.stdin.write(`${JSON.stringify(payload)}
+`);
+  }
+  handleLine(line) {
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (typeof message.id === "number" && this.pending.has(message.id)) {
+      const pendingRequest = this.pending.get(message.id);
+      this.pending.delete(message.id);
+      if (!pendingRequest) return;
+      if (message.error) {
+        pendingRequest.reject(new Error(message.error.message));
+      } else {
+        pendingRequest.resolve(message.result);
+      }
+      return;
+    }
+    if (typeof message.method === "string" && typeof message.id !== "number") {
+      this.emitNotification({
+        method: message.method,
+        params: message.params ?? null
+      });
+      return;
+    }
+    if (typeof message.id === "number" && typeof message.method === "string") {
+      this.handleServerRequest(message.id, message.method, message.params ?? null);
+    }
+  }
+  emitNotification(notification) {
+    for (const listener of this.notificationListeners) {
+      listener(notification);
+    }
+  }
+  sendServerRequestReply(requestId, reply) {
+    if (reply.error) {
+      this.sendLine({
+        jsonrpc: "2.0",
+        id: requestId,
+        error: reply.error
+      });
+      return;
+    }
+    this.sendLine({
+      jsonrpc: "2.0",
+      id: requestId,
+      result: reply.result ?? {}
+    });
+  }
+  resolvePendingServerRequest(requestId, reply) {
+    const pendingRequest = this.pendingServerRequests.get(requestId);
+    if (!pendingRequest) {
+      throw new Error(`No pending server request found for id ${String(requestId)}`);
+    }
+    this.pendingServerRequests.delete(requestId);
+    this.sendServerRequestReply(requestId, reply);
+    const requestParams = asRecord(pendingRequest.params);
+    const threadId = typeof requestParams?.threadId === "string" && requestParams.threadId.length > 0 ? requestParams.threadId : "";
+    this.emitNotification({
+      method: "server/request/resolved",
+      params: {
+        id: requestId,
+        method: pendingRequest.method,
+        threadId,
+        mode: "manual",
+        resolvedAtIso: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    });
+  }
+  handleServerRequest(requestId, method, params) {
+    const pendingRequest = {
+      id: requestId,
+      method,
+      params,
+      receivedAtIso: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.pendingServerRequests.set(requestId, pendingRequest);
+    this.emitNotification({
+      method: "server/request",
+      params: pendingRequest
+    });
+  }
+  async call(method, params) {
+    this.start();
+    const id = this.nextId++;
+    return new Promise((resolve2, reject) => {
+      this.pending.set(id, { resolve: resolve2, reject });
+      this.sendLine({
+        jsonrpc: "2.0",
+        id,
+        method,
+        params
+      });
+    });
+  }
+  async ensureInitialized() {
+    if (this.initialized) return;
+    if (this.initializePromise) {
+      await this.initializePromise;
+      return;
+    }
+    this.initializePromise = this.call("initialize", {
+      clientInfo: {
+        name: "codex-web-local",
+        version: "0.1.0"
+      }
+    }).then(() => {
+      this.initialized = true;
+    }).finally(() => {
+      this.initializePromise = null;
+    });
+    await this.initializePromise;
+  }
+  async rpc(method, params) {
+    await this.ensureInitialized();
+    return this.call(method, params);
+  }
+  onNotification(listener) {
+    this.notificationListeners.add(listener);
+    return () => {
+      this.notificationListeners.delete(listener);
+    };
+  }
+  async respondToServerRequest(payload) {
+    await this.ensureInitialized();
+    const body = asRecord(payload);
+    if (!body) {
+      throw new Error("Invalid response payload: expected object");
+    }
+    const id = body.id;
+    if (typeof id !== "number" || !Number.isInteger(id)) {
+      throw new Error('Invalid response payload: "id" must be an integer');
+    }
+    const rawError = asRecord(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;
+      this.resolvePendingServerRequest(id, { error: { code, message } });
+      return;
+    }
+    if (!("result" in body)) {
+      throw new Error('Invalid response payload: expected "result" or "error"');
+    }
+    this.resolvePendingServerRequest(id, { result: body.result });
+  }
+  listPendingServerRequests() {
+    return Array.from(this.pendingServerRequests.values());
+  }
+  dispose() {
+    if (!this.process) return;
+    const proc = this.process;
+    this.stopping = true;
+    this.process = null;
+    this.initialized = false;
+    this.initializePromise = null;
+    this.readBuffer = "";
+    const failure = new Error("codex app-server stopped");
+    for (const request of this.pending.values()) {
+      request.reject(failure);
+    }
+    this.pending.clear();
+    this.pendingServerRequests.clear();
+    try {
+      proc.stdin.end();
+    } catch {
+    }
+    try {
+      proc.kill("SIGTERM");
+    } catch {
+    }
+    const forceKillTimer = setTimeout(() => {
+      if (!proc.killed) {
+        try {
+          proc.kill("SIGKILL");
+        } catch {
+        }
+      }
+    }, 1500);
+    forceKillTimer.unref();
+  }
+};
+var MethodCatalog = class {
+  constructor() {
+    this.methodCache = null;
+    this.notificationCache = null;
+  }
+  async runGenerateSchemaCommand(outDir) {
+    await new Promise((resolve2, reject) => {
+      const process2 = spawn("codex", ["app-server", "generate-json-schema", "--out", outDir], {
+        stdio: ["ignore", "ignore", "pipe"]
+      });
+      let stderr = "";
+      process2.stderr.setEncoding("utf8");
+      process2.stderr.on("data", (chunk) => {
+        stderr += chunk;
+      });
+      process2.on("error", reject);
+      process2.on("exit", (code) => {
+        if (code === 0) {
+          resolve2();
+          return;
+        }
+        reject(new Error(stderr.trim() || `generate-json-schema exited with code ${String(code)}`));
+      });
+    });
+  }
+  extractMethodsFromClientRequest(payload) {
+    const root = asRecord(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 methodEnum = Array.isArray(methodDef?.enum) ? methodDef.enum : [];
+      for (const item of methodEnum) {
+        if (typeof item === "string" && item.length > 0) {
+          methods.add(item);
+        }
+      }
+    }
+    return Array.from(methods).sort((a, b) => a.localeCompare(b));
+  }
+  extractMethodsFromServerNotification(payload) {
+    const root = asRecord(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 methodEnum = Array.isArray(methodDef?.enum) ? methodDef.enum : [];
+      for (const item of methodEnum) {
+        if (typeof item === "string" && item.length > 0) {
+          methods.add(item);
+        }
+      }
+    }
+    return Array.from(methods).sort((a, b) => a.localeCompare(b));
+  }
+  async listMethods() {
+    if (this.methodCache) {
+      return this.methodCache;
+    }
+    const outDir = await mkdtemp(join(tmpdir(), "codex-web-local-schema-"));
+    await this.runGenerateSchemaCommand(outDir);
+    const clientRequestPath = join(outDir, "ClientRequest.json");
+    const raw = await readFile(clientRequestPath, "utf8");
+    const parsed = JSON.parse(raw);
+    const methods = this.extractMethodsFromClientRequest(parsed);
+    this.methodCache = methods;
+    return methods;
+  }
+  async listNotificationMethods() {
+    if (this.notificationCache) {
+      return this.notificationCache;
+    }
+    const outDir = await mkdtemp(join(tmpdir(), "codex-web-local-schema-"));
+    await this.runGenerateSchemaCommand(outDir);
+    const serverNotificationPath = join(outDir, "ServerNotification.json");
+    const raw = await readFile(serverNotificationPath, "utf8");
+    const parsed = JSON.parse(raw);
+    const methods = this.extractMethodsFromServerNotification(parsed);
+    this.notificationCache = methods;
+    return methods;
+  }
+};
+var SHARED_BRIDGE_KEY = "__codexRemoteSharedBridge__";
+function getSharedBridgeState() {
+  const globalScope = globalThis;
+  const existing = globalScope[SHARED_BRIDGE_KEY];
+  if (existing) return existing;
+  const created = {
+    appServer: new AppServerProcess(),
+    methodCatalog: new MethodCatalog()
+  };
+  globalScope[SHARED_BRIDGE_KEY] = created;
+  return created;
+}
+function createCodexBridgeMiddleware() {
+  const { appServer, methodCatalog } = getSharedBridgeState();
+  const middleware = async (req, res, next) => {
+    try {
+      if (!req.url) {
+        next();
+        return;
+      }
+      const url = new URL(req.url, "http://localhost");
+      if (req.method === "POST" && url.pathname === "/codex-api/rpc") {
+        const payload = await readJsonBody(req);
+        const body = asRecord(payload);
+        if (!body || typeof body.method !== "string" || body.method.length === 0) {
+          setJson(res, 400, { error: "Invalid body: expected { method, params? }" });
+          return;
+        }
+        const result = await appServer.rpc(body.method, body.params ?? null);
+        setJson(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" });
+          return;
+        }
+        const rawBody = await readRawBody(req);
+        const incomingCt = req.headers["content-type"] ?? "application/octet-stream";
+        const upstream = await proxyTranscribe(rawBody, incomingCt, auth.accessToken, auth.accountId);
+        res.statusCode = upstream.status;
+        res.setHeader("Content-Type", "application/json; charset=utf-8");
+        res.end(upstream.body);
+        return;
+      }
+      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 });
+        return;
+      }
+      if (req.method === "GET" && url.pathname === "/codex-api/server-requests/pending") {
+        setJson(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 });
+        return;
+      }
+      if (req.method === "GET" && url.pathname === "/codex-api/meta/notifications") {
+        const methods = await methodCatalog.listNotificationMethods();
+        setJson(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 });
+        return;
+      }
+      if (req.method === "PUT" && url.pathname === "/codex-api/workspace-roots-state") {
+        const payload = await readJsonBody(req);
+        const record = asRecord(payload);
+        if (!record) {
+          setJson(res, 400, { error: "Invalid body: expected object" });
+          return;
+        }
+        const nextState = {
+          order: normalizeStringArray(record.order),
+          labels: normalizeStringRecord(record.labels),
+          active: normalizeStringArray(record.active)
+        };
+        await writeWorkspaceRootsState(nextState);
+        setJson(res, 200, { ok: true });
+        return;
+      }
+      if (req.method === "POST" && url.pathname === "/codex-api/project-root") {
+        const payload = asRecord(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" });
+          return;
+        }
+        const normalizedPath = isAbsolute(rawPath) ? rawPath : resolve(rawPath);
+        let pathExists = true;
+        try {
+          const info = await stat(normalizedPath);
+          if (!info.isDirectory()) {
+            setJson(res, 400, { error: "Path exists but is not a directory" });
+            return;
+          }
+        } catch {
+          pathExists = false;
+        }
+        if (!pathExists && createIfMissing) {
+          await mkdir(normalizedPath, { recursive: true });
+        } else if (!pathExists) {
+          setJson(res, 404, { error: "Directory does not exist" });
+          return;
+        }
+        const existingState = await readWorkspaceRootsState();
+        const nextOrder = [normalizedPath, ...existingState.order.filter((item) => item !== normalizedPath)];
+        const nextActive = [normalizedPath, ...existingState.active.filter((item) => item !== normalizedPath)];
+        const nextLabels = { ...existingState.labels };
+        if (label.trim().length > 0) {
+          nextLabels[normalizedPath] = label.trim();
+        }
+        await writeWorkspaceRootsState({
+          order: nextOrder,
+          labels: nextLabels,
+          active: nextActive
+        });
+        setJson(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" });
+          return;
+        }
+        const normalizedBasePath = isAbsolute(basePath) ? basePath : resolve(basePath);
+        try {
+          const baseInfo = await stat(normalizedBasePath);
+          if (!baseInfo.isDirectory()) {
+            setJson(res, 400, { error: "basePath is not a directory" });
+            return;
+          }
+        } catch {
+          setJson(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);
+          try {
+            await stat(candidatePath);
+            index += 1;
+            continue;
+          } catch {
+            setJson(res, 200, { data: { name: candidateName, path: candidatePath } });
+            return;
+          }
+        }
+        setJson(res, 500, { error: "Failed to compute project name suggestion" });
+        return;
+      }
+      if (req.method === "GET" && url.pathname === "/codex-api/thread-titles") {
+        const cache = await readThreadTitleCache();
+        setJson(res, 200, { data: cache });
+        return;
+      }
+      if (req.method === "PUT" && url.pathname === "/codex-api/thread-titles") {
+        const payload = asRecord(await readJsonBody(req));
+        const id = typeof payload?.id === "string" ? payload.id : "";
+        const title = typeof payload?.title === "string" ? payload.title : "";
+        if (!id) {
+          setJson(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-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/openclaw/skills/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",
+            "openclaw/skills",
+            "--path",
+            skillPathInRepo,
+            "--dest",
+            installDest,
+            "--method",
+            "git"
+          ]);
+          const skillDir = join(installDest, name);
+          await ensureInstalledSkillIsValid(appServer, skillDir);
+          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 });
+          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;
+      }
+      if (req.method === "GET" && url.pathname === "/codex-api/events") {
+        res.statusCode = 200;
+        res.setHeader("Content-Type", "text/event-stream; charset=utf-8");
+        res.setHeader("Cache-Control", "no-cache, no-transform");
+        res.setHeader("Connection", "keep-alive");
+        res.setHeader("X-Accel-Buffering", "no");
+        const unsubscribe = appServer.onNotification((notification) => {
+          if (res.writableEnded || res.destroyed) return;
+          const payload = {
+            ...notification,
+            atIso: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          res.write(`data: ${JSON.stringify(payload)}
+
+`);
+        });
+        res.write(`event: ready
+data: ${JSON.stringify({ ok: true })}
+
+`);
+        const keepAlive = setInterval(() => {
+          res.write(": ping\n\n");
+        }, 15e3);
+        const close = () => {
+          clearInterval(keepAlive);
+          unsubscribe();
+          if (!res.writableEnded) {
+            res.end();
+          }
+        };
+        req.on("close", close);
+        req.on("aborted", close);
+        return;
+      }
+      next();
+    } catch (error) {
+      const message = getErrorMessage(error, "Unknown bridge error");
+      setJson(res, 502, { error: message });
+    }
+  };
+  middleware.dispose = () => {
+    appServer.dispose();
+  };
+  return middleware;
+}
+
+// src/server/authMiddleware.ts
+import { randomBytes, timingSafeEqual } from "crypto";
+var TOKEN_COOKIE = "codex_web_local_token";
+function isLocalhostRequest(req) {
+  const remote = req.socket.remoteAddress ?? "";
+  if (remote === "127.0.0.1" || remote === "::1" || remote === "::ffff:127.0.0.1") {
+    return true;
+  }
+  const host = (req.headers.host ?? "").toLowerCase();
+  return host.startsWith("localhost:") || host === "localhost" || host.startsWith("127.0.0.1:");
+}
+function constantTimeCompare(a, b) {
+  const bufA = Buffer.from(a);
+  const bufB = Buffer.from(b);
+  if (bufA.length !== bufB.length) return false;
+  return timingSafeEqual(bufA, bufB);
+}
+function parseCookies(header) {
+  const cookies = {};
+  if (!header) return cookies;
+  for (const pair of header.split(";")) {
+    const idx = pair.indexOf("=");
+    if (idx === -1) continue;
+    const key = pair.slice(0, idx).trim();
+    const value = pair.slice(idx + 1).trim();
+    cookies[key] = value;
+  }
+  return cookies;
+}
+var LOGIN_PAGE_HTML = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Codex Web Local &mdash; Login</title>
+<style>
+*,*::before,*::after{box-sizing:border-box;margin:0;padding:0}
+body{font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,sans-serif;background:#0a0a0a;color:#e5e5e5;display:flex;align-items:center;justify-content:center;min-height:100vh;padding:1rem}
+.card{background:#171717;border:1px solid #262626;border-radius:12px;padding:2rem;width:100%;max-width:380px}
+h1{font-size:1.25rem;font-weight:600;margin-bottom:1.5rem;text-align:center;color:#fafafa}
+label{display:block;font-size:.875rem;color:#a3a3a3;margin-bottom:.5rem}
+input{width:100%;padding:.625rem .75rem;background:#0a0a0a;border:1px solid #404040;border-radius:8px;color:#fafafa;font-size:1rem;outline:none;transition:border-color .15s}
+input:focus{border-color:#3b82f6}
+button{width:100%;padding:.625rem;margin-top:1rem;background:#3b82f6;color:#fff;border:none;border-radius:8px;font-size:.9375rem;font-weight:500;cursor:pointer;transition:background .15s}
+button:hover{background:#2563eb}
+.error{color:#ef4444;font-size:.8125rem;margin-top:.75rem;text-align:center;display:none}
+</style>
+</head>
+<body>
+<div class="card">
+<h1>Codex Web Local</h1>
+<form id="f">
+<label for="pw">Password</label>
+<input id="pw" name="password" type="password" autocomplete="current-password" autofocus required>
+<button type="submit">Sign in</button>
+<p class="error" id="err">Incorrect password</p>
+</form>
+</div>
+<script>
+const form=document.getElementById('f');
+const errEl=document.getElementById('err');
+form.addEventListener('submit',async e=>{
+  e.preventDefault();
+  errEl.style.display='none';
+  const res=await fetch('/auth/login',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({password:document.getElementById('pw').value})});
+  if(res.ok){window.location.reload()}else{errEl.style.display='block';document.getElementById('pw').value='';document.getElementById('pw').focus()}
+});
+</script>
+</body>
+</html>`;
+function createAuthMiddleware(password) {
+  const validTokens = /* @__PURE__ */ new Set();
+  return (req, res, next) => {
+    if (isLocalhostRequest(req)) {
+      next();
+      return;
+    }
+    if (req.method === "POST" && req.path === "/auth/login") {
+      let body = "";
+      req.setEncoding("utf8");
+      req.on("data", (chunk) => {
+        body += chunk;
+      });
+      req.on("end", () => {
+        try {
+          const parsed = JSON.parse(body);
+          const provided = typeof parsed.password === "string" ? parsed.password : "";
+          if (!constantTimeCompare(provided, password)) {
+            res.status(401).json({ error: "Invalid password" });
+            return;
+          }
+          const token2 = randomBytes(32).toString("hex");
+          validTokens.add(token2);
+          res.setHeader("Set-Cookie", `${TOKEN_COOKIE}=${token2}; Path=/; HttpOnly; SameSite=Strict`);
+          res.json({ ok: true });
+        } catch {
+          res.status(400).json({ error: "Invalid request body" });
+        }
+      });
+      return;
+    }
+    const cookies = parseCookies(req.headers.cookie);
+    const token = cookies[TOKEN_COOKIE];
+    if (token && validTokens.has(token)) {
+      next();
+      return;
+    }
+    res.setHeader("Content-Type", "text/html; charset=utf-8");
+    res.status(200).send(LOGIN_PAGE_HTML);
+  };
+}
+
+// src/server/httpServer.ts
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var distDir = join2(__dirname, "..", "dist");
+var IMAGE_CONTENT_TYPES = {
+  ".avif": "image/avif",
+  ".bmp": "image/bmp",
+  ".gif": "image/gif",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".webp": "image/webp"
+};
+function normalizeLocalImagePath(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 createServer(options = {}) {
+  const app = express();
+  const bridge = createCodexBridgeMiddleware();
+  if (options.password) {
+    app.use(createAuthMiddleware(options.password));
+  }
+  app.use(bridge);
+  app.get("/codex-local-image", (req, res) => {
+    const rawPath = typeof req.query.path === "string" ? req.query.path : "";
+    const localPath = normalizeLocalImagePath(rawPath);
+    if (!localPath || !isAbsolute2(localPath)) {
+      res.status(400).json({ error: "Expected absolute local file path." });
+      return;
+    }
+    const contentType = IMAGE_CONTENT_TYPES[extname(localPath).toLowerCase()];
+    if (!contentType) {
+      res.status(415).json({ error: "Unsupported image type." });
+      return;
+    }
+    res.type(contentType);
+    res.setHeader("Cache-Control", "private, max-age=300");
+    res.sendFile(localPath, { dotfiles: "allow" }, (error) => {
+      if (!error) return;
+      if (!res.headersSent) res.status(404).json({ error: "Image file not found." });
+    });
+  });
+  app.use(express.static(distDir));
+  app.use((_req, res) => {
+    res.sendFile(join2(distDir, "index.html"));
+  });
+  return {
+    app,
+    dispose: () => bridge.dispose()
+  };
+}
+
+// src/server/password.ts
+import { randomInt } from "crypto";
+var CHARS = "abcdefghijklmnopqrstuvwxyz0123456789";
+function randomGroup(length) {
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += CHARS[randomInt(CHARS.length)];
+  }
+  return result;
+}
+function generatePassword() {
+  return `${randomGroup(3)}-${randomGroup(3)}-${randomGroup(3)}`;
+}
+
+// src/cli/index.ts
+var program = new Command().name("codexui").description("Web interface for Codex app-server");
+var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
+async function readCliVersion() {
+  try {
+    const packageJsonPath = join3(__dirname2, "..", "package.json");
+    const raw = await readFile2(packageJsonPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return typeof parsed.version === "string" ? parsed.version : "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function isTermuxRuntime() {
+  return Boolean(process.env.TERMUX_VERSION || process.env.PREFIX?.includes("/com.termux/"));
+}
+function canRun(command, args = []) {
+  const result = spawnSync(command, args, { stdio: "ignore" });
+  return result.status === 0;
+}
+function runOrFail(command, args, label) {
+  const result = spawnSync(command, args, { stdio: "inherit" });
+  if (result.status !== 0) {
+    throw new Error(`${label} failed with exit code ${String(result.status ?? -1)}`);
+  }
+}
+function resolveCodexCommand() {
+  if (canRun("codex", ["--version"])) {
+    return "codex";
+  }
+  const prefix = process.env.PREFIX?.trim();
+  if (!prefix) {
+    return null;
+  }
+  const candidate = join3(prefix, "bin", "codex");
+  if (existsSync(candidate) && canRun(candidate, ["--version"])) {
+    return candidate;
+  }
+  return null;
+}
+function hasCodexAuth() {
+  const codexHome = process.env.CODEX_HOME?.trim() || join3(homedir2(), ".codex");
+  return existsSync(join3(codexHome, "auth.json"));
+}
+function ensureTermuxCodexInstalled() {
+  if (!isTermuxRuntime()) {
+    return resolveCodexCommand();
+  }
+  let codexCommand = resolveCodexCommand();
+  if (!codexCommand) {
+    console.log("\nCodex CLI not found. Installing Termux-compatible Codex CLI from npm...\n");
+    runOrFail("npm", ["install", "-g", "@mmmbuto/codex-cli-termux"], "Codex CLI install");
+    codexCommand = resolveCodexCommand();
+    if (!codexCommand) {
+      console.log("\nTermux npm package did not expose `codex`. Installing official CLI fallback...\n");
+      runOrFail("npm", ["install", "-g", "@openai/codex"], "Codex CLI fallback install");
+      codexCommand = resolveCodexCommand();
+    }
+    if (!codexCommand) {
+      throw new Error("Codex CLI install completed but binary is still not available in PATH");
+    }
+    console.log("\nCodex CLI installed.\n");
+  }
+  return codexCommand;
+}
+function resolvePassword(input) {
+  if (input === false) {
+    return void 0;
+  }
+  if (typeof input === "string") {
+    return input;
+  }
+  return generatePassword();
+}
+function printTermuxKeepAlive(lines) {
+  if (!isTermuxRuntime()) {
+    return;
+  }
+  lines.push("");
+  lines.push("  Android/Termux keep-alive:");
+  lines.push("  1) Keep this Termux session open (do not swipe it away).");
+  lines.push("  2) Disable battery optimization for Termux in Android settings.");
+  lines.push("  3) Optional: run `termux-wake-lock` in another shell.");
+}
+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" });
+  child.on("error", () => {
+  });
+  child.unref();
+}
+function listenWithFallback(server, startPort) {
+  return new Promise((resolve2, reject) => {
+    const attempt = (port) => {
+      const onError = (error) => {
+        server.off("listening", onListening);
+        if (error.code === "EADDRINUSE" || error.code === "EACCES") {
+          attempt(port + 1);
+          return;
+        }
+        reject(error);
+      };
+      const onListening = () => {
+        server.off("error", onError);
+        resolve2(port);
+      };
+      server.once("error", onError);
+      server.once("listening", onListening);
+      server.listen(port);
+    };
+    attempt(startPort);
+  });
+}
+async function startServer(options) {
+  const version = await readCliVersion();
+  const codexCommand = ensureTermuxCodexInstalled() ?? resolveCodexCommand();
+  if (!hasCodexAuth() && codexCommand) {
+    console.log("\nCodex is not logged in. Starting `codex login`...\n");
+    runOrFail(codexCommand, ["login"], "Codex login");
+  }
+  const requestedPort = parseInt(options.port, 10);
+  const password = resolvePassword(options.password);
+  const { app, dispose } = createServer({ password });
+  const server = createServer2(app);
+  const port = await listenWithFallback(server, requestedPort);
+  const lines = [
+    "",
+    "Codex Web Local is running!",
+    `  Version:  ${version}`,
+    "",
+    `  Local:    http://localhost:${String(port)}`
+  ];
+  if (port !== requestedPort) {
+    lines.push(`  Requested port ${String(requestedPort)} was unavailable; using ${String(port)}.`);
+  }
+  if (password) {
+    lines.push(`  Password: ${password}`);
+  }
+  printTermuxKeepAlive(lines);
+  lines.push("");
+  console.log(lines.join("\n"));
+  openBrowser(`http://localhost:${String(port)}`);
+  function shutdown() {
+    console.log("\nShutting down...");
+    server.close(() => {
+      dispose();
+      process.exit(0);
+    });
+    setTimeout(() => {
+      dispose();
+      process.exit(1);
+    }, 5e3).unref();
+  }
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+async function runLogin() {
+  const codexCommand = ensureTermuxCodexInstalled() ?? "codex";
+  console.log("\nStarting `codex login`...\n");
+  runOrFail(codexCommand, ["login"], "Codex login");
+}
+program.option("-p, --port <port>", "port to listen on", "3000").option("--password <pass>", "set a specific password").option("--no-password", "disable password protection").action(async (opts) => {
+  await startServer(opts);
+});
+program.command("login").description("Install/check Codex CLI in Termux and run `codex login`").action(runLogin);
+program.command("help").description("Show codexui command help").action(() => {
+  program.outputHelp();
+});
+program.parseAsync(process.argv).catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`
+Failed to run codexui: ${message}`);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map