pushary 1.9.44 → 1.9.45

package/dist/chunk-6JPDAUFP.js

@@ -0,0 +1,866 @@
+import {
+  LiveTranscriptRelay,
+  liveSessionSleep,
+  postLiveSession,
+  postLiveSessionUntilAccepted,
+  startLiveSessionHeartbeat
+} from "./chunk-EKGQEDQ4.js";
+import {
+  SESSION_IDLE_TIMEOUT_MS,
+  describeIdleWindow,
+  idleDeadlinePassed,
+  startProcessOwnership
+} from "./chunk-H4ODQD3Y.js";
+import {
+  spawnClaude
+} from "./chunk-XHKBHWLX.js";
+import {
+  isAskUserResponse,
+  isDecisionStopped,
+  isWaitForAnswerResponse,
+  repoKeyFor,
+  withdrawQuestion,
+  writeDegraded
+} from "./chunk-CDERSTBO.js";
+import {
+  callMcpTool,
+  isRetryable
+} from "./chunk-SFQSOBLM.js";
+import {
+  AGENT_QUESTION_DESCRIPTION_MAX,
+  AGENT_QUESTION_HEADER_MAX,
+  AGENT_QUESTION_OPTION_MAX,
+  ASK_CONTEXT_MAX,
+  ASK_QUESTION_MAX,
+  CODEX_NATIVE_APPROVAL_CAPABILITY,
+  CODEX_NATIVE_APPROVAL_METHODS,
+  PERSONAL_QUESTION_CAPABILITY,
+  canonicalJsonText,
+  codexNativeApprovalResponse,
+  elicitationContent,
+  isQuestionOwner,
+  parseAgentQuestionAnswers,
+  parseCodexNativeApproval,
+  parseCodexQuestions,
+  planElicitationAsk,
+  readElicitationFields
+} from "./chunk-K7EGWMDU.js";
+
+// src/codex-question-owner.ts
+import { createHash } from "crypto";
+var codexQuestionOwner = (params, requestId, runtime) => {
+  if (params.threadId !== runtime.threadId || typeof params.isBlocking !== "boolean") return null;
+  const owner = {
+    capability: PERSONAL_QUESTION_CAPABILITY,
+    machineId: runtime.machineId,
+    generation: runtime.generation,
+    threadId: params.threadId,
+    turnId: params.turnId,
+    itemId: params.itemId,
+    requestId,
+    method: "item/tool/requestUserInput",
+    subjectHash: createHash("sha256").update(canonicalJsonText(params)).digest("hex")
+  };
+  return isQuestionOwner(owner) ? owner : null;
+};
+var closesOwnedQuestion = (owner, method, params) => {
+  if (method === "serverRequest/resolved") return params.requestId === owner.requestId;
+  if (params.threadId !== owner.threadId) return false;
+  if (method === "thread/closed" || method === "thread/archived") return true;
+  if (method === "turn/completed") {
+    const turn = params.turn;
+    return turn !== null && typeof turn === "object" && "id" in turn && turn.id === owner.turnId;
+  }
+  if (method === "item/completed" && params.turnId === owner.turnId) {
+    const item = params.item;
+    return item !== null && typeof item === "object" && "id" in item && item.id === owner.itemId;
+  }
+  return false;
+};
+
+// src/codex-native-approvals.ts
+import { createHash as createHash2, randomUUID } from "crypto";
+var record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var validId = (id) => typeof id === "string" && id.length > 0 && id.length <= 200 || typeof id === "number" && Number.isSafeInteger(id);
+var PATCH_LIMIT = 32;
+var WAIT_LIMIT_MS = 3e5;
+var CodexNativeApprovals = class {
+  constructor(options) {
+    this.options = options;
+  }
+  generation = randomUUID();
+  pending = /* @__PURE__ */ new Map();
+  retired = /* @__PURE__ */ new Set();
+  patches = /* @__PURE__ */ new Map();
+  tasks = /* @__PURE__ */ new Set();
+  closed = false;
+  handle(message, threadId, cwd = this.options.cwd) {
+    if (this.closed || !message.method) return false;
+    const p = message.params ?? {};
+    if (message.id === void 0) {
+      this.observe(message.method, p);
+      return false;
+    }
+    if (!validId(message.id) || !CODEX_NATIVE_APPROVAL_METHODS.some((method) => method === message.method)) return false;
+    if (this.retired.has(message.id)) return true;
+    const changes = this.patches.get(this.patchKey(p));
+    const approval = parseCodexNativeApproval({ method: message.method, params: p, ...changes ? { changes } : {} });
+    if (!approval || approval.threadId !== threadId) return false;
+    const repoKey = repoKeyFor(approval.cwd ?? cwd);
+    const subjectHash = createHash2("sha256").update(canonicalJsonText({ request: approval.request, cwd, repoKey })).digest("hex");
+    const existing = this.pending.get(message.id);
+    if (existing) {
+      if (existing.owner.subjectHash !== subjectHash) this.retire(message.id, existing, false);
+      return true;
+    }
+    if (this.pending.size >= 8) return false;
+    const owner = {
+      capability: CODEX_NATIVE_APPROVAL_CAPABILITY,
+      machineId: this.options.machineId,
+      generation: this.generation,
+      threadId: approval.threadId,
+      requestId: message.id,
+      subjectHash,
+      method: approval.request.method
+    };
+    const pending = { owner, approval, repoKey, cwd, controller: new AbortController(), replied: false, creating: true, correlationId: randomUUID() };
+    this.pending.set(message.id, pending);
+    const task = this.answer(pending).finally(() => {
+      this.tasks.delete(task);
+    });
+    this.tasks.add(task);
+    return true;
+  }
+  async close() {
+    this.closed = true;
+    for (const [id, pending] of this.pending) this.retire(id, pending, false);
+    await Promise.allSettled(this.tasks);
+  }
+  patchKey(params) {
+    return JSON.stringify([params.threadId, params.turnId, params.itemId]);
+  }
+  observe(method, params) {
+    if (method === "item/started" && record(params.item) && params.item.type === "fileChange" && Array.isArray(params.item.changes)) {
+      if (this.patches.size >= PATCH_LIMIT) this.patches.delete(this.patches.keys().next().value ?? "");
+      this.patches.set(this.patchKey({ ...params, itemId: params.item.id }), params.item.changes);
+    }
+    for (const [id, pending] of this.pending) {
+      const a = pending.approval;
+      const resolved = method === "serverRequest/resolved" && params.requestId === id;
+      const sameThread = params.threadId === a.threadId;
+      const closed = sameThread && (method === "thread/closed" || method === "thread/archived" || method === "turn/completed" && record(params.turn) && params.turn.id === a.turnId || method === "item/completed" && params.turnId === a.turnId && record(params.item) && params.item.id === a.itemId);
+      const patchChanged = method === "item/fileChange/patchUpdated" && sameThread && params.turnId === a.turnId && params.itemId === a.itemId;
+      if (resolved || closed || patchChanged) this.retire(id, pending, resolved || closed);
+    }
+    if (method === "item/fileChange/patchUpdated") this.patches.delete(this.patchKey(params));
+    if (method === "turn/completed" || method === "thread/closed" || method === "thread/archived") {
+      const scope = method === "turn/completed" && record(params.turn) ? [params.threadId, params.turn.id] : [params.threadId];
+      const prefix = JSON.stringify(scope).slice(0, -1) + ",";
+      for (const key of this.patches.keys()) if (key.startsWith(prefix)) this.patches.delete(key);
+    }
+  }
+  retire(id, pending, nativeClosed) {
+    pending.controller.abort();
+    this.pending.delete(id);
+    this.retired.add(id);
+    if (!nativeClosed && !this.closed && !pending.replied && !this.options.shared) {
+      this.options.reply(id, codexNativeApprovalResponse(pending.approval, "Deny"));
+      pending.replied = true;
+    }
+    const task = this.cleanup(pending, nativeClosed).finally(() => {
+      this.tasks.delete(task);
+    });
+    this.tasks.add(task);
+  }
+  async post(pending, operation, signal) {
+    const boundedSignal = AbortSignal.any([signal, AbortSignal.timeout(this.options.requestTimeoutMs ?? 1e4)]);
+    const response = await postLiveSession({ ...this.options, signal: boundedSignal }, "/api/agent/native-approval", {
+      operation,
+      owner: pending.owner,
+      request: pending.approval.request,
+      correlationId: pending.correlationId,
+      claimId: pending.claimId,
+      localSurfaceAvailable: this.options.shared,
+      cwd: pending.cwd,
+      repoKey: pending.repoKey
+    });
+    const body = await response.json();
+    if (!response.ok || !record(body)) throw new Error("Native approval service unavailable");
+    return body;
+  }
+  async cleanup(pending, nativeClosed) {
+    if (pending.creating || !pending.correlationId) return;
+    try {
+      const signal = AbortSignal.timeout(3e3);
+      while (!signal.aborted) {
+        const result = await this.post(pending, nativeClosed ? "request_closed" : "unavailable", signal);
+        if (result.recorded === true) return;
+        await liveSessionSleep(100, signal);
+      }
+      throw new Error("Native approval cleanup not recorded");
+    } catch {
+      writeDegraded("questions", { reason: "native_approval_cleanup_unconfirmed", fallback: "expiry", event: pending.owner.method });
+    }
+  }
+  async answer(pending) {
+    const signal = AbortSignal.any([this.options.signal, pending.controller.signal, AbortSignal.timeout(WAIT_LIMIT_MS)]);
+    try {
+      let created;
+      try {
+        created = await this.post(pending, "create", AbortSignal.timeout(this.options.requestTimeoutMs ?? 1e4));
+        pending.correlationId = typeof created.correlationId === "string" ? created.correlationId : void 0;
+      } finally {
+        pending.creating = false;
+      }
+      if (signal.aborted) return;
+      if (created.kind === "deny") {
+        this.options.reply(pending.owner.requestId, codexNativeApprovalResponse(pending.approval, "Deny"));
+        pending.replied = true;
+        return;
+      }
+      if (created.kind !== "ask" || !pending.correlationId) throw new Error("Native approval unavailable");
+      let answer = null;
+      while (!signal.aborted) {
+        const result = await callMcpTool(
+          this.options.apiKey,
+          "wait_for_answer",
+          { correlationId: pending.correlationId, timeoutMs: 25e3 },
+          { baseUrl: this.options.baseUrl, signal, timeoutMs: 27e3, maxRetries: 1 }
+        );
+        if (!isWaitForAnswerResponse(result)) throw new Error("Invalid native approval answer");
+        if (result.answered) {
+          answer = typeof result.value === "string" ? result.value : null;
+          break;
+        }
+        if (!("status" in result) || result.status !== "pending") throw new Error("Native approval no longer pending");
+        await liveSessionSleep(100, signal);
+      }
+      if (signal.aborted || !answer || !pending.approval.options.includes(answer)) throw new Error("No supported approval answer");
+      const claim = await this.post(pending, "claim", signal);
+      if (typeof claim.claimId !== "string" || !claim.claimId) throw new Error("Native approval dispatch refused");
+      pending.claimId = claim.claimId;
+      if (signal.aborted || this.pending.get(pending.owner.requestId) !== pending) return;
+      this.options.reply(pending.owner.requestId, codexNativeApprovalResponse(pending.approval, answer));
+      pending.replied = true;
+      await this.post(pending, "reply_queued", AbortSignal.timeout(3e3));
+    } catch {
+      if (!pending.controller.signal.aborted && !this.options.signal.aborted && !this.closed && !this.options.shared && !pending.replied) {
+        this.options.reply(pending.owner.requestId, codexNativeApprovalResponse(pending.approval, "Deny"));
+        pending.replied = true;
+      }
+      if (!pending.controller.signal.aborted && !this.options.signal.aborted) writeDegraded("questions", { reason: "native_approval_unavailable", fallback: this.options.shared ? "native client" : "refused", event: pending.owner.method });
+    } finally {
+      if (!pending.claimId || !pending.replied || signal.aborted) await this.cleanup(pending, false);
+    }
+  }
+};
+
+// src/question-dispatch.ts
+var claimOwnedQuestion = async (options, dispatch) => {
+  const response = await postLiveSession(options, "/api/agent/question/dispatch", {
+    owner: dispatch.owner,
+    correlationIds: dispatch.correlationIds,
+    operation: "claim"
+  });
+  const body = await response.json();
+  if (!response.ok || body === null || typeof body !== "object" || !("claimId" in body) || typeof body.claimId !== "string" || !body.claimId) throw new Error("Question delivery could not be claimed");
+  dispatch.claimId = body.claimId;
+};
+var reportOwnedQuestion = async (options, dispatch, operation) => {
+  if (dispatch.correlationIds.length === 0) return;
+  try {
+    const response = await postLiveSession({ ...options, signal: AbortSignal.timeout(3e3), requestTimeoutMs: 3e3 }, "/api/agent/question/dispatch", {
+      owner: dispatch.owner,
+      correlationIds: dispatch.correlationIds,
+      claimId: dispatch.claimId,
+      operation
+    });
+    if (!response.ok) throw new Error("Receipt refused");
+  } catch {
+    writeDegraded("questions", { reason: "question_receipt_unconfirmed", fallback: "no automatic replay", event: operation });
+  }
+};
+
+// src/codex-bridge.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/codex-elicitation.ts
+var planCodexElicitation = (params, threadId) => {
+  if (!threadId || params.threadId !== threadId || params.mode !== "form" || params._meta != null || typeof params.serverName !== "string" || !params.serverName.trim() || typeof params.message !== "string" || !params.message.trim()) return null;
+  const fields = readElicitationFields(params.requestedSchema);
+  if (!fields || fields.length > 3) return null;
+  const plan = [];
+  for (const [index, field] of fields.entries()) {
+    const question = `${params.serverName}: ${params.message} \u2014 ${field.label}`;
+    const ask = planElicitationAsk(question, [field]);
+    if (!ask || ask.kind === "questions" || question.length > 500) return null;
+    let labels = [];
+    if (ask.kind === "confirm") labels = ["Yes", "No"];
+    if (ask.kind === "select") labels = ask.options;
+    if (labels.length > 4 || labels.some((label) => label.length > 100)) return null;
+    plan.push({ ask, question: { id: String(index), question, isOther: false, options: labels.map((label) => ({ label })) } });
+  }
+  return plan;
+};
+var codexElicitationContent = (plan, answers) => {
+  let content = {};
+  for (const { ask, question } of plan) {
+    const values = answers[question.id]?.answers;
+    if (!values || values.length !== 1) return null;
+    const field = elicitationContent(ask, values[0]);
+    if (!field) return null;
+    content = { ...content, ...field };
+  }
+  return content;
+};
+
+// src/codex-bridge.ts
+import { spawn } from "child_process";
+import { basename } from "path";
+var MAX_RPC_LINE = 1024 * 1024;
+var STDERR_TAIL_LIMIT = 2e3;
+var FAILURE_MESSAGE_MAX = 240;
+var MAX_PENDING_RPC = 8;
+var QUESTION_UNAVAILABLE = "Question unavailable";
+var LOCAL_QUESTION_UNAVAILABLE = "Pushary handed this question to the current client, but this Codex bridge has no local question UI. Continue in an interactive Codex session, or choose a Pushary mode that permits remote questions.";
+var MAX_TRANSCRIPT_TEXT = 32 * 1024;
+var MAX_MESSAGE_BUFFERS = 16;
+var JsonRpcClient = class {
+  constructor(command, cwd, timeoutMs, bridgeOptions) {
+    this.bridgeOptions = bridgeOptions;
+    this.approvals = new CodexNativeApprovals({ ...bridgeOptions, shared: false, reply: (id, result) => this.write({ id, result }) });
+    this.threadId = bridgeOptions.resumeThreadId ?? null;
+    const options = { cwd, env: { ...process.env, PUSHARY_CODEX_BRIDGE: "1" }, stdio: ["pipe", "pipe", "pipe"] };
+    this.child = process.platform === "win32" ? spawnClaude(command.command, command.args ?? [], options) : spawn(command.command, command.args ?? [], options);
+    this.child.stdout?.setEncoding("utf8");
+    this.child.stdout?.on("data", (chunk) => this.read(String(chunk)));
+    this.child.stderr?.setEncoding("utf8");
+    this.child.stderr?.on("data", (chunk) => this.keepStderrTail(String(chunk)));
+    this.child.once("error", (error) => this.fail(error));
+    this.child.once("exit", (code, signal) => this.fail(new Error(this.exitMessage(code, signal))));
+    this.timeoutMs = timeoutMs;
+  }
+  approvals;
+  child;
+  pending = /* @__PURE__ */ new Map();
+  notifications = /* @__PURE__ */ new Set();
+  generation = randomUUID2();
+  serverRequests = /* @__PURE__ */ new Map();
+  threadId = null;
+  nextId = 1;
+  buffer = "";
+  closed = false;
+  stderrTail = "";
+  failure = null;
+  keepStderrTail(chunk) {
+    this.stderrTail = (this.stderrTail + chunk).slice(-STDERR_TAIL_LIMIT);
+  }
+  exitMessage(code, signal) {
+    const how = signal ? `signal ${signal}` : `code ${code ?? "unknown"}`;
+    const tail = this.stderrTail.trim();
+    return tail ? `Codex app-server exited (${how}): ${tail}` : `Codex app-server exited (${how})`;
+  }
+  timeoutMs;
+  get isClosed() {
+    return this.closed;
+  }
+  get closedReason() {
+    return this.failure?.message ?? "Codex app-server exited";
+  }
+  onNotification(listener) {
+    this.notifications.add(listener);
+    return () => this.notifications.delete(listener);
+  }
+  bindThread(threadId) {
+    this.threadId = threadId;
+  }
+  notify(method) {
+    this.write({ method });
+  }
+  request(method, params) {
+    if (this.closed) return Promise.reject(new Error("Codex app-server is closed"));
+    if (this.pending.size >= MAX_PENDING_RPC) return Promise.reject(new Error("Codex app-server request limit reached"));
+    const id = this.nextId++;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`${method} timed out`));
+      }, this.timeoutMs);
+      this.pending.set(id, { resolve, reject, timer });
+      this.write({ id, method, params });
+    });
+  }
+  async close() {
+    await this.approvals.close();
+    if (this.closed) return;
+    this.closed = true;
+    for (const request of this.serverRequests.values()) {
+      request.controller.abort();
+      if (request.dispatch) void reportOwnedQuestion(this.bridgeOptions, request.dispatch, "unavailable");
+    }
+    this.serverRequests.clear();
+    this.child.stdin?.end();
+    if (this.child.exitCode != null) return;
+    await Promise.race([
+      new Promise((resolve) => this.child.once("exit", () => resolve())),
+      new Promise((resolve) => setTimeout(resolve, 1e3))
+    ]);
+    if (this.child.exitCode == null) this.child.kill();
+    this.rejectPending(new Error("Codex app-server closed"));
+  }
+  write(value) {
+    this.child.stdin?.write(`${JSON.stringify(value)}
+`);
+  }
+  read(chunk) {
+    this.buffer += chunk;
+    if (this.buffer.length > MAX_RPC_LINE && !this.buffer.includes("\n")) {
+      this.fail(new Error("Codex app-server sent an oversized message"));
+      return;
+    }
+    let newline = this.buffer.indexOf("\n");
+    while (newline >= 0) {
+      const line = this.buffer.slice(0, newline);
+      this.buffer = this.buffer.slice(newline + 1);
+      if (line.length > MAX_RPC_LINE) {
+        this.fail(new Error("Codex app-server sent an oversized message"));
+        return;
+      }
+      this.handle(line);
+      newline = this.buffer.indexOf("\n");
+    }
+  }
+  handle(line) {
+    let message;
+    try {
+      const parsed = JSON.parse(line);
+      if (!isRpcMessage(parsed)) return;
+      message = parsed;
+    } catch {
+      return;
+    }
+    if (this.approvals.handle(message, this.threadId)) return;
+    if (message.id !== void 0 && (message.method === "item/tool/requestUserInput" || message.method === "mcpServer/elicitation/request")) {
+      const id = message.id;
+      const owner = message.method === "item/tool/requestUserInput" ? codexQuestionOwner(message.params ?? {}, id, { machineId: this.bridgeOptions.machineId, generation: this.generation, threadId: this.threadId }) : null;
+      if (message.method === "item/tool/requestUserInput" && !owner) {
+        this.write({ id, error: { code: -32e3, message: "Unsupported question ownership" } });
+        return;
+      }
+      const existing = this.serverRequests.get(id);
+      if (existing) {
+        if (existing.dispatch && existing.dispatch.owner.subjectHash !== owner?.subjectHash) existing.controller.abort();
+        return;
+      }
+      if (this.serverRequests.size >= MAX_PENDING_RPC) {
+        this.write({ id, error: { code: -32e3, message: "Too many pending user questions" } });
+        return;
+      }
+      const controller = new AbortController();
+      const now = this.bridgeOptions.now ?? Date.now;
+      const duration = message.params?.autoResolutionMs;
+      if (duration != null && (typeof duration !== "number" || !Number.isFinite(duration) || duration < 0)) {
+        this.write({ id, error: { code: -32e3, message: "Invalid question deadline" } });
+        return;
+      }
+      const deadline = typeof duration === "number" ? now() + duration : null;
+      const dispatch = owner ? { owner, correlationIds: [], deadline } : void 0;
+      this.serverRequests.set(id, { controller, dispatch });
+      const signal = AbortSignal.any([controller.signal, this.bridgeOptions.signal]);
+      const answer = message.method === "mcpServer/elicitation/request" ? answerCodexElicitation(this.bridgeOptions, message.params ?? {}, this.threadId, signal) : answerCodexQuestions(this.bridgeOptions, message.params ?? {}, signal, "request_user_input", dispatch);
+      void answer.then(
+        async (result) => {
+          if (signal.aborted || this.closed) return;
+          if (dispatch) await claimOwnedQuestion(this.bridgeOptions, dispatch);
+          if (signal.aborted || this.closed || this.serverRequests.get(id)?.controller !== controller) return;
+          if (deadline !== null && now() >= deadline) throw new Error("Question expired");
+          this.write({ id, result });
+          if (dispatch) await reportOwnedQuestion(this.bridgeOptions, dispatch, "reply_queued");
+        },
+        (error) => {
+          if (!signal.aborted && !this.closed) this.write({ id, error: { code: -32e3, message: error instanceof Error && error.message === LOCAL_QUESTION_UNAVAILABLE ? LOCAL_QUESTION_UNAVAILABLE : "No user answer was received through Pushary" } });
+        }
+      ).catch(() => {
+        if (!signal.aborted && !this.closed) this.write({ id, error: { code: -32e3, message: "Question delivery is unconfirmed; no automatic retry" } });
+      }).finally(async () => {
+        if (dispatch && (signal.aborted || !dispatch.claimId)) await reportOwnedQuestion(this.bridgeOptions, dispatch, "unavailable");
+        if (!dispatch?.claimId || signal.aborted) this.serverRequests.delete(id);
+      });
+      return;
+    }
+    if (message.id !== void 0 && message.method) {
+      const result = message.method === "item/commandExecution/requestApproval" || message.method === "item/fileChange/requestApproval" ? { decision: "decline" } : message.method === "applyPatchApproval" || message.method === "execCommandApproval" ? { decision: { denied: { rejection: "No interactive Codex client is attached" } } } : null;
+      this.write(result ? { id: message.id, result } : { id: message.id, error: { code: -32601, message: "Unsupported server request" } });
+      return;
+    }
+    if (typeof message.id === "number") {
+      const pending = this.pending.get(message.id);
+      if (!pending) return;
+      this.pending.delete(message.id);
+      clearTimeout(pending.timer);
+      if (message.error) pending.reject(new Error(message.error.message ?? "Codex app-server request failed"));
+      else pending.resolve(message.result);
+      return;
+    }
+    if (message.method) {
+      for (const request of this.serverRequests.values()) {
+        if (request.dispatch && closesOwnedQuestion(request.dispatch.owner, message.method, message.params ?? {})) {
+          request.controller.abort();
+          void reportOwnedQuestion(this.bridgeOptions, request.dispatch, "request_closed");
+          this.serverRequests.delete(request.dispatch.owner.requestId);
+        } else if (!request.dispatch && message.method === "serverRequest/resolved") {
+          const id = message.params?.requestId;
+          if ((typeof id === "string" || typeof id === "number") && this.serverRequests.get(id) === request) request.controller.abort();
+        }
+      }
+    }
+    if (message.method) {
+      for (const listener of this.notifications) listener(message);
+    }
+  }
+  fail(error) {
+    void this.approvals.close();
+    if (this.closed) return;
+    this.closed = true;
+    this.failure = error;
+    for (const request of this.serverRequests.values()) {
+      request.controller.abort();
+      if (request.dispatch) void reportOwnedQuestion(this.bridgeOptions, request.dispatch, "unavailable");
+    }
+    this.serverRequests.clear();
+    this.rejectPending(error);
+    if (this.child.exitCode == null) this.child.kill();
+  }
+  rejectPending(error) {
+    for (const pending of this.pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+    }
+    this.pending.clear();
+  }
+};
+var isJsonObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var object = (value) => isJsonObject(value) ? value : null;
+var isRpcMessage = (value) => isJsonObject(value) && (value.id === void 0 || typeof value.id === "string" || typeof value.id === "number" && Number.isFinite(value.id)) && (value.method === void 0 || typeof value.method === "string") && (value.params === void 0 || isJsonObject(value.params)) && (value.error === void 0 || isJsonObject(value.error) && (value.error.message === void 0 || typeof value.error.message === "string"));
+var string = (value) => typeof value === "string" && value.length > 0 ? value : null;
+var input = (text) => [{ type: "text", text, text_elements: [] }];
+var rpcThreadId = (result) => string(object(object(result)?.thread)?.id);
+var rpcTurnId = (result) => {
+  const response = object(result);
+  return string(object(response?.turn)?.id) ?? string(response?.turnId);
+};
+var readCodexBridgeQuestion = (raw) => {
+  const question = object(raw);
+  const id = string(question?.id);
+  const prompt = string(question?.question);
+  if (!question || !id || !prompt || prompt.length > ASK_QUESTION_MAX || question.isSecret != null && question.isSecret !== false || question.isOther != null && typeof question.isOther !== "boolean" || question.multiSelect != null && question.multiSelect !== false || question.header !== void 0 && typeof question.header !== "string") throw new Error("Unsupported question");
+  const hasChoices = question.options != null && !(Array.isArray(question.options) && question.options.length === 0);
+  const structured = hasChoices ? parseCodexQuestions("request_user_input", { questions: [{ ...question, multiSelect: false, allowOther: question.isOther === true }] })?.[0] : void 0;
+  if (hasChoices && !structured) throw new Error("Unsupported question");
+  const headerLimit = structured ? AGENT_QUESTION_HEADER_MAX : ASK_CONTEXT_MAX;
+  if (typeof question.header === "string" && question.header.length > headerLimit || structured?.options.some((option) => option.label.length > AGENT_QUESTION_OPTION_MAX || (option.description?.length ?? 0) > AGENT_QUESTION_DESCRIPTION_MAX)) throw new Error("Unsupported question");
+  return { question, id, prompt, structured };
+};
+var answerCodexQuestions = async (options, params, signal, toolName = "request_user_input", dispatch) => {
+  if (!Array.isArray(params.questions) || !params.questions.length || params.questions.length > 3) throw new Error("Invalid questions");
+  const questions = params.questions.map(readCodexBridgeQuestion);
+  if (new Set(questions.map((question) => question.id)).size !== questions.length) throw new Error("Unsupported question");
+  const answers = /* @__PURE__ */ Object.create(null);
+  const now = options.now ?? Date.now;
+  if (params.autoResolutionMs != null && (typeof params.autoResolutionMs !== "number" || !Number.isFinite(params.autoResolutionMs) || params.autoResolutionMs < 0)) throw new Error("Invalid question deadline");
+  const deadline = dispatch ? dispatch.deadline : typeof params.autoResolutionMs === "number" ? now() + params.autoResolutionMs : null;
+  for (const { question, id, prompt, structured } of questions) {
+    if (signal.aborted || deadline !== null && now() >= deadline) throw new Error("Question expired");
+    const labels = structured?.options.map((option) => option.label) ?? [];
+    let correlationId = null;
+    let settled = false;
+    const call = async (name, args, timeoutMs, waitSignal = signal) => {
+      const result = await callMcpTool(options.apiKey, name, args, { baseUrl: options.baseUrl, signal: waitSignal, timeoutMs, maxRetries: 1 });
+      if (name === "wait_for_answer" && !isWaitForAnswerResponse(result)) throw new Error("Invalid wait_for_answer response");
+      return result;
+    };
+    try {
+      signal.throwIfAborted();
+      if (deadline !== null && now() >= deadline) throw new Error("Question expired");
+      const createTimeout = deadline === null ? 1e4 : Math.min(1e4, deadline - now());
+      let result = await call("ask_user", {
+        ...dispatch ? { questionOwner: dispatch.owner } : {},
+        requestId: randomUUID2(),
+        question: prompt,
+        type: labels.length >= 2 ? "select" : "input",
+        ...labels.length >= 2 ? { options: labels } : {},
+        ...structured ? { questions: [structured] } : {},
+        context: string(question?.header),
+        agentName: `Codex - ${basename(options.cwd)}`,
+        sessionId: params.threadId,
+        machineId: options.machineId,
+        toolName,
+        wait: false,
+        ...deadline === null ? {} : { waitEndsAt: new Date(deadline).toISOString() },
+        localSurfaceAvailable: options.shared ?? false
+      }, createTimeout, options.shared ? AbortSignal.timeout(createTimeout) : signal);
+      correlationId = string(object(result)?.correlationId);
+      if (!isAskUserResponse(result)) throw new Error("Invalid ask_user response");
+      if (correlationId && dispatch) dispatch.correlationIds.push(correlationId);
+      while (!result.answered) {
+        if (result.status === "terminal" || result.status === "notified" || result.suppressed || result.mode === "terminal_only" || result.mode === "notify_only") {
+          if (correlationId) {
+            const withdrawn = await withdrawQuestion(options.apiKey, correlationId, {
+              cancelQuestion: (_key, id2, abort) => call("cancel_question", { correlationId: id2 }, 3e3, abort),
+              waitForAnswer: (_key, id2, timeoutMs, abort) => call("wait_for_answer", { correlationId: id2, timeoutMs }, 2e3, abort)
+            });
+            result = { ...withdrawn };
+            settled = withdrawn.answered || withdrawn.status === "withdrawn" || isDecisionStopped(withdrawn);
+            if (withdrawn.answered) break;
+            if (isDecisionStopped(withdrawn)) throw new Error(QUESTION_UNAVAILABLE);
+          }
+          throw new Error(LOCAL_QUESTION_UNAVAILABLE);
+        }
+        if (signal.aborted) throw new Error("Question cancelled");
+        if (!correlationId || result.handoffAction === "stop" && result.status !== "unavailable" || result.noDevices || result.status && result.status !== "pending" && result.status !== "unavailable") throw new Error(QUESTION_UNAVAILABLE);
+        const remaining = deadline === null ? 27e3 : deadline - now();
+        if (remaining <= 0) throw new Error("Question expired");
+        try {
+          result = await call("wait_for_answer", { correlationId, timeoutMs: Math.min(25e3, remaining) }, Math.min(27e3, remaining));
+        } catch (error) {
+          if (signal.aborted || !isRetryable(error)) throw error;
+          await liveSessionSleep(2e3, signal);
+          continue;
+        }
+        if (!result.answered) await liveSessionSleep(result.status === "unavailable" ? 2e3 : 100, signal);
+      }
+      if (signal.aborted || deadline !== null && now() >= deadline) throw new Error("Question expired");
+      settled = true;
+      const rawValue = string(result.value);
+      const value = rawValue && structured ? (parseAgentQuestionAnswers([structured], rawValue) ?? parseAgentQuestionAnswers([structured], JSON.stringify({ [prompt]: rawValue })))?.[prompt] : rawValue;
+      if (!value || value === "defer" || labels.length && question?.isOther !== true && !labels.includes(value)) throw new Error("Invalid answer");
+      answers[id] = { answers: [value] };
+    } finally {
+      if (correlationId && !settled) {
+        await call("cancel_question", { correlationId }, 3e3, AbortSignal.timeout(3e3)).catch(() => {
+        });
+      }
+    }
+  }
+  return { answers };
+};
+var answerCodexElicitation = async (options, params, threadId, signal) => {
+  const plan = planCodexElicitation(params, threadId);
+  if (!plan) {
+    writeDegraded("questions", { reason: "unsupported_codex_elicitation", fallback: "no form answer submitted", event: "mcpServer/elicitation/request" });
+    return { action: "cancel", content: null };
+  }
+  try {
+    const result = await answerCodexQuestions(options, {
+      threadId,
+      questions: plan.map((field) => field.question)
+    }, signal, "Elicitation");
+    const content = codexElicitationContent(plan, result.answers);
+    if (!content) throw new Error("Invalid elicitation answer");
+    return { action: "accept", content };
+  } catch {
+    writeDegraded("questions", { reason: "codex_elicitation_unanswered", fallback: "no form answer submitted", event: "mcpServer/elicitation/request" });
+    return { action: "cancel", content: null };
+  }
+};
+var runCodexBridge = async (options) => {
+  const timeoutMs = options.requestTimeoutMs ?? 1e4;
+  const now = options.now ?? Date.now;
+  const idleTimeoutMs = options.idleTimeoutMs ?? SESSION_IDLE_TIMEOUT_MS;
+  const rpc = new JsonRpcClient(options.appServer, options.cwd, timeoutMs, options);
+  let threadId = options.resumeThreadId ?? null;
+  let activeTurnId = null;
+  let lastCompletedTurnId = null;
+  let idleSince = now();
+  let idledOut = false;
+  let relay = null;
+  let linked = false;
+  let stopHeartbeat = () => {
+  };
+  let ownership = null;
+  const messages = /* @__PURE__ */ new Map();
+  const idleDeadlineReached = () => activeTurnId === null && idleDeadlinePassed(idleSince, now(), idleTimeoutMs);
+  const reportBody = (event, action) => ({
+    event,
+    action,
+    agentType: "codex",
+    agentName: `Codex - ${basename(options.cwd)}`,
+    sessionId: threadId,
+    codexThreadId: threadId,
+    spawnId: options.spawnId,
+    machineId: options.machineId,
+    pid: process.pid,
+    cwd: options.cwd
+  });
+  const report = (event, action) => postLiveSession(options, "/api/agent/event", reportBody(event, action));
+  const removeNotification = rpc.onNotification((message) => {
+    const params = message.params ?? {};
+    if (message.method === "turn/started") activeTurnId = string(object(params.turn)?.id);
+    if (message.method === "turn/completed") {
+      lastCompletedTurnId = string(object(params.turn)?.id) ?? activeTurnId;
+      activeTurnId = null;
+      idleSince = now();
+      void report("stop", "Turn completed").catch(() => {
+      });
+    }
+    if (message.method === "item/agentMessage/delta") {
+      const itemId = string(params.itemId);
+      const delta = string(params.delta);
+      if (!itemId || !delta) return;
+      if (!messages.has(itemId) && messages.size === MAX_MESSAGE_BUFFERS) {
+        const oldest = messages.keys().next().value;
+        if (typeof oldest === "string") messages.delete(oldest);
+      }
+      messages.set(itemId, `${messages.get(itemId) ?? ""}${delta}`.slice(0, MAX_TRANSCRIPT_TEXT));
+    }
+    if (message.method === "item/completed") {
+      const itemId = string(object(params.item)?.id);
+      const text = itemId ? messages.get(itemId) : null;
+      if (!itemId || !text) return;
+      messages.delete(itemId);
+      relay?.add({ type: "assistant", uuid: itemId, message: { role: "assistant", content: text } });
+    }
+  });
+  try {
+    await rpc.request("initialize", {
+      clientInfo: { name: "pushary", title: "Pushary", version: "1" },
+      capabilities: { experimentalApi: true, requestAttestation: false }
+    });
+    rpc.notify("initialized");
+    const thread = options.resumeThreadId ? await rpc.request("thread/resume", { threadId: options.resumeThreadId, cwd: options.cwd, excludeTurns: true }) : await rpc.request("thread/start", { cwd: options.cwd, model: options.model ?? null });
+    threadId = rpcThreadId(thread);
+    if (threadId) rpc.bindThread(threadId);
+    if (!threadId) throw new Error("Codex app-server did not return a thread id");
+    ownership = startProcessOwnership({ sessionId: threadId, pid: process.pid, spawnId: options.spawnId });
+    await ownership.ready;
+    relay = options.transcripts === false ? null : new LiveTranscriptRelay(options, threadId);
+    await postLiveSessionUntilAccepted(
+      options,
+      "/api/agent/event",
+      reportBody("session_start", options.resumeThreadId ? "Session resumed" : "Session started")
+    );
+    linked = true;
+    stopHeartbeat = startLiveSessionHeartbeat(
+      options,
+      reportBody("heartbeat", "Session online"),
+      void 0,
+      () => ownership?.touch()
+    );
+    const startTurn = async (text, commandId) => {
+      relay?.add({ type: "user", uuid: commandId, message: { role: "user", content: text } });
+      const result = activeTurnId ? await rpc.request("turn/steer", {
+        threadId,
+        expectedTurnId: activeTurnId,
+        input: input(text),
+        clientUserMessageId: commandId
+      }) : await rpc.request("turn/start", {
+        threadId,
+        input: input(text),
+        cwd: options.cwd,
+        model: options.model ?? null,
+        clientUserMessageId: commandId
+      });
+      const startedTurnId = rpcTurnId(result);
+      if (startedTurnId && startedTurnId !== lastCompletedTurnId) activeTurnId = startedTurnId;
+    };
+    if (options.prompt) await startTurn(options.prompt, `spawn-${options.spawnId}`);
+    let pendingAck = null;
+    while (!options.signal.aborted && !rpc.isClosed) {
+      if (idleDeadlineReached()) {
+        idledOut = true;
+        break;
+      }
+      try {
+        if (pendingAck) {
+          const acknowledged = await postLiveSession(options, "/api/agent/command/ack", pendingAck);
+          if (acknowledged.ok) pendingAck = null;
+        }
+        if (pendingAck) {
+          await liveSessionSleep(options.pollIntervalMs ?? 2e3, options.signal);
+          continue;
+        }
+        const response = await postLiveSession(options, "/api/agent/command/drain", {
+          sessionId: threadId,
+          machineId: options.machineId,
+          ackMode: true
+        });
+        if (response.ok) {
+          const command = object((await response.json()).command);
+          const commandId = string(command?.id);
+          const text = string(command?.text);
+          if (commandId && text) {
+            idleSince = now();
+            try {
+              await startTurn(text, commandId);
+              pendingAck = {
+                commandId,
+                sessionId: threadId,
+                machineId: options.machineId,
+                state: "delivered"
+              };
+            } catch {
+              pendingAck = {
+                commandId,
+                sessionId: threadId,
+                machineId: options.machineId,
+                state: "failed",
+                failureCode: "codex_rejected"
+              };
+            }
+          }
+        }
+      } catch {
+      }
+      await relay?.flush();
+      await liveSessionSleep(options.pollIntervalMs ?? 2e3, options.signal);
+    }
+    if (rpc.isClosed && !options.signal.aborted) throw new Error(rpc.closedReason);
+    if (activeTurnId) {
+      await rpc.request("turn/interrupt", { threadId, turnId: activeTurnId }).catch(() => null);
+    }
+    await relay?.flush();
+    await report(
+      "session_closed",
+      idledOut ? `Session ended after ${describeIdleWindow(idleTimeoutMs)} idle` : "Session stopped"
+    ).catch(() => null);
+    return "stopped";
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (!linked && options.claimId) {
+      for (let attempt = 0; attempt < 3; attempt++) {
+        const acknowledged = await postLiveSession(options, "/api/agent/spawn/ack", {
+          spawnId: options.spawnId,
+          claimId: options.claimId,
+          machineId: options.machineId,
+          state: "failed",
+          failure: {
+            code: "bridge_failed",
+            message: message.slice(0, FAILURE_MESSAGE_MAX),
+            retryable: false
+          }
+        }).catch(() => null);
+        if (acknowledged?.ok) break;
+        await liveSessionSleep(200 * (attempt + 1), options.signal);
+      }
+    }
+    await report("error", `Live bridge failed: ${message}`.slice(0, FAILURE_MESSAGE_MAX)).catch(() => null);
+    return "failed";
+  } finally {
+    stopHeartbeat();
+    ownership?.stop();
+    removeNotification();
+    await rpc.close();
+  }
+};
+
+export {
+  codexQuestionOwner,
+  closesOwnedQuestion,
+  CodexNativeApprovals,
+  claimOwnedQuestion,
+  reportOwnedQuestion,
+  planCodexElicitation,
+  answerCodexQuestions,
+  answerCodexElicitation,
+  runCodexBridge
+};