@covro/covro 0.0.0-stage → 0.1.0-dev.1

package/dist/codex/adapter.js

@@ -0,0 +1,1195 @@
+import { CODEX_COMPATIBILITY } from "./compatibility.js";
+import { spawn, execFile } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { promisify } from "node:util";
+import { ThreadTitles } from "./thread-titles.js";
+import { TurnTokenUsage } from "./turn-token-usage.js";
+import { AppError } from "../shared/errors.js";
+import { threadNameError } from "../shared/thread-name.js";
+import { permissionModeUnavailable, permissionReviewerUnavailable } from "../shared/permissions.js";
+import {
+  permissionCapabilities
+} from "./permissions.js";
+import { mapAutoReview } from "./auto-review.js";
+import {
+  normalizeElicitationRequest,
+  validateElicitationResolution,
+  validatePermissionResolution
+} from "../shared/elicitation.js";
+import {
+  mapItem,
+  mapThread,
+  mapTurn,
+  permissionSettings,
+  serviceTierSettings,
+  threadSettings,
+  threadStatus,
+  turnSettings,
+  taskInput
+} from "./mapping.js";
+import {
+  asCodexError,
+  CodexError,
+  isRecord,
+  RpcTransport
+} from "./transport.js";
+import { CodexError as CodexError2 } from "./transport.js";
+const VERIFIED_CODEX_VERSION = CODEX_COMPATIBILITY.recommended;
+const CAPABILITIES = [
+  "thread/name/set",
+  "thread/start",
+  "thread/fork",
+  "thread/read",
+  "thread/list",
+  "thread/resume",
+  "thread/archive",
+  "thread/loaded/list",
+  "thread/unarchive",
+  "thread/compact/start",
+  "thread/turns/list",
+  "thread/items/list",
+  "turn/start",
+  "review/start",
+  "turn/steer",
+  "turn/interrupt",
+  "model/list",
+  "config/read",
+  "config/batchWrite",
+  "configRequirements/read",
+  "experimentalFeature/list",
+  "account/read"
+];
+function permissionPathLabel(path) {
+  if (path.type === "path") return path.path;
+  if (path.type === "glob_pattern") return `\u5339\u914D\uFF1A${path.pattern}`;
+  const special = path.value;
+  const subpath = "subpath" in special && special.subpath !== null ? `\uFF08\u5B50\u8DEF\u5F84\uFF1A${special.subpath}\uFF09` : "";
+  switch (special.kind) {
+    case "root":
+      return "\u6574\u4E2A\u6587\u4EF6\u7CFB\u7EDF\uFF08/\uFF09";
+    case "minimal":
+      return "\u7CFB\u7EDF\u57FA\u7840\u8FD0\u884C\u76EE\u5F55";
+    case "project_roots":
+      return `\u9879\u76EE\u6839\u76EE\u5F55${subpath}`;
+    case "tmpdir":
+      return "\u7CFB\u7EDF\u4E34\u65F6\u76EE\u5F55\uFF08TMPDIR\uFF09";
+    case "slash_tmp":
+      return "/tmp";
+    case "unknown":
+      return `\u7279\u6B8A\u8DEF\u5F84\uFF1A${special.path}${subpath}`;
+  }
+}
+class CodexAdapter {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  epoch = randomUUID();
+  child;
+  rpc;
+  stopped = true;
+  starting;
+  recovering;
+  restartTimer;
+  restartAttempt = 0;
+  titles;
+  tokenUsage = new TurnTokenUsage();
+  // Ordering only. Persisted archive state belongs exclusively to Codex.
+  archiveSequence = 0;
+  archives = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  actions = /* @__PURE__ */ new Map();
+  actionIds = /* @__PURE__ */ new Map();
+  stderrTail = Buffer.alloc(0);
+  disabled = /* @__PURE__ */ new Set();
+  permissionState = /* @__PURE__ */ new Map();
+  state = {
+    ready: false,
+    connection: "starting",
+    codexVersion: null,
+    verifiedVersion: VERIFIED_CODEX_VERSION,
+    compatibility: "unavailable",
+    codexEpoch: this.epoch,
+    authenticated: null,
+    models: [],
+    capabilities: []
+  };
+  get pid() {
+    return this.child?.pid;
+  }
+  get ready() {
+    return this.state.ready;
+  }
+  diagnostics() {
+    return structuredClone(this.state);
+  }
+  onEvent(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  emit(event) {
+    for (const listener of this.listeners) listener(event);
+  }
+  publishRuntime() {
+    this.emit({ type: "runtime", diagnostics: this.diagnostics() });
+  }
+  async start() {
+    if (this.starting) return this.starting;
+    this.stopped = false;
+    this.starting = this.startProcess();
+    try {
+      await this.starting;
+    } finally {
+      this.starting = void 0;
+    }
+  }
+  async startProcess() {
+    if (this.child) throw new CodexError("CODEX_BUSY", "Codex app-server is already started");
+    this.epoch = randomUUID();
+    this.disabled.clear();
+    this.archives.clear();
+    this.state = {
+      ...this.state,
+      codexEpoch: this.epoch,
+      ready: false,
+      connection: "starting",
+      error: void 0,
+      capabilities: []
+    };
+    this.publishRuntime();
+    try {
+      const env = {
+        ...process.env,
+        ...this.options.home === void 0 ? {} : { CODEX_HOME: this.options.home }
+      };
+      const { stdout } = await promisify(execFile)(this.options.binary, ["--version"], {
+        env,
+        timeout: 5e3,
+        maxBuffer: 64 * 1024
+      });
+      const version = stdout.trim().replace(/^codex-cli\s+/, "");
+      this.state.codexVersion = version;
+      this.permissionState.clear();
+      this.state.compatibility = CODEX_COMPATIBILITY.verified.includes(version) ? "verified" : "unverified";
+      const child = spawn(
+        this.options.binary,
+        this.options.args ?? ["app-server", "--listen", "stdio://"],
+        { env, stdio: ["pipe", "pipe", "pipe"], shell: false }
+      );
+      this.child = child;
+      const rpc = new RpcTransport(child.stdin, child.stdout, {
+        timeoutMs: this.options.requestTimeoutMs,
+        maxLineBytes: this.options.maxLineBytes
+      });
+      this.rpc = rpc;
+      this.titles = new ThreadTitles(rpc, this.options.titleTimeoutMs);
+      child.stderr.on("data", (chunk) => {
+        const max = this.options.maxStderrBytes ?? 64 * 1024;
+        this.stderrTail = Buffer.concat([this.stderrTail, chunk.subarray(-max)]).subarray(-max);
+      });
+      child.on(
+        "error",
+        (error) => rpc.fail(new CodexError("CODEX_UNAVAILABLE", `Cannot start Codex: ${error.message}`, true))
+      );
+      child.on("exit", (code, signal) => {
+        rpc.fail(
+          new CodexError(
+            "CODEX_UNAVAILABLE",
+            `Codex exited (${signal ?? code ?? "unknown"})`,
+            true
+          )
+        );
+        if (this.child === child) this.child = void 0;
+      });
+      rpc.on("notification", (message) => {
+        try {
+          this.notification(message);
+        } catch (error) {
+          rpc.fail(asCodexError(error));
+        }
+      });
+      rpc.on("request", (message) => {
+        void this.serverRequest(message).catch((error) => rpc.fail(asCodexError(error)));
+      });
+      rpc.on("failure", (error) => {
+        if (this.rpc !== rpc) return;
+        const wasReady = this.ready;
+        this.state.ready = false;
+        this.tokenUsage.clear();
+        this.state.connection = "unavailable";
+        this.state.error = error.message;
+        this.expireActions();
+        this.publishRuntime();
+        if (!child.killed) child.kill("SIGTERM");
+        const kill = setTimeout(() => {
+          if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+        }, 2500);
+        kill.unref();
+        child.once("exit", () => clearTimeout(kill));
+        if (wasReady && !this.stopped) {
+          console.error("Codex transport failed", {
+            code: error.code,
+            ...error.details
+          });
+          this.scheduleRestart();
+        }
+      });
+      const initialized = await this.call(
+        "initialize",
+        {
+          clientInfo: { name: "codex_web_ui", title: "Codex Web UI", version: "0.1.0" },
+          capabilities: {
+            experimentalApi: true,
+            requestAttestation: false,
+            explicitGatewayOauth: true
+          }
+        },
+        true
+      );
+      if (!isRecord(initialized) || typeof initialized.userAgent !== "string")
+        throw new CodexError(
+          "PROTOCOL_INCOMPATIBLE",
+          "Codex initialize returned a malformed result",
+          true
+        );
+      await rpc.notify("initialized");
+      const [account, models] = await Promise.all([
+        this.call("account/read", { refreshToken: false }, true),
+        this.call("model/list", { limit: 100 }, true)
+      ]);
+      if (!isRecord(account) || !Object.hasOwn(account, "account") || typeof account.requiresOpenaiAuth !== "boolean")
+        throw new CodexError(
+          "PROTOCOL_INCOMPATIBLE",
+          "Codex account/read returned a malformed result",
+          true
+        );
+      this.state.authenticated = account.account !== null || !account.requiresOpenaiAuth;
+      this.state.models = models.data.map((model) => ({
+        id: model.model,
+        name: model.displayName,
+        description: model.description,
+        reasoningEfforts: model.supportedReasoningEfforts.map((effort) => effort.reasoningEffort),
+        defaultReasoningEffort: model.defaultReasoningEffort,
+        serviceTiers: model.serviceTiers?.map((tier) => tier.id === "priority" ? "fast" : tier.id) ?? model.additionalSpeedTiers
+      }));
+      let cursor = models.nextCursor;
+      const seen = /* @__PURE__ */ new Set();
+      while (cursor) {
+        if (seen.has(cursor) || seen.size >= 100)
+          throw new CodexError("PROTOCOL_INCOMPATIBLE", "Invalid model pagination");
+        seen.add(cursor);
+        const page = await this.call("model/list", { limit: 100, cursor }, true);
+        this.state.models.push(
+          ...page.data.map((model) => ({
+            id: model.model,
+            name: model.displayName,
+            description: model.description,
+            reasoningEfforts: model.supportedReasoningEfforts.map(
+              (effort) => effort.reasoningEffort
+            ),
+            defaultReasoningEffort: model.defaultReasoningEffort,
+            serviceTiers: model.serviceTiers?.map((tier) => tier.id === "priority" ? "fast" : tier.id) ?? model.additionalSpeedTiers
+          }))
+        );
+        cursor = page.nextCursor;
+      }
+      this.titles?.configure(
+        account.account?.type === "chatgpt",
+        this.state.models.map((model) => model.id)
+      );
+      this.state.ready = true;
+      this.state.connection = "ready";
+      this.state.capabilities = CAPABILITIES.filter((method) => !this.disabled.has(method));
+      this.publishRuntime();
+    } catch (error) {
+      const failure = asCodexError(error);
+      this.state.ready = false;
+      this.state.connection = "unavailable";
+      this.state.error = failure.message;
+      this.publishRuntime();
+      await this.stopProcess(failure);
+      this.scheduleRestart();
+      throw failure;
+    }
+  }
+  async stop() {
+    this.stopped = true;
+    clearTimeout(this.restartTimer);
+    this.restartTimer = void 0;
+    await this.starting?.catch(() => {
+    });
+    await this.recovering;
+    await this.stopProcess();
+  }
+  scheduleRestart() {
+    if (this.stopped || this.restartTimer) return;
+    const delay = Math.min(1e3 * 2 ** Math.min(this.restartAttempt++, 5), 3e4);
+    this.restartTimer = setTimeout(() => {
+      this.restartTimer = void 0;
+      this.recovering = (async () => {
+        await this.stopProcess();
+        if (this.stopped) return;
+        try {
+          await this.start();
+          this.restartAttempt = 0;
+        } catch {
+          this.scheduleRestart();
+        }
+      })();
+      void this.recovering.finally(() => {
+        this.recovering = void 0;
+      });
+    }, delay);
+    this.restartTimer.unref();
+  }
+  async stopProcess(reason = new CodexError("CODEX_UNAVAILABLE", "Codex connection closed by this service", true)) {
+    const child = this.child;
+    this.state.ready = false;
+    this.state.connection = "unavailable";
+    this.expireActions();
+    this.rpc?.fail(reason);
+    if (!child || child.exitCode !== null || child.signalCode !== null) return;
+    child.stdin.end();
+    await new Promise((resolve) => {
+      const term = setTimeout(() => child.kill("SIGTERM"), 1e3);
+      const kill = setTimeout(() => child.kill("SIGKILL"), 2500);
+      const done = setTimeout(() => {
+        cleanup();
+        resolve();
+      }, 3500);
+      const cleanup = () => {
+        clearTimeout(term);
+        clearTimeout(kill);
+        clearTimeout(done);
+      };
+      child.once("exit", () => {
+        cleanup();
+        resolve();
+      });
+    });
+    if (this.child === child) this.child = void 0;
+  }
+  async call(method, params, initializing = false) {
+    if (!this.rpc || !initializing && !this.ready)
+      throw new CodexError("CODEX_UNAVAILABLE", "Codex is not ready");
+    if (this.disabled.has(method))
+      throw new CodexError("PROTOCOL_INCOMPATIBLE", `Codex does not support ${method}`);
+    try {
+      return await this.rpc.request(method, params);
+    } catch (error) {
+      if (!initializing && error instanceof CodexError && error.rpcCode === -32601) {
+        this.disabled.add(method);
+        this.state.capabilities = this.state.capabilities.filter((name) => name !== method);
+        this.state.error = `\u5F53\u524D Codex \u7F3A\u5C11 ${method} \u80FD\u529B`;
+        this.publishRuntime();
+      }
+      throw error;
+    }
+  }
+  validateSettings(settings = {}) {
+    const model = settings.model === void 0 ? void 0 : this.state.models.find((entry) => entry.id === settings.model);
+    if (settings.model !== void 0 && !model)
+      throw new AppError("VALIDATION_ERROR", "\u6A21\u578B\u4E0D\u5728\u5F53\u524D Codex \u6A21\u578B\u5217\u8868\u4E2D");
+    if (settings.reasoningEffort !== void 0 && !(model?.reasoningEfforts ?? this.state.models.flatMap((entry) => entry.reasoningEfforts)).includes(settings.reasoningEffort))
+      throw new AppError("VALIDATION_ERROR", "\u6240\u9009\u63A8\u7406\u5F3A\u5EA6\u4E0D\u53D7\u5F53\u524D\u6A21\u578B\u652F\u6301");
+  }
+  async listThreads(cwd, cursor, archived = false) {
+    const sequence = ++this.archiveSequence;
+    const result = await this.call("thread/list", {
+      cwd,
+      cursor,
+      limit: 30,
+      archived,
+      sourceKinds: ["cli", "appServer", "vscode"],
+      sortKey: "updated_at",
+      sortDirection: "desc"
+    });
+    return {
+      data: result.data.map((thread) => ({
+        ...mapThread(thread),
+        archived: this.observeArchive(thread.id, archived, sequence)
+      })),
+      nextCursor: result.nextCursor
+    };
+  }
+  observeArchive(id, archived, sequence) {
+    const current = this.archives.get(id);
+    if (current && current.sequence > sequence) return current.archived;
+    this.archives.set(id, { archived, sequence });
+    return archived;
+  }
+  archiveChanged(id, archived) {
+    this.observeArchive(id, archived, ++this.archiveSequence);
+    this.emit({ type: "threadArchive", threadId: id, archived });
+  }
+  /** thread/read has no archive field. Query the native index, including paginated history,
+   * instead of guessing from the unstable rollout path or maintaining a second database. */
+  async storedThread(thread, sequence) {
+    let cursor = null;
+    const seen = /* @__PURE__ */ new Set();
+    let archived = false;
+    do {
+      const page = await this.call("thread/list", {
+        archived: true,
+        cwd: thread.cwd,
+        cursor,
+        limit: 100,
+        sourceKinds: [
+          "cli",
+          "vscode",
+          "exec",
+          "appServer",
+          "subAgent",
+          "subAgentReview",
+          "subAgentCompact",
+          "subAgentThreadSpawn",
+          "subAgentOther",
+          "unknown"
+        ]
+      });
+      if (page.data.some((entry) => entry.id === thread.id)) {
+        archived = true;
+        break;
+      }
+      cursor = page.nextCursor;
+      if (cursor && (seen.has(cursor) || seen.size >= 1e3))
+        throw new CodexError("PROTOCOL_INCOMPATIBLE", "Invalid archive pagination");
+      if (cursor) seen.add(cursor);
+    } while (cursor);
+    return { ...mapThread(thread), archived: this.observeArchive(thread.id, archived, sequence) };
+  }
+  /** Native archive also shuts down spawned descendants, even already-archived ones. */
+  async assertArchiveIdle(rootId) {
+    const threads = /* @__PURE__ */ new Map();
+    const read = async (id) => {
+      let thread = threads.get(id);
+      if (!thread) {
+        thread = (await this.call("thread/read", { threadId: id, includeTurns: false })).thread;
+        threads.set(id, thread);
+      }
+      return thread;
+    };
+    let cursor = null;
+    const seen = /* @__PURE__ */ new Set();
+    do {
+      const page = await this.call("thread/loaded/list", {
+        cursor,
+        limit: 100
+      });
+      for (const id of page.data) {
+        let thread = await read(id);
+        if (thread.status.type !== "active") continue;
+        const ancestors = /* @__PURE__ */ new Set();
+        for (; ; ) {
+          if (thread.id === rootId)
+            throw new AppError("THREAD_BUSY", "\u4F1A\u8BDD\u6216\u5176\u5B50\u4EFB\u52A1\u4ECD\u5728\u8FD0\u884C\uFF0C\u7ED3\u675F\u540E\u624D\u80FD\u5F52\u6863", 409);
+          if (!thread.parentThreadId) break;
+          if (ancestors.has(thread.id))
+            throw new CodexError("PROTOCOL_INCOMPATIBLE", "Invalid thread ancestry");
+          ancestors.add(thread.id);
+          thread = await read(thread.parentThreadId);
+        }
+      }
+      cursor = page.nextCursor;
+      if (cursor && (seen.has(cursor) || seen.size >= 1e3))
+        throw new CodexError("PROTOCOL_INCOMPATIBLE", "Invalid loaded thread pagination");
+      if (cursor) seen.add(cursor);
+    } while (cursor);
+  }
+  async renameThread(id, name) {
+    const problem = threadNameError(name);
+    if (problem) throw new AppError("VALIDATION_ERROR", problem);
+    const epoch = this.epoch;
+    await this.titles?.prepareManualName(id);
+    if (this.epoch !== epoch || !this.ready)
+      throw new CodexError(
+        "CODEX_UNAVAILABLE",
+        "\u91CD\u547D\u540D\u7B49\u5F85\u671F\u95F4 Codex \u5B9E\u4F8B\u5DF2\u53D8\u5316\uFF0C\u8BF7\u6838\u5BF9\u540D\u79F0",
+        true
+      );
+    await this.call("thread/name/set", { threadId: id, name: name.trim() });
+  }
+  async archiveThread(id) {
+    await this.assertArchiveIdle(id);
+    await this.call("thread/archive", { threadId: id });
+    this.archiveChanged(id, true);
+  }
+  async unarchiveThread(id) {
+    const { thread } = await this.call("thread/unarchive", { threadId: id });
+    this.archiveChanged(id, false);
+    return { ...mapThread(thread), archived: false };
+  }
+  async readThreadHeader(id) {
+    try {
+      return (await this.call("thread/read", { threadId: id, includeTurns: false })).thread;
+    } catch (error) {
+      if (error instanceof CodexError && error.rpcCode === -32600 && error.message === `thread not loaded: ${id}`)
+        throw new AppError("THREAD_NOT_FOUND", "\u4F1A\u8BDD\u5C1A\u672A\u4FDD\u5B58\u6216\u5DF2\u4E0D\u5B58\u5728", 404, { threadId: id });
+      throw error;
+    }
+  }
+  async readThreadMetadata(id) {
+    const sequence = ++this.archiveSequence;
+    return this.storedThread(await this.readThreadHeader(id), sequence);
+  }
+  async readThread(id) {
+    const sequence = ++this.archiveSequence;
+    const thread = await this.readThreadHeader(id);
+    if (thread.historyMode !== "paginated")
+      return this.storedThread(
+        (await this.call("thread/read", { threadId: id, includeTurns: true })).thread,
+        sequence
+      );
+    let cursor = null;
+    const seen = /* @__PURE__ */ new Set();
+    thread.turns = [];
+    do {
+      const page = await this.call("thread/turns/list", {
+        threadId: id,
+        cursor,
+        limit: 100,
+        sortDirection: "asc",
+        itemsView: "summary"
+      });
+      for (const turn of page.data) {
+        if (turn.itemsView !== "full") {
+          let itemCursor = null;
+          const itemSeen = /* @__PURE__ */ new Set();
+          turn.items = [];
+          do {
+            const items = await this.call("thread/items/list", {
+              threadId: id,
+              turnId: turn.id,
+              cursor: itemCursor,
+              limit: 20,
+              sortDirection: "asc"
+            });
+            turn.items.push(...items.data.map((entry) => entry.item));
+            itemCursor = items.nextCursor;
+            if (itemCursor && (itemSeen.has(itemCursor) || itemSeen.size >= 1e3))
+              throw new CodexError("PROTOCOL_INCOMPATIBLE", "Invalid item pagination");
+            if (itemCursor) itemSeen.add(itemCursor);
+          } while (itemCursor);
+        }
+      }
+      thread.turns.push(...page.data);
+      cursor = page.nextCursor;
+      if (cursor && (seen.has(cursor) || seen.size >= 1e3))
+        throw new CodexError("PROTOCOL_INCOMPATIBLE", "Invalid turn pagination");
+      if (cursor) seen.add(cursor);
+    } while (cursor);
+    return this.storedThread(thread, sequence);
+  }
+  async createThread(cwd, settings) {
+    this.validateSettings(settings);
+    await this.validatePermissionSettings(cwd, settings);
+    const titles = this.titles;
+    const result = await this.call("thread/start", { cwd, ...threadSettings(settings) });
+    this.tokenUsage.created(result.thread.id);
+    titles?.register(result);
+    return {
+      ...mapThread(result.thread),
+      runtimeSettings: await this.responseRuntimeSettings(result)
+    };
+  }
+  async saveModelDefaults(settings) {
+    this.validateSettings({
+      model: settings.model,
+      ...settings.reasoningEffort === null ? {} : { reasoningEffort: settings.reasoningEffort }
+    });
+    const result = await this.call("config/batchWrite", {
+      edits: [
+        { keyPath: "model", value: settings.model, mergeStrategy: "replace" },
+        {
+          keyPath: "model_reasoning_effort",
+          value: settings.reasoningEffort,
+          mergeStrategy: "replace"
+        }
+      ],
+      reloadUserConfig: true
+    });
+    return { status: result.status };
+  }
+  async readRuntimeSettings(cwd) {
+    const { config } = await this.call("config/read", { cwd, includeLayers: false });
+    return {
+      model: typeof config.model === "string" ? config.model : null,
+      reasoningEffort: typeof config.model_reasoning_effort === "string" ? config.model_reasoning_effort : null,
+      ...serviceTierSettings(config.service_tier),
+      sandbox: config.sandbox_mode ?? null,
+      approvalPolicy: typeof config.approval_policy === "string" ? config.approval_policy : config.approval_policy ? "granular" : null,
+      approvalReviewer: config.approvals_reviewer ?? null,
+      networkAccess: config.sandbox_mode === "workspace-write" ? config.sandbox_workspace_write?.network_access ?? null : null,
+      permissionMode: typeof config.default_permissions === "string" && ![":workspace", ":read-only", ":danger-full-access"].includes(config.default_permissions) ? "custom" : null,
+      permissionProfile: typeof config.default_permissions === "string" ? { id: config.default_permissions, extends: null } : null,
+      writableRoots: config.sandbox_workspace_write?.writable_roots ?? null,
+      excludeTmpdirEnvVar: config.sandbox_workspace_write?.exclude_tmpdir_env_var ?? null,
+      excludeSlashTmp: config.sandbox_workspace_write?.exclude_slash_tmp ?? null,
+      permissionCapabilities: await this.readPermissionCapabilities(void 0, config)
+    };
+  }
+  async readPermissionCapabilities(threadId, config) {
+    if (!CODEX_COMPATIBILITY.verified.includes(this.state.codexVersion ?? ""))
+      return permissionCapabilities(
+        null,
+        false,
+        `\u6743\u9650\u6A21\u5F0F\u4EC5\u6838\u9A8C\u8FC7 Codex ${VERIFIED_CODEX_VERSION}\uFF1B\u5F53\u524D\u7248\u672C ${this.state.codexVersion ?? "\u672A\u77E5"}`
+      );
+    try {
+      const [requirements, first] = await Promise.all([
+        this.call("configRequirements/read", void 0),
+        this.call("experimentalFeature/list", { limit: 200, ...threadId ? { threadId } : {} })
+      ]);
+      if (!Object.hasOwn(requirements, "requirements") || !Array.isArray(first.data))
+        throw new Error("Permission capability response is incomplete");
+      const features = [...first.data];
+      let cursor = first.nextCursor;
+      const seen = /* @__PURE__ */ new Set();
+      while (cursor) {
+        if (seen.has(cursor) || seen.size >= 100) throw new Error("Invalid feature pagination");
+        seen.add(cursor);
+        const page = await this.call("experimentalFeature/list", {
+          limit: 200,
+          cursor,
+          ...threadId ? { threadId } : {}
+        });
+        features.push(...page.data);
+        cursor = page.nextCursor;
+      }
+      const configFeatures = config?.features;
+      const explicit = isRecord(configFeatures) ? configFeatures.guardian_approval : void 0;
+      const autoReview = typeof explicit === "boolean" ? explicit : features.find((entry) => entry.name === "guardian_approval")?.enabled === true;
+      return permissionCapabilities(
+        requirements.requirements,
+        autoReview
+      );
+    } catch {
+      return permissionCapabilities(
+        null,
+        false,
+        "\u65E0\u6CD5\u6838\u5B9E\u5F53\u524D Codex \u7684\u529F\u80FD\u548C\u53D7\u7BA1\u8981\u6C42\uFF0C\u8BF7\u91CD\u8BD5\u6216\u68C0\u67E5\u7248\u672C\u652F\u6301"
+      );
+    }
+  }
+  async validatePermissionSettings(cwd, settings, threadId) {
+    if (!settings?.permissionMode && settings?.approvalReviewer === void 0) return;
+    const epoch = this.epoch;
+    const defaults = !threadId || !this.permissionState.has(threadId) ? await this.readRuntimeSettings(cwd) : void 0;
+    const capabilities = defaults ? defaults.permissionCapabilities : await this.readPermissionCapabilities(threadId);
+    if (epoch !== this.epoch)
+      throw new AppError("CODEX_UNAVAILABLE", "Codex \u8FD0\u884C\u5B9E\u4F8B\u5DF2\u53D8\u5316\uFF0C\u8BF7\u91CD\u8BD5");
+    const model = settings.model ?? (threadId ? this.permissionState.get(threadId)?.model : void 0) ?? defaults?.model;
+    const reason = settings.permissionMode ? permissionModeUnavailable(settings.permissionMode, capabilities, model) : permissionReviewerUnavailable(settings.approvalReviewer, capabilities, model);
+    if (reason) throw new AppError("PERMISSION_MODE_UNAVAILABLE", reason);
+  }
+  async responseRuntimeSettings(result) {
+    const previous = this.permissionState.get(result.thread.id);
+    const settings = {
+      model: result.model ?? result.thread.model ?? null,
+      reasoningEffort: result.reasoningEffort ?? null,
+      ...serviceTierSettings(result.serviceTier),
+      ...permissionSettings(
+        result.sandbox,
+        result.approvalPolicy,
+        result.approvalsReviewer,
+        result.activePermissionProfile,
+        result.cwd
+      ),
+      permissionCapabilities: await this.readPermissionCapabilities(result.thread.id)
+    };
+    const latest = this.permissionState.get(result.thread.id);
+    const confirmed = latest && latest !== previous ? { ...latest, permissionCapabilities: settings.permissionCapabilities } : settings;
+    this.permissionState.set(result.thread.id, confirmed);
+    if (confirmed !== settings)
+      this.emit({ type: "threadSettings", threadId: result.thread.id, settings: confirmed });
+    return settings;
+  }
+  async resumeThread(id, cwd, settings) {
+    this.validateSettings(settings);
+    await this.validatePermissionSettings(cwd, settings, id);
+    const titles = this.titles;
+    let result;
+    try {
+      result = await this.call("thread/resume", {
+        threadId: id,
+        cwd,
+        ...threadSettings(settings),
+        excludeTurns: true
+      });
+    } catch (error) {
+      if (error instanceof CodexError && error.rpcCode === -32600 && error.message === `thread ${id} already has an active writer`)
+        throw new AppError("THREAD_IN_USE", "\u6B64\u4F1A\u8BDD\u6B63\u88AB\u5176\u4ED6\u8FDB\u7A0B\u4F7F\u7528", 409, { threadId: id });
+      throw error;
+    }
+    titles?.register(result);
+    const view = await this.readThread(result.thread.id);
+    return { ...view, runtimeSettings: await this.responseRuntimeSettings(result) };
+  }
+  async forkThread(id, cwd, settings) {
+    this.validateSettings(settings);
+    await this.validatePermissionSettings(cwd, settings, id);
+    const titles = this.titles;
+    const result = await this.call("thread/fork", {
+      threadId: id,
+      cwd,
+      ...threadSettings(settings),
+      // Omitting lastTurnId copies the persisted history, including an active turn's
+      // interruption marker in the fork. The source is never resumed or interrupted.
+      excludeTurns: true
+    });
+    let forkedId;
+    try {
+      if (isRecord(result) && isRecord(result.thread) && typeof result.thread.id === "string")
+        forkedId = result.thread.id === id ? void 0 : result.thread.id;
+      const metadata = mapThread(result.thread);
+      if (metadata.id === id)
+        throw new CodexError("PROTOCOL_INCOMPATIBLE", "Codex fork returned the source thread ID");
+      forkedId = metadata.id;
+      const thread = await this.readThread(forkedId);
+      if (thread.id !== forkedId)
+        throw new CodexError("PROTOCOL_INCOMPATIBLE", "Codex returned a different fork thread ID");
+      titles?.register(result);
+      return { ...thread, runtimeSettings: await this.responseRuntimeSettings(result) };
+    } catch (error) {
+      const failure = asCodexError(error);
+      throw new CodexError(
+        failure.code,
+        forkedId ? `\u5DF2\u521B\u5EFA\u5206\u652F\u4F1A\u8BDD ${forkedId}\uFF0C\u4F46\u65E0\u6CD5\u52A0\u8F7D\u5386\u53F2\uFF1B\u8BF7\u4ECE\u4F1A\u8BDD\u5217\u8868\u91CD\u65B0\u6253\u5F00\uFF0C\u4E0D\u8981\u91CD\u590D fork\u3002${failure.message}` : `Codex fork \u5DF2\u8FD4\u56DE\u7ED3\u679C\uFF0C\u4F46\u65E0\u6CD5\u786E\u8BA4\u65B0\u4F1A\u8BDD\uFF1B\u8BF7\u68C0\u67E5\u4F1A\u8BDD\u5217\u8868\uFF0C\u4E0D\u8981\u91CD\u590D fork\u3002${failure.message}`,
+        true,
+        failure.rpcCode
+      );
+    }
+  }
+  async startTurn(id, cwd, text, settings, images) {
+    this.validateSettings(settings);
+    await this.validatePermissionSettings(cwd, settings, id);
+    const turn = mapTurn(
+      id,
+      (await this.call("turn/start", {
+        threadId: id,
+        cwd,
+        input: taskInput(text, images),
+        ...turnSettings(cwd, settings)
+      })).turn
+    );
+    return turn;
+  }
+  async startReview(id) {
+    const result = await this.call("review/start", {
+      threadId: id,
+      target: { type: "uncommittedChanges" },
+      delivery: "inline"
+    });
+    if (!isRecord(result) || result.reviewThreadId !== id)
+      throw new CodexError(
+        "PROTOCOL_INCOMPATIBLE",
+        "Codex review returned a different thread; review result needs reconciliation",
+        true
+      );
+    return mapTurn(id, result.turn);
+  }
+  steerTurn(id, turnId, text, images) {
+    return this.call("turn/steer", {
+      threadId: id,
+      expectedTurnId: turnId,
+      input: taskInput(text, images)
+    });
+  }
+  async interruptTurn(id, turnId) {
+    await this.call("turn/interrupt", { threadId: id, turnId });
+  }
+  async compactThread(id) {
+    await this.call("thread/compact/start", { threadId: id });
+  }
+  notification(message) {
+    if (this.titles?.notification(message)) return;
+    const event = message;
+    const p = event.params;
+    switch (event.method) {
+      case "thread/settings/updated":
+        {
+          const observed = {
+            model: event.params.threadSettings.model ?? null,
+            reasoningEffort: event.params.threadSettings.effort ?? null,
+            ...serviceTierSettings(event.params.threadSettings.serviceTier),
+            ...permissionSettings(
+              event.params.threadSettings.sandboxPolicy,
+              event.params.threadSettings.approvalPolicy,
+              event.params.threadSettings.approvalsReviewer,
+              event.params.threadSettings.activePermissionProfile,
+              event.params.threadSettings.cwd
+            ),
+            permissionCapabilities: this.permissionState.get(event.params.threadId)?.permissionCapabilities
+          };
+          this.permissionState.set(event.params.threadId, observed);
+          this.emit({
+            type: "threadSettings",
+            threadId: event.params.threadId,
+            settings: observed
+          });
+        }
+        break;
+      case "item/autoApprovalReview/started":
+      case "item/autoApprovalReview/completed":
+        this.emit({
+          type: "autoReview",
+          threadId: event.params.threadId,
+          turnId: event.params.turnId,
+          review: mapAutoReview(event.params)
+        });
+        break;
+      case "thread/started":
+        this.emit({ type: "thread", thread: mapThread(event.params.thread) });
+        break;
+      case "thread/archived":
+        this.archiveChanged(event.params.threadId, true);
+        break;
+      case "thread/unarchived":
+        this.archiveChanged(event.params.threadId, false);
+        break;
+      case "thread/name/updated":
+        this.emit({
+          type: "threadName",
+          threadId: event.params.threadId,
+          name: event.params.threadName
+        });
+        break;
+      case "thread/status/changed":
+        this.emit({
+          type: "threadStatus",
+          threadId: event.params.threadId,
+          status: threadStatus(event.params.status)
+        });
+        break;
+      case "turn/started":
+      case "turn/completed": {
+        const { threadId, turn } = event.params;
+        if (event.method === "turn/started") this.tokenUsage.started(threadId, turn.id);
+        const outputTokens = event.method === "turn/completed" ? this.tokenUsage.completed(threadId, turn.id) : void 0;
+        this.emit({
+          type: "turn",
+          threadId,
+          turn: {
+            ...mapTurn(threadId, turn),
+            ...outputTokens !== void 0 ? { outputTokens } : {}
+          }
+        });
+        if (event.method === "turn/completed")
+          this.expireActions(event.params.threadId, event.params.turn.id);
+        break;
+      }
+      case "thread/tokenUsage/updated":
+        this.tokenUsage.updated(
+          event.params.threadId,
+          event.params.turnId,
+          event.params.tokenUsage?.total?.outputTokens
+        );
+        break;
+      case "thread/compacted":
+        this.tokenUsage.compacted(event.params.threadId, event.params.turnId);
+        this.emit({ type: "compactionCompleted", ...event.params });
+        break;
+      case "item/started":
+      case "item/completed":
+        if (event.params.item.type === "contextCompaction")
+          this.tokenUsage.compacted(event.params.threadId, event.params.turnId);
+        if (["agentMessage", "plan", "reasoning"].includes(event.params.item.type))
+          this.emit({
+            type: "turnProgress",
+            threadId: event.params.threadId,
+            turnId: event.params.turnId
+          });
+        this.emit({
+          type: "item",
+          threadId: event.params.threadId,
+          turnId: event.params.turnId,
+          item: {
+            ...mapItem(event.params.item),
+            ...event.params.item.type === "contextCompaction" ? { status: event.method === "item/started" ? "inProgress" : "completed" } : {}
+          }
+        });
+        break;
+      case "item/agentMessage/delta":
+      case "item/plan/delta":
+      case "item/reasoning/summaryTextDelta":
+      case "item/reasoning/textDelta":
+      case "item/commandExecution/outputDelta":
+      case "item/fileChange/outputDelta":
+        if (!event.method.includes("outputDelta"))
+          this.emit({
+            type: "turnProgress",
+            threadId: event.params.threadId,
+            turnId: event.params.turnId
+          });
+        this.emit({
+          type: "delta",
+          threadId: event.params.threadId,
+          turnId: event.params.turnId,
+          itemId: event.params.itemId,
+          field: event.method.includes("outputDelta") ? "output" : "text",
+          delta: event.params.delta,
+          itemType: event.method.split("/")[1]
+        });
+        break;
+      case "item/reasoning/summaryPartAdded":
+      case "rawResponse/completed":
+        this.emit({
+          type: "turnProgress",
+          threadId: event.params.threadId,
+          turnId: event.params.turnId
+        });
+        break;
+      case "turn/diff/updated":
+        this.emit({
+          type: "diff",
+          threadId: event.params.threadId,
+          turnId: event.params.turnId,
+          diff: event.params.diff
+        });
+        break;
+      case "item/fileChange/patchUpdated":
+        this.emit({
+          type: "item",
+          threadId: event.params.threadId,
+          turnId: event.params.turnId,
+          item: mapItem({
+            type: "fileChange",
+            id: event.params.itemId,
+            changes: event.params.changes,
+            status: "inProgress"
+          })
+        });
+        break;
+      case "serverRequest/resolved": {
+        const actionId = this.actionIds.get(event.params.requestId);
+        if (actionId) {
+          this.emit({ type: "actionResolved", actionId });
+          this.actions.delete(actionId);
+          this.actionIds.delete(event.params.requestId);
+        }
+        break;
+      }
+      case "error":
+        this.emit({
+          type: "turnError",
+          threadId: event.params.threadId,
+          turnId: event.params.turnId,
+          message: event.params.error.message,
+          willRetry: event.params.willRetry
+        });
+        break;
+      default:
+        if (!isRecord(p)) break;
+    }
+  }
+  async serverRequest(message) {
+    if (isRecord(message.params) && this.titles?.isInternal(message.params.threadId)) {
+      await this.rpc?.reject(
+        message.id,
+        -32601,
+        "Interactive tools are disabled for title generation"
+      );
+      return;
+    }
+    const request = message;
+    const params = isRecord(message.params) ? message.params : {};
+    const action = {
+      actionId: randomUUID(),
+      codexEpoch: this.epoch,
+      rpcId: message.id,
+      kind: "unsupported",
+      status: "pending",
+      title: "\u4E0D\u652F\u6301\u7684 Codex \u4EA4\u4E92\u8BF7\u6C42",
+      options: [],
+      ...typeof params.threadId === "string" ? { threadId: params.threadId } : {},
+      ...typeof params.turnId === "string" ? { turnId: params.turnId } : {}
+    };
+    const decisions = /* @__PURE__ */ new Map();
+    if (request.method === "item/commandExecution/requestApproval" || request.method === "item/fileChange/requestApproval") {
+      for (const [id, label] of [
+        ["accept", "\u5141\u8BB8\u672C\u6B21"],
+        ["acceptForSession", "\u672C\u4F1A\u8BDD\u5141\u8BB8"],
+        ["decline", "\u62D2\u7EDD"],
+        ["cancel", "\u53D6\u6D88\u5F53\u524D\u4EFB\u52A1"]
+      ]) {
+        action.options.push({ id, label });
+        decisions.set(id, id);
+      }
+      action.reason = request.params.reason ?? void 0;
+      if (request.method === "item/commandExecution/requestApproval") {
+        const p = request.params;
+        action.kind = p.networkApprovalContext ? "network" : "command";
+        action.title = p.networkApprovalContext ? `\u7F51\u7EDC\u6743\u9650\uFF1A${p.networkApprovalContext.protocol}://${p.networkApprovalContext.host}` : "\u547D\u4EE4\u5BA1\u6279";
+        action.command = p.command ?? void 0;
+        action.cwd = p.cwd ?? void 0;
+        action.details = {
+          kind: p.kind,
+          network: p.networkApprovalContext,
+          commandActions: p.commandActions
+        };
+        if (p.proposedExecpolicyAmendment) {
+          action.options.push({
+            id: "acceptWithRule",
+            label: `\u5141\u8BB8\u5E76\u8BB0\u4F4F\u547D\u4EE4\u89C4\u5219\uFF1A${p.proposedExecpolicyAmendment.join(" ")}`
+          });
+          decisions.set("acceptWithRule", {
+            acceptWithExecpolicyAmendment: { execpolicy_amendment: p.proposedExecpolicyAmendment }
+          });
+        }
+        p.proposedNetworkPolicyAmendments?.forEach((amendment, index) => {
+          const id = `networkRule:${index}`;
+          action.options.push({ id, label: `\u5E94\u7528\u7F51\u7EDC\u89C4\u5219\uFF1A${JSON.stringify(amendment)}` });
+          decisions.set(id, {
+            applyNetworkPolicyAmendment: { network_policy_amendment: amendment }
+          });
+        });
+      } else {
+        action.kind = "file";
+        action.title = "\u6587\u4EF6\u53D8\u66F4\u5BA1\u6279";
+        action.details = { itemId: request.params.itemId, grantRoot: request.params.grantRoot };
+      }
+    } else if (request.method === "item/permissions/requestApproval") {
+      const p = request.params;
+      action.kind = "permissions";
+      action.title = "\u989D\u5916\u6743\u9650\u5BA1\u6279";
+      action.reason = p.reason ?? void 0;
+      action.cwd = p.cwd;
+      action.options = [
+        { id: "accept", label: "\u5F53\u524D\u4EFB\u52A1\u5141\u8BB8" },
+        { id: "acceptForSession", label: "\u672C\u4F1A\u8BDD\u5141\u8BB8" },
+        { id: "decline", label: "\u62D2\u7EDD" }
+      ];
+      action.permissionRequest = {
+        ...p.permissions.network === null ? {} : { network: p.permissions.network.enabled },
+        ...p.permissions.fileSystem === null ? {} : {
+          fileSystem: {
+            read: p.permissions.fileSystem.read ?? [],
+            write: p.permissions.fileSystem.write ?? [],
+            entries: (p.permissions.fileSystem.entries ?? []).map((entry) => ({
+              path: permissionPathLabel(entry.path),
+              access: entry.access
+            })),
+            ...p.permissions.fileSystem.globScanMaxDepth === void 0 ? {} : {
+              globScanMaxDepth: p.permissions.fileSystem.globScanMaxDepth
+            }
+          }
+        }
+      };
+      action.details = {
+        itemId: p.itemId,
+        environmentId: p.environmentId,
+        permissions: p.permissions
+      };
+    } else if (request.method === "mcpServer/elicitation/request") {
+      action.kind = "elicitation";
+      action.reason = request.params.message;
+      action.elicitation = normalizeElicitationRequest(params);
+      action.title = `${action.elicitation.approval ? "MCP \u5DE5\u5177\u5BA1\u6279" : "MCP \u4EA4\u4E92"}\uFF1A${request.params.serverName}`;
+      action.options = [
+        {
+          id: "accept",
+          label: action.elicitation.approval ? "\u5141\u8BB8\u672C\u6B21" : action.elicitation.mode === "url" ? "\u5DF2\u5B8C\u6210\uFF0C\u7EE7\u7EED" : "\u63D0\u4EA4"
+        },
+        ...action.elicitation.approval?.allowSession ? [{ id: "acceptSession", label: "\u672C\u4F1A\u8BDD\u5141\u8BB8" }] : [],
+        { id: "decline", label: "\u62D2\u7EDD" },
+        { id: "cancel", label: "\u53D6\u6D88" }
+      ];
+      if (action.elicitation.schemaError)
+        action.details = { requestedSchema: params.requestedSchema, mode: params.mode };
+    } else if (request.method === "item/tool/requestUserInput") {
+      action.kind = "questions";
+      action.title = "\u9700\u8981\u4F60\u7684\u56DE\u7B54";
+      action.blocking = request.params.isBlocking;
+      action.questions = request.params.questions.map((question) => ({
+        ...question,
+        options: question.options ?? []
+      }));
+    } else {
+      action.status = "expired";
+      action.reason = `\u5F53\u524D Web UI \u5C1A\u672A\u5B9E\u73B0 ${message.method}`;
+      this.emit({ type: "action", action });
+      this.state.error = action.reason;
+      this.publishRuntime();
+      await this.rpc.reject(
+        message.id,
+        -32601,
+        `Unsupported interactive request: ${message.method}`
+      );
+      return;
+    }
+    this.actions.set(action.actionId, { action, request, decisions, responding: false });
+    this.actionIds.set(message.id, action.actionId);
+    this.emit({ type: "action", action: structuredClone(action) });
+  }
+  async respond(actionId, resolution) {
+    const context = this.actions.get(actionId);
+    if (!context || context.action.codexEpoch !== this.epoch || !this.ready)
+      throw new AppError("ACTION_EXPIRED", "\u6B64\u4EBA\u5DE5\u8BF7\u6C42\u5DF2\u5931\u6548", 409);
+    if (context.responding) throw new AppError("ACTION_CONFLICT", "\u6B64\u4EBA\u5DE5\u8BF7\u6C42\u5DF2\u63D0\u4EA4\u56DE\u7B54", 409);
+    let response;
+    if (context.request.method === "item/permissions/requestApproval") {
+      const decision = validatePermissionResolution(resolution);
+      const requested = context.request.params.permissions;
+      response = {
+        permissions: decision === "decline" ? {} : structuredClone({
+          ...requested.network === null ? {} : { network: requested.network },
+          ...requested.fileSystem === null ? {} : { fileSystem: requested.fileSystem }
+        }),
+        scope: decision === "acceptForSession" ? "session" : "turn"
+      };
+    } else if (context.request.method === "mcpServer/elicitation/request") {
+      const content = validateElicitationResolution(
+        normalizeElicitationRequest({ ...context.request.params }),
+        resolution
+      );
+      response = {
+        action: resolution.decision,
+        content,
+        _meta: "decision" in resolution && resolution.persist === "session" ? { persist: "session" } : null
+      };
+    } else if (context.request.method === "item/tool/requestUserInput") {
+      if (!("answers" in resolution))
+        throw new AppError("VALIDATION_ERROR", "\u6B64\u8BF7\u6C42\u9700\u8981\u7ED3\u6784\u5316\u56DE\u7B54");
+      const questions = context.request.params.questions;
+      const ids = new Set(questions.map((question) => question.id));
+      if (Object.keys(resolution.answers).some((id) => !ids.has(id)))
+        throw new AppError("VALIDATION_ERROR", "\u56DE\u7B54\u5305\u542B\u672A\u77E5\u9898\u76EE");
+      const answers = {};
+      for (const question of questions) {
+        const values = resolution.answers[question.id];
+        if (!Array.isArray(values) || !values.length || values.some((value) => typeof value !== "string" || !value.trim()))
+          throw new AppError("VALIDATION_ERROR", `\u8BF7\u56DE\u7B54 ${question.header}`);
+        if (question.options?.length && !question.isOther && values.some((value) => !question.options.some((option) => option.label === value)))
+          throw new AppError("VALIDATION_ERROR", `\u9898\u76EE ${question.header} \u53EA\u63A5\u53D7\u6240\u5217\u9009\u9879`);
+        answers[question.id] = { answers: values };
+      }
+      response = { answers };
+    } else {
+      if (!("decision" in resolution) || "content" in resolution || "persist" in resolution || !context.decisions.has(resolution.decision))
+        throw new AppError("VALIDATION_ERROR", "\u6B64\u8BF7\u6C42\u4E0D\u652F\u6301\u6240\u63D0\u4EA4\u7684\u51B3\u5B9A");
+      response = { decision: context.decisions.get(resolution.decision) };
+    }
+    context.responding = true;
+    try {
+      await this.rpc.respond(context.action.rpcId, response);
+    } catch (error) {
+      if (error instanceof CodexError && !error.uncertain) context.responding = false;
+      throw error;
+    }
+  }
+  expireActions(threadId, turnId) {
+    for (const [id, context] of this.actions) {
+      if (threadId && context.action.threadId !== threadId) continue;
+      if (turnId && context.action.turnId !== turnId) continue;
+      this.emit({ type: "action", action: { ...context.action, status: "expired" } });
+      this.actions.delete(id);
+      this.actionIds.delete(context.action.rpcId);
+    }
+  }
+}
+export {
+  CodexAdapter,
+  CodexError2 as CodexError,
+  VERIFIED_CODEX_VERSION
+};
+//# sourceMappingURL=adapter.js.map