@pushary/agent-hooks 1.9.50 → 1.9.52

package/dist/codex-session-launch-KLH2FSSJ.js

@@ -0,0 +1,331 @@
+import {
+  processGroupHasNothingLeftToSignal
+} from "./chunk-XCEN33UP.js";
+import {
+  CodexNativeApprovals,
+  answerCodexElicitation,
+  answerCodexQuestions,
+  claimOwnedQuestion,
+  closesOwnedQuestion,
+  codexQuestionOwner,
+  isCodexQuestionLeftWithTheLocalClient,
+  planCodexElicitation,
+  reportOwnedQuestion
+} from "./chunk-LD4MWJMD.js";
+import "./chunk-UVT6B6XN.js";
+import "./chunk-2LEH5IGX.js";
+import "./chunk-RIVNNBEK.js";
+import "./chunk-56ZTIY6D.js";
+import "./chunk-5463UUO2.js";
+import "./chunk-GCN73COS.js";
+import "./chunk-XHKBHWLX.js";
+import "./chunk-6ICPEJY5.js";
+import "./chunk-JBT3ZSJS.js";
+import {
+  writeDegraded
+} from "./chunk-ZMPR436Z.js";
+import "./chunk-P2546BBI.js";
+import "./chunk-POFBE6ZY.js";
+import "./chunk-L5YTS2BP.js";
+import "./chunk-EK7SZJ4K.js";
+import "./chunk-T6RIKJUO.js";
+import "./chunk-7QLSKOSU.js";
+import "./chunk-KZERVKTD.js";
+import "./chunk-OML4YFBN.js";
+import "./chunk-XUW2DRAQ.js";
+import "./chunk-AQFEP65J.js";
+import "./chunk-CQ5JGRML.js";
+import "./chunk-MC4VY5LK.js";
+import "./chunk-QTOLNRET.js";
+import {
+  canonicalJsonText
+} from "./chunk-LF3TLC7B.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/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((resolve2) => {
+    child.once("exit", () => {
+      controller.abort(new Error("Codex app-server stopped"));
+      resolve2();
+    });
+    child.once("error", () => {
+      controller.abort(new Error("Could not start Codex app-server"));
+      resolve2();
+    });
+  });
+  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((resolve2) => setTimeout(resolve2, 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((resolve2, reject) => {
+      http.once("error", reject);
+      http.listen(socketPath, resolve2);
+    });
+    signal.throwIfAborted();
+    return { endpoint: "unix://" + socketPath, signal, close };
+  } catch (error) {
+    await close();
+    throw error;
+  }
+};
+
+// src/codex-session-launch.ts
+var codexSessionDirectory = (args, cwd) => {
+  if (args.length === 0) return cwd;
+  if (args.length === 2 && args[0] === "--cwd" && args[1]) return resolve(cwd, args[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((resolve2, reject) => {
+        tui.once("error", reject);
+        tui.once("close", (code) => resolve2(code ?? 1));
+      });
+    } finally {
+      session.signal.removeEventListener("abort", stop);
+    }
+  } finally {
+    await session.close();
+  }
+};
+export {
+  codexSessionDirectory,
+  launchCodexSession
+};

package/dist/config-HX6ZNOIL.js

@@ -0,0 +1,14 @@
+import {
+  configFilePath,
+  getApiKey,
+  getBaseUrl,
+  resetKeyDriftWarning
+} from "./chunk-CQ5JGRML.js";
+import "./chunk-MC4VY5LK.js";
+import "./chunk-LF3TLC7B.js";
+export {
+  configFilePath,
+  getApiKey,
+  getBaseUrl,
+  resetKeyDriftWarning
+};

package/dist/{global-upgrade-AIUSS2YH.js → global-upgrade-AZN3BPI3.js}

@@ -5,15 +5,17 @@ import {
   readGlobalUpgradeSubject,
   upgradeInstalledPackage,
   withUpgradeLock
-} from "./chunk-ZTTCYHOM.js";
-import "./chunk-KBGKWB5T.js";
-import "./chunk-APASKZ2I.js";
+} from "./chunk-NECZKPJN.js";
+import "./chunk-H57DXSHR.js";
+import "./chunk-QKU46TK5.js";
 import "./chunk-POFBE6ZY.js";
 import "./chunk-KZERVKTD.js";
