@pushary/agent-hooks 1.9.44 → 1.9.46

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

@@ -1,36 +1,50 @@
 #!/usr/bin/env node
 import {
   exitOnHelpFlag
-} from "../chunk-OR6KJOHE.js";
+} from "../chunk-GG6C4CHH.js";
 import {
-  CodexNativeApprovals
-} from "../chunk-SVCT5D7K.js";
-import "../chunk-PQAFH4DF.js";
+  CodexNativeApprovals,
+  answerCodexElicitation,
+  answerCodexQuestions,
+  claimOwnedQuestion,
+  closesOwnedQuestion,
+  codexQuestionOwner,
+  planCodexElicitation,
+  reportOwnedQuestion
+} from "../chunk-FMDGUCER.js";
+import "../chunk-ELLN4XAF.js";
 import {
   resolveProviderBinary
-} from "../chunk-L2ZM7LXN.js";
+} from "../chunk-2PTJHEX4.js";
 import "../chunk-RIVNNBEK.js";
-import "../chunk-75M7NFFC.js";
-import "../chunk-MRQJCIFO.js";
+import "../chunk-UI3WDOV3.js";
+import "../chunk-EKDSF3IX.js";
+import "../chunk-2VNHP2OE.js";
+import "../chunk-XHKBHWLX.js";
 import "../chunk-6ICPEJY5.js";
-import "../chunk-GOEIW2VH.js";
+import {
+  writeDegraded
+} from "../chunk-UGXRDY3O.js";
 import "../chunk-POFBE6ZY.js";
-import "../chunk-53UZN7JW.js";
-import "../chunk-TKTS3SIM.js";
-import "../chunk-S2ALW446.js";
+import "../chunk-FQW7AV6U.js";
+import "../chunk-2X3PPRNC.js";
+import "../chunk-KJNWVAS6.js";
 import {
   getMachineId
-} from "../chunk-WMO2XVG4.js";
+} from "../chunk-ULEX43F7.js";
 import "../chunk-7QLSKOSU.js";
 import "../chunk-KZERVKTD.js";
-import "../chunk-4JHEZ2PV.js";
+import "../chunk-EW52AGOV.js";
 import "../chunk-AQFEP65J.js";
 import {
   getApiKey,
   getBaseUrl
-} from "../chunk-OWQOMGBF.js";
-import "../chunk-T3KMJI4W.js";
-import "../chunk-JNU3LV47.js";
+} from "../chunk-7XSIUY5F.js";
+import "../chunk-WN3MDHAM.js";
+import {
+  CODEX_NATIVE_APPROVAL_METHODS,
+  canonicalJsonText
+} from "../chunk-EDSXF7NV.js";
 
 // src/codex-session-launch.ts
 import { spawn as spawn2 } from "child_process";
@@ -44,6 +58,95 @@ 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 {
+      if (!signal.aborted) 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/codex-shared-session.ts
+var GROUP_HAS_NOTHING_LEFT_TO_SIGNAL = /* @__PURE__ */ new Set(["ESRCH", "EPERM"]);
 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;
@@ -66,14 +169,14 @@ var startCodexSharedSession = async (options) => {
     detached: true
   });
   child.stderr.resume();
