@landh93/web-codex-client 0.1.0-rc.1

package/dist/cli.js

@@ -0,0 +1,2999 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { parseArgs } from "node:util";
+import { resolve as resolve4 } from "node:path";
+import { readFile as readFile3 } from "node:fs/promises";
+
+// src/probe.ts
+import { mkdirSync, writeFileSync, renameSync } from "node:fs";
+import { dirname } from "node:path";
+import cliProgress from "cli-progress";
+
+// src/rpc.ts
+import { EventEmitter } from "node:events";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { lstat } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import WebSocket from "ws";
+var BridgeError = class extends Error {
+  constructor(code, message = code, retryable = false) {
+    super(message);
+    this.code = code;
+    this.retryable = retryable;
+  }
+};
+var RpcError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+};
+function controlSocketPath(config) {
+  return config.socket ?? join(config.codexHome ?? process.env.CODEX_HOME ?? join(homedir(), ".codex"), "app-server-control", "app-server-control.sock");
+}
+var CodexRpc = class _CodexRpc extends EventEmitter {
+  available = false;
+  version = "unknown";
+  child;
+  ws;
+  next = 0;
+  ended = false;
+  pending = /* @__PURE__ */ new Map();
+  static async connect(config) {
+    const rpc = new _CodexRpc();
+    try {
+      await rpc.open(config);
+      const result = await rpc.call("initialize", {
+        clientInfo: {
+          name: "web_codex_client",
+          title: "Web Codex Client",
+          version: "0.1.0"
+        },
+        capabilities: { experimentalApi: true }
+      });
+      rpc.version = result.userAgent ?? "unknown";
+      rpc.send({ method: "initialized" });
+      rpc.available = true;
+      return rpc;
+    } catch (e) {
+      rpc.close();
+      throw e;
+    }
+  }
+  async open(c) {
+    if (c.mode === "websocket" || c.mode === "unix") {
+      const socketPath = c.mode === "unix" ? controlSocketPath(c) : void 0;
+      if (socketPath) {
+        if (!socketPath.startsWith("/") || socketPath.includes(":")) throw Error("UPSTREAM_SOCKET_INVALID");
+        const info = await lstat(socketPath);
+        if (!info.isSocket() || info.uid !== process.getuid?.() || (info.mode & 63) !== 0)
+          throw Error("UPSTREAM_SOCKET_PERMISSIONS");
+      }
+      const url = socketPath ? "ws+unix://" + socketPath + ":/" : new URL(c.url);
+      if (url instanceof URL && (url.protocol !== "ws:" || !["127.0.0.1", "[::1]", "localhost"].includes(url.hostname)))
+        throw Error("UPSTREAM_MUST_BE_LOOPBACK");
+      this.ws = new WebSocket(url, {
+        maxPayload: 8 * 1024 * 1024,
+        perMessageDeflate: false,
+        handshakeTimeout: 1e4
+      });
+      await new Promise((resolve5, reject) => {
+        this.ws.once("open", resolve5);
+        this.ws.once("error", reject);
+      });
+      this.ws.on("message", (data) => this.parse(data.toString()));
+      this.ws.on("error", () => this.fail());
+      this.ws.on("close", () => this.fail());
+      return;
+    }
+    const args = c.mode === "proxy" ? ["app-server", "proxy", ...c.socket ? ["--sock", c.socket] : []] : ["app-server", "--listen", "stdio://"];
+    if (c.mode === "stdio" && !c.codexHome)
+      throw Error("STANDALONE_REQUIRES_EXPLICIT_CODEX_HOME");
+    this.child = spawn(c.binary ?? "codex", args, {
+      env: {
+        ...process.env,
+        ...c.codexHome ? { CODEX_HOME: c.codexHome } : {}
+      },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let buffer = Buffer.alloc(0);
+    this.child.stdout.on("data", (chunk) => {
+      buffer = Buffer.concat([buffer, chunk]);
+      let i;
+      while ((i = buffer.indexOf(10)) >= 0) {
+        if (i > 8 * 1024 * 1024) {
+          this.fail();
+          return;
+        }
+        const line = buffer.subarray(0, i).toString();
+        buffer = buffer.subarray(i + 1);
+        if (line) this.parse(line);
+      }
+      if (buffer.length > 8 * 1024 * 1024) this.fail();
+    });
+    this.child.stderr.resume();
+    this.child.on("error", () => this.fail());
+    this.child.on("exit", () => this.fail());
+  }
+  parse(line) {
+    try {
+      const m = JSON.parse(line);
+      if (m.method) {
+        this.emit(m.id === void 0 ? "notification" : "serverRequest", m);
+        return;
+      }
+      const key = String(m.id);
+      const p = this.pending.get(key);
+      if (!p) return;
+      this.pending.delete(key);
+      clearTimeout(p.timer);
+      if (m.error) p.reject(new RpcError(m.error.code, m.error.message));
+      else p.resolve(m.result);
+    } catch {
+      this.fail();
+    }
+  }
+  send(value) {
+    if (this.ended) throw new BridgeError("UPSTREAM_UNAVAILABLE");
+    const data = JSON.stringify(value);
+    if (this.ws) {
+      if (this.ws.bufferedAmount > 1024 * 1024) throw new BridgeError("BUSY");
+      this.ws.send(data);
+    } else {
+      if (!this.child || this.child.stdin.writableLength > 1024 * 1024)
+        throw new BridgeError("BUSY");
+      this.child.stdin.write(data + "\n");
+    }
+  }
+  call(method, params) {
+    if (this.pending.size >= 32) return Promise.reject(new BridgeError("BUSY"));
+    return new Promise((resolve5, reject) => {
+      const id2 = "bridge-" + ++this.next;
+      const timer = setTimeout(() => {
+        this.pending.delete(id2);
+        reject(
+          new BridgeError("OUTCOME_UNKNOWN", "Upstream response timed out")
+        );
+      }, 15e3);
+      this.pending.set(id2, { resolve: resolve5, reject, timer });
+      try {
+        this.send({ id: id2, method, params });
+      } catch (e) {
+        clearTimeout(timer);
+        this.pending.delete(id2);
+        reject(e);
+      }
+    });
+  }
+  respond(id2, result, error) {
+    this.send(error ? { id: id2, error } : { id: id2, result });
+  }
+  fail() {
+    if (this.ended) return;
+    this.ended = true;
+    this.available = false;
+    for (const p of this.pending.values()) {
+      clearTimeout(p.timer);
+      p.reject(new BridgeError("UPSTREAM_UNAVAILABLE"));
+    }
+    this.pending.clear();
+    this.ws?.terminate();
+    this.child?.stdin.destroy();
+    this.child?.kill("SIGTERM");
+    this.emit("disconnect");
+  }
+  close() {
+    this.fail();
+  }
+};
+
+// src/probe.ts
+async function probe(config, quiet = false, report) {
+  const result = {
+    cliBaseline: "0.155.1",
+    transport: config.mode,
+    readOnly: true,
+    checks: {}
+  };
+  const checks = result.checks;
+  const start = Date.now();
+  let completed = 0;
+  let rpc;
+  let threadId;
+  const bar = new cliProgress.SingleBar(
+    {
+      format: "Codex probe [{bar}] {percentage}% | {value}/{total} | elapsed {duration_formatted} | ETA {eta_formatted} | {rate}/s | {phase}",
+      noTTYOutput: !quiet,
+      notTTYSchedule: 1e3
+    },
+    cliProgress.Presets.shades_classic
+  );
+  const persist = () => {
+    if (report) {
+      mkdirSync(dirname(report), { recursive: true });
+      writeFileSync(report + ".tmp", JSON.stringify(result, null, 2) + "\n");
+      renameSync(report + ".tmp", report);
+    }
+  };
+  const mark = (phase) => {
+    result.completedUnits = ++completed;
+    result.elapsedMs = Date.now() - start;
+    persist();
+    if (!quiet)
+      bar.update(completed, {
+        phase,
+        rate: (completed / Math.max(1e-3, (Date.now() - start) / 1e3)).toFixed(1)
+      });
+  };
+  if (!quiet) bar.start(6, 0, { phase: "initialize", rate: "0" });
+  try {
+    try {
+      rpc = await CodexRpc.connect(config);
+      result.upstreamVersion = rpc.version;
+      checks.initialize = { status: "PASS" };
+      mark("initialize");
+    } catch (e) {
+      checks.initialize = {
+        status: "FAIL",
+        code: e instanceof Error ? e.message : "UNAVAILABLE"
+      };
+      mark("initialize failed");
+      throw e;
+    }
+    for (const method of [
+      "project/list",
+      "thread/list",
+      "thread/read",
+      "thread/turns/list",
+      "thread/items/list"
+    ]) {
+      if (method.startsWith("thread/") && method !== "thread/list" && !threadId) {
+        checks[method] = {
+          status: "NOT_RUN",
+          reason: "No thread returned by sampled list"
+        };
+        mark(method + " skipped");
+        continue;
+      }
+      try {
+        const params = method === "thread/list" ? {
+          limit: 5,
+          useStateDbOnly: true,
+          sourceKinds: [
+            "cli",
+            "vscode",
+            "exec",
+            "appServer",
+            "subAgent",
+            "subAgentReview",
+            "subAgentCompact",
+            "subAgentThreadSpawn",
+            "subAgentOther",
+            "unknown"
+          ]
+        } : method === "project/list" ? { limit: 5 } : method === "thread/read" ? { threadId, includeTurns: false } : { threadId, limit: 1 };
+        const r = await rpc.call(method, params);
+        if (method === "thread/list") threadId = r.data[0]?.id;
+        checks[method] = {
+          status: "PASS",
+          ...Array.isArray(r.data) ? { count: r.data.length, hasMore: !!r.nextCursor } : {},
+          ...method === "thread/read" ? { threadStatus: r.thread.status?.type ?? null } : {}
+        };
+      } catch (e) {
+        if (method === "thread/items/list" && e instanceof RpcError && e.code === -32601) {
+          try {
+            const page2 = await rpc.call("thread/turns/list", { threadId, limit: 1, sortDirection: "desc", itemsView: "full" });
+            if (!Array.isArray(page2.data) || page2.data.some((turn) => turn.itemsView && turn.itemsView !== "full")) throw Error("FULL_TURN_ITEMS_UNAVAILABLE");
+            checks[method] = { status: "PASS", nativeStatus: "UNSUPPORTED", fallback: "thread/turns/list:full", count: page2.data.reduce((n, t) => n + (t.items?.length ?? 0), 0), hasMore: !!page2.nextCursor };
+            mark(method + " bounded fallback");
+            continue;
+          } catch {
+          }
+        }
+        checks[method] = {
+          status: "FAIL",
+          code: e instanceof RpcError ? e.code : e instanceof Error ? e.message : "UNAVAILABLE"
+        };
+      }
+      mark(method);
+    }
+  } finally {
+    bar.stop();
+    rpc?.close();
+    persist();
+    console.log(JSON.stringify(result, null, 2));
+  }
+  if (Object.values(checks).some((check) => check.status === "FAIL"))
+    throw new Error("Codex probe failed; inspect the check report");
+  return result;
+}
+
+// src/config.ts
+import { z as z4 } from "zod";
+import {
+  readFile as readFile2,
+  writeFile,
+  rename,
+  stat,
+  mkdir,
+  realpath
+} from "node:fs/promises";
+import { dirname as dirname2, resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+
+// sdk/src/node.ts
+import { readFile } from "node:fs/promises";
+
+// sdk/wasm/pkg/web_codex_noise.js
+var wasm;
+var cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachedUint8ArrayMemory0;
+}
+function getArrayU8FromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+function addToExternrefTable0(obj2) {
+  const idx = wasm.__externref_table_alloc();
+  wasm.__wbindgen_export_2.set(idx, obj2);
+  return idx;
+}
+function handleError(f, args) {
+  try {
+    return f.apply(this, args);
+  } catch (e) {
+    const idx = addToExternrefTable0(e);
+    wasm.__wbindgen_exn_store(idx);
+  }
+}
+var cachedTextDecoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-8", { ignoreBOM: true, fatal: true }) : { decode: () => {
+  throw Error("TextDecoder not available");
+} };
+if (typeof TextDecoder !== "undefined") {
+  cachedTextDecoder.decode();
+}
+function getStringFromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+function takeFromExternrefTable0(idx) {
+  const value = wasm.__wbindgen_export_2.get(idx);
+  wasm.__externref_table_dealloc(idx);
+  return value;
+}
+function generate_identity() {
+  const ret = wasm.generate_identity();
+  if (ret[3]) {
+    throw takeFromExternrefTable0(ret[2]);
+  }
+  var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+  wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+  return v1;
+}
+var WASM_VECTOR_LEN = 0;
+function passArray8ToWasm0(arg, malloc) {
+  const ptr = malloc(arg.length * 1, 1) >>> 0;
+  getUint8ArrayMemory0().set(arg, ptr / 1);
+  WASM_VECTOR_LEN = arg.length;
+  return ptr;
+}
+var CipherPairFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_cipherpair_free(ptr >>> 0, 1));
+var CipherPair = class _CipherPair {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj2 = Object.create(_CipherPair.prototype);
+    obj2.__wbg_ptr = ptr;
+    CipherPairFinalization.register(obj2, obj2.__wbg_ptr, obj2);
+    return obj2;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    CipherPairFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_cipherpair_free(ptr, 0);
+  }
+  /**
+   * @returns {RecordCipher}
+   */
+  take_send() {
+    const ret = wasm.cipherpair_take_send(this.__wbg_ptr);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return RecordCipher.__wrap(ret[0]);
+  }
+  /**
+   * @returns {RecordCipher}
+   */
+  take_recv() {
+    const ret = wasm.cipherpair_take_recv(this.__wbg_ptr);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return RecordCipher.__wrap(ret[0]);
+  }
+};
+var HandshakeFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_handshake_free(ptr >>> 0, 1));
+var Handshake = class {
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    HandshakeFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_handshake_free(ptr, 0);
+  }
+  /**
+   * @param {boolean} initiator
+   * @param {Uint8Array} prologue
+   * @param {Uint8Array} private_key
+   */
+  constructor(initiator, prologue2, private_key) {
+    const ptr0 = passArray8ToWasm0(prologue2, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(private_key, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.handshake_new(initiator, ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    this.__wbg_ptr = ret[0] >>> 0;
+    HandshakeFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * @returns {number}
+   */
+  action() {
+    const ret = wasm.handshake_action(this.__wbg_ptr);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0] >>> 0;
+  }
+  /**
+   * @param {Uint8Array} payload
+   * @returns {Uint8Array}
+   */
+  write(payload) {
+    const ptr0 = passArray8ToWasm0(payload, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.handshake_write(this.__wbg_ptr, ptr0, len0);
+    if (ret[3]) {
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+  }
+  /**
+   * @param {Uint8Array} message
+   * @returns {Uint8Array}
+   */
+  read(message) {
+    const ptr0 = passArray8ToWasm0(message, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.handshake_read(this.__wbg_ptr, ptr0, len0);
+    if (ret[3]) {
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+  }
+  /**
+   * @returns {Uint8Array}
+   */
+  hash() {
+    const ret = wasm.handshake_hash(this.__wbg_ptr);
+    if (ret[3]) {
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
+  /**
+   * @returns {Uint8Array}
+   */
+  remote_key() {
+    const ret = wasm.handshake_remote_key(this.__wbg_ptr);
+    if (ret[3]) {
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
+  /**
+   * @returns {CipherPair}
+   */
+  split() {
+    const ret = wasm.handshake_split(this.__wbg_ptr);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return CipherPair.__wrap(ret[0]);
+  }
+};
+var RecordCipherFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_recordcipher_free(ptr >>> 0, 1));
+var RecordCipher = class _RecordCipher {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj2 = Object.create(_RecordCipher.prototype);
+    obj2.__wbg_ptr = ptr;
+    RecordCipherFinalization.register(obj2, obj2.__wbg_ptr, obj2);
+    return obj2;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    RecordCipherFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_recordcipher_free(ptr, 0);
+  }
+  /**
+   * @param {Uint8Array} ad
+   * @param {Uint8Array} plaintext
+   * @returns {Uint8Array}
+   */
+  encrypt(ad, plaintext) {
+    const ptr0 = passArray8ToWasm0(ad, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(plaintext, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.recordcipher_encrypt(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+    if (ret[3]) {
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v3;
+  }
+  /**
+   * @param {Uint8Array} ad
+   * @param {Uint8Array} ciphertext
+   * @returns {Uint8Array}
+   */
+  decrypt(ad, ciphertext) {
+    const ptr0 = passArray8ToWasm0(ad, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(ciphertext, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.recordcipher_decrypt(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+    if (ret[3]) {
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v3;
+  }
+};
+async function __wbg_load(module, imports) {
+  if (typeof Response === "function" && module instanceof Response) {
+    if (typeof WebAssembly.instantiateStreaming === "function") {
+      try {
+        return await WebAssembly.instantiateStreaming(module, imports);
+      } catch (e) {
+        if (module.headers.get("Content-Type") != "application/wasm") {
+          console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+        } else {
+          throw e;
+        }
+      }
+    }
+    const bytes = await module.arrayBuffer();
+    return await WebAssembly.instantiate(bytes, imports);
+  } else {
+    const instance = await WebAssembly.instantiate(module, imports);
+    if (instance instanceof WebAssembly.Instance) {
+      return { instance, module };
+    } else {
+      return instance;
+    }
+  }
+}
+function __wbg_get_imports() {
+  const imports = {};
+  imports.wbg = {};
+  imports.wbg.__wbg_getRandomValues_1c61fac11405ffdc = function() {
+    return handleError(function(arg0, arg1) {
+      globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+    }, arguments);
+  };
+  imports.wbg.__wbindgen_init_externref_table = function() {
+    const table = wasm.__wbindgen_export_2;
+    const offset = table.grow(4);
+    table.set(0, void 0);
+    table.set(offset + 0, void 0);
+    table.set(offset + 1, null);
+    table.set(offset + 2, true);
+    table.set(offset + 3, false);
+    ;
+  };
+  imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
+    const ret = getStringFromWasm0(arg0, arg1);
+    return ret;
+  };
+  imports.wbg.__wbindgen_throw = function(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+  };
+  return imports;
+}
+function __wbg_init_memory(imports, memory) {
+}
+function __wbg_finalize_init(instance, module) {
+  wasm = instance.exports;
+  __wbg_init.__wbindgen_wasm_module = module;
+  cachedUint8ArrayMemory0 = null;
+  wasm.__wbindgen_start();
+  return wasm;
+}
+function initSync(module) {
+  if (wasm !== void 0) return wasm;
+  if (typeof module !== "undefined") {
+    if (Object.getPrototypeOf(module) === Object.prototype) {
+      ({ module } = module);
+    } else {
+      console.warn("using deprecated parameters for `initSync()`; pass a single object instead");
+    }
+  }
+  const imports = __wbg_get_imports();
+  __wbg_init_memory(imports);
+  if (!(module instanceof WebAssembly.Module)) {
+    module = new WebAssembly.Module(module);
+  }
+  const instance = new WebAssembly.Instance(module, imports);
+  return __wbg_finalize_init(instance, module);
+}
+async function __wbg_init(module_or_path) {
+  if (wasm !== void 0) return wasm;
+  if (typeof module_or_path !== "undefined") {
+    if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+      ({ module_or_path } = module_or_path);
+    } else {
+      console.warn("using deprecated parameters for the initialization function; pass a single object instead");
+    }
+  }
+  if (typeof module_or_path === "undefined") {
+    module_or_path = new URL("web_codex_noise_bg.wasm", import.meta.url);
+  }
+  const imports = __wbg_get_imports();
+  if (typeof module_or_path === "string" || typeof Request === "function" && module_or_path instanceof Request || typeof URL === "function" && module_or_path instanceof URL) {
+    module_or_path = fetch(module_or_path);
+  }
+  __wbg_init_memory(imports);
+  const { instance, module } = await __wbg_load(await module_or_path, imports);
+  return __wbg_finalize_init(instance, module);
+}
+
+// sdk/src/relay.ts
+import { z } from "zod";
+var MAX_FRAME_BYTES = 128 * 1024;
+var MAX_MESSAGE_BYTES = 1024 * 1024;
+var CHUNK_BYTES = 32 * 1024;
+var SUITE = "Noise_XX_25519_AESGCM_SHA256";
+var id = z.string().min(1).max(256);
+var decimal = z.string().regex(/^(0|[1-9][0-9]{0,19})$/);
+var secureFrameSchema = z.strictObject({
+  type: z.literal("secure"),
+  wireVersion: z.literal(1),
+  routeId: id,
+  sessionId: z.string().regex(/^[A-Za-z0-9_-]{22,128}$/),
+  phase: z.enum(["handshake", "transport"]),
+  direction: z.enum(["browserToClient", "clientToBrowser"]),
+  recordNo: decimal,
+  payload: z.string().max(9e4).regex(/^[A-Za-z0-9_-]*$/)
+});
+function decodeFrame(text) {
+  if (new TextEncoder().encode(text).length > MAX_FRAME_BYTES)
+    throw Error("FRAME_TOO_LARGE");
+  return secureFrameSchema.parse(JSON.parse(text));
+}
+function encodeFrame(frame) {
+  const text = JSON.stringify(secureFrameSchema.parse(frame));
+  if (new TextEncoder().encode(text).length > MAX_FRAME_BYTES)
+    throw Error("FRAME_TOO_LARGE");
+  return text;
+}
+var utf8 = (s) => new TextEncoder().encode(s);
+function prologue(c) {
+  return utf8(
+    JSON.stringify([
+      "web-codex",
+      1,
+      SUITE,
+      c.deviceId,
+      c.routeId,
+      c.sessionId,
+      "browser:initiator",
+      "client:responder"
+    ])
+  );
+}
+function aad(f) {
+  return utf8(
+    JSON.stringify([
+      "secure",
+      f.wireVersion,
+      f.routeId,
+      f.sessionId,
+      f.phase,
+      f.direction,
+      f.recordNo
+    ])
+  );
+}
+
+// sdk/src/wasm-integrity.ts
+var WASM_SHA256 = "1ac97442f8b0fd8ef20b31d46d2e4cbc30b6d877346f0cf2438eb08026330490";
+
+// sdk/src/noise-provider.ts
+async function initializeNoise(bytes) {
+  const digest = Array.from(new Uint8Array(await crypto.subtle.digest("SHA-256", new Uint8Array(bytes))), (n) => n.toString(16).padStart(2, "0")).join("");
+  if (digest !== WASM_SHA256) throw Error("CRYPTO_ARTIFACT_MISMATCH");
+  initSync({ module: bytes });
+  return {
+    constants: { NOISE_DH_CURVE25519: 1, NOISE_ROLE_INITIATOR: 1, NOISE_ROLE_RESPONDER: 2, NOISE_ACTION_WRITE_MESSAGE: 1, NOISE_ACTION_READ_MESSAGE: 2, NOISE_ACTION_SPLIT: 3 },
+    CreateKeyPair(algorithm) {
+      if (algorithm !== 1) throw Error("UNSUPPORTED_SUITE");
+      const keys = generate_identity();
+      try {
+        return [keys.slice(0, 32), keys.slice(32)];
+      } finally {
+        keys.fill(0);
+      }
+    },
+    HandshakeState: class {
+      constructor(suite, role) {
+        this.role = role;
+        if (suite !== SUITE || ![1, 2].includes(role)) throw Error("UNSUPPORTED_SUITE");
+      }
+      inner;
+      Initialize(prologue2, key) {
+        if (this.inner) throw Error("HANDSHAKE_STATE");
+        this.inner = new Handshake(this.role === 1, prologue2, key);
+      }
+      get state() {
+        if (!this.inner) throw Error("HANDSHAKE_STATE");
+        return this.inner;
+      }
+      WriteMessage() {
+        return this.state.write(new Uint8Array());
+      }
+      ReadMessage(message) {
+        return this.state.read(message);
+      }
+      GetAction() {
+        return this.state.action();
+      }
+      GetHandshakeHash() {
+        return this.state.hash();
+      }
+      GetRemotePublicKey() {
+        return this.state.remote_key();
+      }
+      Split() {
+        const pair = this.state.split();
+        try {
+          const wrap = (c) => ({ EncryptWithAd: (ad, p) => c.encrypt(ad, p), DecryptWithAd: (ad, cipher) => c.decrypt(ad, cipher), free: () => c.free() });
+          return [wrap(pair.take_send()), wrap(pair.take_recv())];
+        } finally {
+          pair.free();
+          this.free();
+        }
+      }
+      free() {
+        this.inner?.free();
+        this.inner = void 0;
+      }
+    }
+  };
+}
+
+// sdk/src/types.ts
+import { z as z2 } from "zod";
+var obj = z2.record(z2.string(), z2.unknown());
+var page = {
+  cursor: id.nullable().optional(),
+  limit: z2.number().int().min(1).max(100).default(40)
+};
+var thread = { threadId: id };
+var methodSchemas = {
+  "bridge.capabilities": z2.strictObject({}),
+  "projects.list": z2.strictObject(page),
+  "projects.read": z2.strictObject({ projectId: id }),
+  "threads.list": z2.strictObject({
+    ...page,
+    projectId: id,
+    archived: z2.boolean().default(false),
+    sourceKinds: z2.array(
+      z2.enum([
+        "cli",
+        "vscode",
+        "exec",
+        "appServer",
+        "subAgent",
+        "subAgentReview",
+        "subAgentCompact",
+        "subAgentThreadSpawn",
+        "subAgentOther",
+        "unknown"
+      ])
+    ).max(10).optional()
+  }),
+  "threads.read": z2.strictObject(thread),
+  "turns.list": z2.strictObject({ ...thread, ...page }),
+  "items.list": z2.strictObject({ ...thread, ...page, turnId: id.optional() }),
+  "threads.subscribe": z2.strictObject(thread),
+  "threads.unsubscribe": z2.strictObject({ subscriptionId: id }),
+  "subscriptions.resume": z2.strictObject({
+    subscriptionId: id,
+    connectionEpoch: id,
+    eventSeq: decimal
+  }),
+  "threads.start": z2.strictObject({ projectId: id, connectionEpoch: id }),
+  "threads.resume": z2.strictObject({ ...thread, connectionEpoch: id }),
+  "turns.start": z2.strictObject({
+    ...thread,
+    connectionEpoch: id,
+    text: z2.string().min(1).max(128 * 1024)
+  }),
+  "turns.interrupt": z2.strictObject({
+    ...thread,
+    turnId: id,
+    connectionEpoch: id
+  }),
+  "leases.acquire": z2.strictObject({
+    ...thread,
+    takeover: z2.boolean().default(false)
+  }),
+  "leases.release": z2.strictObject(thread),
+  "files.list": z2.strictObject({
+    projectId: id,
+    path: z2.string().max(4096).default(".")
+  }),
+  "files.open": z2.strictObject({
+    projectId: id,
+    path: z2.string().min(1).max(4096)
+  }),
+  "resources.read": z2.strictObject({
+    resourceId: id,
+    offset: z2.number().int().nonnegative(),
+    length: z2.number().int().min(1).max(32 * 1024)
+  }),
+  "resources.close": z2.strictObject({ resourceId: id })
+};
+var errorSchema = z2.strictObject({
+  code: id,
+  message: z2.string().max(4096),
+  retryable: z2.boolean()
+});
+var messageSchema = z2.union([
+  z2.strictObject({
+    kind: z2.literal("request"),
+    requestId: id,
+    method: z2.enum(Object.keys(methodSchemas)),
+    params: obj
+  }),
+  z2.strictObject({
+    kind: z2.literal("response"),
+    requestId: id,
+    result: z2.unknown()
+  }),
+  z2.strictObject({
+    kind: z2.literal("response"),
+    requestId: id,
+    error: errorSchema
+  }),
+  z2.strictObject({
+    kind: z2.literal("event"),
+    connectionEpoch: id,
+    subscriptionId: id,
+    eventSeq: decimal,
+    event: id,
+    payload: z2.unknown()
+  }),
+  z2.strictObject({
+    kind: z2.literal("serverRequest"),
+    serverRequestId: id,
+    method: z2.enum(["approvals.request", "userInput.request"]),
+    params: obj
+  }),
+  z2.strictObject({
+    kind: z2.literal("serverResponse"),
+    serverRequestId: id,
+    result: obj
+  }),
+  z2.strictObject({
+    kind: z2.literal("pairing"),
+    status: z2.enum(["pending", "confirmed", "ready", "rejected"]),
+    fingerprint: z2.string().regex(/^[a-f0-9]{64}$/)
+  }),
+  z2.strictObject({
+    kind: z2.literal("ack"),
+    subscriptionId: id,
+    connectionEpoch: id,
+    eventSeq: decimal
+  })
+]);
+function parseMessage(value) {
+  const m = messageSchema.parse(value);
+  if (m.kind === "request") methodSchemas[m.method].parse(m.params);
+  return m;
+}
+function encodeMessage(value) {
+  const bytes = new TextEncoder().encode(JSON.stringify(parseMessage(value)));
+  if (bytes.length > MAX_MESSAGE_BYTES) throw Error("RESOURCE_TOO_LARGE");
+  return bytes;
+}
+var opaque = z2.object({ id: z2.string() }).passthrough();
+var projectDto = z2.strictObject({
+  id: z2.string(),
+  name: z2.string(),
+  cwd: z2.string(),
+  source: z2.enum(["codex", "derived"])
+});
+var pageOf = (entry) => z2.object({
+  data: z2.array(entry),
+  nextCursor: z2.string().nullable(),
+  source: z2.enum(["codex", "bounded-fallback"]).optional()
+}).passthrough();
+var resultSchemas = {
+  "bridge.capabilities": z2.object({
+    connectionEpoch: id,
+    codexAvailable: z2.boolean(),
+    codexVersion: z2.string(),
+    methods: z2.array(z2.string()),
+    limits: z2.strictObject({
+      frameBytes: z2.number(),
+      messageBytes: z2.number(),
+      chunkBytes: z2.number()
+    }),
+    historyFallback: z2.literal("bounded"),
+    activeTakeover: z2.literal("unverified")
+  }),
+  "projects.list": pageOf(projectDto),
+  "projects.read": z2.strictObject({ project: projectDto }),
+  "threads.list": pageOf(opaque),
+  "threads.read": z2.object({ thread: opaque }),
+  "turns.list": pageOf(opaque),
+  "items.list": pageOf(
+    z2.object({
+      turnId: id,
+      item: z2.object({ id, type: id }).passthrough()
+    })
+  ),
+  "threads.subscribe": z2.object({
+    subscriptionId: id,
+    connectionEpoch: id,
+    eventSeq: decimal,
+    snapshotPolicy: z2.literal("reload-complete-item-on-delta")
+  }),
+  "subscriptions.resume": z2.object({
+    subscriptionId: id,
+    connectionEpoch: id,
+    eventSeq: decimal
+  }),
+  "threads.unsubscribe": z2.strictObject({}),
+  "threads.start": z2.object({ thread: opaque }).passthrough(),
+  "threads.resume": z2.object({ thread: opaque }).passthrough(),
+  "turns.start": z2.object({ turn: opaque }).passthrough(),
+  "turns.interrupt": z2.strictObject({}),
+  "leases.acquire": z2.object({
+    threadId: id,
+    holder: id,
+    expiresAt: z2.number()
+  }),
+  "leases.release": z2.strictObject({}),
+  "files.list": pageOf(
+    z2.strictObject({
+      name: z2.string(),
+      type: z2.enum(["file", "directory", "symlink", "other"])
+    })
+  ),
+  "files.open": z2.strictObject({
+    resourceId: id,
+    name: z2.string(),
+    size: z2.number().int().nonnegative(),
+    mime: z2.string(),
+    expiresAt: z2.number()
+  }),
+  "resources.read": z2.strictObject({
+    resourceId: id,
+    offset: z2.number().int().nonnegative(),
+    data: z2.string(),
+    sha256: z2.string().regex(/^[a-f0-9]{64}$/),
+    eof: z2.boolean()
+  }),
+  "resources.close": z2.strictObject({})
+};
+
+// sdk/src/secure.ts
+import { z as z3 } from "zod";
+var b64 = (b) => {
+  let s = "";
+  for (let i = 0; i < b.length; i += 8192)
+    s += String.fromCharCode(...b.subarray(i, i + 8192));
+  return btoa(s).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+};
+function unb64(s) {
+  if (!/^[A-Za-z0-9_-]*$/.test(s)) throw Error("BASE64");
+  const b = Uint8Array.from(
+    atob(s.replaceAll("-", "+").replaceAll("_", "/")),
+    (c) => c.charCodeAt(0)
+  );
+  if (b64(b) !== s) throw Error("BASE64");
+  return b;
+}
+var hex = (b) => Array.from(b, (n) => n.toString(16).padStart(2, "0")).join("");
+var randomId = () => b64(crypto.getRandomValues(new Uint8Array(24)));
+function createIdentity(noise) {
+  const [privateKey, publicKey] = noise.CreateKeyPair(
+    noise.constants.NOISE_DH_CURVE25519
+  );
+  return { privateKey, publicKey };
+}
+var fragment = z3.strictObject({
+  id: z3.string().min(1).max(64),
+  index: z3.number().int().min(0).max(31),
+  total: z3.number().int().min(1).max(32),
+  size: z3.number().int().min(1).max(MAX_MESSAGE_BYTES),
+  data: z3.string().max(44e3)
+});
+var SecureSession = class {
+  constructor(noise, role, context, identity, pinnedPeer) {
+    this.noise = noise;
+    this.role = role;
+    this.context = context;
+    this.pinnedPeer = pinnedPeer;
+    if (identity.privateKey.length !== 32) throw Error("IDENTITY");
+    this.hs = new noise.HandshakeState(
+      SUITE,
+      noise.constants[role === "browser" ? "NOISE_ROLE_INITIATOR" : "NOISE_ROLE_RESPONDER"]
+    );
+    this.hs.Initialize(prologue(context), identity.privateKey);
+  }
+  hs;
+  sendCipher;
+  recvCipher;
+  sendHs = 0n;
+  recvHs = 0n;
+  sendNo = 0n;
+  recvNo = 0n;
+  sent = 0;
+  received = 0;
+  born = Date.now();
+  closed = false;
+  fragmentTimer;
+  incoming;
+  fingerprint = "";
+  peerPublicKey = "";
+  ready = false;
+  trusted = false;
+  guard() {
+    if (this.closed) throw Error("SESSION_CLOSED");
+    if (Date.now() - this.born > 36e5 || this.sent >= 2 ** 30 || this.received >= 2 ** 30) {
+      this.close();
+      throw Error("SESSION_ROTATE");
+    }
+  }
+  header(phase, n) {
+    return {
+      type: "secure",
+      wireVersion: 1,
+      ...{ routeId: this.context.routeId, sessionId: this.context.sessionId },
+      phase,
+      direction: this.role === "browser" ? "browserToClient" : "clientToBrowser",
+      recordNo: String(n)
+    };
+  }
+  finish() {
+    if (this.hs?.GetAction() !== this.noise.constants.NOISE_ACTION_SPLIT)
+      return;
+    this.fingerprint = hex(this.hs.GetHandshakeHash());
+    this.peerPublicKey = b64(this.hs.GetRemotePublicKey());
+    if (this.pinnedPeer && this.pinnedPeer !== this.peerPublicKey)
+      throw Error("PEER_KEY_CHANGED");
+    [this.sendCipher, this.recvCipher] = this.hs.Split();
+    this.hs = void 0;
+    this.ready = true;
+    this.trusted = !!this.pinnedPeer;
+  }
+  writeHandshake() {
+    const payload = this.hs.WriteMessage();
+    const f = {
+      ...this.header("handshake", this.sendHs++),
+      payload: b64(payload)
+    };
+    this.finish();
+    return f;
+  }
+  start() {
+    this.guard();
+    if (this.role !== "browser" || this.sendHs !== 0n)
+      throw Error("HANDSHAKE_STATE");
+    return this.writeHandshake();
+  }
+  receiveHandshake(value) {
+    try {
+      this.guard();
+      const f = this.validate(value, "handshake", this.recvHs);
+      if (!this.hs) throw Error("HANDSHAKE_STATE");
+      const payload = this.hs.ReadMessage(unb64(f.payload), true);
+      if (payload?.length) throw Error("EARLY_DATA");
+      this.recvHs++;
+      if (this.hs.GetAction() === this.noise.constants.NOISE_ACTION_WRITE_MESSAGE)
+        return this.writeHandshake();
+      this.finish();
+      return void 0;
+    } catch (e) {
+      this.close();
+      throw e;
+    }
+  }
+  trust(fingerprint) {
+    if (!this.ready || fingerprint !== this.fingerprint)
+      throw Error("FINGERPRINT_MISMATCH");
+    this.trusted = true;
+  }
+  validate(value, phase, n) {
+    const f = secureFrameSchema.parse(value);
+    if (f.routeId !== this.context.routeId || f.sessionId !== this.context.sessionId || f.phase !== phase || f.recordNo !== String(n) || f.direction === (this.role === "browser" ? "browserToClient" : "clientToBrowser"))
+      throw Error("RECORD_MISMATCH");
+    return f;
+  }
+  *seal(message) {
+    this.guard();
+    if (!this.ready || !this.trusted && message.kind !== "pairing")
+      throw Error("NOT_PAIRED");
+    const bytes = encodeMessage(message);
+    const total = Math.ceil(bytes.length / CHUNK_BYTES);
+    const id2 = randomId();
+    for (let index = 0; index < total; index++) {
+      this.guard();
+      const body = new TextEncoder().encode(
+        JSON.stringify({
+          id: id2,
+          index,
+          total,
+          size: bytes.length,
+          data: b64(
+            bytes.subarray(index * CHUNK_BYTES, (index + 1) * CHUNK_BYTES)
+          )
+        })
+      );
+      const h = this.header("transport", this.sendNo);
+      try {
+        const cipher = this.sendCipher.EncryptWithAd(aad(h), body);
+        this.sendNo++;
+        this.sent += cipher.length;
+        yield { ...h, payload: b64(cipher) };
+      } catch (e) {
+        this.close();
+        throw e;
+      }
+    }
+  }
+  open(value) {
+    try {
+      this.guard();
+      if (!this.ready) throw Error("HANDSHAKE_REQUIRED");
+      const f = this.validate(value, "transport", this.recvNo);
+      const cipher = unb64(f.payload);
+      const clear = this.recvCipher.DecryptWithAd(aad(f), cipher);
+      this.recvNo++;
+      this.received += cipher.length;
+      const p = fragment.parse(
+        JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(clear))
+      );
+      if (!this.incoming) {
+        if (p.index !== 0) throw Error("FRAGMENT_ORDER");
+        this.incoming = {
+          id: p.id,
+          total: p.total,
+          size: p.size,
+          index: 0,
+          bytes: 0,
+          parts: [],
+          deadline: Date.now() + 15e3
+        };
+        this.fragmentTimer = setTimeout(() => this.close(), 15e3);
+      }
+      const m = this.incoming;
+      if (Date.now() > m.deadline || p.id !== m.id || p.total !== m.total || p.size !== m.size || p.index !== m.index)
+        throw Error("FRAGMENT_ORDER");
+      const chunk = unb64(p.data);
+      if (chunk.length > CHUNK_BYTES || p.index < p.total - 1 && chunk.length !== CHUNK_BYTES)
+        throw Error("FRAGMENT_SIZE");
+      m.bytes += chunk.length;
+      if (m.bytes > m.size) throw Error("FRAGMENT_SIZE");
+      m.parts.push(chunk);
+      m.index++;
+      if (m.index !== m.total) return;
+      if (m.bytes !== m.size) throw Error("FRAGMENT_TRUNCATED");
+      const out = new Uint8Array(m.bytes);
+      let offset = 0;
+      for (const part of m.parts) {
+        out.set(part, offset);
+        offset += part.length;
+      }
+      this.incoming = void 0;
+      clearTimeout(this.fragmentTimer);
+      this.fragmentTimer = void 0;
+      const message = parseMessage(
+        JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(out))
+      );
+      if (!this.trusted && message.kind !== "pairing")
+        throw Error("NOT_PAIRED");
+      return message;
+    } catch (e) {
+      this.close();
+      throw e;
+    }
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    clearTimeout(this.fragmentTimer);
+    this.fragmentTimer = void 0;
+    this.hs?.free();
+    this.hs = void 0;
+    this.sendCipher?.free();
+    this.recvCipher?.free();
+    this.sendCipher = this.recvCipher = void 0;
+    this.incoming = void 0;
+    this.trusted = false;
+  }
+};
+
+// sdk/src/node.ts
+var pending;
+function loadNoise() {
+  return pending ??= (async () => {
+    const file = import.meta.url.endsWith("/src/node.ts") ? new URL("../dist/assets/noise.wasm", import.meta.url) : new URL("./assets/noise.wasm", import.meta.url);
+    return initializeNoise(new Uint8Array(await readFile(file)));
+  })().catch((error) => {
+    pending = void 0;
+    throw error;
+  });
+}
+
+// src/config.ts
+var configSchema = z4.strictObject({
+  relayUrl: z4.url().refine((s) => {
+    if (!URL.canParse(s)) return false;
+    const u = new URL(s);
+    return u.protocol === "wss:" && !u.username && !u.password && !u.search && !u.hash && u.pathname === "/";
+  }, "Relay requires WSS without URL credentials"),
+  deviceTokenFile: z4.string(),
+  stateDir: z4.string(),
+  experimentalCrypto: z4.literal(true).optional(),
+  cryptoPolicy: z4.enum(["local-reviewed-v1", "remote-wss-v1"]).optional(),
+  upstream: z4.strictObject({
+    mode: z4.enum(["proxy", "stdio", "websocket", "unix"]).default("unix"),
+    socket: z4.string().optional(),
+    url: z4.string().optional(),
+    codexHome: z4.string().optional(),
+    binary: z4.string().optional()
+  })
+}).superRefine((c, ctx) => {
+  if (c.cryptoPolicy === "local-reviewed-v1") {
+    if (!URL.canParse(c.relayUrl) || !["localhost", "127.0.0.1", "[::1]"].includes(new URL(c.relayUrl).hostname))
+      ctx.addIssue({ code: "custom", message: "Local crypto policy requires a loopback relay" });
+  } else if (c.cryptoPolicy !== "remote-wss-v1" && !c.experimentalCrypto) {
+    ctx.addIssue({ code: "custom", message: "Select local-reviewed-v1 or remote-wss-v1 explicitly" });
+  }
+});
+async function privateRead(path) {
+  const s = await stat(path);
+  if ((s.mode & 63) !== 0 || s.uid !== process.getuid?.())
+    throw Error("PRIVATE_FILE_PERMISSIONS");
+  return readFile2(path, "utf8");
+}
+async function atomicPrivate(path, value) {
+  await mkdir(dirname2(path), { recursive: true, mode: 448 });
+  const tmp = path + "." + randomUUID();
+  await writeFile(tmp, JSON.stringify(value, null, 2) + "\n", {
+    mode: 384,
+    flag: "wx"
+  });
+  await rename(tmp, path);
+}
+async function readConfig(path) {
+  const c = configSchema.parse(JSON.parse(await readFile2(path, "utf8")));
+  const base = dirname2(resolve(path));
+  c.stateDir = resolve(base, c.stateDir);
+  c.deviceTokenFile = resolve(base, c.deviceTokenFile);
+  return c;
+}
+async function loadState(dir) {
+  await mkdir(dir, { recursive: true, mode: 448 });
+  const s = await stat(dir);
+  if ((s.mode & 63) !== 0 || s.uid !== process.getuid?.())
+    throw Error("STATE_DIRECTORY_PERMISSIONS");
+  const path = dir + "/identity.json";
+  let identity;
+  try {
+    const data = JSON.parse(await privateRead(path));
+    identity = {
+      privateKey: unb64(data.privateKey),
+      publicKey: unb64(data.publicKey)
+    };
+    if (identity.privateKey.length !== 32 || identity.publicKey.length !== 32)
+      throw Error("IDENTITY");
+  } catch (e) {
+    if (e.code !== "ENOENT") throw e;
+    identity = createIdentity(await loadNoise());
+    await atomicPrivate(path, {
+      privateKey: b64(identity.privateKey),
+      publicKey: b64(identity.publicKey)
+    });
+  }
+  let list = [];
+  try {
+    list = z4.array(
+      z4.strictObject({
+        peer: z4.string(),
+        roots: z4.array(z4.string()).min(1).max(32),
+        write: z4.boolean()
+      })
+    ).max(256).parse(JSON.parse(await privateRead(dir + "/grants.json")));
+  } catch (e) {
+    if (e.code !== "ENOENT") throw e;
+  }
+  for (const g of list)
+    g.roots = await Promise.all(g.roots.map((r) => realpath(r)));
+  return { identity, grants: new Map(list.map((g) => [g.peer, g])) };
+}
+
+// src/daemon.ts
+import WebSocket2 from "ws";
+import {
+  createServer,
+  createConnection
+} from "node:net";
+import { chmod, realpath as realpath3, unlink, lstat as lstat2 } from "node:fs/promises";
+import { z as z5 } from "zod";
+
+// src/bridge.ts
+import { randomUUID as randomUUID4 } from "node:crypto";
+import { basename as basename2 } from "node:path";
+
+// src/files.ts
+import { realpath as realpath2, open, opendir } from "node:fs/promises";
+import { constants } from "node:fs";
+import { resolve as resolve2, relative, basename, extname, isAbsolute } from "node:path";
+import { createHash, randomUUID as randomUUID2 } from "node:crypto";
+function within(root, path) {
+  const rel = relative(root, path);
+  return rel === "" || !rel.startsWith("../") && rel !== ".." && !isAbsolute(rel);
+}
+async function authorizedPath(roots, path) {
+  const actual = await realpath2(path).catch(() => {
+    throw new BridgeError("NOT_FOUND");
+  });
+  if (!roots.some((r) => within(r, actual))) throw new BridgeError("FORBIDDEN");
+  return actual;
+}
+var FileResources = class {
+  handles = /* @__PURE__ */ new Map();
+  async list(roots, cwd, path) {
+    const target = await authorizedPath(roots, resolve2(cwd, path));
+    const dir = await opendir(target);
+    const entries = [];
+    for await (const entry of dir) {
+      if (entries.length >= 1e3)
+        throw new BridgeError(
+          "RESOURCE_TOO_LARGE",
+          "Directory exceeds 1000 entries"
+        );
+      entries.push({
+        name: entry.name,
+        type: entry.isDirectory() ? "directory" : entry.isSymbolicLink() ? "symlink" : entry.isFile() ? "file" : "other"
+      });
+    }
+    await authorizedPath(roots, target);
+    return {
+      data: entries.sort((a, b) => a.name.localeCompare(b.name)),
+      nextCursor: null
+    };
+  }
+  async open(owner, roots, cwd, path) {
+    await this.expire();
+    if (this.handles.size >= 64) throw new BridgeError("BUSY");
+    const target = await authorizedPath(roots, resolve2(cwd, path));
+    const fd = await open(
+      target,
+      constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK
+    );
+    try {
+      const bound = await realpath2("/proc/self/fd/" + fd.fd);
+      if (!roots.some((r) => within(r, bound)))
+        throw new BridgeError("FORBIDDEN");
+      const s = await fd.stat();
+      if (!s.isFile()) throw new BridgeError("FORBIDDEN");
+      if (s.size > 64 * 1024 * 1024)
+        throw new BridgeError("RESOURCE_TOO_LARGE");
+      const resourceId = randomUUID2(), expiresAt = Date.now() + 6e4;
+      this.handles.set(resourceId, {
+        owner,
+        fd,
+        size: s.size,
+        mtime: s.mtimeMs,
+        ctime: s.ctimeMs,
+        expiresAt,
+        path: target,
+        roots
+      });
+      const mime = {
+        ".png": "image/png",
+        ".jpg": "image/jpeg",
+        ".jpeg": "image/jpeg",
+        ".webp": "image/webp",
+        ".gif": "image/gif",
+        ".txt": "text/plain",
+        ".md": "text/plain",
+        ".ts": "text/plain",
+        ".js": "text/plain",
+        ".json": "application/json"
+      };
+      return {
+        resourceId,
+        name: basename(target),
+        size: s.size,
+        mime: mime[extname(target)] ?? "application/octet-stream",
+        expiresAt
+      };
+    } catch (e) {
+      await fd.close();
+      throw e;
+    }
+  }
+  async get(owner, id2) {
+    await this.expire();
+    const h = this.handles.get(id2);
+    if (!h || h.owner !== owner) throw new BridgeError("NOT_FOUND");
+    return h;
+  }
+  async read(owner, id2, offset, length) {
+    const h = await this.get(owner, id2);
+    if (!Number.isSafeInteger(offset) || offset < 0 || !Number.isInteger(length) || length < 1 || length > 32768 || offset > h.size)
+      throw new BridgeError("FORBIDDEN");
+    const verify = async () => {
+      const s = await h.fd.stat();
+      const path = await realpath2("/proc/self/fd/" + h.fd.fd);
+      if (!h.roots.some((r) => within(r, path)))
+        throw new BridgeError("FORBIDDEN");
+      if (s.size !== h.size || s.mtimeMs !== h.mtime || s.ctimeMs !== h.ctime)
+        throw new BridgeError("RESOURCE_CHANGED");
+    };
+    try {
+      await verify();
+      const bytes = Buffer.alloc(Math.min(length, h.size - offset));
+      const { bytesRead } = await h.fd.read(bytes, 0, bytes.length, offset);
+      await verify();
+      if (bytesRead !== bytes.length) throw new BridgeError("RESOURCE_CHANGED");
+      return {
+        resourceId: id2,
+        offset,
+        data: bytes.toString("base64url"),
+        sha256: createHash("sha256").update(bytes).digest("hex"),
+        eof: offset + bytesRead === h.size
+      };
+    } catch (e) {
+      await this.close(owner, id2);
+      throw e;
+    }
+  }
+  async close(owner, id2) {
+    const h = this.handles.get(id2);
+    if (!h || h.owner !== owner) throw new BridgeError("NOT_FOUND");
+    this.handles.delete(id2);
+    await h.fd.close();
+    return {};
+  }
+  async closeOwner(owner) {
+    for (const [id2, h] of this.handles)
+      if (h.owner === owner) await this.close(owner, id2);
+  }
+  async expire() {
+    for (const [id2, h] of this.handles)
+      if (h.expiresAt < Date.now()) {
+        this.handles.delete(id2);
+        await h.fd.close();
+      }
+  }
+  async dispose() {
+    for (const h of this.handles.values()) await h.fd.close();
+    this.handles.clear();
+  }
+};
+
+// src/state.ts
+import { randomUUID as randomUUID3, createHash as createHash2 } from "node:crypto";
+var Leases = class {
+  map = /* @__PURE__ */ new Map();
+  acquire(thread2, owner, takeover = false) {
+    const old = this.map.get(thread2);
+    if (old && old.expires > Date.now() && old.owner !== owner && !takeover)
+      throw new BridgeError("BUSY");
+    if (this.map.size >= 1024 && !old) throw new BridgeError("BUSY");
+    this.map.set(thread2, { owner, expires: Date.now() + 3e5 });
+    return { threadId: thread2, holder: owner, expiresAt: Date.now() + 3e5 };
+  }
+  assert(thread2, owner) {
+    const l = this.map.get(thread2);
+    if (!l || l.owner !== owner || l.expires < Date.now())
+      throw new BridgeError("LEASE_REQUIRED");
+    l.expires = Date.now() + 3e5;
+  }
+  holder(thread2) {
+    const l = this.map.get(thread2);
+    return l && l.expires > Date.now() ? l.owner : void 0;
+  }
+  release(thread2, owner) {
+    this.assert(thread2, owner);
+    this.map.delete(thread2);
+    return {};
+  }
+  revoke(owner) {
+    for (const [k, l] of this.map) if (l.owner === owner) this.map.delete(k);
+  }
+  clear() {
+    this.map.clear();
+  }
+};
+var Dedup = class {
+  bytes = 0;
+  entries = /* @__PURE__ */ new Map();
+  run(owner, id2, body, fn) {
+    const key = owner + ":" + id2;
+    const digest = createHash2("sha256").update(JSON.stringify(body)).digest("hex");
+    const old = this.entries.get(key);
+    if (old) {
+      if (old.digest !== digest) throw new BridgeError("REQUEST_ID_REUSED");
+      return old.promise;
+    }
+    if (this.entries.size >= 2048 || this.bytes >= 8 * 1024 * 1024)
+      throw new BridgeError(
+        "BUSY",
+        "Dedup budget exhausted; reconnect after a deliberate client restart and reconcile outcomes"
+      );
+    const promise = Promise.resolve().then(fn).then((result) => {
+      const bytes = Buffer.byteLength(JSON.stringify(result));
+      if (bytes > 1024 * 1024 || this.bytes + bytes > 8 * 1024 * 1024)
+        throw new BridgeError(
+          "OUTCOME_UNKNOWN",
+          "Write executed; response exceeds retained dedup budget; reconcile upstream"
+        );
+      this.bytes += bytes;
+      return result;
+    });
+    this.entries.set(key, { digest, promise, at: Date.now() });
+    return promise;
+  }
+};
+var Subscriptions = class {
+  constructor(deliver) {
+    this.deliver = deliver;
+  }
+  epoch = randomUUID3();
+  subs = /* @__PURE__ */ new Map();
+  subscribe(owner, thread2) {
+    if (this.subs.size >= 128) throw new BridgeError("BUSY");
+    const subscriptionId = randomUUID3();
+    this.subs.set(subscriptionId, {
+      owner,
+      thread: thread2,
+      seq: 0n,
+      events: [],
+      bytes: 0,
+      floor: 0n,
+      at: Date.now()
+    });
+    return {
+      subscriptionId,
+      connectionEpoch: this.epoch,
+      eventSeq: "0",
+      snapshotPolicy: "reload-complete-item-on-delta"
+    };
+  }
+  unsubscribe(owner, id2) {
+    this.owned(owner, id2);
+    this.subs.delete(id2);
+    return {};
+  }
+  owned(owner, id2) {
+    const s = this.subs.get(id2);
+    if (!s || s.owner !== owner) throw new BridgeError("RESYNC_REQUIRED");
+    return s;
+  }
+  emit(thread2, event, payload) {
+    for (const [id2, s] of this.subs) {
+      if (s.thread !== thread2) continue;
+      const e = {
+        kind: "event",
+        connectionEpoch: this.epoch,
+        subscriptionId: id2,
+        eventSeq: String(++s.seq),
+        event,
+        payload
+      };
+      const size = Buffer.byteLength(JSON.stringify(e));
+      if (size > 512 * 1024) {
+        s.events = [];
+        s.bytes = 0;
+        s.floor = s.seq;
+        this.deliver(s.owner, {
+          ...e,
+          event: "resyncRequired",
+          payload: { reason: "event-too-large" }
+        });
+        continue;
+      }
+      s.events.push({ e, size, at: Date.now() });
+      s.bytes += size;
+      this.trim(s);
+      this.deliver(s.owner, e);
+    }
+  }
+  trim(s) {
+    while (s.events.length && (s.bytes > 1024 * 1024 || Date.now() - s.events[0].at > 6e4)) {
+      const e = s.events.shift();
+      s.bytes -= e.size;
+      s.floor = BigInt(e.e.eventSeq);
+    }
+  }
+  resume(owner, id2, epoch, seq) {
+    const s = this.owned(owner, id2);
+    this.trim(s);
+    const n = BigInt(seq);
+    if (epoch !== this.epoch || n < s.floor || n > s.seq)
+      throw new BridgeError("RESYNC_REQUIRED");
+    s.at = Date.now();
+    for (const { e } of s.events)
+      if (BigInt(e.eventSeq) > n) this.deliver(owner, e);
+    return {
+      subscriptionId: id2,
+      connectionEpoch: this.epoch,
+      eventSeq: String(s.seq)
+    };
+  }
+  ack(owner, id2, epoch, seq) {
+    const s = this.owned(owner, id2);
+    if (epoch !== this.epoch || BigInt(seq) > s.seq)
+      throw new BridgeError("RESYNC_REQUIRED");
+    s.at = Date.now();
+    while (s.events.length && BigInt(s.events[0].e.eventSeq) <= BigInt(seq)) {
+      const e = s.events.shift();
+      s.bytes -= e.size;
+      s.floor = BigInt(e.e.eventSeq);
+    }
+  }
+  revoke(owner) {
+    for (const [id2, s] of this.subs)
+      if (s.owner === owner) this.subs.delete(id2);
+  }
+  clear() {
+    for (const [id2, s] of this.subs)
+      this.deliver(s.owner, {
+        kind: "event",
+        connectionEpoch: this.epoch,
+        subscriptionId: id2,
+        eventSeq: String(++s.seq),
+        event: "resyncRequired",
+        payload: { reason: "upstream-disconnected" }
+      });
+    this.subs.clear();
+  }
+  expire() {
+    for (const [id2, s] of this.subs)
+      if (Date.now() - s.at > 36e5) this.subs.delete(id2);
+  }
+};
+
+// src/bridge.ts
+var sources = [
+  "cli",
+  "vscode",
+  "exec",
+  "appServer",
+  "subAgent",
+  "subAgentReview",
+  "subAgentCompact",
+  "subAgentThreadSpawn",
+  "subAgentOther",
+  "unknown"
+];
+var writes = /* @__PURE__ */ new Set([
+  "threads.start",
+  "threads.resume",
+  "turns.start",
+  "turns.interrupt"
+]);
+var unsupported = (e) => e instanceof RpcError && (e.code === -32601 || /paginated|pagination|history mode/i.test(e.message));
+var Bridge = class {
+  constructor(upstream, grants, deliver) {
+    this.upstream = upstream;
+    this.grants = grants;
+    this.deliver = deliver;
+    this.subscriptions = new Subscriptions(deliver);
+    upstream.on("notification", (m) => this.notification(m));
+    upstream.on("serverRequest", (m) => this.serverRequest(m));
+    upstream.on("disconnect", () => {
+      this.subscriptions.clear();
+      this.leases.clear();
+      this.approvals.clear();
+    });
+    this.timer = setInterval(() => {
+      void this.files.expire();
+      this.subscriptions.expire();
+      for (const [id2, a] of this.approvals)
+        if (a.expires < Date.now()) this.deny(id2, a);
+      for (const [id2, h] of this.histories)
+        if (h.expires < Date.now()) this.histories.delete(id2);
+      for (const [id2, p] of this.projectCursors)
+        if (p.expires < Date.now()) this.projectCursors.delete(id2);
+    }, 1e3);
+    this.timer.unref();
+  }
+  leases = new Leases();
+  files = new FileResources();
+  dedup = new Dedup();
+  subscriptions;
+  approvals = /* @__PURE__ */ new Map();
+  histories = /* @__PURE__ */ new Map();
+  projectCursors = /* @__PURE__ */ new Map();
+  timer;
+  grant(owner) {
+    const grant = this.grants.get(owner);
+    if (!grant) throw new BridgeError("NOT_PAIRED");
+    return grant;
+  }
+  async project(owner, id2) {
+    const g = this.grant(owner);
+    if (id2.startsWith("cwd:")) {
+      const cwd = Buffer.from(id2.slice(4), "base64url").toString();
+      const actual = await authorizedPath(g.roots, cwd);
+      if (actual !== cwd) throw new BridgeError("FORBIDDEN");
+      return { id: id2, name: basename2(cwd), cwd, source: "derived" };
+    }
+    const { project: p } = await this.upstream.call("project/read", {
+      projectId: id2
+    });
+    const roots = [];
+    for (const root of p.roots ?? [])
+      try {
+        roots.push(await authorizedPath(g.roots, root.path));
+      } catch {
+      }
+    if (!roots.length) throw new BridgeError("FORBIDDEN");
+    return { id: p.id, name: p.name, cwd: roots[0], source: "codex" };
+  }
+  async thread(owner, id2) {
+    const g = this.grant(owner);
+    const r = await this.upstream.call("thread/read", {
+      threadId: id2,
+      includeTurns: false
+    });
+    await authorizedPath(g.roots, r.thread.cwd);
+    return r.thread;
+  }
+  async history(owner, method, p) {
+    if (p.cursor?.startsWith("turn-items:")) {
+      const h = this.histories.get(p.cursor);
+      if (!h || h.owner !== owner || h.thread !== p.threadId || h.kind !== method + ":" + (p.turnId ?? "") || h.expires < Date.now())
+        throw new BridgeError("RESYNC_REQUIRED");
+      return this.turnItems(owner, p, h);
+    }
+    if (p.cursor?.startsWith("fallback:")) {
+      const h = this.histories.get(p.cursor);
+      if (!h || h.owner !== owner || h.thread !== p.threadId || h.kind !== method + ":" + (p.turnId ?? "") || h.expires < Date.now())
+        throw new BridgeError("RESYNC_REQUIRED");
+      const data2 = h.data.slice(h.offset, h.offset + p.limit);
+      h.offset += data2.length;
+      this.histories.delete(p.cursor);
+      const nextCursor2 = h.offset < h.data.length ? "fallback:" + randomUUID4() : null;
+      if (nextCursor2) this.histories.set(nextCursor2, h);
+      return { data: data2, nextCursor: nextCursor2, source: "bounded-fallback" };
+    }
+    try {
+      const r2 = await this.upstream.call(
+        method === "turns.list" ? "thread/turns/list" : "thread/items/list",
+        {
+          ...p,
+          sortDirection: "desc",
+          ...method === "turns.list" ? { itemsView: "summary" } : {}
+        }
+      );
+      return {
+        data: r2.data,
+        nextCursor: r2.nextCursor ?? null,
+        source: "codex"
+      };
+    } catch (e) {
+      if (!unsupported(e)) throw e;
+    }
+    if (p.cursor) throw new BridgeError("RESYNC_REQUIRED");
+    if (method === "items.list") {
+      try {
+        return await this.turnItems(owner, p);
+      } catch (e) {
+        if (!unsupported(e)) throw e;
+      }
+    }
+    const r = await this.upstream.call("thread/read", {
+      threadId: p.threadId,
+      includeTurns: true
+    });
+    const bytes = Buffer.byteLength(JSON.stringify(r));
+    if (bytes > 8 * 1024 * 1024 || Array.from(this.histories.values()).reduce((n, h) => n + h.bytes, 0) + bytes > 8 * 1024 * 1024)
+      throw new BridgeError(
+        "RESOURCE_TOO_LARGE",
+        "Legacy history exceeds bounded fallback budget"
+      );
+    const turns = (r.thread.turns ?? []).slice().reverse();
+    const data = method === "turns.list" ? turns.map((t) => ({ ...t, items: [] })) : turns.filter((t) => !p.turnId || p.turnId === t.id).flatMap(
+      (t) => (t.items ?? []).slice().reverse().map((item) => ({ turnId: t.id, item }))
+    );
+    const nextCursor = data.length > p.limit ? "fallback:" + randomUUID4() : null;
+    if (nextCursor) {
+      if (this.histories.size >= 32) throw new BridgeError("BUSY");
+      this.histories.set(nextCursor, {
+        owner,
+        thread: p.threadId,
+        kind: method + ":" + (p.turnId ?? ""),
+        data,
+        offset: p.limit,
+        bytes,
+        expires: Date.now() + 6e4
+      });
+    }
+    return {
+      data: data.slice(0, p.limit),
+      nextCursor,
+      source: "bounded-fallback"
+    };
+  }
+  /** Older app-server versions paginate full turns but not individual items.
+   * Buffer at most one turn; never load a whole long conversation for this path. */
+  async turnItems(owner, p, previous) {
+    const h = previous ? { ...previous } : { owner, thread: p.threadId, kind: "items.list:" + (p.turnId ?? ""), data: [], offset: 0, bytes: 0, expires: Date.now() + 6e4 };
+    const data = [];
+    let pages = 0;
+    const visited = /* @__PURE__ */ new Set();
+    while (data.length < p.limit) {
+      const part = h.data.slice(h.offset, h.offset + p.limit - data.length);
+      data.push(...part);
+      h.offset += part.length;
+      if (data.length >= p.limit || h.upstream === null || pages >= 10) break;
+      if (h.upstream && visited.has(h.upstream)) throw new BridgeError("RESYNC_REQUIRED");
+      if (h.upstream) visited.add(h.upstream);
+      const r = await this.upstream.call("thread/turns/list", { threadId: p.threadId, cursor: h.upstream, limit: 1, sortDirection: "desc", itemsView: "full" });
+      pages++;
+      const bytes = Buffer.byteLength(JSON.stringify(r));
+      const retained = Array.from(this.histories.values()).reduce((sum, entry) => sum + (entry === previous ? 0 : entry.bytes), 0);
+      if (bytes > 8 * 1024 * 1024 || retained + bytes > 8 * 1024 * 1024) throw new BridgeError("RESOURCE_TOO_LARGE");
+      if (r.data.some((turn) => turn.itemsView && turn.itemsView !== "full")) throw new BridgeError("UNSUPPORTED_CAPABILITY", "Upstream did not return full turn items");
+      h.data = r.data.filter((turn) => !p.turnId || turn.id === p.turnId).flatMap((turn) => (turn.items ?? []).slice().reverse().map((item) => ({ turnId: turn.id, item })));
+      h.offset = 0;
+      h.bytes = bytes;
+      h.upstream = r.nextCursor ?? null;
+    }
+    const more = h.offset < h.data.length || h.upstream !== null;
+    if (more && this.histories.size - (previous ? 1 : 0) >= 32) throw new BridgeError("BUSY");
+    if (previous) this.histories.delete(p.cursor);
+    const nextCursor = more ? "turn-items:" + randomUUID4() : null;
+    if (nextCursor) this.histories.set(nextCursor, h);
+    return { data, nextCursor, source: "bounded-fallback" };
+  }
+  async handle(owner, message) {
+    if (message.kind === "serverResponse") {
+      await this.answer(owner, message.serverRequestId, message.result);
+      return;
+    }
+    if (message.kind === "ack") {
+      this.grant(owner);
+      this.subscriptions.ack(
+        owner,
+        message.subscriptionId,
+        message.connectionEpoch,
+        message.eventSeq
+      );
+      return;
+    }
+    if (message.kind !== "request") throw new BridgeError("FORBIDDEN");
+    try {
+      const g = this.grant(owner);
+      const p = methodSchemas[message.method].parse(message.params);
+      if (writes.has(message.method) && !g.write)
+        throw new BridgeError("FORBIDDEN");
+      const invoke = () => this.execute(owner, message.method, p);
+      const result = writes.has(message.method) ? await this.dedup.run(
+        owner,
+        message.requestId,
+        { method: message.method, params: p },
+        invoke
+      ) : await invoke();
+      if (Buffer.byteLength(JSON.stringify(result)) > MAX_MESSAGE_BYTES - 1024)
+        throw new BridgeError(
+          "RESOURCE_TOO_LARGE",
+          "Response exceeds page budget; request a smaller page"
+        );
+      return { kind: "response", requestId: message.requestId, result };
+    } catch (e) {
+      const code = e instanceof BridgeError ? e.code : e instanceof RpcError ? e.code === -32601 ? "UNSUPPORTED_CAPABILITY" : "UPSTREAM_ERROR" : "INVALID_REQUEST";
+      return {
+        kind: "response",
+        requestId: message.requestId,
+        error: {
+          code,
+          message: e instanceof BridgeError ? e.message : code,
+          retryable: e instanceof BridgeError && e.retryable
+        }
+      };
+    }
+  }
+  async execute(owner, method, p) {
+    const g = this.grant(owner);
+    if (writes.has(method) && p.connectionEpoch !== this.subscriptions.epoch)
+      throw new BridgeError(
+        "OUTCOME_UNKNOWN",
+        "Client epoch changed; reconcile upstream before submitting a new request"
+      );
+    if (method === "bridge.capabilities")
+      return {
+        connectionEpoch: this.subscriptions.epoch,
+        codexAvailable: this.upstream.available,
+        codexVersion: this.upstream.version,
+        methods: Object.keys(methodSchemas).filter(
+          (m) => g.write || !writes.has(m)
+        ),
+        limits: {
+          frameBytes: MAX_FRAME_BYTES,
+          messageBytes: MAX_MESSAGE_BYTES,
+          chunkBytes: CHUNK_BYTES
+        },
+        historyFallback: "bounded",
+        activeTakeover: "unverified"
+      };
+    if ("threadId" in p) await this.thread(owner, p.threadId);
+    if (writes.has(method) && "threadId" in p) {
+      this.leases.assert(p.threadId, owner);
+      if ((method === "turns.start" || method === "turns.interrupt") && p.connectionEpoch !== this.subscriptions.epoch)
+        throw new BridgeError(
+          "OUTCOME_UNKNOWN",
+          "Client epoch changed; reconcile upstream before submitting a new request"
+        );
+    }
+    switch (method) {
+      case "projects.list": {
+        const previous = p.cursor?.startsWith("derived:") ? this.projectCursors.get(p.cursor) : void 0;
+        if (p.cursor?.startsWith("derived:") && (!previous || previous.owner !== owner || previous.expires < Date.now()))
+          throw new BridgeError("RESYNC_REQUIRED");
+        try {
+          if (previous)
+            throw new RpcError(-32601, "Use bounded derived-project cursor");
+          const r = await this.upstream.call("project/list", p);
+          if (!p.cursor && r.data.length === 0 && !r.nextCursor)
+            throw new RpcError(-32601, "Empty project catalog; discover history roots");
+          const data = [];
+          for (const item of r.data) {
+            for (const root of item.roots ?? []) {
+              try {
+                const cwd = await authorizedPath(g.roots, root.path);
+                data.push({
+                  id: item.id,
+                  name: item.name,
+                  cwd,
+                  source: "codex"
+                });
+                break;
+              } catch {
+              }
+            }
+          }
+          return { data, nextCursor: r.nextCursor ?? null };
+        } catch (e) {
+          if (!unsupported(e)) throw e;
+          const data = [];
+          const seen = new Set(previous?.seen);
+          let upstreamCursor = previous?.upstream ?? p.cursor;
+          const visited = /* @__PURE__ */ new Set();
+          for (let page2 = 0; page2 < 10; page2++) {
+            if (upstreamCursor) {
+              if (visited.has(upstreamCursor)) throw new BridgeError("RESYNC_REQUIRED");
+              visited.add(upstreamCursor);
+            }
+            const r = await this.upstream.call("thread/list", {
+              cursor: upstreamCursor,
+              limit: (p.limit ?? 50) - data.length,
+              useStateDbOnly: true,
+              sourceKinds: sources,
+              sortKey: "updated_at",
+              sortDirection: "desc"
+            });
+            for (const t of r.data) {
+              let cwd;
+              try {
+                cwd = await authorizedPath(g.roots, t.cwd);
+              } catch {
+                continue;
+              }
+              if (!seen.has(cwd)) {
+                seen.add(cwd);
+                data.push({
+                  id: "cwd:" + Buffer.from(cwd).toString("base64url"),
+                  name: basename2(cwd),
+                  cwd,
+                  source: "derived"
+                });
+              }
+            }
+            upstreamCursor = r.nextCursor ?? void 0;
+            if (!upstreamCursor || data.length >= (p.limit ?? 50)) break;
+          }
+          if (seen.size > 1024 || this.projectCursors.size >= 128)
+            throw new BridgeError("RESOURCE_TOO_LARGE");
+          if (previous) this.projectCursors.delete(p.cursor);
+          const nextCursor = upstreamCursor ? "derived:" + randomUUID4() : null;
+          if (nextCursor)
+            this.projectCursors.set(nextCursor, {
+              owner,
+              upstream: upstreamCursor,
+              seen,
+              expires: Date.now() + 6e4
+            });
+          return { data, nextCursor };
+        }
+      }
+      case "projects.read":
+        return { project: await this.project(owner, p.projectId) };
+      case "threads.list": {
+        const project = await this.project(owner, p.projectId);
+        const r = await this.upstream.call("thread/list", {
+          cursor: p.cursor,
+          limit: p.limit,
+          archived: p.archived,
+          sourceKinds: p.sourceKinds ?? sources,
+          cwd: project.cwd,
+          useStateDbOnly: true,
+          sortKey: "updated_at",
+          sortDirection: "desc"
+        });
+        const data = [];
+        for (const t of r.data)
+          try {
+            await authorizedPath(g.roots, t.cwd);
+            data.push(t);
+          } catch {
+          }
+        return { data, nextCursor: r.nextCursor ?? null };
+      }
+      case "threads.read":
+        return { thread: await this.thread(owner, p.threadId) };
+      case "turns.list":
+      case "items.list":
+        return this.history(owner, method, p);
+      case "threads.subscribe":
+        return this.subscriptions.subscribe(owner, p.threadId);
+      case "threads.unsubscribe":
+        return this.subscriptions.unsubscribe(owner, p.subscriptionId);
+      case "subscriptions.resume":
+        return this.subscriptions.resume(
+          owner,
+          p.subscriptionId,
+          p.connectionEpoch,
+          p.eventSeq
+        );
+      case "leases.acquire": {
+        if (!g.write) throw new BridgeError("FORBIDDEN");
+        const lease = this.leases.acquire(p.threadId, owner, p.takeover);
+        this.subscriptions.emit(p.threadId, "lease.changed", lease);
+        return lease;
+      }
+      case "leases.release": {
+        const result = this.leases.release(p.threadId, owner);
+        this.subscriptions.emit(p.threadId, "lease.changed", {
+          threadId: p.threadId,
+          holder: null
+        });
+        return result;
+      }
+      case "threads.start": {
+        const project = await this.project(owner, p.projectId);
+        const r = await this.upstream.call("thread/start", {
+          cwd: project.cwd,
+          sandbox: "workspace-write",
+          approvalPolicy: "on-request",
+          ...project.source === "codex" ? { projectId: project.id } : {}
+        });
+        this.leases.acquire(r.thread.id, owner);
+        return r;
+      }
+      case "threads.resume":
+        return this.upstream.call("thread/resume", {
+          threadId: p.threadId,
+          excludeTurns: true,
+          sandbox: "workspace-write",
+          approvalPolicy: "on-request"
+        });
+      case "turns.start":
+        return this.upstream.call("turn/start", {
+          threadId: p.threadId,
+          input: [{ type: "text", text: p.text, text_elements: [] }]
+        });
+      case "turns.interrupt":
+        return this.upstream.call("turn/interrupt", {
+          threadId: p.threadId,
+          turnId: p.turnId
+        });
+      case "files.list": {
+        const project = await this.project(owner, p.projectId);
+        return this.files.list(g.roots, project.cwd, p.path);
+      }
+      case "files.open": {
+        const project = await this.project(owner, p.projectId);
+        return this.files.open(owner, g.roots, project.cwd, p.path);
+      }
+      case "resources.read":
+        return this.files.read(owner, p.resourceId, p.offset, p.length);
+      case "resources.close":
+        return this.files.close(owner, p.resourceId);
+    }
+  }
+  notification(m) {
+    const thread2 = m.params?.threadId ?? m.params?.thread?.id;
+    if (typeof thread2 !== "string") return;
+    if (m.method.endsWith("/delta"))
+      this.subscriptions.emit(thread2, "item.invalidated", {
+        threadId: thread2,
+        turnId: m.params.turnId,
+        itemId: m.params.itemId,
+        requiresReload: true
+      });
+    else if ([
+      "item/started",
+      "item/completed",
+      "turn/started",
+      "turn/completed",
+      "thread/status/changed",
+      "turn/plan/updated",
+      "turn/diff/updated"
+    ].includes(m.method))
+      this.subscriptions.emit(thread2, m.method, m.params);
+  }
+  serverRequest(m) {
+    const thread2 = m.params?.threadId, owner = this.leases.holder(thread2);
+    const supported = [
+      "item/commandExecution/requestApproval",
+      "item/fileChange/requestApproval",
+      "item/permissions/requestApproval",
+      "item/tool/requestUserInput"
+    ];
+    if (!owner || !this.grants.get(owner)?.write || !supported.includes(m.method) || this.approvals.size >= 128) {
+      this.upstream.respond(m.id, null, {
+        code: -32001,
+        message: "No authorized bridge controller"
+      });
+      return;
+    }
+    const id2 = randomUUID4();
+    const a = {
+      owner,
+      thread: thread2,
+      rpcId: m.id,
+      method: m.method,
+      params: m.params,
+      expires: Date.now() + 12e4
+    };
+    this.approvals.set(id2, a);
+    this.deliver(owner, {
+      kind: "serverRequest",
+      serverRequestId: id2,
+      method: m.method.endsWith("requestUserInput") ? "userInput.request" : "approvals.request",
+      params: { ...m.params, upstreamMethod: m.method, expiresAt: a.expires }
+    });
+  }
+  deny(id2, a) {
+    this.approvals.delete(id2);
+    try {
+      this.upstream.respond(a.rpcId, null, {
+        code: -32001,
+        message: "Approval expired or controller disconnected"
+      });
+    } catch {
+    }
+    this.subscriptions.emit(a.thread, "approval.closed", {
+      serverRequestId: id2,
+      status: "expired"
+    });
+  }
+  async answer(owner, id2, result) {
+    const g = this.grant(owner), a = this.approvals.get(id2);
+    if (!a || a.owner !== owner || a.expires < Date.now())
+      throw new BridgeError("APPROVAL_EXPIRED");
+    if (!g.write) throw new BridgeError("FORBIDDEN");
+    this.leases.assert(a.thread, owner);
+    await this.thread(owner, a.thread);
+    if (this.approvals.get(id2) !== a) throw new BridgeError("APPROVAL_EXPIRED");
+    this.grant(owner);
+    this.leases.assert(a.thread, owner);
+    let response;
+    if (a.method.endsWith("requestUserInput")) {
+      const answers = result.answers;
+      if (!answers || typeof answers !== "object" || Array.isArray(answers))
+        throw new BridgeError("INVALID_REQUEST");
+      const out = {};
+      for (const q of a.params.questions ?? []) {
+        const value = answers[q.id];
+        if (!value || !Array.isArray(value.answers) || value.answers.length > 16 || value.answers.some(
+          (s) => typeof s !== "string" || s.length > 8192
+        ))
+          throw new BridgeError("INVALID_REQUEST");
+        out[q.id] = { answers: value.answers };
+      }
+      response = { answers: out };
+    } else if (a.method.endsWith("permissions/requestApproval")) {
+      if (result.decision !== "decline")
+        throw new BridgeError(
+          "UNSUPPORTED_CAPABILITY",
+          "Permission expansion requires local Codex approval"
+        );
+      response = { permissions: {}, scope: "turn" };
+    } else {
+      if (!["accept", "decline", "cancel"].includes(result.decision))
+        throw new BridgeError("INVALID_REQUEST");
+      response = { decision: result.decision };
+    }
+    this.approvals.delete(id2);
+    this.upstream.respond(a.rpcId, response);
+    this.subscriptions.emit(a.thread, "approval.closed", {
+      serverRequestId: id2,
+      status: "answered"
+    });
+  }
+  disconnect(owner) {
+    for (const [id2, a] of this.approvals)
+      if (a.owner === owner) this.deny(id2, a);
+    void this.files.closeOwner(owner);
+    this.leases.revoke(owner);
+  }
+  revoke(owner) {
+    this.grants.delete(owner);
+    this.disconnect(owner);
+    this.subscriptions.revoke(owner);
+    for (const [id2, h] of this.histories)
+      if (h.owner === owner) this.histories.delete(id2);
+  }
+  async close() {
+    clearInterval(this.timer);
+    for (const [id2, a] of this.approvals) this.deny(id2, a);
+    await this.files.dispose();
+    this.upstream.close();
+  }
+};
+
+// src/daemon.ts
+var ClientDaemon = class {
+  constructor(config, identity, grants, connectUpstream = () => CodexRpc.connect(config.upstream)) {
+    this.config = config;
+    this.identity = identity;
+    this.grants = grants;
+    this.connectUpstream = connectUpstream;
+  }
+  ws;
+  bridge;
+  deviceId = "";
+  stopped = false;
+  routes = /* @__PURE__ */ new Map();
+  pairUntil = 0;
+  admin;
+  timer;
+  retry;
+  attempts = 0;
+  noise;
+  token = "";
+  alive = true;
+  connecting;
+  async start() {
+    this.noise = await loadNoise();
+    this.token = (await privateRead(this.config.deviceTokenFile)).trim();
+    if (!this.token || /[\r\n]/.test(this.token)) throw Error("DEVICE_TOKEN");
+    await this.startAdmin();
+    this.connect();
+    this.timer = setInterval(() => {
+      if (this.ws?.readyState === WebSocket2.OPEN) {
+        if (!this.alive) this.ws.terminate();
+        else {
+          this.alive = false;
+          this.ws.ping();
+        }
+      }
+      for (const [id2, r] of this.routes)
+        if (Date.now() > r.expires && !r.owner) this.closeRoute(id2);
+    }, 1e4);
+    this.timer.unref();
+  }
+  async ensureUpstream() {
+    if (this.bridge?.upstream.available) return;
+    if (this.connecting) return this.connecting;
+    this.connecting = (async () => {
+      await this.bridge?.close();
+      this.bridge = new Bridge(
+        await this.connectUpstream(),
+        this.grants,
+        (owner, m) => {
+          for (const [id2, r] of this.routes)
+            if (r.owner === owner) this.send(id2, m);
+        }
+      );
+    })().finally(() => {
+      this.connecting = void 0;
+    });
+    return this.connecting;
+  }
+  connect() {
+    if (this.stopped) return;
+    this.ws = new WebSocket2(new URL("/ws/v1/client", this.config.relayUrl), {
+      headers: { Authorization: "Bearer " + this.token },
+      perMessageDeflate: false,
+      maxPayload: 128 * 1024,
+      handshakeTimeout: 1e4
+    });
+    this.ws.on("open", () => {
+      this.alive = true;
+      this.attempts = 0;
+    });
+    this.ws.on("pong", () => this.alive = true);
+    this.ws.on("error", () => {
+    });
+    this.ws.on("message", (data) => {
+      try {
+        this.receive(data.toString());
+      } catch {
+        this.ws?.close(1008, "Protocol violation");
+      }
+    });
+    this.ws.on("close", () => {
+      this.deviceId = "";
+      for (const id2 of this.routes.keys()) this.closeRoute(id2, false);
+      if (!this.stopped) {
+        const delay = Math.min(3e4, 500 * 2 ** Math.min(this.attempts++, 7)) * (0.5 + Math.random());
+        this.retry = setTimeout(() => this.connect(), delay);
+      }
+    });
+  }
+  control(value) {
+    if (this.ws?.readyState === WebSocket2.OPEN)
+      this.ws.send(JSON.stringify(value));
+  }
+  receive(text) {
+    if (Buffer.byteLength(text) > 128 * 1024) throw Error("FRAME_TOO_LARGE");
+    const m = JSON.parse(text);
+    if (m.type === "device.ready") {
+      if (typeof m.deviceId !== "string" || this.deviceId)
+        throw Error("DEVICE_STATE");
+      this.deviceId = m.deviceId;
+      return;
+    }
+    if (m.type === "route.opened") {
+      if (!this.deviceId || m.deviceId !== this.deviceId || typeof m.routeId !== "string" || this.routes.has(m.routeId) || this.routes.size >= 32) {
+        this.control({ type: "route.close", routeId: m.routeId });
+        return;
+      }
+      this.routes.set(m.routeId, {
+        confirmed: false,
+        expires: Date.now() + 12e4,
+        queue: Promise.resolve(),
+        pending: 0,
+        out: [],
+        bytes: 0,
+        sending: false
+      });
+      return;
+    }
+    if (m.type === "route.closed") {
+      this.closeRoute(m.routeId, false);
+      return;
+    }
+    if (m.type !== "secure") return;
+    const frame = decodeFrame(text);
+    const r = this.routes.get(frame.routeId);
+    if (!r) return;
+    if (++r.pending > 64) {
+      this.closeRoute(frame.routeId);
+      return;
+    }
+    r.queue = r.queue.then(async () => {
+      if (!this.routes.has(frame.routeId)) return;
+      if (!r.session) {
+        if (frame.phase !== "handshake" || frame.recordNo !== "0")
+          throw Error("HANDSHAKE_REQUIRED");
+        r.session = new SecureSession(
+          this.noise,
+          "client",
+          {
+            deviceId: this.deviceId,
+            routeId: frame.routeId,
+            sessionId: frame.sessionId
+          },
+          this.identity
+        );
+      }
+      if (frame.phase === "handshake") {
+        const reply = r.session.receiveHandshake(frame);
+        if (reply) this.ws.send(encodeFrame(reply));
+        if (r.session.ready) {
+          const grant = this.grants.get(r.session.peerPublicKey);
+          if (grant) {
+            r.session.trust(r.session.fingerprint);
+            r.owner = grant.peer;
+            this.send(frame.routeId, {
+              kind: "pairing",
+              status: "ready",
+              fingerprint: r.session.fingerprint
+            });
+          } else {
+            if (Date.now() > this.pairUntil)
+              throw new BridgeError("NOT_PAIRED");
+            this.send(frame.routeId, {
+              kind: "pairing",
+              status: "pending",
+              fingerprint: r.session.fingerprint
+            });
+          }
+        }
+        return;
+      }
+      const message = r.session.open(frame);
+      if (!message) return;
+      if (message.kind === "pairing") {
+        if (message.fingerprint !== r.session.fingerprint || message.status !== "confirmed" || Date.now() > r.expires)
+          throw Error("PAIRING_MISMATCH");
+        r.confirmed = true;
+        return;
+      }
+      if (!r.owner || !this.grants.has(r.owner))
+        throw new BridgeError("NOT_PAIRED");
+      await this.ensureUpstream();
+      const response = await this.bridge.handle(r.owner, message);
+      if (response) this.send(frame.routeId, response);
+    }).catch(() => this.closeRoute(frame.routeId)).finally(() => r.pending--);
+  }
+  send(id2, message) {
+    const r = this.routes.get(id2);
+    if (!r?.session?.ready) return;
+    const bytes = Buffer.byteLength(JSON.stringify(message));
+    if (r.bytes + bytes > 1024 * 1024 || this.ws.bufferedAmount > 4 * 1024 * 1024) {
+      this.closeRoute(id2);
+      return;
+    }
+    r.out.push(message);
+    r.bytes += bytes;
+    if (!r.sending) void this.flush(id2, r);
+  }
+  async flush(id2, r) {
+    r.sending = true;
+    try {
+      while (r.out.length && this.routes.has(id2)) {
+        const m = r.out.shift();
+        r.bytes -= Buffer.byteLength(JSON.stringify(m));
+        for (const frame of r.session.seal(m)) {
+          if (this.ws?.readyState !== WebSocket2.OPEN)
+            throw Error("DISCONNECTED");
+          await new Promise(
+            (resolve5, reject) => this.ws.send(
+              encodeFrame(frame),
+              (e) => e ? reject(e) : resolve5()
+            )
+          );
+        }
+      }
+    } catch {
+      this.closeRoute(id2);
+    } finally {
+      r.sending = false;
+    }
+  }
+  closeRoute(id2, notify = true) {
+    const r = this.routes.get(id2);
+    if (!r) return;
+    this.routes.delete(id2);
+    r.session?.close();
+    r.out = [];
+    if (r.owner && !Array.from(this.routes.values()).some((x) => x.owner === r.owner))
+      this.bridge?.disconnect(r.owner);
+    if (notify) this.control({ type: "route.close", routeId: id2 });
+  }
+  async adminCommand(value) {
+    const m = z5.object({ command: z5.string() }).passthrough().parse(value);
+    switch (m.command) {
+      case "status":
+        return {
+          relayOnline: !!this.deviceId,
+          codexAvailable: this.bridge?.upstream.available ?? false,
+          handshakes: Array.from(this.routes.values()).filter(
+            (r) => r.session?.ready
+          ).length,
+          authorizedSessions: Array.from(this.routes.values()).filter(
+            (r) => r.owner
+          ).length,
+          pairingUntil: this.pairUntil
+        };
+      case "pair-open":
+        this.pairUntil = Date.now() + 12e4;
+        return { expiresAt: this.pairUntil };
+      case "pair-list":
+        return {
+          pending: Array.from(this.routes.entries()).filter(([, r]) => r.session?.ready && !r.owner).map(([routeId, r]) => ({
+            routeId,
+            fingerprint: r.session.fingerprint,
+            peer: r.session.peerPublicKey,
+            browserConfirmed: r.confirmed,
+            expiresAt: r.expires
+          }))
+        };
+      case "pair-approve": {
+        const p = z5.object({
+          fingerprint: z5.string().regex(/^[a-f0-9]{64}$/),
+          roots: z5.array(z5.string()).min(1).max(32),
+          write: z5.boolean().default(false)
+        }).parse(m);
+        const found = Array.from(this.routes.entries()).find(
+          ([, r2]) => r2.session?.fingerprint === p.fingerprint
+        );
+        if (!found || !found[1].confirmed || Date.now() > this.pairUntil || Date.now() > found[1].expires)
+          throw Error("PAIRING_EXPIRED_OR_UNCONFIRMED");
+        if (this.grants.size >= 256) throw Error("GRANT_LIMIT");
+        const [id2, r] = found;
+        const peer = r.session.peerPublicKey;
+        const grant = {
+          peer,
+          roots: await Promise.all(p.roots.map((x) => realpath3(x))),
+          write: p.write
+        };
+        this.grants.set(peer, grant);
+        try {
+          await atomicPrivate(
+            this.config.stateDir + "/grants.json",
+            Array.from(this.grants.values())
+          );
+        } catch (e) {
+          this.grants.delete(peer);
+          throw e;
+        }
+        r.session.trust(p.fingerprint);
+        r.owner = peer;
+        this.pairUntil = 0;
+        this.send(id2, {
+          kind: "pairing",
+          status: "ready",
+          fingerprint: p.fingerprint
+        });
+        return { peer, approved: true };
+      }
+      case "revoke": {
+        const peer = z5.string().parse(m.peer);
+        this.bridge?.revoke(peer);
+        this.grants.delete(peer);
+        for (const [id2, r] of this.routes)
+          if (r.owner === peer || r.session?.peerPublicKey === peer)
+            this.closeRoute(id2);
+        await atomicPrivate(
+          this.config.stateDir + "/grants.json",
+          Array.from(this.grants.values())
+        );
+        return { revoked: true };
+      }
+      default:
+        throw Error("ADMIN_COMMAND");
+    }
+  }
+  async startAdmin() {
+    const path = this.config.stateDir + "/control.sock";
+    try {
+      const entry = await lstat2(path);
+      if (!entry.isSocket() || entry.uid !== process.getuid?.())
+        throw Error("UNSAFE_CONTROL_PATH");
+      const active = await new Promise((resolve5, reject) => {
+        const socket = createConnection(path);
+        socket.setTimeout(1e3, () => {
+          socket.destroy();
+          reject(Error("CONTROL_SOCKET_BUSY"));
+        });
+        socket.once("connect", () => {
+          socket.destroy();
+          resolve5(true);
+        });
+        socket.once("error", (e) => {
+          if (e.code === "ECONNREFUSED" || e.code === "ENOENT") resolve5(false);
+          else reject(e);
+        });
+      });
+      if (active) throw Error("CLIENT_ALREADY_RUNNING");
+      const current = await lstat2(path);
+      if (current.ino !== entry.ino) throw Error("CONTROL_SOCKET_CHANGED");
+      await unlink(path);
+    } catch (e) {
+      if (e.code !== "ENOENT") throw e;
+    }
+    this.admin = createServer((socket) => {
+      socket.setTimeout(5e3, () => socket.destroy());
+      let data = "";
+      socket.on("data", (chunk) => {
+        data += chunk.toString();
+        if (data.length > 16384) {
+          socket.destroy();
+          return;
+        }
+        if (!data.includes("\n")) return;
+        socket.pause();
+        void Promise.resolve().then(() => this.adminCommand(JSON.parse(data))).then(
+          (result) => socket.end(JSON.stringify({ result }) + "\n"),
+          () => socket.end(
+            JSON.stringify({ error: "ADMIN_REQUEST_REJECTED" }) + "\n"
+          )
+        );
+      });
+      socket.on("error", () => {
+      });
+    });
+    await new Promise((resolve5, reject) => {
+      this.admin.once("error", reject);
+      this.admin.listen(path, () => resolve5());
+    });
+    await chmod(path, 384);
+  }
+  async stop() {
+    this.stopped = true;
+    clearInterval(this.timer);
+    clearTimeout(this.retry);
+    for (const id2 of this.routes.keys()) this.closeRoute(id2);
+    this.ws?.terminate();
+    await this.bridge?.close();
+    await new Promise(
+      (resolve5) => this.admin ? this.admin.close(() => resolve5()) : resolve5()
+    );
+    await unlink(this.config.stateDir + "/control.sock").catch(() => {
+    });
+    this.identity.privateKey.fill(0);
+  }
+};
+
+// src/control.ts
+import { createConnection as createConnection2 } from "node:net";
+import { join as join2 } from "node:path";
+function control(stateDir, request) {
+  return new Promise((resolve5, reject) => {
+    const socket = createConnection2(join2(stateDir, "control.sock"));
+    let data = "";
+    socket.setTimeout(5e3, () => socket.destroy(Error("ADMIN_TIMEOUT")));
+    socket.on("connect", () => socket.write(JSON.stringify(request) + "\n"));
+    socket.on("data", (chunk) => {
+      data += chunk.toString();
+      if (Buffer.byteLength(data) > 65536) socket.destroy(Error("ADMIN_TOO_LARGE"));
+    });
+    socket.on("error", reject);
+    socket.on("end", () => {
+      try {
+        resolve5(JSON.parse(data));
+      } catch {
+        reject(Error("ADMIN_INVALID_RESPONSE"));
+      }
+    });
+  });
+}
+
+// src/setup.ts
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname3, join as join3, resolve as resolve3, basename as basename3 } from "node:path";
+import { mkdir as mkdir2, lstat as lstat3, writeFile as writeFile2, unlink as unlink2 } from "node:fs/promises";
+import { randomUUID as randomUUID5 } from "node:crypto";
+import { createInterface } from "node:readline/promises";
+import { Writable } from "node:stream";
+function defaultConfigPath() {
+  return resolve3(process.env.WEB_CODEX_CLIENT_CONFIG ?? join3(process.env.XDG_CONFIG_HOME ?? join3(homedir2(), ".config"), "web-codex-client", "config.json"));
+}
+function validateToken(value) {
+  const token = value.trim();
+  if (!token || token.length > 4096 || /[^\x21-\x7e]/.test(token)) throw Error("DEVICE_TOKEN_INVALID: expected a single token without whitespace");
+  return token;
+}
+async function privateDirectory(path) {
+  await mkdir2(path, { recursive: true, mode: 448 });
+  const info = await lstat3(path);
+  if (!info.isDirectory() || info.isSymbolicLink() || info.uid !== process.getuid?.() || info.mode & 63) throw Error("CONFIG_DIRECTORY_PERMISSIONS: use a private directory owned by this user (0700)");
+}
+async function tokenFromStdin() {
+  if (process.stdin.isTTY) throw Error("TOKEN_STDIN_REQUIRES_PIPE");
+  let value = "";
+  for await (const chunk of process.stdin) {
+    value += chunk.toString();
+    if (Buffer.byteLength(value) > 4098) throw Error("DEVICE_TOKEN_TOO_LARGE");
+  }
+  return validateToken(value);
+}
+async function question(prompt, secret = false) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) throw Error("INTERACTIVE_TERMINAL_REQUIRED: use --relay and --token-stdin");
+  const output = new Writable({ write(chunk, _encoding, done) {
+    if (!secret) process.stdout.write(chunk);
+    done();
+  } });
+  const rl = createInterface({ input: process.stdin, output, terminal: true });
+  const abort = new AbortController();
+  rl.on("SIGINT", () => abort.abort());
+  if (secret) process.stdout.write(prompt);
+  try {
+    return await rl.question(secret ? "" : prompt, { signal: abort.signal });
+  } finally {
+    rl.close();
+    if (secret) process.stdout.write("\n");
+  }
+}
+async function saveConfiguration(path, relayUrl, token, socket) {
+  path = resolve3(path);
+  const directory = dirname3(path);
+  const parsed = configSchema.safeParse({ relayUrl, deviceTokenFile: "placeholder", stateDir: "./state", cryptoPolicy: "remote-wss-v1", upstream: { mode: "unix", ...socket ? { socket: resolve3(socket) } : {} } });
+  if (!parsed.success) throw Error("RELAY_URL_INVALID: use a WSS origin without path, credentials, query or fragment");
+  token = validateToken(token);
+  await privateDirectory(directory);
+  let existing;
+  try {
+    existing = await readConfig(path);
+  } catch (e) {
+    if (e.code !== "ENOENT") throw Error("CONFIG_INVALID: repair the existing configuration before replacing it");
+  }
+  if (existing) {
+    try {
+      await control(existing.stateDir, { command: "status" });
+      throw Error("CLIENT_RUNNING: stop the client before reconfiguring");
+    } catch (e) {
+      if (!["ENOENT", "ECONNREFUSED"].includes(e.code ?? "")) throw e;
+    }
+  }
+  const host = new URL(relayUrl).hostname;
+  const stateDir = existing?.stateDir ?? join3(directory, "state");
+  await loadState(stateDir);
+  const tokenFile = join3(directory, "device-token-" + randomUUID5());
+  await writeFile2(tokenFile, token + "\n", { mode: 384, flag: "wx" });
+  try {
+    await atomicPrivate(path, {
+      ...parsed.data,
+      relayUrl: new URL(relayUrl).origin,
+      deviceTokenFile: "./" + tokenFile.slice(directory.length + 1),
+      stateDir,
+      cryptoPolicy: ["localhost", "127.0.0.1", "[::1]"].includes(host) ? "local-reviewed-v1" : "remote-wss-v1",
+      upstream: socket ? parsed.data.upstream : existing?.upstream ?? parsed.data.upstream
+    });
+  } catch (e) {
+    await unlink2(tokenFile);
+    throw e;
+  }
+  if (existing && dirname3(existing.deviceTokenFile) === directory && /^device-token-[0-9a-f-]{36}$/.test(basename3(existing.deviceTokenFile))) await unlink2(existing.deviceTokenFile).catch(() => {
+  });
+  return { path, socket: controlSocketPath(socket ? parsed.data.upstream : existing?.upstream ?? parsed.data.upstream) };
+}
+
+// src/doctor.ts
+import { join as join4, dirname as dirname4 } from "node:path";
+import WebSocket3 from "ws";
+import { SingleBar, Presets } from "cli-progress";
+async function authenticateRelay(relayUrl, token) {
+  await new Promise((resolve5, reject) => {
+    const ws = new WebSocket3(new URL("/ws/v1/client", relayUrl), {
+      headers: { Authorization: "Bearer " + token },
+      perMessageDeflate: false,
+      maxPayload: 4096,
+      handshakeTimeout: 1e4
+    });
+    const timer = setTimeout(() => finish(Error("RELAY_TIMEOUT")), 12e3);
+    let finished = false;
+    function finish(error) {
+      if (finished) return;
+      finished = true;
+      clearTimeout(timer);
+      ws.terminate();
+      if (error) reject(error);
+      else resolve5();
+    }
+    ws.on("error", () => finish(Error("RELAY_TLS_OR_NETWORK: check DNS, certificate trust and reachability")));
+    ws.on("unexpected-response", (_request, response) => {
+      response.resume();
+      finish(Error(response.statusCode === 401 ? "RELAY_UNAUTHORIZED: replace the device token" : "RELAY_HTTP_REJECTED: check the reverse proxy"));
+    });
+    ws.on("close", () => finish(Error("RELAY_CLOSED")));
+    ws.on("message", (bytes) => {
+      try {
+        const frame = JSON.parse(bytes.toString());
+        if (frame.type === "device.ready" && typeof frame.deviceId === "string") finish();
+        else finish(Error("RELAY_PROTOCOL"));
+      } catch {
+        finish(Error("RELAY_PROTOCOL"));
+      }
+    });
+  });
+}
+async function doctor(configPath, quiet = false, reportPath = join4(dirname4(configPath), "doctor-report.json")) {
+  const results = [];
+  const started = Date.now();
+  const bar = new SingleBar({ format: "Doctor [{bar}] {percentage}% | {value}/{total} | elapsed {duration_formatted} | ETA {eta_formatted} | {rate}/s | {phase}", noTTYOutput: true }, Presets.shades_classic);
+  await privateDirectory(dirname4(reportPath));
+  if (!quiet) bar.start(4, 0, { phase: "configuration", rate: "0" });
+  async function check(phase, fn) {
+    try {
+      const detail = await fn();
+      results.push({ phase, status: "PASS", ...detail ? { detail } : {} });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "";
+      const detail = message.startsWith("RELAY_UNAUTHORIZED:") ? "device token rejected; register or rotate the device credential" : message.startsWith("RELAY_TLS_OR_NETWORK:") ? "check DNS, certificate trust, port and WSS reverse proxy" : message === "CLIENT_OFFLINE" ? "existing local client is offline; inspect its relay configuration" : "check configuration, permissions and service availability";
+      results.push({ phase, status: "FAIL", detail });
+      await atomicPrivate(reportPath, { results, elapsedMs: Date.now() - started });
+      throw Error("DOCTOR_FAILED: " + phase + ": " + detail);
+    }
+    await atomicPrivate(reportPath, { results, elapsedMs: Date.now() - started });
+    if (!quiet) bar.update(results.length, { phase, rate: (results.length / Math.max(1e-3, (Date.now() - started) / 1e3)).toFixed(2) });
+  }
+  let config, token;
+  try {
+    await check("configuration and private token", async () => {
+      config = await readConfig(configPath);
+      token = validateToken(await privateRead(config.deviceTokenFile));
+      await privateDirectory(config.stateDir);
+    });
+    await check("locked encryption WASM", async () => {
+      await loadNoise();
+    });
+    await check("relay TLS and device authentication", async () => {
+      try {
+        const running = await control(config.stateDir, { command: "status" });
+        if (running.result?.relayOnline) return "existing client is authenticated; no duplicate connection";
+        throw Error("CLIENT_OFFLINE");
+      } catch (e) {
+        if (!["ENOENT", "ECONNREFUSED"].includes(e.code ?? "")) throw e;
+      }
+      await authenticateRelay(config.relayUrl, token);
+    });
+    await check("Codex initialization (no model request)", async () => {
+      const rpc = await CodexRpc.connect(config.upstream);
+      try {
+        if (!rpc.available) throw Error("CODEX_UNAVAILABLE");
+      } finally {
+        rpc.close();
+      }
+    });
+  } finally {
+    bar.stop();
+  }
+  console.log("PASS: configuration, encryption, authenticated WSS and Codex initialization.");
+}
+
+// src/cli.ts
+var { values, positionals } = parseArgs({
+  allowPositionals: true,
+  options: {
+    config: { type: "string" },
+    state: { type: "string" },
+    socket: { type: "string" },
+    binary: { type: "string" },
+    standalone: { type: "boolean" },
+    transport: { type: "string" },
+    "codex-home": { type: "string" },
+    fingerprint: { type: "string" },
+    peer: { type: "string" },
+    root: { type: "string", multiple: true },
+    write: { type: "boolean" },
+    quiet: { type: "boolean" },
+    report: { type: "string" },
+    relay: { type: "string" },
+    "token-stdin": { type: "boolean" },
+    help: { type: "boolean", short: "h" },
+    version: { type: "boolean", short: "v" }
+  }
+});
+var command = positionals[0] ?? "help";
+async function main() {
+  if (values.version) {
+    console.log(JSON.parse(await readFile3(new URL("../package.json", import.meta.url), "utf8")).version);
+    return;
+  }
+  if (command === "help" || values.help) {
+    console.log(
+      "web-codex-client configure [--config FILE] [--relay wss://HOST --token-stdin] [--socket PATH]\nweb-codex-client doctor [--config FILE] [--quiet] [--report FILE]\nweb-codex-client run [--config FILE]\nweb-codex-client init [--state DIR]\nweb-codex-client status|pair-open|pair-list [--state DIR] [--config FILE]\nweb-codex-client pair-approve --fingerprint FULL_HASH --root PATH [--write] [--state DIR]\nweb-codex-client revoke --peer PUBLIC_KEY [--state DIR]\nweb-codex-client probe [--transport unix|proxy] [--socket PATH] [--binary PATH] [--quiet] [--report FILE] (default: unix; --standalone starts an isolated stdio server)\nDefault config: " + defaultConfigPath()
+    );
+    return;
+  }
+  if (process.platform !== "linux" || Number(process.versions.node.split(".")[0]) !== 24) throw Error("SUPPORTED_RUNTIME: Linux with Node.js 24 required");
+  if (process.env.NODE_TLS_REJECT_UNAUTHORIZED === "0") throw Error("TLS_VERIFICATION_REQUIRED: remove NODE_TLS_REJECT_UNAUTHORIZED=0");
+  const configPath = resolve4(values.config ?? defaultConfigPath());
+  if (command === "configure") {
+    const relay = values.relay ?? (await question("Relay WSS origin (e.g. wss://relay.example.com): ")).trim();
+    if (values["token-stdin"] && !values.relay) throw Error("--token-stdin requires --relay");
+    const socket = values.socket ?? (values["token-stdin"] ? void 0 : (await question("Codex socket [" + controlSocketPath({ mode: "unix" }) + "]: ")).trim() || void 0);
+    const token = values["token-stdin"] ? await tokenFromStdin() : await question("Device token (hidden): ", true);
+    const result2 = await saveConfiguration(configPath, relay, token, socket);
+    console.log("Configuration saved: " + result2.path + "\nRun web-codex-client doctor, then web-codex-client run. Pairing and directory approval are still required.");
+    return;
+  }
+  if (command === "doctor") {
+    await doctor(configPath, values.quiet, values.report ? resolve4(values.report) : void 0);
+    return;
+  }
+  if (command === "init") {
+    await loadState(values.state ? resolve4(values.state) : (await readConfig(configPath)).stateDir);
+    console.log("Client identity initialized in private state directory.");
+    return;
+  }
+  if (command === "probe") {
+    if (values.transport && !["unix", "proxy"].includes(values.transport)) throw Error("probe --transport must be unix or proxy");
+    if (values.standalone && values.transport) throw Error("Do not combine --standalone and --transport");
+    await probe(
+      {
+        mode: values.standalone ? "stdio" : values.transport ?? "unix",
+        socket: values.socket,
+        binary: values.binary,
+        codexHome: values["codex-home"]
+      },
+      values.quiet,
+      values.report
+    );
+    return;
+  }
+  if (command === "run") {
+    const config = await readConfig(configPath);
+    const state = await loadState(config.stateDir);
+    const daemon = new ClientDaemon(config, state.identity, state.grants);
+    await daemon.start();
+    console.log(
+      "Client running; use local status/pair-open/pair-list commands."
+    );
+    let stopping = false;
+    const stop = () => {
+      if (stopping) return;
+      stopping = true;
+      void daemon.stop().then(() => process.exit(0));
+    };
+    process.on("SIGINT", stop);
+    process.on("SIGTERM", stop);
+    return;
+  }
+  if (!["status", "pair-open", "pair-list", "pair-approve", "revoke"].includes(command)) throw Error("UNKNOWN_COMMAND: use --help");
+  const stateDir = values.state ? resolve4(values.state) : (await readConfig(configPath)).stateDir;
+  const request = {
+    command,
+    fingerprint: values.fingerprint,
+    peer: values.peer,
+    roots: values.root,
+    write: values.write ?? false
+  };
+  const result = await control(stateDir, request);
+  console.log(JSON.stringify(result));
+  if (result.error) process.exitCode = 1;
+}
+main().catch((e) => {
+  console.error(e?.code === "ENOENT" ? "CONFIG_OR_FILE_MISSING: run configure; check the configured paths" : e?.name === "ZodError" ? "CONFIG_INVALID: check the configuration fields" : e instanceof Error ? e.message : "CLIENT_FAILED");
+  process.exitCode = 1;
+});
+//# sourceMappingURL=cli.js.map