-import "./chunk-ZYYQJSIO.js";
+import "./chunk-OML4YFBN.js";
+import "./chunk-XUW2DRAQ.js";
 import "./chunk-AQFEP65J.js";
-import "./chunk-ZOKMGBPR.js";
-import "./chunk-OR5F63C2.js";
+import "./chunk-MC4VY5LK.js";
+import "./chunk-QTOLNRET.js";
+import "./chunk-LF3TLC7B.js";
 export {
   finishGlobalUpgrade,
   finishUpgradeWithLock,

package/dist/identity-AQIMUWYN.js

@@ -0,0 +1,15 @@
+import {
+  getMachineId,
+  getOrCreateMachineId,
+  readExistingMachineId
+} from "./chunk-T6RIKJUO.js";
+import "./chunk-OML4YFBN.js";
+import "./chunk-XUW2DRAQ.js";
+import "./chunk-AQFEP65J.js";
+import "./chunk-QTOLNRET.js";
+import "./chunk-LF3TLC7B.js";
+export {
+  getMachineId,
+  getOrCreateMachineId,
+  readExistingMachineId
+};

package/dist/live-capabilities-4IIFAMHU.js

@@ -0,0 +1,53 @@
+import {
+  CLAUDE_BRIDGE_CAPABILITY,
+  CLAUDE_RESUME_CAPABILITY,
+  CODEX_BRIDGE_CAPABILITY,
+  CODEX_RESUME_CAPABILITY,
+  GEMINI_BRIDGE_CAPABILITY,
+  GEMINI_RESUME_CAPABILITY,
+  SPAWN_CAPABILITY,
+  codexBinaryIsBroken,
+  detectLaunchableProviderCapabilities,
+  detectProviderLiveCapabilities,
+  discoverProviderInventory,
+  expectedLaunchCapabilities,
+  geminiLiveCapabilities,
+  hasSpawnProvider,
+  launchAdvertisement,
+  launchableProviders,
+  missingControlPrerequisite,
+  phoneStartIsRequired,
+  providerLiveCapabilities,
+  resolveControlPolicy,
+  resolveProviderBinary,
+  trackProviderInventory
+} from "./chunk-2LEH5IGX.js";
+import "./chunk-RIVNNBEK.js";
+import "./chunk-6ICPEJY5.js";
+import "./chunk-XUW2DRAQ.js";
+import "./chunk-QTOLNRET.js";
+import "./chunk-LF3TLC7B.js";
+export {
+  CLAUDE_BRIDGE_CAPABILITY,
+  CLAUDE_RESUME_CAPABILITY,
+  CODEX_BRIDGE_CAPABILITY,
+  CODEX_RESUME_CAPABILITY,
+  GEMINI_BRIDGE_CAPABILITY,
+  GEMINI_RESUME_CAPABILITY,
+  SPAWN_CAPABILITY,
+  codexBinaryIsBroken,
+  detectLaunchableProviderCapabilities,
+  detectProviderLiveCapabilities,
+  discoverProviderInventory,
+  expectedLaunchCapabilities,
+  geminiLiveCapabilities,
+  hasSpawnProvider,
+  launchAdvertisement,
+  launchableProviders,
+  missingControlPrerequisite,
+  phoneStartIsRequired,
+  providerLiveCapabilities,
+  resolveControlPolicy,
+  resolveProviderBinary,
+  trackProviderInventory
+};

package/dist/{paths-RO34TYNM.js → paths-X4IPV2WJ.js}

@@ -32,8 +32,10 @@ import {
   pusharyDir,
   vscodePluginDir,
   vscodePluginMcp
-} from "./chunk-ZYYQJSIO.js";
-import "./chunk-OR5F63C2.js";
+} from "./chunk-OML4YFBN.js";
+import "./chunk-XUW2DRAQ.js";
+import "./chunk-QTOLNRET.js";
+import "./chunk-LF3TLC7B.js";
 export {
   autoUpdateLock,
   autoUpdateLog,

package/dist/{reapply-KTNPP4XE.js → reapply-CXODG53B.js}

@@ -11,34 +11,40 @@ import {
   reapplyOpenCodePlugin,
   reapplyVsCodePlugin,
   repairCodexHolds
-} from "./chunk-7RMSB4A2.js";
-import "./chunk-KIO2MZQC.js";
-import "./chunk-LLRYP5TR.js";
-import "./chunk-Y74IJ2IO.js";
-import "./chunk-WEY5ZHDB.js";
-import "./chunk-25SYEAW4.js";
-import "./chunk-PA54A437.js";
-import "./chunk-XTVEW2NG.js";
-import "./chunk-GMXKITVA.js";
+} from "./chunk-RL7EOD6I.js";
+import "./chunk-FCMWUYIE.js";
+import "./chunk-MTKV4RUQ.js";
+import "./chunk-46TC24ET.js";
+import "./chunk-K23WMLPY.js";
 import "./chunk-RIVNNBEK.js";
