@pushary/agent-hooks 1.9.43 → 1.9.45

package/dist/bin/pushary-codex-bridge.js

@@ -1,703 +1,45 @@
 #!/usr/bin/env node
 import {
-  LiveTranscriptRelay,
-  liveSessionSleep,
-  postLiveSession,
-  postLiveSessionUntilAccepted,
-  startLiveSessionHeartbeat
-} from "../chunk-IDVKJICN.js";
+  transcriptsEnabled
+} from "../chunk-7SGYCU5C.js";
+import "../chunk-YK7FGPYS.js";
+import {
+  runCodexBridge
+} from "../chunk-6JPDAUFP.js";
+import "../chunk-EKGQEDQ4.js";
 import {
   resolveProviderBinary
-} from "../chunk-NV2LARV4.js";
+} from "../chunk-WPPKXVV3.js";
 import "../chunk-RIVNNBEK.js";
 import {
-  SESSION_IDLE_TIMEOUT_MS,
-  describeIdleWindow,
-  idleDeadlinePassed,
-  startProcessOwnership,
   withSpawnProcessOwnership
-} from "../chunk-LWW7SBK3.js";
-import "../chunk-MSUMSXTI.js";
-import "../chunk-J6MVBWF2.js";
-import {
-  transcriptsEnabled
-} from "../chunk-VQL62ECJ.js";
-import {
-  spawnClaude
-} from "../chunk-XHKBHWLX.js";
+} from "../chunk-H4ODQD3Y.js";
+import "../chunk-SIN7NJD7.js";
+import "../chunk-RFQWB5ZV.js";
+import "../chunk-XHKBHWLX.js";
 import "../chunk-6ICPEJY5.js";
-import "../chunk-C3RVRTHS.js";
-import {
-  isAskUserResponse,
-  isDecisionStopped,
-  isWaitForAnswerResponse,
-  withdrawQuestion,
-  writeDegraded
-} from "../chunk-4T2TGP4T.js";
+import "../chunk-CFMCV6Z7.js";
+import "../chunk-CDERSTBO.js";
 import "../chunk-POFBE6ZY.js";
-import {
-  callMcpTool,
-  isRetryable
-} from "../chunk-53KLSE2F.js";
-import "../chunk-C54VJJ37.js";
-import "../chunk-H6V5S52A.js";
+import "../chunk-SFQSOBLM.js";
+import "../chunk-PWUIPQ2I.js";
+import "../chunk-6TYKZ4DN.js";
 import {
   getMachineId
-} from "../chunk-W3BO56VE.js";
+} from "../chunk-4A6VUVXV.js";
 import "../chunk-7QLSKOSU.js";
 import "../chunk-KZERVKTD.js";
-import "../chunk-LAAOHBLO.js";
-import "../chunk-S3OWTQ6Z.js";
+import "../chunk-IOVJVGIT.js";
 import "../chunk-AQFEP65J.js";
 import {
   getApiKey,
   getBaseUrl
-} from "../chunk-GTOBOC6M.js";
-import "../chunk-LDCRV6HG.js";
-import {
-  AGENT_QUESTION_DESCRIPTION_MAX,
-  AGENT_QUESTION_HEADER_MAX,
-  AGENT_QUESTION_OPTION_MAX,
-  ASK_CONTEXT_MAX,
-  ASK_QUESTION_MAX,
-  PERSONAL_QUESTION_CAPABILITY,
-  canonicalJsonText,
-  elicitationContent,
-  isQuestionOwner,
-  parseAgentQuestionAnswers,
-  parseCodexQuestions,
-  planElicitationAsk,
-  readElicitationFields
-} from "../chunk-RXXKFM22.js";
+} from "../chunk-EWC4P4ZL.js";
+import "../chunk-57M4ERJK.js";
+import "../chunk-K7EGWMDU.js";
 
 // bin/pushary-codex-bridge.ts
 import { existsSync } from "fs";
-
-// 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/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 } 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.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;
-  }
-  child;
-  pending = /* @__PURE__ */ new Map();
-  notifications = /* @__PURE__ */ new Set();
-  generation = randomUUID();
-  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() {
-    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 (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.dispatch.claimId ? "request_closed" : "unavailable");
-          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) {
-    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");
-      let result = await call("ask_user", {
-        ...dispatch ? { questionOwner: dispatch.owner } : {},
-        requestId: randomUUID(),
-        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: false
-      }, deadline === null ? 1e4 : Math.min(1e4, deadline - now()));
-      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, abort2) => call("cancel_question", { correlationId: id2 }, 3e3, abort2),
-              waitForAnswer: (_key, id2, timeoutMs, abort2) => call("wait_for_answer", { correlationId: id2, timeoutMs }, 2e3, abort2)
-            });
-            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();
-  }
-};
-
-// bin/pushary-codex-bridge.ts
 var spawnId = process.env.PUSHARY_SPAWN_ID?.trim();
 var requestedCwd = process.env.PUSHARY_BRIDGE_CWD?.trim();
 if (!spawnId || !requestedCwd || !existsSync(requestedCwd)) {