pushary 1.9.50 → 1.9.51

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

@@ -1,638 +1,39 @@
 #!/usr/bin/env node
 import {
-  exitOnHelpFlag
-} from "../chunk-BOVSUH4N.js";
-import {
-  CodexNativeApprovals,
-  answerCodexElicitation,
-  answerCodexQuestions,
-  claimOwnedQuestion,
-  closesOwnedQuestion,
-  codexQuestionOwner,
-  isCodexQuestionLeftWithTheLocalClient,
-  planCodexElicitation,
-  reportOwnedQuestion
-} from "../chunk-SE4JFMLW.js";
-import "../chunk-BXK6ZJVJ.js";
-import {
-  resolveProviderBinary
-} from "../chunk-GBKSCDEK.js";
-import "../chunk-RIVNNBEK.js";
-import "../chunk-FPKQGWAF.js";
-import "../chunk-XNZB274I.js";
-import "../chunk-KK2DIUVV.js";
-import "../chunk-XHKBHWLX.js";
-import "../chunk-6ICPEJY5.js";
-import {
-  writeDegraded
-} from "../chunk-AWMMABVB.js";
-import "../chunk-POFBE6ZY.js";
-import "../chunk-LZYJMSOY.js";
-import "../chunk-34RXPM5U.js";
-import "../chunk-ABMEBN2R.js";
-import {
-  getMachineId
-} from "../chunk-LY3OJFBW.js";
-import "../chunk-7QLSKOSU.js";
-import "../chunk-KZERVKTD.js";
-import "../chunk-ZYYQJSIO.js";
-import "../chunk-AQFEP65J.js";
-import {
-  getApiKey,
-  getBaseUrl
-} from "../chunk-VUS6QGND.js";
-import "../chunk-ZOKMGBPR.js";
-import {
-  CODEX_NATIVE_APPROVAL_METHODS,
-  canonicalJsonText
-} from "../chunk-OR5F63C2.js";
-
-// src/codex-session-launch.ts
-import { spawn as spawn2 } from "child_process";
-import { stat } from "fs/promises";
-import { resolve } from "path";
-
-// src/codex-shared-session.ts
-import { spawn } from "child_process";
-import { mkdtemp, rm } from "fs/promises";
-import { createServer } from "http";
-import { tmpdir } from "os";
-import { join } from "path";
-import WebSocket, { WebSocketServer } from "ws";
-
-// src/codex-shared-questions.ts
-import { createHash, randomUUID } from "crypto";
-var CodexSharedQuestions = class {
-  constructor(options) {
-    this.options = options;
-  }
-  generation = randomUUID();
-  pending = /* @__PURE__ */ new Map();
-  retired = /* @__PURE__ */ new Set();
-  tasks = /* @__PURE__ */ new Set();
-  closed = false;
-  handle(message, threadId) {
-    if (this.closed || !message.method) return;
-    const params = message.params ?? {};
-    if (message.id === void 0) {
-      for (const [id2, pending2] of this.pending) {
-        const closed = pending2.dispatch ? closesOwnedQuestion(pending2.dispatch.owner, message.method, params) : message.method === "serverRequest/resolved" && params.requestId === id2 || params.threadId === pending2.threadId && ["thread/closed", "thread/archived", "turn/completed"].includes(message.method);
-        if (closed) {
-          pending2.controller.abort();
-          this.pending.delete(id2);
-          this.retired.add(id2);
-          if (pending2.dispatch) {
-            const task2 = reportOwnedQuestion(this.options, pending2.dispatch, "request_closed").finally(() => this.tasks.delete(task2));
-            this.tasks.add(task2);
-          }
-        }
-      }
-      return;
-    }
-    const id = message.id;
-    if (typeof id !== "string" && !(typeof id === "number" && Number.isSafeInteger(id))) return;
-    if (this.retired.has(id)) return;
-    const subjectHash = createHash("sha256").update(canonicalJsonText(params)).digest("hex");
-    const existing = this.pending.get(id);
-    if (existing) {
-      if (existing.subjectHash !== subjectHash) {
-        existing.controller.abort();
-        this.pending.delete(id);
-        this.retired.add(id);
-      }
-      return;
-    }
-    if (this.pending.size >= 8) return;
-    const isQuestion = message.method === "item/tool/requestUserInput";
-    if (!isQuestion && message.method !== "mcpServer/elicitation/request") return;
-    const owner = isQuestion ? codexQuestionOwner(params, id, { machineId: this.options.machineId, generation: this.generation, threadId }) : null;
-    if (isQuestion ? !owner : !planCodexElicitation(params, threadId)) return;
-    const duration = params.autoResolutionMs;
-    if (duration != null && (typeof duration !== "number" || !Number.isFinite(duration) || duration < 0)) return;
-    const dispatch = owner ? { owner, correlationIds: [], deadline: typeof duration === "number" ? Date.now() + duration : null } : void 0;
-    const pending = { controller: new AbortController(), dispatch, threadId, subjectHash };
-    this.pending.set(id, pending);
-    const task = this.answer(id, params, pending).finally(() => this.tasks.delete(task));
-    this.tasks.add(task);
-  }
-  async answer(id, params, pending) {
-    const signal = AbortSignal.any([this.options.signal, pending.controller.signal]);
-    const options = { ...this.options, shared: true, signal };
-    const dispatch = pending.dispatch;
-    try {
-      const result = dispatch ? await answerCodexQuestions(options, params, signal, "request_user_input", dispatch) : await answerCodexElicitation(options, params, pending.threadId, signal);
-      if (signal.aborted || this.closed || "action" in result && result.action !== "accept") return;
-      if (dispatch) await claimOwnedQuestion(options, dispatch);
-      if (signal.aborted || this.closed || this.pending.get(id) !== pending) return;
-      if (dispatch?.deadline != null && Date.now() >= dispatch.deadline) throw new Error("Question expired");
-      this.options.reply(id, result);
-      if (dispatch) await reportOwnedQuestion(options, dispatch, "reply_queued");
-    } catch (error) {
-      if (!signal.aborted && !isCodexQuestionLeftWithTheLocalClient(error)) writeDegraded("questions", { reason: "shared_codex_question_unavailable", fallback: "native client", event: "question" });
-    } finally {
-      if (dispatch && (!dispatch.claimId || signal.aborted)) await reportOwnedQuestion(options, dispatch, "unavailable");
-      if (!dispatch?.claimId || signal.aborted) {
-        this.pending.delete(id);
-        this.retired.add(id);
-      }
-    }
-  }
-  async close() {
-    this.closed = true;
-    for (const pending of this.pending.values()) pending.controller.abort();
-    await Promise.allSettled(this.tasks);
-    await Promise.allSettled([...this.pending.values()].flatMap((pending) => pending.dispatch ? [reportOwnedQuestion(this.options, pending.dispatch, "unavailable")] : []));
-    this.pending.clear();
-  }
-};
-
-// src/process-group.ts
-var GROUP_HAS_NOTHING_LEFT_TO_SIGNAL = /* @__PURE__ */ new Set(["ESRCH", "EPERM"]);
-var processGroupHasNothingLeftToSignal = (error) => error !== null && typeof error === "object" && "code" in error && typeof error.code === "string" && GROUP_HAS_NOTHING_LEFT_TO_SIGNAL.has(error.code);
-
-// src/codex-shared-session.ts
-var record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
-var requestId = (value) => typeof value === "string" || typeof value === "number" && Number.isSafeInteger(value);
-var MAX_MESSAGE_BYTES = 16 * 1024 * 1024;
-var startCodexSharedSession = async (options) => {
-  if (process.platform === "win32") throw new Error("Managed Codex sessions currently require macOS or Linux");
-  options.signal.throwIfAborted();
-  const directory = await mkdtemp(join(tmpdir(), "pushary-codex-"));
-  const socketPath = join(directory, "terminal.sock");
-  const controller = new AbortController();
-  const signal = AbortSignal.any([controller.signal, options.signal]);
-  const http = createServer((_request, response) => {
-    response.writeHead(404);
-    response.end();
-  });
-  const websocket = new WebSocketServer({ server: http, maxPayload: MAX_MESSAGE_BYTES, perMessageDeflate: false });
-  const child = spawn(options.binary, ["app-server"], {
-    cwd: options.cwd,
-    env: { ...options.env ?? process.env, PUSHARY_CODEX_BRIDGE: "1" },
-    stdio: ["pipe", "pipe", "pipe"],
-    detached: true
-  });
-  child.stderr.resume();
-  const exited = new Promise((resolve3) => {
-    child.once("exit", () => {
-      controller.abort(new Error("Codex app-server stopped"));
-      resolve3();
-    });
-    child.once("error", () => {
-      controller.abort(new Error("Could not start Codex app-server"));
-      resolve3();
-    });
-  });
-  let terminal = null;
-  let closing = null;
-  let buffered = "";
-  const unanswered = /* @__PURE__ */ new Set();
-  const write = (message) => {
-    if (signal.aborted || child.stdin.destroyed) throw new Error("Codex connection closed");
-    child.stdin.write(JSON.stringify(message) + "\n");
-  };
-  const reply = (id, result) => {
-    if (!unanswered.delete(id)) throw new Error("Native request already answered");
-    write({ id, result });
-  };
-  const approvals = new CodexNativeApprovals({ ...options, signal, shared: true, reply });
-  const questions = new CodexSharedQuestions({ ...options, signal, reply });
-  const observeNative = (message) => {
-    if (typeof message.method !== "string") return;
-    if (requestId(message.id)) unanswered.add(message.id);
-    if (!record(message.params)) return;
-    if (message.method === "serverRequest/resolved" && requestId(message.params.requestId)) unanswered.delete(message.params.requestId);
-    const event = { id: message.id, method: message.method, params: message.params };
-    const threadId = typeof message.params.threadId === "string" ? message.params.threadId : null;
-    if (!approvals.handle(event, threadId)) questions.handle(event, threadId);
-  };
-  child.stdout.setEncoding("utf8");
-  child.stdout.on("data", (chunk) => {
-    buffered += chunk;
-    let end;
-    while ((end = buffered.indexOf("\n")) >= 0) {
-      const line = buffered.slice(0, end);
-      buffered = buffered.slice(end + 1);
-      if (!line.trim()) continue;
-      if (Buffer.byteLength(line) > MAX_MESSAGE_BYTES) {
-        controller.abort();
-        return;
-      }
-      try {
-        const message = JSON.parse(line);
-        if (!record(message)) throw new Error("Invalid Codex message");
-        observeNative(message);
-        if (terminal?.readyState === WebSocket.OPEN) terminal.send(line);
-      } catch {
-        controller.abort();
-        return;
-      }
-    }
-    if (Buffer.byteLength(buffered) > MAX_MESSAGE_BYTES) controller.abort();
-  });
-  child.stdin.on("error", () => controller.abort());
-  websocket.on("connection", (client) => {
-    if (terminal || signal.aborted) {
-      client.close();
-      return;
-    }
-    terminal = client;
-    client.on("error", () => controller.abort());
-    client.on("close", () => controller.abort());
-    client.on("message", (bytes) => {
-      try {
-        const message = JSON.parse(bytes.toString());
-        if (!record(message)) throw new Error("Invalid terminal message");
-        if (requestId(message.id) && !("method" in message)) {
-          if (!unanswered.delete(message.id)) return;
-          approvals.handle({ method: "serverRequest/resolved", params: { requestId: message.id } }, null);
-          questions.handle({ method: "serverRequest/resolved", params: { requestId: message.id } }, null);
-        }
-        write(message);
-      } catch {
-        controller.abort();
-      }
-    });
-  });
-  const signalServerGroup = (signal2) => {
-    if (!child.pid) return false;
-    try {
-      process.kill(-child.pid, signal2);
-      return true;
-    } catch (error) {
-      if (processGroupHasNothingLeftToSignal(error)) return false;
-      throw error;
-    }
-  };
-  const stopServer = async () => {
-    signalServerGroup("SIGTERM");
-    const deadline = Date.now() + 2e3;
-    while (signalServerGroup(0) && Date.now() < deadline) await new Promise((resolve3) => setTimeout(resolve3, 25));
-    if (signalServerGroup(0)) signalServerGroup("SIGKILL");
-    await exited;
-  };
-  const close = () => {
-    if (closing) return closing;
-    closing = Promise.resolve().then(async () => {
-      controller.abort();
-      terminal?.terminate();
-      websocket.close();
-      http.close();
-      try {
-        await Promise.all([approvals.close(), questions.close(), stopServer()]);
-      } finally {
-        await rm(directory, { recursive: true, force: true });
-      }
-    });
-    return closing;
-  };
-  signal.addEventListener("abort", () => {
-    void close();
-  }, { once: true });
-  try {
-    await new Promise((resolve3, reject) => {
-      http.once("error", reject);
-      http.listen(socketPath, resolve3);
-    });
-    signal.throwIfAborted();
-    return { endpoint: "unix://" + socketPath, signal, close };
-  } catch (error) {
-    await close();
-    throw error;
-  }
-};
-
-// src/codex-session-launch.ts
-var codexSessionDirectory = (args2, cwd) => {
-  if (args2.length === 0) return cwd;
-  if (args2.length === 2 && args2[0] === "--cwd" && args2[1]) return resolve(cwd, args2[1]);
-  throw new Error("Usage: pushary codex [--cwd <directory>]");
-};
-var launchCodexSession = async (options) => {
-  if (!(await stat(options.cwd)).isDirectory()) throw new Error("Codex needs a project directory");
-  const session = await startCodexSharedSession(options);
-  try {
-    process.stderr.write("[pushary] Managed Codex session. Supported questions and native permissions can reach Pushary; other prompts stay in this terminal.\n");
-    const tui = spawn2(options.binary, ["--remote", session.endpoint], {
-      cwd: options.cwd,
-      env: { ...options.env ?? process.env, PUSHARY_CODEX_BRIDGE: "1" },
-      stdio: "inherit"
-    });
-    const stop = () => {
-      tui.kill("SIGTERM");
-    };
-    session.signal.addEventListener("abort", stop, { once: true });
-    if (session.signal.aborted) stop();
-    try {
-      return await new Promise((resolve3, reject) => {
-        tui.once("error", reject);
-        tui.once("close", (code) => resolve3(code ?? 1));
-      });
-    } finally {
-      session.signal.removeEventListener("abort", stop);
-    }
-  } finally {
-    await session.close();
-  }
-};
-
-// src/codex-desktop-launch.ts
-import { spawn as spawn4, execFileSync } from "child_process";
-import { existsSync } from "fs";
-import { mkdtemp as mkdtemp2, readFile, rm as rm2, writeFile, access } from "fs/promises";
-import { constants } from "fs";
-import { tmpdir as tmpdir2 } from "os";
-import { join as join2, resolve as resolve2 } from "path";
-
-// src/codex-desktop-proxy.ts
-import { spawn as spawn3 } from "child_process";
-import { isAbsolute } from "path";
-import { PassThrough, Transform } from "stream";
-var record2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
-var requestId2 = (value) => typeof value === "string" && value.length > 0 || typeof value === "number" && Number.isSafeInteger(value);
-var THREAD_METHODS = ["thread/start", "thread/resume", "thread/fork", "thread/read"];
-var MAX_MESSAGE_BYTES2 = 16 * 1024 * 1024;
-var MAX_CONTEXTS = 1024;
-var CodexDesktopApprovals = class {
-  threads = /* @__PURE__ */ new Map();
-  requests = /* @__PURE__ */ new Map();
-  answered = /* @__PURE__ */ new Map();
-  approvals;
-  closing;
-  constructor(options) {
-    this.approvals = new CodexNativeApprovals({ ...options, cwd: "/", shared: true, reply: (id, result) => {
-      if (this.closing || this.answered.get(id) !== false) throw new Error("Desktop already resolved this permission");
-      this.answered.set(id, true);
-      options.reply({ id, result });
-    } });
-  }
-  client(message) {
-    if (requestId2(message.id) && !("method" in message)) {
-      if (this.answered.get(message.id) === true) return false;
-      if (this.answered.has(message.id)) {
-        this.answered.set(message.id, true);
-        this.approvals.handle({ method: "serverRequest/resolved", params: { requestId: message.id } }, null);
-      }
-    }
-    if (this.closing) return true;
-    if (requestId2(message.id) && typeof message.method === "string" && (THREAD_METHODS.includes(message.method) || message.method === "turn/start")) {
-      if (this.requests.size >= MAX_CONTEXTS) {
-        void this.close();
-        return true;
-      }
-      this.requests.set(message.id, message);
-      const p = message.params;
-      if (message.method === "turn/start" && record2(p) && typeof p.threadId === "string" && p.cwd != null) this.forgetThread(p.threadId);
-    }
-    return true;
-  }
-  server(message) {
-    if (this.closing) return;
-    if (requestId2(message.id) && !("method" in message)) {
-      const request = this.requests.get(message.id);
-      this.requests.delete(message.id);
-      if (request && record2(message.result)) {
-        this.rememberThread(message.result.thread);
-        const p2 = request.params;
-        if (request.method === "turn/start" && record2(p2)) this.rememberThread({ id: p2.threadId, cwd: p2.cwd });
-      }
-      return;
-    }
-    if (typeof message.method !== "string" || !record2(message.params)) return;
-    const p = message.params;
-    if (message.method === "thread/started") this.rememberThread(p.thread);
-    if (message.method === "thread/closed" || message.method === "thread/archived") {
-      if (typeof p.threadId === "string") this.forgetThread(p.threadId);
-    }
-    if (message.method === "serverRequest/resolved" && requestId2(p.requestId) && this.answered.has(p.requestId)) this.answered.set(p.requestId, true);
-    const threadId = typeof p.threadId === "string" ? p.threadId : null;
-    const cwd = threadId ? this.threads.get(threadId) : void 0;
-    if (message.id !== void 0) {
-      if (!cwd || !requestId2(message.id) || !CODEX_NATIVE_APPROVAL_METHODS.some((method) => method === message.method)) return;
-      if (this.answered.has(message.id)) return;
-      if (this.answered.size >= 1e4) {
-        void this.close();
-        return;
-      }
-      this.answered.set(message.id, false);
-    }
-    this.approvals.handle({ id: message.id, method: message.method, params: p }, threadId, cwd);
-  }
-  close() {
-    if (!this.closing) this.closing = this.approvals.close();
-    return this.closing;
-  }
-  forgetThread(id) {
-    this.threads.delete(id);
-    this.approvals.handle({ method: "thread/closed", params: { threadId: id } }, id);
-  }
-  rememberThread(thread) {
-    if (!record2(thread) || typeof thread.id !== "string" || typeof thread.cwd !== "string" || !isAbsolute(thread.cwd)) return;
-    if (this.threads.has(thread.id) && this.threads.get(thread.id) !== thread.cwd) this.forgetThread(thread.id);
-    if (this.threads.size >= MAX_CONTEXTS && !this.threads.has(thread.id)) return;
-    this.threads.set(thread.id, thread.cwd);
-  }
-};
-var codexProtocolLines = (observe, unavailable) => {
-  let buffered = Buffer.alloc(0), passthrough = false;
-  const forward = (stream, line) => {
-    try {
-      const message = JSON.parse(line.toString("utf8"));
-      if (!record2(message)) throw new Error("Unknown Codex protocol message");
-      if (observe(message)) stream.push(line);
-    } catch {
-      unavailable();
-      passthrough = true;
-      stream.push(line);
-    }
-  };
-  return new Transform({
-    transform(chunk, _encoding, callback) {
-      if (passthrough) {
-        this.push(chunk);
-        callback();
-        return;
-      }
-      buffered = Buffer.concat([buffered, chunk]);
-      if (buffered.length > MAX_MESSAGE_BYTES2) {
-        unavailable();
-        passthrough = true;
-        this.push(buffered);
-        buffered = Buffer.alloc(0);
-        callback();
-        return;
-      }
-      let end;
-      while ((end = buffered.indexOf(10)) >= 0) {
-        const line = buffered.subarray(0, end + 1);
-        buffered = buffered.subarray(end + 1);
-        if (passthrough || !line.toString("utf8").trim()) this.push(line);
-        else forward(this, line);
-      }
-      callback();
-    },
-    flush(callback) {
-      if (buffered.length) {
-        if (passthrough) this.push(buffered);
-        else forward(this, buffered);
-      }
-      callback();
-    }
-  });
-};
-var runCodexDesktopProxy = async (binary, args2, readAccount) => {
-  const stdioServer = args2[0] === "app-server" && !args2.some((arg) => arg === "--listen" || arg.startsWith("--listen="));
-  const child = spawn3(binary, [...args2], {
-    stdio: ["pipe", "pipe", "inherit"],
-    detached: true,
-    env: { ...process.env, CODEX_CLI_PATH: binary }
-  });
-  const account = stdioServer ? readAccount() : null;
-  const abort = new AbortController();
-  let approvals;
-  let timer;
-  let killTimer;
-  const unavailable = () => {
-    abort.abort();
-    clearInterval(timer);
-    void approvals?.close();
-    process.stderr.write("[pushary] Desktop forwarding unavailable; answer permissions in Codex.\n");
-  };
-  if (account && stdioServer) {
-    approvals = new CodexDesktopApprovals({ ...account, signal: abort.signal, reply: (message) => {
-      if (child.stdin.destroyed) throw new Error("Codex engine stopped");
-      child.stdin.write(JSON.stringify(message) + "\n");
-    } });
-    timer = setInterval(() => {
-      const current = readAccount();
-      if (!current || current.apiKey !== account.apiKey || current.baseUrl !== account.baseUrl || current.machineId !== account.machineId) unavailable();
-    }, 1e3);
-  }
-  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"), 2e3);
-  };
-  const input = stdioServer ? codexProtocolLines((message) => approvals?.client(message) ?? true, unavailable) : new PassThrough();
-  const output = stdioServer ? codexProtocolLines((message) => {
-    approvals?.server(message);
-    return true;
-  }, unavailable) : new PassThrough();
-  process.stdin.pipe(input).pipe(child.stdin);
-  child.stdout.pipe(output).pipe(process.stdout, { end: false });
-  if (stdioServer) process.stdin.once("end", stop);
-  for (const stream of [process.stdin, input, child.stdin, child.stdout, output, process.stdout]) stream.on("error", stop);
-  for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) process.on(signal, stop);
-  try {
-    return await new Promise((resolve3, reject) => {
-      child.once("error", reject);
-      child.once("close", (code) => resolve3(code ?? 1));
-    });
-  } finally {
-    abort.abort();
-    clearInterval(timer);
-    clearTimeout(killTimer);
-    signalChild("SIGKILL");
-    process.stdin.unpipe(input);
-    child.stdout.unpipe(output);
-    output.unpipe(process.stdout);
-    process.stdin.pause();
-    process.stdin.off("end", stop);
-    for (const stream of [process.stdin, input, child.stdin, child.stdout, output, process.stdout]) stream.off("error", stop);
-    for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) process.off(signal, stop);
-    await approvals?.close();
-  }
-};
-
-// src/codex-desktop-launch.ts
-var record3 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
-var quote = (value) => "'" + value.replace(/'/g, "'\\''") + "'";
-var TESTED_ENGINE_VERSION = "0.162.0-alpha.2";
-var desktopEngineFromManifest = (app, manifest) => {
-  if (!record3(manifest) || manifest.layoutVersion !== 1 || manifest.entrypoint !== "bin/codex" || manifest.version !== TESTED_ENGINE_VERSION) {
-    throw new Error(`Experimental Desktop forwarding requires bundled Codex ${TESTED_ENGINE_VERSION}. Launch Codex normally for this version.`);
-  }
-  return join2(app, "Contents/Resources/codex-cli/bin/codex");
-};
-var writeDesktopProxy = async (entry, app, directory) => {
-  const shim = join2(directory, "codex");
-  await writeFile(shim, "#!/bin/sh\nexec " + [...entry, "--desktop-proxy", app, "--"].map(quote).join(" ") + ' "$@"\n', { mode: 448, flag: "wx" });
-  return shim;
-};
-var desktopEngine = async (app) => {
-  const manifest = JSON.parse(await readFile(join2(app, "Contents/Resources/codex-cli/codex-package.json"), "utf8"));
-  const engine = desktopEngineFromManifest(app, manifest);
-  await access(engine, constants.X_OK);
-  return engine;
-};
-var desktopExecutable = (app) => {
-  const plist = join2(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 (record3(error) && error.status === 1) return join2(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 (args2, entry, readAccount) => {
-  if (args2[0] !== "--desktop" && args2[0] !== "--desktop-proxy") return null;
-  if (process.platform !== "darwin") throw new Error("Experimental Codex Desktop forwarding currently requires macOS");
-  if (args2[0] === "--desktop-proxy") {
-    if (!args2[1] || args2[2] !== "--") throw new Error("Invalid Desktop proxy invocation");
-    return runCodexDesktopProxy(await desktopEngine(args2[1]), args2.slice(3), readAccount);
-  }
-  if (args2.length > 2) throw new Error("Usage: pushary codex --desktop [path/to/Codex.app]");
-  if (!readAccount()) throw new Error("Connect Pushary before starting Desktop forwarding");
-  const app = resolve2(args2[1] ?? ["/Applications/ChatGPT.app", "/Applications/Codex.app"].find((candidate) => existsSync(join2(candidate, "Contents/Resources/codex-cli/codex-package.json"))) ?? "/Applications/Codex.app");
-  await desktopEngine(app);
-  const executable = desktopExecutable(app);
-  const directory = await mkdtemp2(join2(tmpdir2(), "pushary-codex-desktop-"));
-  try {
-    const shim = await writeDesktopProxy(entry, app, directory);
-    process.stderr.write("[pushary] Experimental Desktop launch. Supported approvals can reach Pushary; other prompts stay in Codex. Quit and open Codex normally to disable.\n");
-    const child = spawn4(executable, [], { stdio: "ignore", detached: true, env: { ...process.env, CODEX_CLI_PATH: shim } });
-    return await new Promise((resolve3, reject) => {
-      child.once("error", reject);
-      child.once("close", (code) => resolve3(code ?? 1));
-    });
-  } finally {
-    await rm2(directory, { recursive: true, force: true });
-  }
-};
+  letCodexRunWithoutPushary
+} from "../chunk-36NGFHE4.js";
 
 // bin/pushary-codex-session.ts
 var args = process.argv.slice(2);
 if (args[0] === "codex") args.shift();
-if (args[0] !== "--desktop-proxy") exitOnHelpFlag("codex");
-var desktopAccount = () => {
+var appBehindTheProxy = args[0] === "--desktop-proxy" && args[2] === "--" ? args[1] : void 0;
+if (args[0] !== "--desktop-proxy") (await import("../usage-ZC6BKIE3.js")).exitOnHelpFlag("codex");
+var desktopAccount = async () => {
   try {
+    const [{ getApiKey, getBaseUrl }, { getMachineId }] = await Promise.all([import("../config-HX6ZNOIL.js"), import("../identity-YISWVJ2A.js")]);
     return { apiKey: getApiKey(), baseUrl: getBaseUrl(), machineId: getMachineId() };
   } catch {
     return null;
   }
 };
-{
+var desktopLaunch = await import("../codex-desktop-launch-X7UKQ4VR.js").catch(() => null);
+if (desktopLaunch === null && appBehindTheProxy !== void 0) {
+  process.exitCode = await letCodexRunWithoutPushary(appBehindTheProxy, args.slice(3));
+} else {
   const abort = new AbortController();
   const stop = () => abort.abort();
   if (!args[0]?.startsWith("--desktop")) for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) process.on(signal, stop);
   try {
+    const { codexDesktopCommand } = desktopLaunch ?? await import("../codex-desktop-launch-X7UKQ4VR.js");
     const desktop = await codexDesktopCommand(args, [process.execPath, ...process.execArgv, process.argv[1], "codex"], desktopAccount);
     if (desktop !== null) process.exitCode = desktop;
     else {
+      const [{ getApiKey, getBaseUrl }, { getMachineId }, { resolveProviderBinary }, { codexSessionDirectory, launchCodexSession }] = await Promise.all([
+        import("../config-HX6ZNOIL.js"),
+        import("../identity-YISWVJ2A.js"),
+        import("../live-capabilities-44KFBOD4.js"),
+        import("../codex-session-launch-IX33LOQZ.js")
+      ]);
       const binary = resolveProviderBinary("codex");
       if (!binary) throw new Error("Install Codex first, then run pushary codex");
       process.exitCode = await launchCodexSession({