+import "./chunk-N77BH7H2.js";
+import "./chunk-Q7OXI6VS.js";
+import "./chunk-6C4S3QYD.js";
+import "./chunk-BUXDR6US.js";
+import "./chunk-LIESRXK5.js";
+import "./chunk-GMXKITVA.js";
 import "./chunk-XHKBHWLX.js";
 import "./chunk-6ICPEJY5.js";
-import "./chunk-YVO4HIHX.js";
-import "./chunk-B7LV6W7U.js";
-import "./chunk-KEAIIVW3.js";
-import "./chunk-AWMMABVB.js";
+import "./chunk-VYBH6D4X.js";
+import "./chunk-U2L42GVI.js";
+import "./chunk-3RPN7AAT.js";
+import "./chunk-JBT3ZSJS.js";
+import "./chunk-ZMPR436Z.js";
+import "./chunk-P2546BBI.js";
 import "./chunk-POFBE6ZY.js";
-import "./chunk-LZYJMSOY.js";
-import "./chunk-34RXPM5U.js";
-import "./chunk-ABMEBN2R.js";
-import "./chunk-LY3OJFBW.js";
+import "./chunk-L5YTS2BP.js";
+import "./chunk-EK7SZJ4K.js";
+import "./chunk-T6RIKJUO.js";
 import "./chunk-7QLSKOSU.js";
 import "./chunk-KZERVKTD.js";
-import "./chunk-ZYYQJSIO.js";
+import "./chunk-4QQEUJL4.js";
+import "./chunk-OML4YFBN.js";
+import "./chunk-XUW2DRAQ.js";
 import "./chunk-AQFEP65J.js";
-import "./chunk-VUS6QGND.js";
-import "./chunk-ZOKMGBPR.js";
-import "./chunk-OR5F63C2.js";
+import "./chunk-CQ5JGRML.js";
+import "./chunk-MC4VY5LK.js";
+import "./chunk-QTOLNRET.js";
+import "./chunk-LF3TLC7B.js";
 export {
   ensureCodexTrustAfterReapply,
   inspectConfiguredManagedProviders,

package/dist/src/index.d.ts

@@ -187,9 +187,9 @@ interface AnswerResult {
     note?: string;
 }
 
-declare const askUser: (apiKey: string, params: AskUserParams, timeoutMs?: number) => Promise<AskUserResponse>;
-declare const waitForAnswer: (apiKey: string, correlationId: string, timeoutMs?: number, signal?: AbortSignal) => Promise<AnswerResult>;
-declare const cancelQuestion: (apiKey: string, correlationId: string, signal?: AbortSignal) => Promise<{
+declare const askUser: (apiKey: string, params: AskUserParams, timeoutMs?: number, baseUrl?: string) => Promise<AskUserResponse>;
+declare const waitForAnswer: (apiKey: string, correlationId: string, timeoutMs?: number, signal?: AbortSignal, baseUrl?: string) => Promise<AnswerResult>;
+declare const cancelQuestion: (apiKey: string, correlationId: string, signal?: AbortSignal, baseUrl?: string) => Promise<{
     cancelled?: boolean;
     status?: string;
     handoffAction?: string;

package/dist/src/index.js

@@ -1,14 +1,14 @@
 import {
   handlePreToolUse
-} from "../chunk-TGCIFEDE.js";
-import "../chunk-EP6S6VY3.js";
-import "../chunk-Y7WD72J7.js";
-import "../chunk-IF2UPWD2.js";
-import "../chunk-Y74IJ2IO.js";
-import "../chunk-25SYEAW4.js";
+} from "../chunk-NELH25J7.js";
+import "../chunk-JPABKXK6.js";
+import "../chunk-7CLLWDCP.js";
+import "../chunk-DHJSBK63.js";
+import "../chunk-N77BH7H2.js";
+import "../chunk-6C4S3QYD.js";
 import {
   fetchAccountPublicKey
-} from "../chunk-KK2DIUVV.js";
+} from "../chunk-GCN73COS.js";
 import "../chunk-6ICPEJY5.js";
 import {
   fetchModeOverride,
@@ -18,31 +18,34 @@ import {
   handlePostToolUse,
   handleStop,
   reportEvent
-} from "../chunk-YVO4HIHX.js";
-import "../chunk-B7LV6W7U.js";
-import "../chunk-KEAIIVW3.js";
+} from "../chunk-U2L42GVI.js";
+import "../chunk-3RPN7AAT.js";
+import "../chunk-JBT3ZSJS.js";
 import {
   askUser,
   cancelQuestion,
   waitForAnswer
-} from "../chunk-AWMMABVB.js";
+} from "../chunk-ZMPR436Z.js";
+import "../chunk-P2546BBI.js";
 import "../chunk-POFBE6ZY.js";
