@pushary/agent-hooks 0.89.2 → 0.89.4

package/dist/bin/pushary-wait.js

@@ -14,8 +14,8 @@ import {
 } from "../chunk-GMXKITVA.js";
 import {
   exitOnHelpFlag
-} from "../chunk-SQOFGPNX.js";
-import "../chunk-GOEXZ5QJ.js";
+} from "../chunk-KJ57OPCC.js";
+import "../chunk-GPNOHKFO.js";
 import "../chunk-DINDL2CF.js";
 import "../chunk-SAF6HGAA.js";
 import {

package/dist/bin/pushary.js

@@ -3,7 +3,7 @@ import {
   COMMANDS,
   isCommandName,
   renderHelp
-} from "../chunk-GOEXZ5QJ.js";
+} from "../chunk-GPNOHKFO.js";
 import {
   getPackageVersion
 } from "../chunk-DINDL2CF.js";

package/dist/chunk-2HYPZLYY.js

@@ -0,0 +1,45 @@
+import {
+  pusharyDir
+} from "./chunk-V37ZXMH3.js";
+import {
+  writeFileAtomic
+} from "./chunk-6MTNS63X.js";
+
+// src/identity.ts
+import { randomUUID } from "crypto";
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var readMachineId = (filePath) => {
+  try {
+    const value = readFileSync(filePath, "utf8").trim();
+    return UUID.test(value) ? value : null;
+  } catch {
+    return null;
+  }
+};
+var getOrCreateMachineId = (options = {}) => {
+  const filePath = options.filePath ?? join(pusharyDir(), "machine-id");
+  const existing = readMachineId(filePath);
+  if (existing) return existing;
+  const id = (options.randomId ?? randomUUID)();
+  if (!UUID.test(id)) throw new Error("machine id generator returned an invalid UUID");
+  mkdirSync(dirname(filePath), { recursive: true });
+  try {
+    writeFileSync(filePath, `${id}
+`, { flag: "wx", mode: 384 });
+    return id;
+  } catch (err) {
+    if (err.code !== "EEXIST") throw err;
+  }
+  const winner = readMachineId(filePath);
+  if (winner) return winner;
+  writeFileAtomic(filePath, `${id}
+`, 384);
+  return id;
+};
+var getMachineId = (options = {}) => getOrCreateMachineId(options);
+
+export {
+  getMachineId
+};

package/dist/{chunk-ZYPS2XMT.js → chunk-4ZHQNBDP.js}

@@ -1,6 +1,6 @@
 import {
   pusharyDir
-} from "./chunk-VKVHY5HD.js";
+} from "./chunk-V37ZXMH3.js";
 import {
   readJsonSafe
 } from "./chunk-6MTNS63X.js";

package/dist/{chunk-B7JE4XHD.js → chunk-7IJYOBHL.js}

@@ -1,6 +1,6 @@
 import {
   readConfigFileKey
-} from "./chunk-LALHWDWL.js";
+} from "./chunk-W6NPWHBJ.js";
 
 // src/bell/fleet.ts
 import { closeSync, constants, futimesSync, lstatSync, mkdirSync, openSync, readdirSync, unlinkSync } from "fs";

package/dist/{chunk-NRGRUOAR.js → chunk-FWUEYXSD.js}

@@ -1,4 +1,6 @@
 // src/live-capabilities.ts
+var CLAUDE_BRIDGE_CAPABILITY = "claude-bridge";
+var CLAUDE_RESUME_CAPABILITY = "claude-resume";
 var CODEX_BRIDGE_CAPABILITY = "codex-bridge";
 var CODEX_RESUME_CAPABILITY = "codex-resume";
 var GEMINI_BRIDGE_CAPABILITY = "gemini-bridge";
@@ -19,6 +21,8 @@ var geminiLiveCapabilities = (rawVersion) => {
 };
 
 export {
+  CLAUDE_BRIDGE_CAPABILITY,
+  CLAUDE_RESUME_CAPABILITY,
   CODEX_BRIDGE_CAPABILITY,
   CODEX_RESUME_CAPABILITY,
   geminiLiveCapabilities

package/dist/{chunk-J3YDT4HM.js → chunk-GKAKAOKC.js}

@@ -68,13 +68,74 @@ var sendNotification = async (apiKey, params, timeoutMs = 15e3) => {
 
 // src/pending.ts
 import { join } from "path";
-import { tmpdir } from "os";
-import { existsSync, mkdirSync, writeFileSync, readdirSync, unlinkSync, rmSync, statSync } from "fs";
+import { homedir, tmpdir } from "os";
+import { createHash } from "crypto";
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, renameSync, unlinkSync, rmSync, statSync } from "fs";
 var PENDING_DIR = join(tmpdir(), "pushary-pending");
+var COMMAND_DIR = join(homedir(), ".pushary", "run", "commands");
 var DEFAULT_SESSION = "_no_session";
 var GRACE_MS = 10 * 60 * 1e3;
 var sanitize = (sessionId) => sessionId.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 128) || DEFAULT_SESSION;
 var dirFor = (sessionId) => join(PENDING_DIR, sanitize(sessionId));
