pushary 1.9.49 → 1.9.51

package/dist/chunk-PVDSN6TB.js

@@ -0,0 +1,729 @@
+import {
+  processGroupHasNothingLeftToSignal
+} from "./chunk-XCEN33UP.js";
+import {
+  CODEX_APP_LAUNCH_VARIABLE,
+  CODEX_ENGINE_DIRECTORY,
+  CODEX_ENGINE_ENTRYPOINT,
+  CODEX_ENGINE_MANIFEST,
+  CODEX_ENGINE_PENDING_VARIABLE,
+  codexEngineEnvironment,
+  codexEngineInside,
+  launcherIsGone,
+  launcherWaitingOnThisProcess,
+  tellTheLauncherTheEngineStarted
+} from "./chunk-36NGFHE4.js";
+
+// src/codex-desktop-launch.ts
+import { spawn as spawn2, execFileSync } from "child_process";
+import { existsSync } from "fs";
+import { mkdtemp, readFile, rm, writeFile, access } from "fs/promises";
+import { constants } from "fs";
+import { tmpdir } from "os";
+import { join, resolve } from "path";
+
+// src/codex-desktop-proxy.ts
+import { spawn } from "child_process";
+import { Transform } from "stream";
+
+// src/codex-app-card.ts
+var CODEX_APP_CARD_METHOD = "mcpServer/elicitation/request";
+var CODEX_REQUEST_RESOLVED_METHOD = "serverRequest/resolved";
+var COMPUTER_USE_SERVER = "cua_repl";
+var COMPUTER_USE_CONNECTOR = "computer-use";
+var TOOL_CALL_APPROVAL = "mcp_tool_call";
+var CONVERSATION_GRANT = "session";
+var FORM_MODES = ["form", "openai/form", "openaiForm"];
+var APP_PARAMETER = "app";
+var MAX_IDENTIFIER_LENGTH = 200;
+var MAX_APP_NAME_LENGTH = 100;
+var MAX_CARDS_ANSWERED_ON_THE_PHONE = 64;
+var APP_LINES_A_LATE_REPLY_CAN_FOLLOW = 256;
+var ONE_PRINTABLE_LINE = /^[^\p{Cc}\p{Cf}\p{Zl}\p{Zp}]+$/u;
+var APP_IDENTIFIER = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+var RISK_LEVELS = ["low", "medium", "high"];
+var PHONE_ANSWER_YES = "yes";
+var PHONE_ANSWER_NO = "no";
+var ALLOW_THIS_CONVERSATION = { action: "accept", content: {}, _meta: { persist: CONVERSATION_GRANT } };
+var DENY = { action: "decline", content: null, _meta: null };
+var isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var isRequestId = (value) => typeof value === "string" && value.length > 0 && value.length <= MAX_IDENTIFIER_LENGTH || typeof value === "number" && Number.isSafeInteger(value);
+var isIdentifier = (value) => typeof value === "string" && value.length > 0 && value.length <= MAX_IDENTIFIER_LENGTH;
+var asksForNothingToFillIn = (schema) => isRecord(schema) && isRecord(schema.properties) && Object.keys(schema.properties).length === 0;
+var offersAConversationGrant = (persist) => Array.isArray(persist) && persist.includes(CONVERSATION_GRANT);
+var isTheAppParameter = (entry) => isRecord(entry) && entry.name === APP_PARAMETER;
+var appNameShownBy = (meta) => {
+  const shown = Array.isArray(meta.tool_params_display) ? meta.tool_params_display.find(isTheAppParameter) : void 0;
+  const name = typeof shown?.value === "string" ? shown.value.trim() : "";
+  return name.length > 0 && name.length <= MAX_APP_NAME_LENGTH && ONE_PRINTABLE_LINE.test(name) ? name : null;
+};
+var appIdentifierIn = (meta) => {
+  const identifier = isRecord(meta.tool_params) ? meta.tool_params[APP_PARAMETER] : void 0;
+  return isIdentifier(identifier) && APP_IDENTIFIER.test(identifier) ? identifier : null;
+};
+var riskIn = (meta) => RISK_LEVELS.find((level) => level === meta.riskLevel) ?? null;
+var wordingCodexShowsFor = (appName) => `Allow Computer Use to use "${appName}"?`;
+var codexAppCardOf = (message) => {
+  if (!isRecord(message) || message.method !== CODEX_APP_CARD_METHOD || !isRequestId(message.id)) return null;
+  const params = message.params;
+  if (!isRecord(params) || !isIdentifier(params.threadId) || params.serverName !== COMPUTER_USE_SERVER) return null;
+  if (typeof params.mode !== "string" || !FORM_MODES.includes(params.mode)) return null;
+  if (!asksForNothingToFillIn(params.requestedSchema)) return null;
+  const meta = params._meta;
+  if (!isRecord(meta) || meta.connector_id !== COMPUTER_USE_CONNECTOR || meta.codex_approval_kind !== TOOL_CALL_APPROVAL) return null;
+  if (!offersAConversationGrant(meta.persist)) return null;
+  const appName = appNameShownBy(meta);
+  if (appName === null || params.message !== wordingCodexShowsFor(appName)) return null;
+  return {
+    requestId: message.id,
+    threadId: params.threadId,
+    appName,
+    appIdentifier: appIdentifierIn(meta),
+    risk: riskIn(meta)
+  };
+};
+var comesFromComputerUse = (message) => isRecord(message) && message.method === CODEX_APP_CARD_METHOD && isRecord(message.params) && message.params.serverName === COMPUTER_USE_SERVER;
+var codexRequestResolvedBy = (message) => {
+  if (!isRecord(message) || message.method !== CODEX_REQUEST_RESOLVED_METHOD || !isRecord(message.params)) return null;
+  return isRequestId(message.params.requestId) ? message.params.requestId : null;
+};
+var codexRequestAnsweredBy = (message) => isRecord(message) && !("method" in message) && isRequestId(message.id) ? message.id : null;
+var codexAppCardQuestion = (card) => `Allow Codex to use ${card.appName} for this conversation?`;
+var codexAppCardContext = (card) => [
+  card.appIdentifier ? `App: ${card.appName} (${card.appIdentifier})` : `App: ${card.appName}`,
+  ...card.risk ? [`Risk Codex reports: ${card.risk}`] : [],
+  "Codex is showing the same question on your Mac. Yes allows this app for this conversation only."
+].join("\n");
+var codexAppCardDecisionOf = (phoneAnswer) => {
+  if (phoneAnswer === PHONE_ANSWER_YES) return "allow";
+  if (phoneAnswer === PHONE_ANSWER_NO) return "deny";
+  return null;
+};
+var codexAppCardReply = (requestId, decision) => ({
+  id: requestId,
+  result: decision === "allow" ? ALLOW_THIS_CONVERSATION : DENY
+});
+var FORWARD_UNRELATED_REPLY = { kind: "forward", phoneQuestionIsMoot: false };
+var FORWARD_THE_APPS_ANSWER = { kind: "forward", phoneQuestionIsMoot: true };
+var DROP_THE_LATE_REPLY = { kind: "drop" };
+var codexRequestKey = (requestId) => JSON.stringify(requestId);
+var CodexAppCardLedger = class {
+  waiting = /* @__PURE__ */ new Set();
+  answeredOnThePhone = /* @__PURE__ */ new Map();
+  get tracksNothing() {
+    return this.waiting.size === 0 && this.answeredOnThePhone.size === 0;
+  }
+  open(requestId) {
+    const key = codexRequestKey(requestId);
+    if (this.waiting.has(key) || this.answeredOnThePhone.has(key)) return false;
+    this.waiting.add(key);
+    return true;
+  }
+  isWaiting(requestId) {
+    return this.waiting.has(codexRequestKey(requestId));
+  }
+  settleOnThePhone(requestId) {
+    const key = codexRequestKey(requestId);
+    if (!this.waiting.delete(key)) return false;
+    this.answeredOnThePhone.set(key, { appLinesLeft: APP_LINES_A_LATE_REPLY_CAN_FOLLOW, engineConfirmed: false });
+    if (this.answeredOnThePhone.size > MAX_CARDS_ANSWERED_ON_THE_PHONE) this.forgetTheOldestAnswer();
+    return true;
+  }
+  leaveWithTheApp(requestId) {
+    return this.waiting.delete(codexRequestKey(requestId));
+  }
+  engineResolved(requestId) {
+    const key = codexRequestKey(requestId);
+    if (this.waiting.delete(key)) return "phone_question_is_moot";
+    const answer = this.answeredOnThePhone.get(key);
+    if (!answer) return "unrelated";
+    this.answeredOnThePhone.set(key, { ...answer, engineConfirmed: true });
+    return "confirmed_the_phone_answer";
+  }
+  appReplied(requestId) {
+    const key = codexRequestKey(requestId);
+    const answer = this.answeredOnThePhone.get(key);
+    if (answer) {
+      this.answeredOnThePhone.delete(key);
+      return answer.engineConfirmed ? DROP_THE_LATE_REPLY : FORWARD_UNRELATED_REPLY;
+    }
+    return this.waiting.delete(key) ? FORWARD_THE_APPS_ANSWER : FORWARD_UNRELATED_REPLY;
+  }
+  appSentALine() {
+    for (const [key, answer] of this.answeredOnThePhone) {
+      if (answer.appLinesLeft <= 1) this.answeredOnThePhone.delete(key);
+      else this.answeredOnThePhone.set(key, { ...answer, appLinesLeft: answer.appLinesLeft - 1 });
+    }
+  }
+  forgetEverything() {
+    this.waiting.clear();
+    this.answeredOnThePhone.clear();
+  }
+  forgetTheOldestAnswer() {
+    const oldest = this.answeredOnThePhone.keys().next();
+    if (!oldest.done) this.answeredOnThePhone.delete(oldest.value);
+  }
+};
+
+// src/codex-desktop-proxy.ts
+var APP_SERVER_COMMAND = "app-server";
+var CONFIG_FLAGS = ["-c", "--config"];
+var CONFIG_FLAG_PREFIXES = ["-c=", "--config="];
+var LISTEN_FLAG = "--listen";
+var LISTEN_FLAG_PREFIX = "--listen=";
+var STDIO_LISTENER = "stdio://";
+var NEWLINE = 10;
+var MAX_WATCHED_LINE_BYTES = 256 * 1024;
+var MAX_HELD_LINE_BYTES = 64 * 1024;
+var CARD_MARKER = Buffer.from(`"${CODEX_APP_CARD_METHOD}"`);
+var RESOLVED_MARKER = Buffer.from(`"${CODEX_REQUEST_RESOLVED_METHOD}"`);
+var CODEX_APP_AGENT_NAME = "Codex app";
+var ASK_TIMEOUT_MS = 15e3;
+var MAX_CONSECUTIVE_WAIT_FAILURES = 5;
+var WITHDRAW_TIMEOUT_MS = 4e3;
+var CLOSE_GRACE_MS = 1500;
+var ENGINE_KILL_GRACE_MS = 2e3;
+var ENGINE_EXIT_GRACE_MS = 5e3;
+var QUESTION_IN_AN_UNKNOWN_SHAPE = "Codex asked about Computer Use in a way this version of Pushary does not know, so the question stays in Codex.";
+var LAUNCHER_CHECK_MS = 2e3;
+var USUAL_TIMING = { answerWindowMs: 10 * 6e4, longPollMs: 25e3, pauseBetweenPollsMs: 2e3 };
+var subcommandIndexOf = (args) => {
+  let index = 0;
+  while (index < args.length) {
+    const argument = args[index];
+    if (CONFIG_FLAGS.includes(argument)) {
+      index += 2;
+      continue;
+    }
+    if (CONFIG_FLAG_PREFIXES.some((prefix) => argument.startsWith(prefix))) {
+      index += 1;
+      continue;
+    }
+    return argument.startsWith("-") ? -1 : index;
+  }
+  return -1;
+};
+var listenersIn = (args) => args.flatMap((argument, index) => {
+  if (argument === LISTEN_FLAG) return [args[index + 1] ?? ""];
+  return argument.startsWith(LISTEN_FLAG_PREFIX) ? [argument.slice(LISTEN_FLAG_PREFIX.length)] : [];
+});
+var startsAStdioAppServer = (args) => {
+  const subcommandAt = subcommandIndexOf(args);
+  if (subcommandAt < 0 || args[subcommandAt] !== APP_SERVER_COMMAND) return false;
+  return listenersIn(args.slice(subcommandAt + 1)).every((listener) => listener === STDIO_LISTENER);
+};
+var BoundedLineReader = class {
+  constructor(limit, onLine) {
+    this.limit = limit;
+    this.onLine = onLine;
+  }
+  pieces = [];
+  bytes = 0;
+  overLimit = false;
+  read(chunk) {
+    let start = 0;
+    while (start < chunk.length) {
+      const newlineAt = chunk.indexOf(NEWLINE, start);
+      const piece = chunk.subarray(start, newlineAt < 0 ? chunk.length : newlineAt);
+      this.keep(piece);
+      if (newlineAt < 0) return;
+      this.finishLine();
+      start = newlineAt + 1;
+    }
+  }
+  keep(piece) {
+    if (this.overLimit || piece.length === 0) return;
+    if (this.bytes + piece.length > this.limit) {
+      this.overLimit = true;
+      this.pieces = [];
+      this.bytes = 0;
+      return;
+    }
+    this.pieces.push(piece);
+    this.bytes += piece.length;
+  }
+  finishLine() {
+    const line = this.overLimit || this.bytes === 0 ? null : this.pieces.length === 1 ? this.pieces[0] : Buffer.concat(this.pieces, this.bytes);
+    this.pieces = [];
+    this.bytes = 0;
+    this.overLimit = false;
+    if (line) this.onLine(line);
+  }
+};
+var AppToEngineGate = class extends Transform {
+  constructor(keeps) {
+    super();
+    this.keeps = keeps;
+  }
+  held = [];
+  heldBytes = 0;
+  passingALongLine = false;
+  waitingForALineEnd = [];
+  writeBetweenLines(line) {
+    if (this.destroyed || this.readableEnded) throw new Error("Codex engine input is closed");
+    if (this.passingALongLine) this.waitingForALineEnd.push(line);
+    else this.push(line);
+  }
+  _transform(chunk, _encoding, callback) {
+    let start = 0;
+    while (start < chunk.length) {
+      const newlineAt = chunk.indexOf(NEWLINE, start);
+      const end = newlineAt < 0 ? chunk.length : newlineAt + 1;
+      this.accept(chunk.subarray(start, end), newlineAt >= 0);
+      start = end;
+    }
+    callback();
+  }
+  _flush(callback) {
+    if (this.heldBytes > 0) this.push(Buffer.concat(this.held, this.heldBytes));
+    this.held = [];
+    this.heldBytes = 0;
+    callback();
+  }
+  accept(piece, endsALine) {
+    if (this.passingALongLine) {
+      this.push(piece);
+      if (endsALine) this.finishTheLongLine();
+      return;
+    }
+    this.held.push(piece);
+    this.heldBytes += piece.length;
+    if (endsALine) {
+      const line = this.held.length === 1 ? piece : Buffer.concat(this.held, this.heldBytes);
+      this.held = [];
+      this.heldBytes = 0;
+      if (this.keeps(line)) this.push(line);
+      return;
+    }
+    if (this.heldBytes <= MAX_HELD_LINE_BYTES) return;
+    this.push(Buffer.concat(this.held, this.heldBytes));
+    this.held = [];
+    this.heldBytes = 0;
+    this.passingALongLine = true;
+  }
+  finishTheLongLine() {
+    this.passingALongLine = false;
+    for (const line of this.waitingForALineEnd.splice(0)) this.push(line);
+  }
+};
+var parsedLine = (line) => {
+  try {
+    return JSON.parse(line.toString("utf8"));
+  } catch {
+    return null;
+  }
+};
+var isTheSameAccount = (current, asked) => current !== null && current.apiKey === asked.apiKey && current.baseUrl === asked.baseUrl && current.machineId === asked.machineId;
+var reachesAPersonAwayFromCodex = (phone, asked) => !phone.isAwayPaused(asked) && !phone.isDecisionStopped(asked) && !phone.isLocalQuestionHandoff({ status: asked.status, noDevices: asked.noDevices });
+var pauseUnlessStopped = (ms, signal) => new Promise((resolve2) => {
+  if (signal.aborted) {
+    resolve2();
+    return;
+  }
+  const finish = () => {
+    clearTimeout(timer);
+    signal.removeEventListener("abort", finish);
+    resolve2();
+  };
+  const timer = setTimeout(finish, ms);
+  signal.addEventListener("abort", finish, { once: true });
+});
+var CodexAppCards = class {
+  constructor(options) {
+    this.options = options;
+    this.timing = options.timing ?? USUAL_TIMING;
+  }
+  ledger = new CodexAppCardLedger();
+  questions = /* @__PURE__ */ new Map();
+  phone;
+  stoodDown = false;
+  saidAQuestionWasUnknown = false;
+  timing;
+  standDown() {
+    this.stoodDown = true;
+    this.ledger.forgetEverything();
+    void this.close();
+  }
+  fromTheEngine(line) {
+    if (this.stoodDown) return;
+    try {
+      if (line.includes(CARD_MARKER)) this.questionShown(parsedLine(line));
+      else if (line.includes(RESOLVED_MARKER)) this.requestResolved(codexRequestResolvedBy(parsedLine(line)));
+    } catch (error) {
+      this.options.report(`Codex app card was left with Codex: ${error instanceof Error ? error.message : "unreadable"}`);
+    }
+  }
+  keepsFromTheApp(line) {
+    try {
+      if (this.stoodDown || this.ledger.tracksNothing) return true;
+      const answered = codexRequestAnsweredBy(parsedLine(line));
+      if (answered === null) {
+        this.ledger.appSentALine();
+        return true;
+      }
+      const handling = this.ledger.appReplied(answered);
+      this.ledger.appSentALine();
+      if (handling.kind === "drop") return false;
+      if (handling.phoneQuestionIsMoot) this.withdraw(answered);
+      return true;
+    } catch {
+      return true;
+    }
+  }
+  async close() {
+    const outstanding = [...this.questions.values()];
+    this.questions.clear();
+    for (const question of outstanding) question.waiting.abort();
+    await Promise.allSettled(outstanding.map((question) => this.cancel(question)));
+  }
+  thePhone() {
+    this.phone ??= import("./api-PPNFRSJC.js");
+    return this.phone;
+  }
+  questionShown(message) {
+    const card = codexAppCardOf(message);
+    if (card) {
+      if (this.ledger.open(card.requestId)) void this.askThePhone(card);
+      return;
+    }
+    if (this.saidAQuestionWasUnknown || !comesFromComputerUse(message)) return;
+    this.saidAQuestionWasUnknown = true;
+    this.options.report(QUESTION_IN_AN_UNKNOWN_SHAPE);
+  }
+  requestResolved(requestId) {
+    if (requestId !== null && this.ledger.engineResolved(requestId) === "phone_question_is_moot") this.withdraw(requestId);
+  }
+  async askThePhone(card) {
+    try {
+      const account = await this.options.readAccount();
+      if (!account) {
+        this.ledger.leaveWithTheApp(card.requestId);
+        return;
+      }
+      const phone = await this.thePhone();
+      if (!this.ledger.isWaiting(card.requestId)) return;
+      const answerableUntil = Date.now() + this.timing.answerWindowMs;
+      const asked = await phone.askUser(account.apiKey, {
+        question: codexAppCardQuestion(card),
+        type: "confirm",
+        context: codexAppCardContext(card),
+        agentName: CODEX_APP_AGENT_NAME,
+        sessionId: card.threadId,
+        machineId: account.machineId,
+        waitEndsAt: new Date(answerableUntil).toISOString()
+      }, ASK_TIMEOUT_MS, account.baseUrl);
+      const question = { account, correlationId: asked.correlationId, waiting: new AbortController(), answerableUntil };
+      if (!this.ledger.isWaiting(card.requestId)) {
+        await this.cancel(question);
+        return;
+      }
+      if (asked.answered) {
+        await this.settle(card, question, asked.value);
+        return;
+      }
+      if (!reachesAPersonAwayFromCodex(phone, asked)) {
+        this.ledger.leaveWithTheApp(card.requestId);
+        await this.cancel(question);
+        return;
+      }
+      this.questions.set(codexRequestKey(card.requestId), question);
+      await this.waitForThePhone(phone, card, question);
+    } catch (error) {
+      if (this.ledger.leaveWithTheApp(card.requestId)) {
+        this.options.report(`Could not ask about ${card.appName} through Pushary; answer in Codex. ${error instanceof Error ? error.message.split("\n")[0] : ""}`.trim());
+      }
+    }
+  }
+  async waitForThePhone(phone, card, question) {
+    const { account, correlationId } = question;
+    const stopped = AbortSignal.any([this.options.signal, question.waiting.signal]);
+    let failures = 0;
+    while (this.ledger.isWaiting(card.requestId) && !stopped.aborted && failures < MAX_CONSECUTIVE_WAIT_FAILURES) {
+      const timeLeft = question.answerableUntil - Date.now();
+      if (timeLeft <= 0) break;
+      let answer;
+      try {
+        answer = await phone.waitForAnswer(account.apiKey, correlationId, Math.min(this.timing.longPollMs, timeLeft), stopped, account.baseUrl);
+        failures = 0;
+      } catch {
+        failures += 1;
+        await pauseUnlessStopped(this.timing.pauseBetweenPollsMs, stopped);
+        continue;
+      }
+      if (!this.ledger.isWaiting(card.requestId)) return;
+      if (answer.answered) {
+        await this.settle(card, question, answer.value);
+        return;
+      }
+      if (phone.isDecisionStopped(answer) || answer.status === "expired") {
+        this.questions.delete(codexRequestKey(card.requestId));
+        this.ledger.leaveWithTheApp(card.requestId);
+        return;
+      }
+      await pauseUnlessStopped(this.timing.pauseBetweenPollsMs, stopped);
+    }
+    if (this.ledger.leaveWithTheApp(card.requestId)) this.withdraw(card.requestId);
+  }
+  async settle(card, question, phoneAnswer) {
+    this.questions.delete(codexRequestKey(card.requestId));
+    const decision = codexAppCardDecisionOf(phoneAnswer);
+    if (this.stoodDown) return;
+    if (decision === null || !isTheSameAccount(await this.options.readAccount(), question.account)) {
+      this.ledger.leaveWithTheApp(card.requestId);
+      return;
+    }
+    if (this.ledger.settleOnThePhone(card.requestId)) this.options.reply(codexAppCardReply(card.requestId, decision));
+  }
+  withdraw(requestId) {
+    const key = codexRequestKey(requestId);
+    const question = this.questions.get(key);
+    if (!question) return;
+    this.questions.delete(key);
+    question.waiting.abort();
+    void this.cancel(question);
+  }
+  async cancel(question) {
+    try {
+      const phone = await this.thePhone();
+      await phone.cancelQuestion(question.account.apiKey, question.correlationId, AbortSignal.timeout(WITHDRAW_TIMEOUT_MS), question.account.baseUrl);
+    } catch {
+      return;
+    }
+  }
+};
+var watchingTheEngine = (cards) => {
+  const lines = new BoundedLineReader(MAX_WATCHED_LINE_BYTES, (line) => cards.fromTheEngine(line));
+  return new Transform({
+    transform(chunk, _encoding, callback) {
+      lines.read(chunk);
+      callback(null, chunk);
+    }
+  });
+};
+var reportOnStderr = (line) => {
+  process.stderr.write(`[pushary] ${line}
+`);
+};
+var withinTheCloseGrace = (closing) => Promise.race([closing, new Promise((resolve2) => setTimeout(resolve2, CLOSE_GRACE_MS).unref())]);
+var runCodexDesktopProxy = async (binary, args, readAccount, options = { watchesForCards: true }) => {
+  const watches = options.watchesForCards && startsAStdioAppServer(args);
+  const child = spawn(binary, [...args], {
+    stdio: watches ? ["pipe", "pipe", "inherit"] : "inherit",
+    detached: true,
+    env: codexEngineEnvironment(binary)
+  });
+  child.once("spawn", tellTheLauncherTheEngineStarted);
+  const abort = new AbortController();
+  let killTimer;
+  let lingerTimer;
+  const signalChild = (signal) => {
+    if (!child.pid) return;
+    try {
+      process.kill(-child.pid, signal);
+    } catch (error) {
+      if (!processGroupHasNothingLeftToSignal(error)) throw error;
+    }
+  };
+  const stop = () => {
+    if (killTimer) return;
+    abort.abort();
+    signalChild("SIGTERM");
+    killTimer = setTimeout(() => signalChild("SIGKILL"), ENGINE_KILL_GRACE_MS);
+  };
+  const stopIfTheEngineLingers = () => {
+    lingerTimer ??= setTimeout(stop, ENGINE_EXIT_GRACE_MS);
+  };
+  const launcher = launcherWaitingOnThisProcess();
+  const launcherCheck = launcher === null ? void 0 : setInterval(() => {
+    if (launcherIsGone(launcher)) stop();
+  }, LAUNCHER_CHECK_MS);
+  launcherCheck?.unref();
+  let cards;
+  const streams = [];
+  const keepCopyingWithoutCards = (error) => {
+    cards?.standDown();
+    reportOnStderr(`Codex app cards stopped for this session after an unexpected error; Codex keeps working. ${error instanceof Error ? error.message.split("\n")[0] : ""}`.trim());
+  };
+  if (watches && child.stdin && child.stdout) {
+    const gate = new AppToEngineGate((line) => cards?.keepsFromTheApp(line) ?? true);
+    cards = new CodexAppCards({
+      readAccount,
+      reply: (reply) => gate.writeBetweenLines(Buffer.from(`${JSON.stringify(reply)}
+`)),
+      signal: abort.signal,
+      report: reportOnStderr
+    });
+    const watcher = watchingTheEngine(cards);
+    streams.push(process.stdin, child.stdin, child.stdout, process.stdout, gate, watcher);
+    process.stdin.pipe(gate).pipe(child.stdin);
+    child.stdout.pipe(watcher).pipe(process.stdout, { end: false });
+    process.stdin.once("end", stopIfTheEngineLingers);
+    process.on("uncaughtException", keepCopyingWithoutCards);
+    process.on("unhandledRejection", keepCopyingWithoutCards);
+  }
+  for (const stream of streams) stream.on("error", stop);
+  for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) process.on(signal, stop);
+  try {
+    return await new Promise((resolve2, reject) => {
+      child.once("error", reject);
+      child.once("close", (code) => resolve2(code ?? 1));
+    });
+  } finally {
+    abort.abort();
+    clearTimeout(killTimer);
+    clearTimeout(lingerTimer);
+    clearInterval(launcherCheck);
+    signalChild("SIGKILL");
+    if (watches) {
+      process.stdin.unpipe();
+      child.stdout?.unpipe();
+      process.stdin.pause();
+      process.stdin.off("end", stopIfTheEngineLingers);
+    }
+    process.off("uncaughtException", keepCopyingWithoutCards);
+    process.off("unhandledRejection", keepCopyingWithoutCards);
+    for (const stream of streams) stream.off("error", stop);
+    for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) process.off(signal, stop);
+    if (cards) await withinTheCloseGrace(cards.close());
+  }
+};
+
+// src/codex-desktop-launch.ts
+var record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var QUOTE = "'";
+var QUOTE_INSIDE_QUOTES = "'\\''";
+var shellQuoted = (value) => QUOTE + value.replaceAll(QUOTE, QUOTE_INSIDE_QUOTES) + QUOTE;
+var shellUnquoted = (quoted) => quoted.length >= 2 && quoted.startsWith(QUOTE) && quoted.endsWith(QUOTE) ? quoted.slice(1, -1).replaceAll(QUOTE_INSIDE_QUOTES, QUOTE) : null;
+var KNOWN_ENGINE_LAYOUT = 1;
+var ENGINE_COMMAND_THE_PROXY_WATCHES = "app-server";
+var INSTALLED_CODEX_APPS = ["/Applications/ChatGPT.app", "/Applications/Codex.app"];
+var LAUNCHCTL = "/bin/launchctl";
+var APP_CARDS_FLAG = "--app-cards";
+var LAUNCHER_INTERPRETER = "#!/bin/sh";
+var ENGINE_ASSIGNMENT = "ENGINE=";
+var RUN_THE_ENGINE = `${CODEX_APP_LAUNCH_VARIABLE}="$ENGINE" exec "$ENGINE" "$@"`;
+var desktopEngineFromManifest = (app, manifest) => {
+  if (!record(manifest) || manifest.layoutVersion !== KNOWN_ENGINE_LAYOUT || manifest.entrypoint !== CODEX_ENGINE_ENTRYPOINT || typeof manifest.version !== "string") {
+    throw new Error("This Codex app keeps its engine somewhere Pushary does not know. Launch Codex normally for this version.");
+  }
+  return codexEngineInside(app);
+};
+var isAbsolutePath = (value) => value.startsWith("/");
+var everyProgramFileIsThere = (entry) => [`[ -x ${shellQuoted(entry[0] ?? "")} ]`, ...entry.slice(1).filter(isAbsolutePath).map((path) => `[ -e ${shellQuoted(path)} ]`)].join(" && ");
+var TURN_THIS_LAUNCH_OFF = [
+  `  if [ "$(${LAUNCHCTL} getenv ${CODEX_APP_LAUNCH_VARIABLE})" = "$0" ]; then ${LAUNCHCTL} unsetenv ${CODEX_APP_LAUNCH_VARIABLE}; fi`
+];
+var desktopProxyScript = (entry, app, engine, options = { turnsItselfOffWithoutTheEngine: false }) => {
+  const throughTheProxy = [...entry, "--desktop-proxy", app, "--"].map(shellQuoted).join(" ") + ' "$@"';
+  return [
+    LAUNCHER_INTERPRETER,
+    `${ENGINE_ASSIGNMENT}${shellQuoted(engine)}`,
+    'if [ ! -x "$ENGINE" ]; then',
+    ...options.turnsItselfOffWithoutTheEngine ? TURN_THIS_LAUNCH_OFF : [],
+    '  echo "[pushary] The Codex engine is not at $ENGINE, so Pushary stepped aside. Open Codex again." >&2',
+    "  exit 127",
+    "fi",
+    `if ${everyProgramFileIsThere(entry)}; then`,
+    '  for argument in "$@"; do',
+    `    if [ "$argument" = ${shellQuoted(ENGINE_COMMAND_THE_PROXY_WATCHES)} ]; then`,
+    '      for left in "$0".pending.*; do',
+    '        [ -e "$left" ] && ! kill -0 "${left##*.}" 2>/dev/null && rm -f "$left"',
+    "      done",
+    '      PENDING="$0.pending.$$"',
+    `      if ! { printf '' > "$PENDING"; } 2>/dev/null; then break; fi`,
+    `      ${CODEX_ENGINE_PENDING_VARIABLE}="$PENDING" ${throughTheProxy}`,
+    "      STATUS=$?",
+    '      if [ ! -e "$PENDING" ]; then exit "$STATUS"; fi',
+    '      rm -f "$PENDING"',
+    '      echo "[pushary] Pushary did not start, so Codex runs without it." >&2',
+    "      break",
+    "    fi",
+    "  done",
+    "fi",
+    RUN_THE_ENGINE,
+    ""
+  ].join("\n");
+};
+var codexPassThroughScript = (engine) => [LAUNCHER_INTERPRETER, `${ENGINE_ASSIGNMENT}${shellQuoted(engine)}`, RUN_THE_ENGINE, ""].join("\n");
+var codexEngineBehindLauncher = (script) => {
+  const [interpreter, assignment] = script.split("\n", 2);
+  if (interpreter !== LAUNCHER_INTERPRETER || !assignment?.startsWith(ENGINE_ASSIGNMENT) || !script.trimEnd().endsWith(RUN_THE_ENGINE)) return null;
+  return shellUnquoted(assignment.slice(ENGINE_ASSIGNMENT.length));
+};
+var writeDesktopProxy = async (entry, app, engine, directory) => {
+  const shim = join(directory, "codex");
+  await writeFile(shim, desktopProxyScript(entry, app, engine), { mode: 448, flag: "wx" });
+  return shim;
+};
+var desktopEngine = async (app) => {
+  const manifest = JSON.parse(await readFile(join(app, CODEX_ENGINE_DIRECTORY, CODEX_ENGINE_MANIFEST), "utf8"));
+  const engine = desktopEngineFromManifest(app, manifest);
+  await access(engine, constants.X_OK);
+  return engine;
+};
+var engineWhateverTheLayout = async (app) => {
+  const engine = codexEngineInside(app);
+  await access(engine, constants.X_OK);
+  try {
+    return { engine, layoutIsKnown: await desktopEngine(app) === engine };
+  } catch {
+    return { engine, layoutIsKnown: false };
+  }
+};
+var installedCodexApp = (chosen) => resolve(chosen ?? INSTALLED_CODEX_APPS.find((candidate) => existsSync(join(candidate, CODEX_ENGINE_DIRECTORY, CODEX_ENGINE_MANIFEST))) ?? INSTALLED_CODEX_APPS[1]);
+var desktopExecutable = (app) => {
+  const plist = join(app, "Contents/Info.plist");
+  const read = (key) => execFileSync("/usr/bin/plutil", ["-extract", key, "raw", plist], { encoding: "utf8" }).trim();
+  if (read("CFBundleIdentifier") !== "com.openai.codex") throw new Error("Choose the Codex Desktop application");
+  const name = read("CFBundleExecutable");
+  if (!name || name.includes("/") || name === "." || name === "..") throw new Error("Invalid Desktop executable");
+  try {
+    execFileSync("/usr/bin/pgrep", ["-x", name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")], { stdio: "ignore" });
+  } catch (error) {
+    if (record(error) && error.status === 1) return join(app, "Contents/MacOS", name);
+    throw error;
+  }
+  throw new Error("Codex Desktop is already running. Finish active work and quit it yourself, then retry. Pushary will not restart it.");
+};
+var codexDesktopCommand = async (args, entry, readAccount) => {
+  if (args[0] !== "--desktop" && args[0] !== "--desktop-proxy" && args[0] !== APP_CARDS_FLAG) return null;
+  if (process.platform !== "darwin") throw new Error("Experimental Codex Desktop forwarding currently requires macOS");
+  if (args[0] === "--desktop-proxy") {
+    if (!args[1] || args[2] !== "--") throw new Error("Invalid Desktop proxy invocation");
+    const { engine: engine2, layoutIsKnown } = await engineWhateverTheLayout(args[1]);
+    return runCodexDesktopProxy(engine2, args.slice(3), readAccount, { watchesForCards: layoutIsKnown });
+  }
+  if (args[0] === APP_CARDS_FLAG) {
+    const { codexAppCardsCommandOnThisMac } = await import("./codex-app-cards-switch-ZQRT7MXB.js");
+    return codexAppCardsCommandOnThisMac(args.slice(1), entry, readAccount);
+  }
+  if (args.length > 2) throw new Error("Usage: pushary codex --desktop [path/to/Codex.app]");
+  if (!await readAccount()) throw new Error("Connect Pushary before starting Desktop forwarding");
+  const app = installedCodexApp(args[1]);
+  const engine = await desktopEngine(app);
+  const executable = desktopExecutable(app);
+  const directory = await mkdtemp(join(tmpdir(), "pushary-codex-desktop-"));
+  try {
+    const shim = await writeDesktopProxy(entry, app, engine, directory);
+    process.stderr.write("[pushary] Experimental Codex app launch. When Codex asks to use an app on this Mac, the question also reaches Pushary; every other prompt stays as it is. Quit and open Codex normally to turn this off.\n");
+    const child = spawn2(executable, [], { stdio: "ignore", detached: true, env: { ...process.env, [CODEX_APP_LAUNCH_VARIABLE]: shim } });
+    return await new Promise((resolve2, reject) => {
+      child.once("error", reject);
+      child.once("close", (code) => resolve2(code ?? 1));
+    });
+  } finally {
+    await rm(directory, { recursive: true, force: true });
+  }
+};
+
+export {
+  shellQuoted,
+  desktopEngineFromManifest,
+  desktopProxyScript,
+  codexPassThroughScript,
+  codexEngineBehindLauncher,
+  writeDesktopProxy,
+  desktopEngine,
+  installedCodexApp,
+  codexDesktopCommand
+};