-  const exited = new Promise((resolve2) => {
+  const exited = new Promise((resolve3) => {
     child.once("exit", () => {
       controller.abort(new Error("Codex app-server stopped"));
-      resolve2();
+      resolve3();
     });
     child.once("error", () => {
       controller.abort(new Error("Could not start Codex app-server"));
-      resolve2();
+      resolve3();
     });
   });
   let terminal = null;
@@ -84,16 +187,20 @@ var startCodexSharedSession = async (options) => {
     if (signal.aborted || child.stdin.destroyed) throw new Error("Codex connection closed");
     child.stdin.write(JSON.stringify(message) + "\n");
   };
-  const approvals = new CodexNativeApprovals({ ...options, signal, shared: true, reply: (id, result) => {
+  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);
-    approvals.handle({ id: message.id, method: message.method, params: message.params }, typeof message.params.threadId === "string" ? message.params.threadId : null);
+    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) => {
@@ -135,6 +242,7 @@ var startCodexSharedSession = async (options) => {
         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 {
@@ -148,14 +256,14 @@ var startCodexSharedSession = async (options) => {
       process.kill(-child.pid, signal2);
       return true;
     } catch (error) {
-      if (record(error) && error.code === "ESRCH") return false;
+      if (record(error) && typeof error.code === "string" && GROUP_HAS_NOTHING_LEFT_TO_SIGNAL.has(error.code)) return false;
       throw error;
     }
   };
   const stopServer = async () => {
     signalServerGroup("SIGTERM");
     const deadline = Date.now() + 2e3;
-    while (signalServerGroup(0) && Date.now() < deadline) await new Promise((resolve2) => setTimeout(resolve2, 25));
+    while (signalServerGroup(0) && Date.now() < deadline) await new Promise((resolve3) => setTimeout(resolve3, 25));
     if (signalServerGroup(0)) signalServerGroup("SIGKILL");
     await exited;
   };
@@ -167,7 +275,7 @@ var startCodexSharedSession = async (options) => {
       websocket.close();
       http.close();
       try {
-        await Promise.all([approvals.close(), stopServer()]);
+        await Promise.all([approvals.close(), questions.close(), stopServer()]);
       } finally {
         await rm(directory, { recursive: true, force: true });
       }
@@ -178,9 +286,9 @@ var startCodexSharedSession = async (options) => {
     void close();
   }, { once: true });
   try {
-    await new Promise((resolve2, reject) => {
+    await new Promise((resolve3, reject) => {
       http.once("error", reject);
-      http.listen(socketPath, resolve2);
+      http.listen(socketPath, resolve3);
     });
     signal.throwIfAborted();
     return { endpoint: "unix://" + socketPath, signal, close };
@@ -200,7 +308,7 @@ 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 native permissions can reach Pushary; other prompts stay in this terminal.\n");
+    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" },
@@ -212,9 +320,9 @@ var launchCodexSession = async (options) => {
     session.signal.addEventListener("abort", stop, { once: true });
     if (session.signal.aborted) stop();
     try {
-      return await new Promise((resolve2, reject) => {
+      return await new Promise((resolve3, reject) => {
         tui.once("error", reject);
-        tui.once("close", (code) => resolve2(code ?? 1));
+        tui.once("close", (code) => resolve3(code ?? 1));
       });
     } finally {
       session.signal.removeEventListener("abort", stop);
@@ -224,25 +332,314 @@ var launchCodexSession = async (options) => {
   }
 };
 
+// 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 (!record2(error) || error.code !== "ESRCH") 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 });
+  }
+};
+
 // bin/pushary-codex-session.ts
-exitOnHelpFlag("codex");
 var args = process.argv.slice(2);
 if (args[0] === "codex") args.shift();
+if (args[0] !== "--desktop-proxy") exitOnHelpFlag("codex");
+var desktopAccount = () => {
+  try {
+    return { apiKey: getApiKey(), baseUrl: getBaseUrl(), machineId: getMachineId() };
+  } catch {
+    return null;
+  }
+};
 {
   const abort = new AbortController();
   const stop = () => abort.abort();
-  for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) process.on(signal, stop);
+  if (!args[0]?.startsWith("--desktop")) for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) process.on(signal, stop);
   try {
-    const binary = resolveProviderBinary("codex");
-    if (!binary) throw new Error("Install Codex first, then run pushary codex");
-    process.exitCode = await launchCodexSession({
-      binary,
-      cwd: codexSessionDirectory(args, process.cwd()),
-      apiKey: getApiKey(),
-      baseUrl: getBaseUrl(),
-      machineId: getMachineId(),
-      signal: abort.signal
-    });
+    const desktop = await codexDesktopCommand(args, [process.execPath, ...process.execArgv, process.argv[1], "codex"], desktopAccount);
+    if (desktop !== null) process.exitCode = desktop;
+    else {
+      const binary = resolveProviderBinary("codex");
+      if (!binary) throw new Error("Install Codex first, then run pushary codex");
+      process.exitCode = await launchCodexSession({
+        binary,
+        cwd: codexSessionDirectory(args, process.cwd()),
+        apiKey: getApiKey(),
+        baseUrl: getBaseUrl(),
+        machineId: getMachineId(),
+        signal: abort.signal
+      });
+    }
   } catch (error) {
     process.stderr.write(`[pushary] ${error instanceof Error ? error.message : "Codex session failed"}
 `);

package/dist/bin/pushary-codex.js

@@ -1,33 +1,32 @@
 #!/usr/bin/env node
 import {
   reportEvent
-} from "../chunk-BKK3JCTD.js";
-import "../chunk-CAJCCQ7N.js";
+} from "../chunk-WYD4PYTL.js";
+import "../chunk-NWZZTHWF.js";
+import "../chunk-W7MXYDGP.js";
 import {
   askUser,
   isDecisionStopped,
   waitForAnswer
-} from "../chunk-5ZSBQHCM.js";
-import "../chunk-M2L7625S.js";
-import "../chunk-GOEIW2VH.js";
+} from "../chunk-UGXRDY3O.js";
 import "../chunk-POFBE6ZY.js";
-import "../chunk-53UZN7JW.js";
-import "../chunk-TKTS3SIM.js";
-import "../chunk-S2ALW446.js";
+import "../chunk-FQW7AV6U.js";
+import "../chunk-2X3PPRNC.js";
+import "../chunk-KJNWVAS6.js";
 import {
   getMachineId
-} from "../chunk-WMO2XVG4.js";
+} from "../chunk-ULEX43F7.js";
 import "../chunk-7QLSKOSU.js";
 import "../chunk-KZERVKTD.js";
-import "../chunk-4JHEZ2PV.js";
+import "../chunk-EW52AGOV.js";
 import "../chunk-AQFEP65J.js";
 import {
   getApiKey
-} from "../chunk-OWQOMGBF.js";
+} from "../chunk-7XSIUY5F.js";
 import {
   NPX_LATEST_COMMAND
-} from "../chunk-T3KMJI4W.js";
-import "../chunk-JNU3LV47.js";
+} from "../chunk-WN3MDHAM.js";
+import "../chunk-EDSXF7NV.js";
 
 // bin/pushary-codex.ts
 import { basename } from "path";