+var commandDirFor = (sessionId, namespace = "") => join(
+  COMMAND_DIR,
+  createHash("sha256").update(namespace).digest("hex").slice(0, 16),
+  sanitize(sessionId)
+);
+var commandFile = (sessionId, namespace = "") => join(commandDirFor(sessionId, namespace), "command.json");
+var readPendingCommand = (sessionId, namespace = "") => {
+  try {
+    const value = JSON.parse(readFileSync(commandFile(sessionId, namespace), "utf-8"));
+    if (typeof value.id !== "string" || typeof value.text !== "string" || typeof value.expiresAtMs !== "number") return null;
+    if (value.expiresAtMs <= Date.now()) {
+      unlinkSync(commandFile(sessionId, namespace));
+      return null;
+    }
+    return {
+      ...value,
+      delivered: value.delivered === true,
+      ...value.failed === true ? { failed: true } : {}
+    };
+  } catch {
+    return null;
+  }
+};
+var savePendingCommand = (sessionId, command, namespace = "") => {
+  const dir = commandDirFor(sessionId, namespace);
+  try {
+    mkdirSync(dir, { recursive: true, mode: 448 });
+    writeFileSync(commandFile(sessionId, namespace), JSON.stringify(command), { encoding: "utf-8", mode: 384, flag: "wx" });
+    return true;
+  } catch {
+    return false;
+  }
+};
+var updatePendingCommand = (sessionId, id, update, namespace = "") => {
+  const command = readPendingCommand(sessionId, namespace);
+  if (!command || command.id !== id) return false;
+  const file = commandFile(sessionId, namespace);
+  const temporary = `${file}.${process.pid}.tmp`;
+  try {
+    writeFileSync(temporary, JSON.stringify({ ...command, ...update }), { encoding: "utf-8", mode: 384 });
+    renameSync(temporary, file);
+    return true;
+  } catch {
+    try {
+      unlinkSync(temporary);
+    } catch {
+    }
+    return false;
+  }
+};
+var markPendingCommandDelivered = (sessionId, id, namespace = "") => updatePendingCommand(sessionId, id, { delivered: true, failed: void 0 }, namespace);
+var markPendingCommandFailed = (sessionId, id, namespace = "") => updatePendingCommand(sessionId, id, { delivered: false, failed: true }, namespace);
+var removePendingCommand = (sessionId, id, namespace = "") => {
+  if (readPendingCommand(sessionId, namespace)?.id !== id) return;
+  try {
+    unlinkSync(commandFile(sessionId, namespace));
+  } catch {
+  }
+};
 var isDefaultSession = (sessionId) => sanitize(sessionId) === DEFAULT_SESSION;
 var savePendingQuestion = (sessionId, correlationId) => {
   const dir = dirFor(sessionId);
@@ -120,6 +181,11 @@ export {
   cancelQuestion,
   sendNotification,
   DEFAULT_SESSION,
+  readPendingCommand,
+  savePendingCommand,
+  markPendingCommandDelivered,
+  markPendingCommandFailed,
+  removePendingCommand,
   isDefaultSession,
   savePendingQuestion,
   listPendingQuestions,

package/dist/{chunk-GOEXZ5QJ.js → chunk-GPNOHKFO.js}

@@ -19,8 +19,8 @@ var COMMAND_LIST = [
     module: "pushary-daemon",
     summary: "Keep this machine reachable so your phone can START a new session",
     detail: [
-      "Leave it running in a project dir; it launches a headless",
-      "'pushary claude --remote' when you send a prompt from the app."
+      "Install the native per-user service for restart-on-login and restart-on-failure.",
+      "A bare `pushary daemon` remains foreground mode for diagnostics."
     ]
   },
   {
@@ -114,6 +114,13 @@ var COMMAND_OPTIONS = {
   claude: [
     ["--remote", "Start headless and drive it entirely from your phone"],
     ["-p <prompt>", "Initial prompt"]
+  ],
+  daemon: [
+    ["install", "Install and start the native per-user service"],
+    ["start | stop | restart", "Control the installed service"],
+    ["status", "Show local daemon health and PID"],
+    ["uninstall", "Stop and remove the native service"],
+    ["foreground", "Run attached to this terminal for diagnostics"]
   ]
 };
 var SETUP_OPTIONS = [

package/dist/{chunk-SQOFGPNX.js → chunk-KJ57OPCC.js}

@@ -1,6 +1,6 @@
 import {
   renderCommandHelp
-} from "./chunk-GOEXZ5QJ.js";
+} from "./chunk-GPNOHKFO.js";
 import {
   getPackageVersion
 } from "./chunk-DINDL2CF.js";

package/dist/{chunk-LGXTBUT4.js → chunk-KOPUTJQC.js}

@@ -268,6 +268,7 @@ var sessionEndAction = (reason) => typeof reason === "string" && SESSION_END_ACT
 var taskTitleFrom = (prompt) => typeof prompt === "string" ? prompt.replace(/\s+/g, " ").trim().slice(0, TASK_TITLE_MAX_LENGTH) || void 0 : void 0;
 
 export {
+  HOOK_FALLBACK_MAX,
   describeToolCall,
   deriveToolTarget,
   parseApplyPatchOps,

package/dist/{chunk-HEQVIIBN.js → chunk-MZBT2LXW.js}

@@ -17,7 +17,7 @@ import {
   readLastUserPrompt,
   repoKeyFor,
   throttlePass
-} from "./chunk-6XSC6Z2K.js";
+} from "./chunk-NFI2K2ZQ.js";
 import {
   DEFAULT_SESSION,
   askUser,
@@ -25,7 +25,7 @@ import {
   pollForAnswer,
   savePendingQuestion,
   sendNotification
-} from "./chunk-J3YDT4HM.js";
+} from "./chunk-GKAKAOKC.js";
 import {
   deriveAction,
   deriveActionBody,
@@ -33,10 +33,10 @@ import {
   deriveToolTarget,
   describeToolCall,
   scopePathFor
-} from "./chunk-LGXTBUT4.js";
+} from "./chunk-KOPUTJQC.js";
 import {
   getMachineId
-} from "./chunk-RN3NOEJF.js";
+} from "./chunk-2HYPZLYY.js";
 import {
   getApiKey,
   getBaseUrl

package/dist/{chunk-6XSC6Z2K.js → chunk-NFI2K2ZQ.js}

@@ -4,11 +4,15 @@ import {
   isDefaultSession,
   isPolicyConfig,
   listPendingQuestions,
+  markPendingCommandDelivered,
+  readPendingCommand,
+  removePendingCommand,
   removePendingQuestion,
   removePendingSession,
+  savePendingCommand,
   sendNotification,
   waitForAnswer
-} from "./chunk-J3YDT4HM.js";
+} from "./chunk-GKAKAOKC.js";
 import {
   AGENT_IDENTITIES,
   deriveReceiptMeta,
@@ -22,10 +26,10 @@ import {
   summarizeStop,
   taskTitleFrom,
   toolResultErrorText
-} from "./chunk-LGXTBUT4.js";
+} from "./chunk-KOPUTJQC.js";
 import {
   getMachineId
-} from "./chunk-RN3NOEJF.js";
+} from "./chunk-2HYPZLYY.js";
 import {
   withRetry
 } from "./chunk-BSZYIAZL.js";
@@ -666,10 +670,37 @@ var consumesActivityContext = (agentType) => {
   return pendingCommandEvents(source).some((event) => event !== "Stop");
 };
 var detectInstallMode = () => (process.argv[1] ?? "").includes("_npx") ? "npx" : "cli";
+var acknowledgePendingCommand = async (apiKey, baseUrl, commandId, sessionId, machineId, timeoutMs, state = "delivered") => {
+  try {
+    const response = await fetch(`${baseUrl}/api/agent/command/ack`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        commandId,
+        sessionId: sessionId ?? null,
+        machineId,
+        state,
+        ...state === "failed" ? { failureCode: "consumer_rejected" } : {}
+      }),
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+};
 var reportEvent = async (event, options = {}) => {
   const apiKey = options.apiKey ?? getApiKey();
   const baseUrl = getBaseUrl();
+  const machineId = event.machineId ?? getMachineId();
+  const sessionKey = event.sessionId || DEFAULT_SESSION;
+  const receiptNamespace = `${apiKey}:${machineId}:${event.agentType}`;
+  const clientCanDrain = consumesActivityContext(event.agentType) && options.timeoutMs === void 0;
   return withRetry(async () => {
+    const storedCommand = clientCanDrain ? readPendingCommand(sessionKey, receiptNamespace) : null;
     const res = await fetch(`${baseUrl}/api/agent/event`, {
       method: "POST",
       headers: {
@@ -678,7 +709,7 @@ var reportEvent = async (event, options = {}) => {
       },
       body: JSON.stringify({
         ...event,
-        machineId: event.machineId ?? getMachineId(),
+        machineId,
         // Lets the phone's Stop end this process instead of only denying its next
         // tool call. Ours alone: never another process, never a parent.
         pid: event.pid,
@@ -693,27 +724,56 @@ var reportEvent = async (event, options = {}) => {
         // Link-back for a phone-spawned session: forward the spawn id the daemon
         // set in the environment so the server can map spawnId -> sessionId.
         ...process.env.PUSHARY_SPAWN_ID ? { spawnId: process.env.PUSHARY_SPAWN_ID } : {},
-        // Advertise that this client reads `pendingCommand` back off the
-        // response, so the server may drain the phone-queued instruction on
-        // activity events (tool_complete/tool_error/user_prompt), not only Stop.
-        // Only Claude Code consumes additionalContext from these hooks; Codex and
-        // Gemini keep their existing session_end-only drain, so they must NOT
-        // advertise it or the server would pop-and-drop their queued command.
-        //
-        // And only when this caller kept the full budget. The pop is a destructive
-        // LPOP that happens before the response is written, so a caller that
-        // abandons the request destroys the message: `user_prompt` runs on a human
-        // keystroke and gave it 800ms, which a cold function misses routinely.
-        // Asking the server to consume something we may not wait to receive is the
-        // one shape that loses it outright, and the instruction reaches the agent
-        // on its next tool call instead.
-        canDrainCommand: consumesActivityContext(event.agentType) && options.timeoutMs === void 0
+        canDrainCommand: clientCanDrain && !storedCommand,
+        ackMode: clientCanDrain && !storedCommand,
+        skipCommandDrain: storedCommand != null
       }),
       signal: AbortSignal.timeout(options.timeoutMs ?? 1e4)
     });
     if (options.requireOk && !res.ok) throw new Error(`/api/agent/event rejected (${res.status})`);
     try {
-      return await res.json();
+      const result = await res.json();
+      const withoutPending = () => ({ ...result, pendingCommand: void 0, pendingCommandId: void 0 });
+      if (storedCommand) {
+        const failed = storedCommand.failed === true;
+        const acknowledged = await acknowledgePendingCommand(
+          apiKey,
+          baseUrl,
+          storedCommand.id,
+          event.sessionId,
+          machineId,
+          options.timeoutMs ?? 1e4,
+          failed ? "failed" : "delivered"
+        );
+        if (!acknowledged) return withoutPending();
+        if (storedCommand.delivered || failed) {
+          removePendingCommand(sessionKey, storedCommand.id, receiptNamespace);
+          return withoutPending();
+        }
+        if (!markPendingCommandDelivered(sessionKey, storedCommand.id, receiptNamespace)) return withoutPending();
+        return { ...withoutPending(), pendingCommand: storedCommand.text, pendingCommandId: storedCommand.id };
+      }
+      if (typeof result.pendingCommandId === "string" && typeof result.pendingCommand === "string") {
+        const saved = savePendingCommand(sessionKey, {
+          id: result.pendingCommandId,
+          text: result.pendingCommand,
+          expiresAtMs: typeof result.pendingCommandExpiresAtMs === "number" ? result.pendingCommandExpiresAtMs : Date.now() + 36e5,
+          delivered: false
+        }, receiptNamespace);
+        if (!saved) return withoutPending();
+        const acknowledged = await acknowledgePendingCommand(
+          apiKey,
+          baseUrl,
+          result.pendingCommandId,
+          event.sessionId,
+          machineId,
+          options.timeoutMs ?? 1e4
+        );
+        if (!acknowledged || !markPendingCommandDelivered(sessionKey, result.pendingCommandId, receiptNamespace)) {
+          return withoutPending();
+        }
+      }
+      return result;
     } catch {
       return null;
     }
@@ -810,9 +870,6 @@ var handleStop = async (input, agent = CLAUDE_CODE_AGENT) => {
     const sessionKey = input.session_id || DEFAULT_SESSION;
     const late = await reconcilePendingQuestions(sessionKey);
     const tasks = [
-      // maxAttempts:1 for the same reason as the activity-event drains: session_end
-      // always pops the command server-side (single-use LPOP), so a retry after a
-      // slow-but-successful response would pop a second command and drop the first.
       reportEvent({
         event: "session_end",
         agentType: agent.type,