-import "../chunk-LZYJMSOY.js";
-import "../chunk-34RXPM5U.js";
-import "../chunk-ABMEBN2R.js";
-import "../chunk-LY3OJFBW.js";
+import "../chunk-L5YTS2BP.js";
+import "../chunk-EK7SZJ4K.js";
+import "../chunk-T6RIKJUO.js";
 import "../chunk-7QLSKOSU.js";
 import "../chunk-KZERVKTD.js";
-import "../chunk-ZYYQJSIO.js";
+import "../chunk-4QQEUJL4.js";
+import "../chunk-OML4YFBN.js";
+import "../chunk-XUW2DRAQ.js";
 import "../chunk-AQFEP65J.js";
 import {
   getApiKey,
   getBaseUrl
-} from "../chunk-VUS6QGND.js";
-import "../chunk-ZOKMGBPR.js";
+} from "../chunk-CQ5JGRML.js";
+import "../chunk-MC4VY5LK.js";
+import "../chunk-QTOLNRET.js";
 import {
   resolvePolicy
-} from "../chunk-OR5F63C2.js";
+} from "../chunk-LF3TLC7B.js";
 export {
   askUser,
   cancelQuestion,

package/dist/{upgrade-lock-5UAGXIW7.js → upgrade-lock-AHISGKER.js}

@@ -5,10 +5,12 @@ import {
   installWithUpgradeLock,
   ownsUpgradeLock,
   releaseAutoUpdateLock
-} from "./chunk-KBGKWB5T.js";
-import "./chunk-ZYYQJSIO.js";
+} from "./chunk-H57DXSHR.js";
+import "./chunk-OML4YFBN.js";
+import "./chunk-XUW2DRAQ.js";
 import "./chunk-AQFEP65J.js";
-import "./chunk-OR5F63C2.js";
+import "./chunk-QTOLNRET.js";
+import "./chunk-LF3TLC7B.js";
 export {
   claimUpgradeLock,
   finishWithUpgradeLock,

package/dist/usage-ZC6BKIE3.js

@@ -0,0 +1,10 @@
+import {
+  exitOnHelpFlag
+} from "./chunk-S6RNS4UL.js";
+import "./chunk-KZERVKTD.js";
+import "./chunk-MC4VY5LK.js";
+import "./chunk-QTOLNRET.js";
+import "./chunk-LF3TLC7B.js";
+export {
+  exitOnHelpFlag
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushary/agent-hooks",
-  "version": "1.9.50",
+  "version": "1.9.52",
   "description": "Permission hooks for AI coding agents: route tool approvals through Pushary push notifications",
   "keywords": [
     "pushary",