pushary 1.8.0

package/dist/bin/pushary-codex-bridge.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

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

@@ -0,0 +1,599 @@
+#!/usr/bin/env node
+import "../chunk-HQ6G3B5R.js";
+import {
+  LiveTranscriptRelay,
+  liveSessionSleep,
+  postLiveSession,
+  postLiveSessionUntilAccepted,
+  startLiveSessionHeartbeat
+} from "../chunk-R7437YI3.js";
+import {
+  SESSION_IDLE_TIMEOUT_MS,
+  describeIdleWindow,
+  idleDeadlinePassed,
+  startProcessOwnership,
+  withSpawnProcessOwnership
+} from "../chunk-ZSZSSJCV.js";
+import "../chunk-MPWXGONV.js";
+import "../chunk-SAXBC4AZ.js";
+import {
+  transcriptsEnabled
+} from "../chunk-OLQRRFBX.js";
+import {
+  spawnClaude
+} from "../chunk-XHKBHWLX.js";
+import {
+  isAskUserResponse,
+  isDecisionStopped,
+  isWaitForAnswerResponse,
+  withdrawQuestion
+} from "../chunk-NGDD6TXY.js";
+import {
+  writeDegraded
+} from "../chunk-CVQYGMSR.js";
+import "../chunk-POFBE6ZY.js";
+import "../chunk-P7WQEVWA.js";
+import {
+  callMcpTool
+} from "../chunk-M5ICYGHT.js";
+import "../chunk-2ABTSGFT.js";
+import "../chunk-2OY3ZZ5N.js";
+import {
+  getMachineId
+} from "../chunk-LXQ5FBBD.js";
+import "../chunk-7QLSKOSU.js";
+import "../chunk-KZERVKTD.js";
+import "../chunk-DB3ONZB4.js";
+import {
+  resolveBinary
+} from "../chunk-A2A2YTMG.js";
+import "../chunk-T7E75EKA.js";
+import {
+  getApiKey,
+  getBaseUrl
+} from "../chunk-GPEGOGRJ.js";
+import "../chunk-E4FJTUH4.js";
+import {
+  elicitationContent,
+  parseAgentQuestion,
+  parseAgentQuestionAnswers,
+  planElicitationAsk,
+  readElicitationFields
+} from "../chunk-NQTHFF4W.js";
+
+// bin/pushary-codex-bridge.ts
+import { existsSync } from "fs";
+
+// 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, 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();
+  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.abort();
+    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;
+      if (this.serverRequests.has(id)) 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();
+      this.serverRequests.set(id, controller);
+      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);
+      void answer.then(
+        (result) => {
+          if (!signal.aborted && !this.closed) this.write({ id, result });
+        },
+        (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" } });
+        }
+      ).finally(() => 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 === "serverRequest/resolved") {
+      const id = message.params?.requestId;
+      if (typeof id === "number" || typeof id === "string") this.serverRequests.get(id)?.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.abort();
+    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 answerCodexQuestions = async (options, params, signal, toolName = "request_user_input") => {
+  if (!Array.isArray(params.questions) || !params.questions.length || params.questions.length > 3) throw new Error("Invalid questions");
+  const answers = /* @__PURE__ */ Object.create(null);
+  const deadline = Date.now() + Math.min(12e4, typeof params.autoResolutionMs === "number" ? Math.max(0, params.autoResolutionMs) : 12e4);
+  for (const raw of params.questions) {
+    if (signal.aborted || Date.now() >= deadline) throw new Error("Question expired");
+    const question = object(raw);
+    const id = string(question?.id);
+    const prompt = string(question?.question);
+    if (!id || !prompt || id in answers || question?.isSecret === true) throw new Error("Unsupported question");
+    const labels = Array.isArray(question?.options) ? question.options.map((option) => string(object(option)?.label)).filter((label) => !!label) : [];
+    const structured = labels.length >= 2 ? parseAgentQuestion({ ...question, multiSelect: false, allowOther: question?.isOther === true }) : void 0;
+    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 (Date.now() >= deadline) throw new Error("Question expired");
+      let result = await call("ask_user", {
+        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,
+        waitEndsAt: new Date(deadline).toISOString()
+      }, Math.min(1e4, deadline - Date.now()));
+      correlationId = string(object(result)?.correlationId);
+      if (!isAskUserResponse(result)) throw new Error("Invalid ask_user response");
+      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 (!correlationId || result.handoffAction === "stop" || result.noDevices || result.status && result.status !== "pending") throw new Error(QUESTION_UNAVAILABLE);
+        const remaining = deadline - Date.now();
+        if (remaining <= 0) throw new Error("Question expired");
+        result = await call("wait_for_answer", { correlationId, timeoutMs: Math.min(25e3, remaining) }, Math.min(27e3, remaining));
+        if (!result.answered) await liveSessionSleep(100, signal);
+      }
+      if (signal.aborted || Date.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)) {
+  process.stderr.write("[pushary] Codex bridge received an invalid launch request\n");
+  process.exit(1);
+}
+var abort = new AbortController();
+var signals = process.platform === "win32" ? ["SIGINT", "SIGTERM"] : ["SIGINT", "SIGTERM", "SIGHUP"];
+var stop = () => abort.abort();
+for (const signal of signals) process.on(signal, stop);
+var outcome = await withSpawnProcessOwnership(spawnId, () => runCodexBridge({
+  apiKey: getApiKey(),
+  baseUrl: getBaseUrl(),
+  machineId: getMachineId(),
+  spawnId,
+  claimId: process.env.PUSHARY_SPAWN_CLAIM_ID?.trim() || void 0,
+  cwd: requestedCwd,
+  prompt: process.env.PUSHARY_BRIDGE_PROMPT?.trim() || void 0,
+  model: process.env.PUSHARY_BRIDGE_MODEL?.trim() || void 0,
+  resumeThreadId: process.env.PUSHARY_BRIDGE_RESUME_SESSION_ID?.trim() || void 0,
+  appServer: {
+    command: process.env.PUSHARY_CODEX_COMMAND?.trim() || resolveBinary("codex") || "codex",
+    args: ["app-server", "--stdio"]
+  },
+  signal: abort.signal,
+  transcripts: transcriptsEnabled()
+}));
+for (const signal of signals) process.off(signal, stop);
+process.exit(outcome === "stopped" ? 0 : 1);

package/dist/bin/pushary-codex-hook.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node