codexair 0.1.0

package/README.md

@@ -0,0 +1,34 @@
+# CodexAir CLI
+
+Local CodexAir agent CLI. It connects Relay `/ws/agent` to `codex app-server`.
+
+Install:
+
+```bash
+npm install -g codexair
+```
+
+Run:
+
+```bash
+codexair
+```
+
+Required runtime dependencies:
+
+1. Bun `>=1.3.0`
+2. `codex` available on `PATH`
+3. A saved CodexAir agent identity from Desktop Setup, or Relay env vars
+
+Useful environment variables:
+
+```text
+REPO_PATH=/path/to/project
+CODEX_CMD=codex
+CODEX_MODEL=gpt-5.4
+RELAY_URL=http://127.0.0.1:8788
+RELAY_AGENT_TOKEN=...
+RELAY_AGENT_NAME=...
+CODEXAIR_AGENT_IDENTITY_PATH=~/.codexair/agent.json
+```
+

package/bin/codexair

@@ -0,0 +1,3 @@
+#!/usr/bin/env bun
+import "../dist/index.js";
+

package/dist/index.js

@@ -0,0 +1,1312 @@
+// @bun
+// src/taskSession.ts
+function enterStarting(task, goal) {
+  task.status = "starting";
+  task.goal = goal;
+  task.lastText = undefined;
+  task.error = undefined;
+  task.threadId = undefined;
+  task.turnId = undefined;
+  task.updatedAt = Date.now();
+}
+function enterRunning(task, threadId, turnId) {
+  task.status = "running";
+  task.threadId = threadId;
+  if (turnId)
+    task.turnId = turnId;
+  task.updatedAt = Date.now();
+}
+function enterWaitingApproval(task, approval) {
+  task.status = "waiting_approval";
+  task.updatedAt = Date.now();
+}
+function returnToRunning(task) {
+  task.status = "running";
+  task.updatedAt = Date.now();
+}
+function enterDone(task, lastText) {
+  task.status = "done";
+  task.lastText = lastText;
+  task.error = undefined;
+  task.updatedAt = Date.now();
+}
+function enterFailed(task, error, lastText) {
+  task.status = "failed";
+  task.error = error;
+  if (lastText)
+    task.lastText = lastText;
+  task.updatedAt = Date.now();
+}
+function enterCancelled(task) {
+  task.status = "cancelled";
+  task.updatedAt = Date.now();
+}
+function isCancellable(status) {
+  return status === "running" || status === "waiting_approval";
+}
+function isTerminal(status) {
+  return status === "done" || status === "failed" || status === "cancelled";
+}
+function isActive(status) {
+  return status === "starting" || status === "running" || status === "waiting_approval";
+}
+function canStartNew(currentTask) {
+  return currentTask === null || isTerminal(currentTask.status);
+}
+function isSteerable(status) {
+  return status === "running";
+}
+
+// src/spokenSummary.ts
+function clean(s = "", maxLen = 180) {
+  return s.replace(/\x1B\[[0-9;]*m/g, "").replace(/\s+/g, " ").trim().slice(0, maxLen) || "\u6709\u65B0\u7684\u4EFB\u52A1\u72B6\u6001\u3002";
+}
+function summarizeForLog(value, max = 800) {
+  if (value == null)
+    return "";
+  const raw = typeof value === "string" ? value : JSON.stringify(value, (_key, nestedValue) => typeof nestedValue === "bigint" ? nestedValue.toString() : nestedValue);
+  return clean(raw, max);
+}
+function summaryTaskStarted(goal) {
+  return "\u6536\u5230\u3002\u6211\u4F1A\u5F00\u59CB\u5904\u7406\uFF0C\u53EA\u5728\u5173\u952E\u8282\u70B9\u901A\u77E5\u4F60\u3002";
+}
+function summaryTaskDone(lastText) {
+  return clean(lastText || "\u4EFB\u52A1\u5B8C\u6210\u3002");
+}
+function summaryTaskFailed(error) {
+  return clean(error || "\u4EFB\u52A1\u5931\u8D25\u3002");
+}
+function summaryTaskCancelled() {
+  return "\u4EFB\u52A1\u5DF2\u53D6\u6D88\u3002";
+}
+function summaryStatusNone() {
+  return "\u5F53\u524D\u6CA1\u6709\u4EFB\u52A1\u3002";
+}
+function summaryStatusActive(goal, status) {
+  if (status === "waiting_approval") {
+    return clean(`\u4EFB\u52A1\u7B49\u5F85\u5BA1\u6279\uFF1A${goal}`);
+  }
+  return clean(`\u4EFB\u52A1\u6B63\u5728\u8FD0\u884C\uFF1A${goal}`);
+}
+function summaryStatusFinished(status, lastText, error) {
+  if (status === "cancelled")
+    return "\u4EFB\u52A1\u5DF2\u53D6\u6D88\u3002";
+  return clean(error || lastText || `\u4EFB\u52A1\u72B6\u6001\uFF1A${status}`);
+}
+function summaryApprovalReason(text) {
+  return clean(text || "Codex \u9700\u8981\u4F60\u7684\u786E\u8BA4\u624D\u80FD\u7EE7\u7EED\u3002");
+}
+function summarySteerAck() {
+  return "\u6536\u5230\uFF0C\u5DF2\u8865\u5145\u7ED9\u5F53\u524D\u4EFB\u52A1\u3002";
+}
+function summaryApprovalAccepted() {
+  return "\u5DF2\u786E\u8BA4\uFF0C\u7EE7\u7EED\u5904\u7406\u3002";
+}
+function summaryApprovalDeclined() {
+  return "\u5DF2\u62D2\u7EDD\uFF0C\u505C\u6B62\u8BE5\u64CD\u4F5C\u3002";
+}
+
+// src/codexRuntime.ts
+function buildTurnInterruptParams(task) {
+  if (!task.threadId || !task.turnId)
+    return null;
+  return {
+    threadId: task.threadId,
+    turnId: task.turnId
+  };
+}
+
+// src/agentName.ts
+import { hostname } from "os";
+var defaultAgentName = (host = hostname()) => {
+  const trimmed = host.trim();
+  return trimmed || "local-agent";
+};
+
+// src/relayClient.ts
+var createRelayAgentConfig = (env) => {
+  const relayUrl = env.RELAY_URL?.trim();
+  const agentToken = env.RELAY_AGENT_TOKEN?.trim();
+  if (!relayUrl || !agentToken)
+    return null;
+  return {
+    relayUrl,
+    agentToken,
+    agentName: env.RELAY_AGENT_NAME?.trim() || defaultAgentName(),
+    reconnectMs: Number(env.RELAY_RECONNECT_MS ?? 3000)
+  };
+};
+var buildRelayAgentWsUrl = (relayUrl) => {
+  const url = new URL(relayUrl);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  url.pathname = "/ws/agent";
+  url.search = "";
+  url.hash = "";
+  return url.toString();
+};
+
+class RelayAgentClient {
+  config;
+  deps;
+  ws = null;
+  closed = false;
+  constructor(config, deps) {
+    this.config = config;
+    this.deps = deps;
+  }
+  connect() {
+    this.closed = false;
+    const WebSocketImpl = this.deps.WebSocketImpl ?? globalThis.WebSocket;
+    const ws = new WebSocketImpl(buildRelayAgentWsUrl(this.config.relayUrl), {
+      headers: {
+        Authorization: `Bearer ${this.config.agentToken}`,
+        "X-Agent-Name": this.config.agentName
+      }
+    });
+    this.ws = ws;
+    ws.onopen = () => {
+      this.deps.onStatus?.("connected");
+    };
+    ws.onmessage = (event) => {
+      try {
+        const message = JSON.parse(String(event.data));
+        this.deps.onMessage(message);
+      } catch (error) {
+        this.deps.onStatus?.("error", error instanceof Error ? error.message : "Invalid relay message");
+      }
+    };
+    ws.onerror = (event) => {
+      this.deps.onStatus?.("error", String(event));
+    };
+    ws.onclose = () => {
+      this.ws = null;
+      this.deps.onStatus?.("disconnected");
+      if (this.closed)
+        return;
+      const setTimeoutImpl = this.deps.setTimeoutImpl ?? setTimeout;
+      setTimeoutImpl(() => this.connect(), this.config.reconnectMs);
+    };
+  }
+  send(type, payload = {}) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN)
+      return false;
+    this.ws.send(JSON.stringify({ type, payload }));
+    return true;
+  }
+  close() {
+    this.closed = true;
+    this.ws?.close();
+    this.ws = null;
+  }
+}
+
+// src/codexHistory.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { homedir } from "os";
+import { basename, join } from "path";
+var DEFAULT_LIMIT = 80;
+var DUPLICATE_HISTORY_MESSAGE_WINDOW_MS = 1e4;
+var shortText = (value, max = 80) => {
+  const normalized = value.trim().replace(/\s+/g, " ");
+  if (normalized.length <= max)
+    return normalized;
+  return normalized.slice(0, max - 1) + "\u2026";
+};
+var messageSignature = (message) => `${message.role}|${message.text.trim().replace(/\s+/g, " ")}`;
+var projectNameFromPath = (path) => basename(path.replace(/\/$/, "")) || path;
+var collectJsonlFiles = (root) => {
+  if (!existsSync(root))
+    return [];
+  const entries = [];
+  const walk = (dir) => {
+    for (const name of readdirSync(dir)) {
+      const fullPath = join(dir, name);
+      const info = statSync(fullPath);
+      if (info.isDirectory()) {
+        walk(fullPath);
+        continue;
+      }
+      if (name.endsWith(".jsonl")) {
+        entries.push(fullPath);
+      }
+    }
+  };
+  walk(root);
+  return entries;
+};
+var timestampToMs = (value) => {
+  if (typeof value !== "string")
+    return 0;
+  const ms = Date.parse(value);
+  return Number.isFinite(ms) ? ms : 0;
+};
+var readStringContent = (content) => {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return "";
+  return content.map((item) => {
+    if (!item || typeof item !== "object")
+      return "";
+    const record = item;
+    return typeof record.text === "string" ? record.text : "";
+  }).filter(Boolean).join("");
+};
+var isBootstrapContext = (text) => {
+  const normalized = text.trim();
+  return normalized.startsWith("# AGENTS.md instructions") || normalized.startsWith("<environment_context>") || normalized.includes("<INSTRUCTIONS>") || normalized.includes("You are Codex, a coding agent");
+};
+var isAutomationSession = (text) => {
+  const normalized = text.trim();
+  return normalized.startsWith("Automation:") || normalized.includes("Automation ID:") || normalized.includes("$CODEX_HOME/automations/");
+};
+var isInternalPromptSession = (text) => {
+  const normalized = text.trim();
+  return normalized.startsWith("You are the coding execution layer behind CodexAir") || normalized.startsWith("User goal:") || normalized.includes(`
+User goal:
+`);
+};
+var parseArchivedSession = (filePath) => {
+  let id = basename(filePath).replace(/\.jsonl$/, "");
+  let cwd;
+  let firstUserMessage = "";
+  let updatedAt = 0;
+  for (const line of readFileSync(filePath, "utf8").split(`
+`)) {
+    if (!line.trim())
+      continue;
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    updatedAt = Math.max(updatedAt, timestampToMs(obj.timestamp));
+    const type = obj.type;
+    const payload = obj.payload;
+    if (!payload)
+      continue;
+    if (type === "session_meta") {
+      if (typeof payload.id === "string" && payload.id.trim())
+        id = payload.id;
+      if (typeof payload.cwd === "string" && payload.cwd.trim())
+        cwd = payload.cwd;
+      updatedAt = Math.max(updatedAt, timestampToMs(payload.timestamp));
+      continue;
+    }
+    if (type === "event_msg" && payload.type === "user_message") {
+      if (typeof payload.message === "string")
+        firstUserMessage = payload.message;
+      continue;
+    }
+    if (!firstUserMessage && type === "response_item") {
+      if (payload.role === "user") {
+        const content = readStringContent(payload.content);
+        if (content && !isBootstrapContext(content)) {
+          firstUserMessage = content;
+        }
+      }
+    }
+  }
+  if (!cwd && !firstUserMessage)
+    return null;
+  const text = shortText(firstUserMessage || "Codex \u4F1A\u8BDD");
+  if (isAutomationSession(text) || isInternalPromptSession(text))
+    return null;
+  return {
+    id,
+    cwd,
+    text,
+    updatedAt: updatedAt || statSync(filePath).mtimeMs,
+    filePath
+  };
+};
+var collectSessionFiles = (options = {}) => {
+  const archiveDir = options.archiveDir ?? join(homedir(), ".codex", "archived_sessions");
+  const sessionsDir = options.sessionsDir ?? join(homedir(), ".codex", "sessions");
+  const limit = options.limit ?? DEFAULT_LIMIT;
+  return [...collectJsonlFiles(archiveDir), ...collectJsonlFiles(sessionsDir)].sort((a, b) => statSync(b).mtimeMs - statSync(a).mtimeMs).slice(0, limit);
+};
+var loadCodexHistory = (options = {}) => {
+  const sessionFiles = collectSessionFiles(options);
+  if (sessionFiles.length === 0) {
+    return { projects: [], sessions: [] };
+  }
+  const parsed = sessionFiles.map(parseArchivedSession).filter((item) => item !== null).sort((a, b) => b.updatedAt - a.updatedAt);
+  const sessions = parsed.map((session) => {
+    const projectId = session.cwd;
+    const projectName = projectId ? projectNameFromPath(projectId) : undefined;
+    return {
+      id: session.id,
+      title: session.text,
+      project_id: projectId,
+      project_name: projectName,
+      status: "history",
+      thread_id: session.id,
+      text: session.text,
+      last_summary: session.text,
+      waiting_approval: false,
+      updated_at: session.updatedAt
+    };
+  });
+  const dedupedSessions = [];
+  const seenSessionIds = new Set;
+  for (const session of sessions) {
+    if (seenSessionIds.has(session.id))
+      continue;
+    seenSessionIds.add(session.id);
+    dedupedSessions.push(session);
+  }
+  const projectMap = new Map;
+  for (const session of dedupedSessions) {
+    const projectId = session.project_id ?? "unknown";
+    const existing = projectMap.get(projectId);
+    if (!existing) {
+      projectMap.set(projectId, {
+        id: projectId,
+        name: session.project_name ?? "\u672A\u77E5\u9879\u76EE",
+        repo_path: session.project_id,
+        conversation_count: 1,
+        last_summary: session.last_summary,
+        updated_at: session.updated_at
+      });
+      continue;
+    }
+    existing.conversation_count += 1;
+    if (session.updated_at > existing.updated_at) {
+      existing.updated_at = session.updated_at;
+      existing.last_summary = session.last_summary;
+    }
+  }
+  return {
+    projects: [...projectMap.values()].sort((a, b) => b.updated_at - a.updated_at),
+    sessions: dedupedSessions
+  };
+};
+var loadCodexSessionMessages = (sessionId, options = {}) => {
+  const parsed = collectSessionFiles(options).map(parseArchivedSession).filter((item) => item !== null);
+  const session = parsed.find((item) => item.id === sessionId);
+  if (!session)
+    return [];
+  const messages = [];
+  let nextId = 0;
+  for (const line of readFileSync(session.filePath, "utf8").split(`
+`)) {
+    if (!line.trim())
+      continue;
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const timestamp = timestampToMs(obj.timestamp) || session.updatedAt;
+    const type = obj.type;
+    const payload = obj.payload;
+    if (!payload)
+      continue;
+    if (type === "event_msg" && payload.type === "user_message" && typeof payload.message === "string") {
+      const text = payload.message.trim();
+      if (text && !isBootstrapContext(text) && !isAutomationSession(text)) {
+        messages.push({
+          id: `${sessionId}-m-${nextId++}`,
+          role: "user",
+          text,
+          created_at: timestamp
+        });
+      }
+      continue;
+    }
+    if (type === "response_item" && payload.type === "message") {
+      const role = payload.role;
+      if (role !== "user" && role !== "assistant")
+        continue;
+      const text = readStringContent(payload.content).trim();
+      if (!text || isBootstrapContext(text))
+        continue;
+      messages.push({
+        id: `${sessionId}-m-${nextId++}`,
+        role,
+        text,
+        created_at: timestamp
+      });
+    }
+  }
+  const seen = new Map;
+  const deduped = [];
+  for (const message of messages.sort((a, b) => a.created_at - b.created_at)) {
+    const signature = messageSignature(message);
+    const lastSeenAt = seen.get(signature);
+    if (lastSeenAt !== undefined && Math.abs(message.created_at - lastSeenAt) < DUPLICATE_HISTORY_MESSAGE_WINDOW_MS) {
+      continue;
+    }
+    seen.set(signature, message.created_at);
+    deduped.push(message);
+  }
+  return deduped.slice(-80);
+};
+
+// src/agentIdentity.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname, join as join2 } from "path";
+var normalizeRelayUrl = (value) => {
+  const trimmed = value.trim().replace(/\/$/, "");
+  if (!trimmed)
+    return "";
+  if (trimmed.startsWith("http://") || trimmed.startsWith("https://"))
+    return trimmed;
+  if (trimmed.startsWith("ws://"))
+    return trimmed.replace(/^ws:\/\//, "http://");
+  if (trimmed.startsWith("wss://"))
+    return trimmed.replace(/^wss:\/\//, "https://");
+  return `http://${trimmed}`;
+};
+var defaultAgentIdentityPath = (home = homedir2()) => join2(home, ".codexair", "agent.json");
+var loadSavedAgentIdentity = (identityPath) => {
+  if (!existsSync2(identityPath))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync2(identityPath, "utf8"));
+    if (typeof parsed.relayUrl !== "string" || typeof parsed.agentId !== "string" || typeof parsed.agentToken !== "string" || typeof parsed.agentName !== "string" || !parsed.relayUrl.trim() || !parsed.agentId.trim() || !parsed.agentToken.trim()) {
+      return null;
+    }
+    return {
+      relayUrl: normalizeRelayUrl(parsed.relayUrl),
+      agentId: parsed.agentId,
+      agentToken: parsed.agentToken,
+      agentName: parsed.agentName || defaultAgentName()
+    };
+  } catch {
+    return null;
+  }
+};
+
+// src/builtinReply.ts
+var BUILTIN_REPLIES = new Map([
+  ["say_hello", "\u4F60\u597D\uFF0C\u6211\u5728\u3002\u9700\u8981\u6211\u505A\u4EC0\u4E48\uFF1F"],
+  ["say hello", "\u4F60\u597D\uFF0C\u6211\u5728\u3002\u9700\u8981\u6211\u505A\u4EC0\u4E48\uFF1F"],
+  ["testchat", "\u804A\u5929\u94FE\u8DEF\u6B63\u5E38\u3002\u4F60\u53EF\u4EE5\u7EE7\u7EED\u53D1\u4EFB\u52A1\u3002"],
+  ["test chat", "\u804A\u5929\u94FE\u8DEF\u6B63\u5E38\u3002\u4F60\u53EF\u4EE5\u7EE7\u7EED\u53D1\u4EFB\u52A1\u3002"],
+  ["test_chat", "\u804A\u5929\u94FE\u8DEF\u6B63\u5E38\u3002\u4F60\u53EF\u4EE5\u7EE7\u7EED\u53D1\u4EFB\u52A1\u3002"]
+]);
+var normalizeBuiltinInput = (text) => text.trim().toLowerCase().replace(/\s+/g, " ");
+var resolveBuiltinReply = (text) => {
+  return BUILTIN_REPLIES.get(normalizeBuiltinInput(text)) ?? null;
+};
+
+// src/codexAppServerConfig.ts
+var CONFIG_ERROR = "CODEX_APP_SERVER_CONFIG must be a JSON string array or newline-delimited key=value lines.";
+var configKeyFromEntry = (entry) => {
+  const index = entry.indexOf("=");
+  return index >= 0 ? entry.slice(0, index).trim() : entry.trim();
+};
+var normalizeConfigEntry = (entry) => {
+  const trimmed = entry.trim();
+  const index = trimmed.indexOf("=");
+  if (index <= 0 || index === trimmed.length - 1) {
+    throw new Error(`${CONFIG_ERROR} Invalid entry: ${trimmed || "(empty)"}`);
+  }
+  const key = trimmed.slice(0, index).trim();
+  const value = trimmed.slice(index + 1).trim();
+  if (!key || !value) {
+    throw new Error(`${CONFIG_ERROR} Invalid entry: ${trimmed || "(empty)"}`);
+  }
+  return `${key}=${value}`;
+};
+var parseCodexAppServerConfig = (raw) => {
+  if (!raw?.trim())
+    return [];
+  const trimmed = raw.trim();
+  let entries;
+  if (trimmed.startsWith("[")) {
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      throw new Error(CONFIG_ERROR);
+    }
+    if (!Array.isArray(parsed) || parsed.some((entry) => typeof entry !== "string")) {
+      throw new Error(CONFIG_ERROR);
+    }
+    entries = parsed;
+  } else {
+    entries = trimmed.split(/\r?\n/);
+  }
+  return entries.map((entry) => entry.trim()).filter((entry) => entry && !entry.startsWith("#")).map(normalizeConfigEntry);
+};
+var cloneEnv = (env) => Object.fromEntries(Object.entries(env).filter((entry) => typeof entry[1] === "string"));
+var buildCodexAppServerLaunch = (codexCmd, env) => {
+  const configEntries = parseCodexAppServerConfig(env.CODEX_APP_SERVER_CONFIG);
+  const cmd = [codexCmd, "app-server"];
+  for (const entry of configEntries) {
+    cmd.push("-c", entry);
+  }
+  cmd.push("--listen", "stdio://");
+  return {
+    cmd,
+    env: cloneEnv(env),
+    configEntries,
+    configKeys: configEntries.map(configKeyFromEntry)
+  };
+};
+
+// index.ts
+var REPO_PATH = Bun.env.REPO_PATH ?? process.cwd();
+var CODEX_CMD = Bun.env.CODEX_CMD ?? "codex";
+var CODEX_MODEL = Bun.env.CODEX_MODEL ?? "gpt-5.4";
+var CODEX_LOG_MAX_CHARS = Number(Bun.env.CODEX_LOG_MAX_CHARS ?? 800);
+var AGENT_IDENTITY_PATH = Bun.env.CODEXAIR_AGENT_IDENTITY_PATH?.trim() || defaultAgentIdentityPath();
+var relayConfigFromEnv = createRelayAgentConfig(Bun.env);
+var codexLaunch = buildCodexAppServerLaunch(CODEX_CMD, Bun.env);
+var TELEMETRY_MAX = 1000;
+var telemetryEvents = [];
+var trace = (type, data = {}) => {
+  const ev = { ts: Date.now(), type, task_id: task?.id, data };
+  telemetryEvents.push(ev);
+  if (telemetryEvents.length > TELEMETRY_MAX)
+    telemetryEvents.shift();
+};
+var rpcLatencies = [];
+var MAX_LATENCIES = 500;
+var recordLatency = (method, ms, ok) => {
+  rpcLatencies.push({ method, ms, ok });
+  if (rpcLatencies.length > MAX_LATENCIES)
+    rpcLatencies.shift();
+};
+var task = null;
+var pendingApproval = null;
+var lastProgressAt = 0;
+var activeRequestId;
+var taskRequestIds = new Map;
+var sessionHistory = [];
+var relayClient = null;
+var resolveRelayConfig = async () => {
+  if (relayConfigFromEnv)
+    return relayConfigFromEnv;
+  const savedIdentity = loadSavedAgentIdentity(AGENT_IDENTITY_PATH);
+  if (savedIdentity) {
+    return {
+      relayUrl: savedIdentity.relayUrl,
+      agentToken: savedIdentity.agentToken,
+      agentName: savedIdentity.agentName,
+      reconnectMs: Number(Bun.env.RELAY_RECONNECT_MS ?? 3000)
+    };
+  }
+  const relayUrl = Bun.env.RELAY_URL?.trim();
+  if (!relayUrl)
+    return null;
+  console.warn("No agent identity found.");
+  console.warn("Open Desktop Setup, sign in as owner, and register this computer as an agent.");
+  return null;
+};
+var emit = (type, payload = {}) => {
+  const taskId = typeof payload.task_id === "string" ? payload.task_id : undefined;
+  const requestId = activeRequestId ?? (taskId ? taskRequestIds.get(taskId) : undefined);
+  if (requestId && !payload.request_id) {
+    payload.request_id = requestId;
+  }
+  relayClient?.send(type, payload);
+  trace("ws_out:" + type, payload);
+};
+var speak = (text, priority = "normal", extra = {}) => emit("speak", { text: clean(text), priority, ...extra });
+var upsertSessionHistory = (snapshot) => {
+  const index = sessionHistory.findIndex((item) => item.id == snapshot.id);
+  if (index >= 0) {
+    sessionHistory[index] = snapshot;
+  } else {
+    sessionHistory.unshift(snapshot);
+  }
+  if (sessionHistory.length > 12)
+    sessionHistory.length = 12;
+};
+var progress = (text) => {
+  const now = Date.now();
+  if (now - lastProgressAt < 30000)
+    return;
+  lastProgressAt = now;
+  emit("progress", { task_id: task?.id, thread_id: task?.threadId, text: clean(text) });
+};
+var promptFor = (goal) => `
+You are the coding execution layer behind CodexAir, a remote-first async coding agent.
+
+User goal:
+${goal}
+
+Rules:
+- Work inside the current repository.
+- Do not push, publish, deploy, or perform destructive operations.
+- Ask for approval before risky actions.
+- Prefer small, safe changes.
+- Run relevant tests when possible.
+- Final answer must be concise and suitable for a mobile chat update.
+
+End with:
+1. What changed.
+2. Whether tests passed.
+3. Whether user approval is needed.
+`.trim();
+
+class Codex {
+  proc = Bun.spawn({
+    cmd: codexLaunch.cmd,
+    stdin: "pipe",
+    stdout: "pipe",
+    stderr: "pipe",
+    env: codexLaunch.env,
+    onExit(proc, exitCode, signalCode, error) {
+      const reason = signalCode ? `signal ${signalCode}` : `exit code ${exitCode}`;
+      console.error(`[codex] process exited: ${reason}${error ? ` (${error.message})` : ""}`);
+    }
+  });
+  nextId = 1;
+  ready = false;
+  waiters = new Map;
+  constructor() {
+    this.readLines(this.proc.stdout, (line) => this.onMessage(JSON.parse(line)));
+    this.readLines(this.proc.stderr, (line) => console.error("[codex]", line));
+  }
+  async init() {
+    if (this.ready)
+      return;
+    await this.call("initialize", {
+      clientInfo: { name: "codexair", title: "CodexAir", version: "0.1.0" },
+      capabilities: { experimentalApi: true }
+    });
+    this.notify("initialized");
+    this.ready = true;
+  }
+  async start(goal) {
+    await this.init();
+    const thread = await this.call("thread/start", { model: CODEX_MODEL });
+    const threadId = thread.thread?.id ?? thread.threadId;
+    await this.call("turn/start", {
+      threadId,
+      cwd: REPO_PATH,
+      approvalPolicy: "on-request",
+      sandbox: "workspaceWrite",
+      input: [{ type: "text", text: promptFor(goal) }]
+    });
+    return threadId;
+  }
+  async resumeThread(threadId) {
+    await this.init();
+    const resumed = await this.call("thread/resume", { threadId });
+    return resumed.thread?.id ?? threadId;
+  }
+  async continueThread(threadId, text) {
+    await this.call("turn/start", {
+      threadId,
+      input: [{ type: "text", text }]
+    });
+  }
+  async steer(text) {
+    if (!task?.threadId)
+      throw new Error("No active thread");
+    await this.call("turn/steer", {
+      threadId: task.threadId,
+      input: [{ type: "text", text }]
+    });
+  }
+  async interrupt() {
+    if (!task)
+      return;
+    const params = buildTurnInterruptParams(task);
+    if (!params)
+      return;
+    await this.call("turn/interrupt", params);
+  }
+  answer(id, result) {
+    this.write({ id, result });
+  }
+  call(method, params = {}) {
+    const id = this.nextId++;
+    const start = Date.now();
+    this.write({ id, method, params });
+    return new Promise((ok, fail) => {
+      this.waiters.set(id, {
+        ok: (v) => {
+          recordLatency(method, Date.now() - start, true);
+          trace("rpc_latency", { method, ms: Date.now() - start, ok: true });
+          ok(v);
+        },
+        fail: (e) => {
+          recordLatency(method, Date.now() - start, false);
+          trace("rpc_latency", { method, ms: Date.now() - start, ok: false });
+          fail(e);
+        }
+      });
+      setTimeout(() => {
+        if (!this.waiters.delete(id))
+          return;
+        recordLatency(method, 120000, false);
+        fail(new Error(`Codex timeout: ${method}`));
+      }, 120000);
+    });
+  }
+  notify(method, params = {}) {
+    this.write({ method, params });
+  }
+  write(msg) {
+    this.proc.stdin.write(`${JSON.stringify(msg)}
+`);
+  }
+  async readLines(stream, onLine) {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder;
+    let buf = "";
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done)
+        break;
+      buf += decoder.decode(value, { stream: true });
+      for (;; ) {
+        const i = buf.indexOf(`
+`);
+        if (i < 0)
+          break;
+        const line = buf.slice(0, i).trim();
+        buf = buf.slice(i + 1);
+        if (line)
+          onLine(line);
+      }
+    }
+  }
+  onMessage(msg) {
+    this.logMessage(msg);
+    if (msg.id != null && !msg.method)
+      return this.onResponse(msg);
+    if (msg.id != null && msg.method)
+      return this.onServerRequest(msg);
+    if (msg.method)
+      return this.onEvent(msg.method, msg.params ?? {});
+  }
+  logMessage(msg) {
+    if (msg.id != null && !msg.method) {
+      if (msg.error) {
+        console.log("[codex:response:error]", {
+          id: msg.id,
+          code: msg.error.code,
+          message: msg.error.message,
+          data: summarizeForLog(msg.error.data)
+        });
+        return;
+      }
+      console.log("[codex:response]", {
+        id: msg.id,
+        result: summarizeForLog(msg.result)
+      });
+      return;
+    }
+    if (msg.id != null && msg.method) {
+      console.log("[codex:request]", {
+        id: msg.id,
+        method: msg.method,
+        params: summarizeForLog(msg.params)
+      });
+      return;
+    }
+    if (!msg.method)
+      return;
+    const delta = msg.params?.delta ?? msg.params?.text;
+    if (msg.method === "item/agentMessage/delta" && typeof delta === "string") {
+      console.log("[codex:text]", clean(delta, CODEX_LOG_MAX_CHARS));
+      return;
+    }
+    console.log("[codex:event]", {
+      method: msg.method,
+      params: summarizeForLog(msg.params)
+    });
+  }
+  onResponse(msg) {
+    const waiter = this.waiters.get(msg.id);
+    if (!waiter)
+      return;
+    this.waiters.delete(msg.id);
+    msg.error ? waiter.fail(new Error(msg.error.message)) : waiter.ok(msg.result);
+  }
+  onServerRequest(msg) {
+    pendingApproval = {
+      id: msg.id,
+      method: msg.method,
+      params: msg.params ?? {}
+    };
+    if (task) {
+      enterWaitingApproval(task, pendingApproval);
+    }
+    trace("approval_requested", { method: msg.method });
+    emit("needs_approval", {
+      task_id: task?.id,
+      thread_id: task?.threadId,
+      request_id: msg.id,
+      text: summaryApprovalReason(msg.params?.reason || msg.params?.message),
+      options: ["\u7EE7\u7EED", "\u53D6\u6D88", "\u62D2\u7EDD"]
+    });
+  }
+  onEvent(method, p) {
+    if (!task)
+      return;
+    if (isTerminal(task.status))
+      return;
+    task.updatedAt = Date.now();
+    if (method === "turn/started") {
+      enterRunning(task, task.threadId, p.turn?.id);
+      progress("Codex \u5DF2\u5F00\u59CB\u5904\u7406\u3002");
+      return;
+    }
+    if (method === "item/started") {
+      const kind = p.item?.type ?? p.type ?? "step";
+      if (["commandExecution", "command", "shell"].includes(kind))
+        progress("\u6B63\u5728\u6267\u884C\u547D\u4EE4\u3002");
+      else
+        progress("\u6B63\u5728\u7EE7\u7EED\u5904\u7406\u3002");
+      return;
+    }
+    if (method === "item/agentMessage/delta") {
+      const d = p.delta ?? p.text ?? "";
+      if (typeof d === "string") {
+        task.lastText = (task.lastText ?? "") + d;
+      }
+      return;
+    }
+    if (method === "item/completed") {
+      const item = p.item ?? {};
+      const text = item.text ?? item.summary ?? item.message ?? item.content;
+      if (typeof text === "string" && text.trim())
+        task.lastText = text;
+      return;
+    }
+    if (method === "turn/completed") {
+      const status = p.turn?.status ?? p.status ?? "completed";
+      if (task.status === "cancelled")
+        return;
+      if (["completed", "success"].includes(status)) {
+        enterDone(task, task.lastText);
+        trace("task_done", { lastText: clean(task.lastText || "\u4EFB\u52A1\u5B8C\u6210\u3002") });
+        emit("task_done", {
+          task_id: task.id,
+          thread_id: task.threadId,
+          text: summaryTaskDone(task.lastText)
+        });
+      } else {
+        const errorMsg = task.lastText || `\u4EFB\u52A1\u7ED3\u675F\uFF0C\u72B6\u6001\u4E3A ${status}\u3002`;
+        enterFailed(task, errorMsg, task.lastText);
+        trace("task_failed", { error: task.error });
+        emit("task_failed", {
+          task_id: task.id,
+          thread_id: task.threadId,
+          text: summaryTaskFailed(task.error)
+        });
+      }
+      return;
+    }
+    if (method === "error") {
+      const text = p.error?.message ?? p.message ?? "\u4EFB\u52A1\u5931\u8D25\u3002";
+      enterFailed(task, text);
+      trace("codex_error", { message: text });
+      emit("task_failed", {
+        task_id: task.id,
+        thread_id: task.threadId,
+        text: summaryTaskFailed(text)
+      });
+    }
+  }
+}
+var codex = new Codex;
+function clearPendingApprovalIfTaskInactive() {
+  if (task && !isActive(task.status) && pendingApproval) {
+    pendingApproval = null;
+  }
+}
+async function startTask(text) {
+  if (task && !canStartNew(task)) {
+    speak(clean("\u5F53\u524D\u4EFB\u52A1\u8FD8\u5728\u8FDB\u884C\u4E2D\uFF0C\u8BF7\u5148\u5B8C\u6210\u6216\u53D6\u6D88\u540E\u518D\u5F00\u59CB\u65B0\u7684\u4EFB\u52A1\u3002"), "normal", {
+      task_id: task.id
+    });
+    return;
+  }
+  task = {
+    id: crypto.randomUUID(),
+    goal: "",
+    status: "starting",
+    updatedAt: Date.now()
+  };
+  if (activeRequestId)
+    taskRequestIds.set(task.id, activeRequestId);
+  enterStarting(task, text);
+  trace("task_started", { goal: text });
+  emit("task_started", { task_id: task.id, text: summaryTaskStarted(text) });
+  speak(summaryTaskStarted(text), "normal", {
+    task_id: task.id
+  });
+  try {
+    task.threadId = await codex.start(text);
+    enterRunning(task, task.threadId);
+    upsertSessionHistory(buildSessionSnapshotPayload());
+  } catch (e) {
+    enterFailed(task, e instanceof Error ? e.message : "\u542F\u52A8 Codex \u5931\u8D25\u3002");
+    trace("codex_start_failed", { error: task.error });
+    speak(summaryTaskFailed(task.error), "high", { task_id: task.id });
+    upsertSessionHistory(buildSessionSnapshotPayload());
+  }
+}
+async function continueHistoricalThread(text, threadId, taskId) {
+  if (task && !canStartNew(task)) {
+    speak(clean("\u5F53\u524D\u4EFB\u52A1\u8FD8\u5728\u8FDB\u884C\u4E2D\uFF0C\u8BF7\u5148\u5B8C\u6210\u6216\u53D6\u6D88\u540E\u518D\u5F00\u59CB\u65B0\u7684\u4EFB\u52A1\u3002"), "normal", {
+      task_id: task.id
+    });
+    return;
+  }
+  task = {
+    id: crypto.randomUUID(),
+    goal: text,
+    status: "starting",
+    updatedAt: Date.now(),
+    threadId
+  };
+  if (activeRequestId)
+    taskRequestIds.set(task.id, activeRequestId);
+  try {
+    const resumedThreadId = await codex.resumeThread(threadId);
+    task.threadId = resumedThreadId;
+    trace("task_started", { goal: text, thread_id: resumedThreadId, resumed_task_id: taskId });
+    emit("task_started", {
+      task_id: task.id,
+      thread_id: resumedThreadId,
+      text: summaryTaskStarted(text)
+    });
+    speak(summaryTaskStarted(text), "normal", {
+      task_id: task.id,
+      thread_id: resumedThreadId
+    });
+    await codex.continueThread(resumedThreadId, text);
+    enterRunning(task, resumedThreadId);
+    upsertSessionHistory(buildSessionSnapshotPayload());
+  } catch (e) {
+    enterFailed(task, e instanceof Error ? e.message : "\u7EED\u5199 Codex \u4F1A\u8BDD\u5931\u8D25\u3002");
+    trace("codex_resume_failed", { error: task.error, thread_id: task.threadId });
+    speak(summaryTaskFailed(task.error), "high", {
+      task_id: task.id,
+      thread_id: task.threadId
+    });
+    upsertSessionHistory(buildSessionSnapshotPayload());
+  }
+}
+async function answerApproval(text) {
+  if (!pendingApproval)
+    return false;
+  const req = pendingApproval;
+  pendingApproval = null;
+  const negative = /\u53D6\u6D88|\u62D2\u7EDD|\u4E0D\u8981|decline|cancel|no/i.test(text);
+  const positive = !negative;
+  let result;
+  if (req.method.includes("permissions")) {
+    result = positive ? { scope: "session", permissions: req.params.permissions ?? {} } : { scope: "turn", permissions: {} };
+  } else if (req.method.includes("elicitation")) {
+    result = positive ? { action: "accept", content: text } : { action: "decline", content: null };
+  } else if (req.method.includes("requestUserInput")) {
+    result = { input: text };
+  } else {
+    result = { decision: positive ? "accept" : "decline" };
+  }
+  codex.answer(req.id, result);
+  if (task) {
+    returnToRunning(task);
+  }
+  clearPendingApprovalIfTaskInactive();
+  speak(positive ? summaryApprovalAccepted() : summaryApprovalDeclined(), "normal", {
+    task_id: task?.id
+  });
+  return true;
+}
+async function onUserInput(text, target) {
+  trace("user_input", { text, task_id: target?.taskId, thread_id: target?.threadId });
+  if (await answerApproval(text))
+    return;
+  if (task && !isActive(task.status)) {
+    clearPendingApprovalIfTaskInactive();
+  }
+  const matchesCurrentTask = Boolean(target?.threadId && task?.threadId && target.threadId === task.threadId) || !target?.taskId || target.taskId === "current" || target.taskId === task?.id;
+  const matchesCurrentThread = !target?.threadId || target.threadId === task?.threadId;
+  const canContinueCurrentTask = task ? isActive(task.status) : false;
+  const wantsHistoricalThread = Boolean(target?.threadId && !canContinueCurrentTask);
+  const targetsCurrentThread = Boolean(target?.threadId && task?.threadId && target.threadId === task.threadId);
+  if (target?.threadId && task?.threadId && canContinueCurrentTask && target.threadId !== task.threadId) {
+    speak(clean("\u5F53\u524D\u8FD8\u4E0D\u80FD\u76F4\u63A5\u7EED\u5199\u5386\u53F2\u5BF9\u8BDD\uFF0C\u8BF7\u5148\u6253\u5F00\u5BF9\u5E94\u4EFB\u52A1\u540E\u518D\u53D1\u9001\u3002"), "normal", {
+      task_id: target.taskId,
+      thread_id: target.threadId
+    });
+    return;
+  }
+  if (wantsHistoricalThread && target?.threadId) {
+    await continueHistoricalThread(text, target.threadId, target.taskId);
+    return;
+  }
+  if (task && isSteerable(task.status) && matchesCurrentTask && matchesCurrentThread) {
+    task.lastText = null;
+    await codex.steer(text);
+    speak(summarySteerAck(), "normal", { task_id: task.id, thread_id: task.threadId });
+    return;
+  }
+  if (target?.taskId && target.taskId !== "current" && task?.id && canContinueCurrentTask && target.taskId !== task.id && !targetsCurrentThread) {
+    speak(clean("\u5F53\u524D\u9009\u4E2D\u7684\u4E0D\u662F\u6B63\u5728\u8FD0\u884C\u7684\u4EFB\u52A1\uFF0C\u8BF7\u5148\u5207\u56DE\u5F53\u524D\u4EFB\u52A1\u6216\u65B0\u5EFA\u5BF9\u8BDD\u3002"), "normal", {
+      task_id: target.taskId,
+      thread_id: target.threadId
+    });
+    return;
+  }
+  const builtinReply = resolveBuiltinReply(text);
+  if (builtinReply) {
+    if (task && !canStartNew(task)) {
+      speak(clean("\u5F53\u524D\u4EFB\u52A1\u8FD8\u5728\u8FDB\u884C\u4E2D\uFF0C\u8BF7\u5148\u5B8C\u6210\u6216\u53D6\u6D88\u540E\u518D\u5F00\u59CB\u65B0\u7684\u4EFB\u52A1\u3002"), "normal", {
+        task_id: task.id
+      });
+      return;
+    }
+    task = {
+      id: crypto.randomUUID(),
+      goal: text,
+      status: "starting",
+      updatedAt: Date.now(),
+      lastText: builtinReply
+    };
+    if (activeRequestId)
+      taskRequestIds.set(task.id, activeRequestId);
+    enterDone(task, task.lastText);
+    trace("task_done", { lastText: task.lastText });
+    const reply = summaryTaskDone(task.lastText);
+    emit("task_done", { task_id: task.id, text: reply });
+    speak(reply, "normal", { task_id: task.id });
+    upsertSessionHistory(buildSessionSnapshotPayload());
+    return;
+  }
+  await startTask(text);
+}
+async function onControl(action) {
+  if (!task)
+    return speak(summaryStatusNone());
+  if (action === "cancel") {
+    if (task.status === "cancelled") {
+      return speak(summaryTaskCancelled(), "normal", { task_id: task.id, thread_id: task.threadId });
+    }
+    if (!isCancellable(task.status)) {
+      return speak(clean("\u5F53\u524D\u4EFB\u52A1\u65E0\u6CD5\u53D6\u6D88\u3002"), "normal", { task_id: task.id, thread_id: task.threadId });
+    }
+    enterCancelled(task);
+    pendingApproval = null;
+    trace("task_cancelled");
+    emit("task_cancelled", {
+      task_id: task.id,
+      thread_id: task.threadId,
+      text: summaryTaskCancelled()
+    });
+    await codex.interrupt();
+    speak(summaryTaskCancelled(), "high", { task_id: task.id, thread_id: task.threadId });
+    return;
+  }
+  speak(clean(`\u6682\u4E0D\u652F\u6301 ${action}\u3002\u76EE\u524D\u53EA\u652F\u6301\u53D6\u6D88\u3002`), "normal", {
+    task_id: task.id,
+    thread_id: task.threadId
+  });
+}
+function buildStatusPayload() {
+  if (!task) {
+    return { text: summaryStatusNone() };
+  }
+  let text;
+  if (task.status === "starting") {
+    text = clean(`\u4EFB\u52A1\u6B63\u5728\u542F\u52A8\uFF1A${task.goal}`);
+  } else if (task.status === "running" || task.status === "waiting_approval") {
+    text = summaryStatusActive(task.goal, task.status);
+  } else if (task.status === "cancelled") {
+    text = summaryTaskCancelled();
+  } else {
+    text = summaryStatusFinished(task.status, task.lastText, task.error);
+  }
+  return {
+    task_id: task.id,
+    status: task.status,
+    thread_id: task.threadId,
+    turn_id: task.turnId,
+    text
+  };
+}
+function buildSessionSnapshotPayload() {
+  const defaultProjectName = REPO_PATH.split("/").filter(Boolean).at(-1) || "current";
+  const history = loadCodexHistory();
+  const projectMap = new Map(history.projects.map((item) => [item.id, { ...item }]));
+  const sessions = history.sessions.map((item) => ({ ...item }));
+  const seenSessionIds = new Set(sessions.map((item) => item.id));
+  if (!task) {
+    for (const session of sessionHistory) {
+      const sessionId = session.threadId || session.id;
+      if (seenSessionIds.has(sessionId))
+        continue;
+      seenSessionIds.add(sessionId);
+      sessions.unshift({
+        id: sessionId,
+        title: session.title,
+        project_id: REPO_PATH,
+        project_name: defaultProjectName,
+        status: session.status,
+        task_id: session.taskId,
+        thread_id: session.threadId,
+        turn_id: session.turnId,
+        text: session.text,
+        last_summary: session.lastSummary ?? session.text,
+        waiting_approval: session.waitingApproval,
+        updated_at: session.updatedAt
+      });
+    }
+    if (!projectMap.has(REPO_PATH)) {
+      projectMap.set(REPO_PATH, {
+        id: REPO_PATH,
+        name: defaultProjectName,
+        repo_path: REPO_PATH,
+        conversation_count: sessions.filter((item) => item.project_id === REPO_PATH).length,
+        last_summary: sessions.find((item) => item.project_id === REPO_PATH)?.last_summary,
+        updated_at: sessions.find((item) => item.project_id === REPO_PATH)?.updated_at ?? Date.now()
+      });
+    }
+    return {
+      status: "idle",
+      text: summaryStatusNone(),
+      waiting_approval: false,
+      projects: [...projectMap.values()].sort((a, b) => b.updated_at - a.updated_at),
+      sessions: sessions.sort((a, b) => b.updated_at - a.updated_at)
+    };
+  }
+  let text;
+  if (task.status === "starting") {
+    text = clean(`\u4EFB\u52A1\u6B63\u5728\u542F\u52A8\uFF1A${task.goal}`);
+  } else if (task.status === "running" || task.status === "waiting_approval") {
+    text = summaryStatusActive(task.goal, task.status);
+  } else if (task.status === "cancelled") {
+    text = summaryTaskCancelled();
+  } else {
+    text = summaryStatusFinished(task.status, task.lastText, task.error);
+  }
+  const snapshot = {
+    id: task.id,
+    title: task.goal,
+    project_id: REPO_PATH,
+    project_name: defaultProjectName,
+    status: task.status,
+    task_id: task.id,
+    thread_id: task.threadId,
+    turn_id: task.turnId,
+    goal: task.goal,
+    text,
+    last_summary: task.lastText,
+    waiting_approval: task.status === "waiting_approval",
+    updated_at: task.updatedAt
+  };
+  upsertSessionHistory({
+    id: snapshot.id,
+    title: snapshot.title,
+    status: snapshot.status,
+    taskId: snapshot.task_id,
+    threadId: snapshot.thread_id,
+    turnId: snapshot.turn_id,
+    text: snapshot.text,
+    lastSummary: snapshot.last_summary ?? undefined,
+    waitingApproval: snapshot.waiting_approval,
+    updatedAt: snapshot.updated_at
+  });
+  const mergedSessions = [
+    snapshot,
+    ...sessions.filter((item) => item.id !== snapshot.id && item.thread_id !== snapshot.thread_id)
+  ].sort((a, b) => b.updated_at - a.updated_at);
+  projectMap.set(REPO_PATH, {
+    id: REPO_PATH,
+    name: defaultProjectName,
+    repo_path: REPO_PATH,
+    conversation_count: mergedSessions.filter((item) => item.project_id === REPO_PATH).length,
+    last_summary: snapshot.last_summary ?? snapshot.text,
+    updated_at: snapshot.updated_at
+  });
+  return {
+    ...snapshot,
+    projects: [...projectMap.values()].sort((a, b) => b.updated_at - a.updated_at),
+    sessions: mergedSessions
+  };
+}
+async function onRelayMessage(message) {
+  if (message.type === "ping")
+    return;
+  const requestId = message.payload && typeof message.payload === "object" && "request_id" in message.payload && typeof message.payload.request_id === "string" ? message.payload.request_id : undefined;
+  activeRequestId = requestId;
+  if (message.type === "status_query") {
+    relayClient?.send("status", {
+      ...buildStatusPayload(),
+      ...activeRequestId ? { request_id: activeRequestId } : {}
+    });
+    activeRequestId = undefined;
+    return;
+  }
+  if (message.type === "session_query") {
+    const threadId = message.payload && "thread_id" in message.payload && typeof message.payload.thread_id === "string" ? message.payload.thread_id : undefined;
+    if (threadId) {
+      relayClient?.send("session_messages", {
+        thread_id: threadId,
+        messages: loadCodexSessionMessages(threadId),
+        ...activeRequestId ? { request_id: activeRequestId } : {}
+      });
+      activeRequestId = undefined;
+      return;
+    }
+    relayClient?.send("session_snapshot", {
+      ...buildSessionSnapshotPayload(),
+      ...activeRequestId ? { request_id: activeRequestId } : {}
+    });
+    activeRequestId = undefined;
+    return;
+  }
+  if (message.type === "control") {
+    await onControl(message.payload.action);
+    activeRequestId = undefined;
+    return;
+  }
+  if (message.type === "user_input") {
+    await onUserInput(message.payload.text, {
+      taskId: message.payload.task_id,
+      threadId: message.payload.thread_id
+    });
+    activeRequestId = undefined;
+    return;
+  }
+  activeRequestId = undefined;
+}
+console.log(`Repo: ${REPO_PATH}`);
+console.log(`Agent identity: ${AGENT_IDENTITY_PATH}`);
+console.log("CodexAir CLI runs in Relay-only mode; no local HTTP/WebSocket debug server is exposed.");
+if (codexLaunch.configKeys.length > 0) {
+  console.log(`[codex] app-server config keys: ${codexLaunch.configKeys.join(", ")}`);
+}
+var boot = async () => {
+  const relayConfig = await resolveRelayConfig();
+  if (relayConfig) {
+    relayClient = new RelayAgentClient(relayConfig, {
+      onMessage: onRelayMessage,
+      onStatus(status, detail) {
+        if (status === "connected") {
+          console.log(`[relay] connected: ${relayConfig.relayUrl}`);
+          return;
+        }
+        if (status === "disconnected") {
+          console.warn("[relay] disconnected, will retry");
+          return;
+        }
+        console.warn(`[relay] error: ${detail ?? "unknown"}`);
+      }
+    });
+    relayClient.connect();
+    console.log(`[relay] enabled: ${relayConfig.relayUrl}`);
+  }
+  await codex.init();
+  console.log("[codex] initialized");
+};
+boot().catch((e) => {
+  console.error("[boot] failed:", e instanceof Error ? e.message : String(e));
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "codexair",
+  "version": "0.1.0",
+  "description": "CodexAir local agent CLI for connecting Relay to codex app-server.",
+  "type": "module",
+  "bin": {
+    "codexair": "bin/codexair"
+  },
+  "files": [
+    "bin/",
+    "dist/",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "bun build --target=bun --outfile dist/index.js index.ts",
+    "prepack": "bun run build",
+    "start": "bun run index.ts"
+  },
+  "keywords": [
+    "codexair",
+    "codex",
+    "agent",
+    "relay"
+  ],
+  "license": "UNLICENSED",
+  "engines": {
+    "bun": ">=1.3.0"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@types/bun": "latest"
+  }
+}