@pushary/agent-hooks 0.40.0 → 0.43.0

package/dist/bin/pushary-claude.js

@@ -12,7 +12,7 @@ import {
   getPolicy,
   resolvePolicy,
   waitForAnswer
-} from "../chunk-AUEPQATK.js";
+} from "../chunk-ETDXSKR5.js";
 import "../chunk-DWED7BS3.js";
 import "../chunk-Z5PL3K7C.js";
 import {
@@ -46,8 +46,17 @@ var findClaudeBinary = () => {
   return null;
 };
 
-// src/wrapper/localPassthrough.ts
+// src/wrapper/spawnClaude.ts
 import { spawn } from "child_process";
+var needsShell = (binary, platform = process.platform) => platform === "win32" && /\.(cmd|bat)$/i.test(binary);
+var spawnClaude = (binary, args2, options) => {
+  if (needsShell(binary)) {
+    return spawn(`"${binary}"`, args2, { ...options, shell: true });
+  }
+  return spawn(binary, args2, options);
+};
+
+// src/wrapper/localPassthrough.ts
 var SIGNAL_NUMBERS = {
   SIGHUP: 1,
   SIGINT: 2,
@@ -60,7 +69,7 @@ var runLocalPassthrough = (binary, args2) => {
   return new Promise((resolve) => {
     let child;
     try {
-      child = spawn(binary, args2, {
+      child = spawnClaude(binary, args2, {
         stdio: "inherit",
         env: { ...process.env, [WRAPPER_ACTIVE_ENV]: "1" }
       });
@@ -95,15 +104,24 @@ var runLocalPassthrough = (binary, args2) => {
 import { basename } from "path";
 
 // src/wrapper/sdkLoader.ts
+import { spawn as spawn2 } from "child_process";
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+import { pathToFileURL } from "url";
 var userMessage = (text) => ({
   type: "user",
   message: { role: "user", content: text },
   parent_tool_use_id: null
 });
-var loadClaudeSdk = async () => {
-  const specifier = "@anthropic-ai/claude-agent-sdk";
+var SDK_VERSION = "0.3.207";
+var SDK_PACKAGE = "@anthropic-ai/claude-agent-sdk";
+var SDK_SPEC = `${SDK_PACKAGE}@${SDK_VERSION}`;
+var sdkCacheDir = () => process.env.PUSHARY_REMOTE_SDK_DIR?.trim() || join2(homedir(), ".pushary", "remote-sdk");
+var cachedSdkEntry = () => join2(sdkCacheDir(), "node_modules", "@anthropic-ai", "claude-agent-sdk", "sdk.mjs");
+var importSdk = async (specifierOrUrl) => {
   try {
-    const mod = await import(specifier);
+    const mod = await import(specifierOrUrl);
     if (typeof mod.query === "function") return mod;
     if (mod.default && typeof mod.default.query === "function") return mod.default;
     return null;
@@ -111,6 +129,44 @@ var loadClaudeSdk = async () => {
     return null;
   }
 };
+var loadClaudeSdk = async () => {
+  const fromResolution = await importSdk(SDK_PACKAGE);
+  if (fromResolution) return fromResolution;
+  const entry = cachedSdkEntry();
+  if (existsSync(entry)) return importSdk(pathToFileURL(entry).href);
+  return null;
+};
+var ensureClaudeSdk = async (log) => {
+  const present = await loadClaudeSdk();
+  if (present) return present;
+  const dir = sdkCacheDir();
+  try {
+    mkdirSync(dir, { recursive: true });
+    const pkgJson = join2(dir, "package.json");
+    if (!existsSync(pkgJson)) {
+      writeFileSync(pkgJson, `${JSON.stringify({ name: "pushary-remote-sdk", private: true })}
+`);
+    }
+  } catch {
+    return null;
+  }
+  log?.("[pushary] setting up remote mode (one-time, fetching the Claude Agent SDK)...");
+  const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
+  const installed = await new Promise((resolve) => {
+    const child = spawn2(
+      npmCmd,
+      ["install", "--no-optional", "--no-audit", "--no-fund", "--loglevel=error", SDK_SPEC],
+      { cwd: dir, stdio: "ignore", shell: process.platform === "win32" }
+    );
+    child.on("error", () => resolve(false));
+    child.on("close", (code) => resolve(code === 0));
+  });
+  if (!installed) {
+    log?.(`[pushary] could not auto-install the SDK. Install it manually: npm i -g ${SDK_SPEC}`);
+    return null;
+  }
+  return loadClaudeSdk();
+};
 
 // src/wrapper/messageQueue.ts
 var BoundedInputQueue = class {
@@ -119,12 +175,14 @@ var BoundedInputQueue = class {
   closed = false;
   cap;
   onDrop;
+  coalesce;
   pushedCount = 0;
   deliveredCount = 0;
   droppedCount = 0;
   constructor(options = {}) {
     this.cap = Math.max(1, options.cap ?? 32);
     this.onDrop = options.onDrop;
+    this.coalesce = options.coalesce;
   }
   push(item) {
     if (this.closed) return;
@@ -179,6 +237,11 @@ var BoundedInputQueue = class {
     return {
       next: () => {
         if (this.buffer.length > 0) {
+          if (this.coalesce && this.buffer.length > 1) {
+            const items = this.buffer.splice(0, this.buffer.length);
+            this.deliveredCount += items.length;
+            return Promise.resolve({ value: this.coalesce(items), done: false });
+          }
           const value = this.buffer.shift();
           this.deliveredCount++;
           return Promise.resolve({ value, done: false });
@@ -383,13 +446,28 @@ var startCommandPoller = (opts) => {
     if (stopped) return;
     timer = setTimeout(tick, jitter(delayMs));
   };
+  const fetchMode = async () => {
+    if (!opts.fetchModeState || !opts.onModeState) return;
+    try {
+      const state = await opts.fetchModeState(opts.apiKey, opts.getSessionId?.());
+      try {
+        opts.onModeState(state);
+      } catch {
+      }
+    } catch {
+    }
+  };
   const tick = async () => {
     if (stopped) return;
     const controller = new AbortController();
     inflight = controller;
     const timeout = setTimeout(() => controller.abort(), requestTimeout);
     try {
-      const command = await drain(opts.apiKey, opts.getSessionId?.(), controller.signal);
+      const wantCommands = opts.shouldDrainCommands ? opts.shouldDrainCommands() : true;
+      const [command] = await Promise.all([
+        wantCommands ? drain(opts.apiKey, opts.getSessionId?.(), controller.signal) : Promise.resolve(null),
+        fetchMode()
+      ]);
       errorStreak = 0;
       if (command) {
         idleTicks = 0;
@@ -420,6 +498,286 @@ var startCommandPoller = (opts) => {
   };
 };
 
+// src/wrapper/wsProtocol.ts
+var PROTOCOL_VERSION = 1;
+var TRANSCRIPT_TEXT_MAX = 4e3;
+var encodeFrame = (frame) => JSON.stringify(frame);
+var helloFrame = (fields) => ({ v: PROTOCOL_VERSION, t: "hello", ...fields });
+var transcriptFrame = (seq, kind, text, meta) => ({
+  v: PROTOCOL_VERSION,
+  t: "transcript",
+  seq,
+  kind,
+  ...text !== void 0 ? { text: text.slice(0, TRANSCRIPT_TEXT_MAX) } : {},
+  ...meta ? { meta } : {}
+});
+var parse = (raw) => {
+  try {
+    const value = JSON.parse(raw);
+    if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+    const obj = value;
+    if (obj.v !== PROTOCOL_VERSION) return null;
+    return obj;
+  } catch {
+    return null;
+  }
+};
+var isString = (v) => typeof v === "string";
+var isFiniteNumber = (v) => typeof v === "number" && Number.isFinite(v);
+var decodeServerFrame = (raw) => {
+  const f = parse(raw);
+  if (!f) return null;
+  switch (f.t) {
+    case "welcome":
+      return isFiniteNumber(f.resumeFromSeq) ? { v: PROTOCOL_VERSION, t: "welcome", resumeFromSeq: f.resumeFromSeq } : null;
+    case "ping":
+      return { v: PROTOCOL_VERSION, t: "ping" };
+    case "pong":
+      return { v: PROTOCOL_VERSION, t: "pong" };
+    case "command":
+      return isString(f.id) && isString(f.text) ? { v: PROTOCOL_VERSION, t: "command", id: f.id, text: f.text } : null;
+    case "resume":
+      return isFiniteNumber(f.afterSeq) ? { v: PROTOCOL_VERSION, t: "resume", afterSeq: f.afterSeq } : null;
+    case "error":
+      if (isString(f.code) && isString(f.message)) {
+        return { v: PROTOCOL_VERSION, t: "error", code: f.code, message: f.message, fatal: f.fatal === true };
+      }
+      return null;
+    default:
+      return null;
+  }
+};
+
+// src/wrapper/relayClient.ts
+var DEFAULT_HEARTBEAT_MS = 2e4;
+var DEFAULT_PONG_TIMEOUT_MS = 1e4;
+var DEFAULT_MAX_OUTBOUND = 128;
+var DEFAULT_MAX_SEEN_COMMANDS = 256;
+var defaultBackoff = (attempt) => Math.min(1e3 * 2 ** attempt, 3e4);
+var defaultSocketFactory = (url) => {
+  const WS = globalThis.WebSocket;
+  if (!WS) throw new Error("no WebSocket in this runtime");
+  const socket = new WS(url);
+  return {
+    send: (data) => socket.send(data),
+    close: () => socket.close(),
+    onOpen: (cb) => socket.addEventListener("open", () => cb()),
+    onMessage: (cb) => socket.addEventListener("message", (event) => cb(String(event.data))),
+    onClose: (cb) => socket.addEventListener("close", () => cb()),
+    onError: (cb) => socket.addEventListener("error", (event) => cb(event))
+  };
+};
+var createRelayClient = (options) => {
+  const factory = options.socketFactory ?? defaultSocketFactory;
+  const heartbeatMs = options.heartbeatMs ?? DEFAULT_HEARTBEAT_MS;
+  const pongTimeoutMs = options.pongTimeoutMs ?? DEFAULT_PONG_TIMEOUT_MS;
+  const backoff = options.backoffMs ?? defaultBackoff;
+  const maxOutbound = Math.max(1, options.maxOutbound ?? DEFAULT_MAX_OUTBOUND);
+  const maxSeenCommands = Math.max(1, options.maxSeenCommands ?? DEFAULT_MAX_SEEN_COMMANDS);
+  let socket;
+  let isConnected = false;
+  let stopped = false;
+  let seq = 0;
+  let attempt = 0;
+  let reconnectTimer;
+  let heartbeatTimer;
+  let pongTimer;
+  const outbound = [];
+  const seenCommands = [];
+  const seenSet = /* @__PURE__ */ new Set();
+  const log = (message) => options.log?.(message);
+  const clearTimers = () => {
+    if (heartbeatTimer) clearInterval(heartbeatTimer);
+    if (pongTimer) clearTimeout(pongTimer);
+    if (reconnectTimer) clearTimeout(reconnectTimer);
+    heartbeatTimer = void 0;
+    pongTimer = void 0;
+    reconnectTimer = void 0;
+  };
+  const rememberCommand = (id) => {
+    if (seenSet.has(id)) return false;
+    seenSet.add(id);
+    seenCommands.push(id);
+    while (seenCommands.length > maxSeenCommands) {
+      const evicted = seenCommands.shift();
+      if (evicted) seenSet.delete(evicted);
+    }
+    return true;
+  };
+  const sendFrame = (frame) => {
+    if (!socket || !isConnected) return;
+    try {
+      socket.send(encodeFrame(frame));
+    } catch {
+    }
+  };
+  const enqueueTranscript = (frame) => {
+    if (isConnected) {
+      sendFrame(frame);
+      return;
+    }
+    outbound.push(frame);
+    while (outbound.length > maxOutbound) outbound.shift();
+  };
+  const flushOutbound = () => {
+    while (outbound.length > 0 && isConnected) {
+      const frame = outbound.shift();
+      if (frame) sendFrame(frame);
+    }
+  };
+  const armPong = () => {
+    if (pongTimer) clearTimeout(pongTimer);
+    pongTimer = setTimeout(() => {
+      log("[pushary] relay heartbeat timed out; reconnecting");
+      dropAndReconnect();
+    }, pongTimeoutMs);
+  };
+  const startHeartbeat = () => {
+    if (heartbeatTimer) clearInterval(heartbeatTimer);
+    heartbeatTimer = setInterval(() => {
+      sendFrame({ v: PROTOCOL_VERSION, t: "ping" });
+      armPong();
+    }, heartbeatMs);
+  };
+  const onServerFrame = (raw) => {
+    const frame = decodeServerFrame(raw);
+    if (!frame) return;
+    switch (frame.t) {
+      case "welcome":
+        attempt = 0;
+        flushOutbound();
+        log("[pushary] relay connected");
+        break;
+      case "command":
+        sendFrame({ v: PROTOCOL_VERSION, t: "ack", id: frame.id });
+        if (rememberCommand(frame.id)) {
+          try {
+            options.onCommand(frame.text);
+          } catch {
+          }
+        }
+        break;
+      case "ping":
+        sendFrame({ v: PROTOCOL_VERSION, t: "pong" });
+        break;
+      case "pong":
+        if (pongTimer) clearTimeout(pongTimer);
+        pongTimer = void 0;
+        break;
+      case "resume":
+        log(`[pushary] relay signalled a gap; catch up after seq ${frame.afterSeq}`);
+        break;
+      case "error":
+        if (frame.fatal) {
+          log(`[pushary] relay fatal: ${frame.message}`);
+          fatal(frame.message);
+        } else {
+          log(`[pushary] relay error: ${frame.message}`);
+        }
+        break;
+    }
+  };
+  const dropSocket = () => {
+    isConnected = false;
+    if (heartbeatTimer) clearInterval(heartbeatTimer);
+    if (pongTimer) clearTimeout(pongTimer);
+    heartbeatTimer = void 0;
+    pongTimer = void 0;
+    if (socket) {
+      try {
+        socket.close();
+      } catch {
+      }
+    }
+    socket = void 0;
+  };
+  const scheduleReconnect = () => {
+    if (stopped) return;
+    if (reconnectTimer) return;
+    const delay = backoff(attempt);
+    attempt++;
+    const jittered = Math.max(1, Math.round(delay * (0.85 + Math.random() * 0.3)));
+    reconnectTimer = setTimeout(() => {
+      reconnectTimer = void 0;
+      connect();
+    }, jittered);
+  };
+  const dropAndReconnect = () => {
+    dropSocket();
+    scheduleReconnect();
+  };
+  const fatal = (message) => {
+    stopped = true;
+    clearTimers();
+    dropSocket();
+    options.onFatal?.(message);
+  };
+  const connect = () => {
+    if (stopped) return;
+    let created;
+    try {
+      created = factory(options.url);
+    } catch (error) {
+      fatal(error instanceof Error ? error.message : String(error));
+      return;
+    }
+    socket = created;
+    created.onOpen(() => {
+      isConnected = true;
+      sendFrame(
+        helloFrame({
+          apiKey: options.apiKey,
+          machineId: options.machineId,
+          agentType: options.agentType,
+          sessionId: options.getSessionId(),
+          lastSeq: seq
+        })
+      );
+      startHeartbeat();
+    });
+    created.onMessage((data) => onServerFrame(data));
+    created.onClose(() => {
+      if (stopped) return;
+      dropAndReconnect();
+    });
+    created.onError(() => {
+    });
+  };
+  return {
+    start() {
+      if (stopped) return;
+      connect();
+    },
+    connected() {
+      return isConnected;
+    },
+    sendTranscript(kind, text, meta) {
+      if (stopped) return;
+      seq++;
+      enqueueTranscript(transcriptFrame(seq, kind, text, meta));
+    },
+    reannounce() {
+      if (stopped || !isConnected) return;
+      sendFrame(
+        helloFrame({
+          apiKey: options.apiKey,
+          machineId: options.machineId,
+          agentType: options.agentType,
+          sessionId: options.getSessionId(),
+          lastSeq: seq
+        })
+      );
+    },
+    stop() {
+      if (stopped) return;
+      stopped = true;
+      sendFrame({ v: PROTOCOL_VERSION, t: "bye" });
+      clearTimers();
+      dropSocket();
+    }
+  };
+};
+
 // src/wrapper/remoteLoop.ts
 var errMsg = (err) => err instanceof Error ? err.message : String(err);
 var DEFAULT_MAX_RESTARTS = 5;
@@ -441,7 +799,8 @@ var runRemoteLoop = async (deps) => {
           permissionMode: deps.permissionMode,
           canUseTool: deps.canUseTool,
           env: deps.env,
-          cwd: deps.cwd
+          cwd: deps.cwd,
+          pathToClaudeCodeExecutable: deps.pathToClaudeCodeExecutable
         }
       });
     } catch (err) {
@@ -457,6 +816,7 @@ var runRemoteLoop = async (deps) => {
     else deps.signal.addEventListener("abort", onAbort, { once: true });
     try {
       for await (const message of query) {
+        deps.onMessage?.(message);
         if (message.type === "system" && message.subtype === "init" && typeof message.session_id === "string") {
           resumeId = message.session_id;
           deps.onSessionId?.(resumeId);
@@ -490,6 +850,10 @@ var resolveClaudeArgs = (argv) => {
   const rest = argv.slice(2);
   return rest[0] === "claude" ? rest.slice(1) : rest;
 };
+var extractRemoteFlag = (args2) => ({
+  remote: args2.includes("--remote"),
+  rest: args2.filter((arg) => arg !== "--remote")
+});
 var flagValue = (args2, index) => {
   const inline = args2[index];
   const eq = inline?.indexOf("=") ?? -1;
@@ -516,7 +880,37 @@ var parseRemoteArgs = (args2) => {
 
 // src/wrapper/remoteMode.ts
 var INPUT_QUEUE_CAP = 32;
-var runRemoteMode = async (_binary, args2) => {
+var extractAssistantText = (message) => {
+  const content = message.message?.content;
+  if (typeof content === "string") return content || void 0;
+  if (Array.isArray(content)) {
+    const text = content.filter((block) => !!block && typeof block === "object").filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text).join("");
+    return text || void 0;
+  }
+  return void 0;
+};
+var echoLocal = (message) => {
+  if (message.type === "assistant") {
+    const text = extractAssistantText(message);
+    if (text) process.stdout.write(`${text}
+`);
+  } else if (message.type === "result") {
+    process.stderr.write("[pushary] turn complete \u2014 standing by for phone commands (Ctrl-C to exit)\n");
+  }
+};
+var streamTranscript = (relay, message) => {
+  if (message.type === "assistant") {
+    const text = extractAssistantText(message);
+    if (text) relay.sendTranscript("assistant", text);
+  } else if (message.type === "result") {
+    relay.sendTranscript(
+      "turn_end",
+      void 0,
+      typeof message.total_cost_usd === "number" ? { cost: message.total_cost_usd } : void 0
+    );
+  }
+};
+var runRemoteMode = async (binary, args2) => {
   let apiKey;
   try {
     apiKey = getApiKey();
@@ -526,21 +920,24 @@ var runRemoteMode = async (_binary, args2) => {
     );
     return { implemented: false };
   }
-  const sdk = await loadClaudeSdk();
+  const sdk = await ensureClaudeSdk((message) => process.stderr.write(`${message}
+`));
   if (!sdk) {
-    process.stderr.write(
-      "[pushary] remote mode needs the Claude Agent SDK, which is not installed. Enable it with:\n  npm i -g @anthropic-ai/claude-agent-sdk@0.3.207\nRunning the normal passthrough for now.\n"
-    );
+    process.stderr.write("[pushary] remote mode is unavailable; running the normal passthrough.\n");
     return { implemented: false };
   }
   const projectName = basename(process.cwd());
   const machineId = getMachineId();
   const controller = new AbortController();
   let sessionId;
+  let killed = false;
+  let totalCostUsd = 0;
   const input = new BoundedInputQueue({
     cap: INPUT_QUEUE_CAP,
     onDrop: (_dropped, total) => process.stderr.write(`[pushary] input queue full; dropped ${total} stale instruction(s)
-`)
+`),
+    // Several instructions that piled up between turns are sent as one turn.
+    coalesce: (items) => userMessage(items.map((m) => m.message.content).join("\n\n"))
   });
   const approver = createRemoteApprover({
     apiKey,
@@ -548,10 +945,41 @@ var runRemoteMode = async (_binary, args2) => {
     projectName,
     getSessionId: () => sessionId
   });
+  const initialMode = await fetchModeState(apiKey).catch(() => null);
+  let relay;
+  if (initialMode?.relayUrl) {
+    relay = createRelayClient({
+      url: initialMode.relayUrl,
+      apiKey,
+      machineId,
+      agentType: "claude_code",
+      getSessionId: () => sessionId,
+      onCommand: (command) => input.push(userMessage(command)),
+      onFatal: (message) => process.stderr.write(`[pushary] relay unavailable (${message}); using polling
+`),
+      log: (message) => process.stderr.write(`${message}
+`)
+    });
+    relay.start();
+  }
   const poller = startCommandPoller({
     apiKey,
     getSessionId: () => sessionId,
     onCommand: (command) => input.push(userMessage(command)),
+    // While the relay socket owns command delivery, the poller must not also drain
+    // the single-use queue (that would deliver the command twice); it still reads
+    // mode/kill. When the socket is down or absent, the poller is the source.
+    shouldDrainCommands: () => !(relay?.connected() ?? false),
+    // Watch the kill switch: a phone "stop" interrupts the running turn (via the
+    // controller abort below), instead of only denying the next tool call.
+    fetchModeState,
+    onModeState: (state) => {
+      if (state.kill && !killed) {
+        killed = true;
+        process.stderr.write("[pushary] halted from Pushary \u2014 stopping the agent\n");
+        controller.abort();
+      }
+    },
     log: (message) => process.stderr.write(`${message}
 `)
   });
@@ -572,8 +1000,24 @@ var runRemoteMode = async (_binary, args2) => {
       // recursion guard so a wrapper-spawned claude cannot re-enter the wrapper.
       env: { ...process.env, [WRAPPER_ACTIVE_ENV]: "1" },
       cwd: process.cwd(),
+      // Run the user's OWN claude, not the SDK's bundled copy, so whatever login
+      // already works for `claude` works here with no extra setup. On Windows a
+      // `.cmd`/`.bat` shim can't be spawned directly by the SDK, so there we let
+      // the SDK use its bundled binary (Windows reads creds from a plain file, so
+      // there is no keychain-ACL mismatch to work around).
+      pathToClaudeCodeExecutable: needsShell(binary) ? void 0 : binary,
       onSessionId: (id) => {
         sessionId = id;
+        relay?.reannounce();
+      },
+      onCost: (usd) => {
+        totalCostUsd = usd;
+      },
+      // Always echo the turn to the local terminal; also stream a bounded live
+      // transcript to the phone when the relay is up (it presence-gates it).
+      onMessage: (message) => {
+        echoLocal(message);
+        if (relay) streamTranscript(relay, message);
       },
       log: (message) => process.stderr.write(`${message}
 `)
@@ -581,9 +1025,14 @@ var runRemoteMode = async (_binary, args2) => {
     return { implemented: true, exitCode: result.exitCode };
   } finally {
     for (const signal of signals) process.off(signal, onSignal);
+    relay?.stop();
     poller.stop();
     approver.teardown();
     input.close();
+    if (totalCostUsd > 0) {
+      process.stderr.write(`[pushary] remote session cost: $${totalCostUsd.toFixed(4)}
+`);
+    }
   }
 };
 
@@ -597,14 +1046,15 @@ var runClaudeWrapper = async (args2) => {
     return 127;
   }
   const nested = process.env[WRAPPER_ACTIVE_ENV] === "1";
-  if (!nested && process.env.PUSHARY_WRAPPER_REMOTE === "1") {
+  const { remote: wantRemote, rest } = extractRemoteFlag(args2);
+  if (!nested && wantRemote) {
     try {
-      const remote = await runRemoteMode(binary, args2);
+      const remote = await runRemoteMode(binary, rest);
       if (remote.implemented) return remote.exitCode ?? 0;
     } catch {
     }
   }
-  return runLocalPassthrough(binary, args2);
+  return runLocalPassthrough(binary, rest);
 };
 
 // bin/pushary-claude.ts

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

@@ -20,7 +20,7 @@ import {
   savePendingQuestion,
   toCodexWire,
   toPolicyLookup
-} from "../chunk-V2WKECMG.js";
+} from "../chunk-NRCQ5UUR.js";
 import {
   askUser,
   cancelQuestion,
@@ -34,7 +34,7 @@ import {
   resolvePolicy,
   sendNotification,
   waitForAnswer
-} from "../chunk-AUEPQATK.js";
+} from "../chunk-ETDXSKR5.js";
 import {
   isGatingMoment,
   recordKeylessMoment

package/dist/bin/pushary-codex.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import {
   reportEvent
-} from "../chunk-V2WKECMG.js";
+} from "../chunk-NRCQ5UUR.js";
 import {
   askUser,
   getMachineId,
   waitForAnswer
-} from "../chunk-AUEPQATK.js";
+} from "../chunk-ETDXSKR5.js";
 import "../chunk-DWED7BS3.js";
 import "../chunk-Z5PL3K7C.js";
 import {

package/dist/bin/pushary-gemini-hook.js

@@ -12,7 +12,7 @@ import {
   readLastUserPrompt,
   reportEvent,
   savePendingQuestion
-} from "../chunk-V2WKECMG.js";
+} from "../chunk-NRCQ5UUR.js";
 import {
   askUser,
   cancelQuestion,
@@ -26,7 +26,7 @@ import {
   resolvePolicy,
   sendNotification,
   waitForAnswer
-} from "../chunk-AUEPQATK.js";
+} from "../chunk-ETDXSKR5.js";
 import {
   isGatingMoment,
   recordKeylessMoment

package/dist/bin/pushary-hook.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import {
   handlePreToolUse
-} from "../chunk-7JSFIVNA.js";
+} from "../chunk-V2TSLWTV.js";
 import "../chunk-7EW3USQF.js";
 import "../chunk-KQYIHZ5E.js";
-import "../chunk-V2WKECMG.js";
-import "../chunk-AUEPQATK.js";
+import "../chunk-NRCQ5UUR.js";
+import "../chunk-ETDXSKR5.js";
 import "../chunk-R5AJNXZS.js";
 import "../chunk-DWED7BS3.js";
 import "../chunk-Z5PL3K7C.js";

package/dist/bin/pushary-notification-hook.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import {
   handleNotification
-} from "../chunk-V2WKECMG.js";
-import "../chunk-AUEPQATK.js";
+} from "../chunk-NRCQ5UUR.js";
+import "../chunk-ETDXSKR5.js";
 import "../chunk-DWED7BS3.js";
 import "../chunk-Z5PL3K7C.js";
 import "../chunk-NKXSILEW.js";

package/dist/bin/pushary-permission-denied-hook.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import {
   handlePermissionDenied
-} from "../chunk-7JSFIVNA.js";
+} from "../chunk-V2TSLWTV.js";
 import "../chunk-7EW3USQF.js";
 import "../chunk-KQYIHZ5E.js";
-import "../chunk-V2WKECMG.js";
-import "../chunk-AUEPQATK.js";
+import "../chunk-NRCQ5UUR.js";
+import "../chunk-ETDXSKR5.js";
 import "../chunk-R5AJNXZS.js";
 import "../chunk-DWED7BS3.js";
 import "../chunk-Z5PL3K7C.js";

package/dist/bin/pushary-permission-hook.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import {
   handlePermissionRequest
-} from "../chunk-7JSFIVNA.js";
+} from "../chunk-V2TSLWTV.js";
 import "../chunk-7EW3USQF.js";
 import "../chunk-KQYIHZ5E.js";
-import "../chunk-V2WKECMG.js";
-import "../chunk-AUEPQATK.js";
+import "../chunk-NRCQ5UUR.js";
+import "../chunk-ETDXSKR5.js";
 import "../chunk-R5AJNXZS.js";
 import "../chunk-DWED7BS3.js";
 import "../chunk-Z5PL3K7C.js";

package/dist/bin/pushary-post-hook.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import {
   handlePostToolUse
-} from "../chunk-V2WKECMG.js";
-import "../chunk-AUEPQATK.js";
+} from "../chunk-NRCQ5UUR.js";
+import "../chunk-ETDXSKR5.js";
 import "../chunk-DWED7BS3.js";
 import "../chunk-Z5PL3K7C.js";
 import "../chunk-NKXSILEW.js";

package/dist/bin/pushary-prompt-hook.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import {
   handleUserPrompt
-} from "../chunk-V2WKECMG.js";
-import "../chunk-AUEPQATK.js";
+} from "../chunk-NRCQ5UUR.js";
+import "../chunk-ETDXSKR5.js";
 import "../chunk-DWED7BS3.js";
 import "../chunk-Z5PL3K7C.js";
 import "../chunk-NKXSILEW.js";

package/dist/bin/pushary-session-end-hook.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import {
   handleSessionEnd
-} from "../chunk-V2WKECMG.js";
-import "../chunk-AUEPQATK.js";
+} from "../chunk-NRCQ5UUR.js";
+import "../chunk-ETDXSKR5.js";
 import "../chunk-DWED7BS3.js";
 import "../chunk-Z5PL3K7C.js";
 import "../chunk-NKXSILEW.js";

package/dist/bin/pushary-session-start-hook.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import {
   handleSessionStart
-} from "../chunk-V2WKECMG.js";
-import "../chunk-AUEPQATK.js";
+} from "../chunk-NRCQ5UUR.js";
+import "../chunk-ETDXSKR5.js";
 import "../chunk-DWED7BS3.js";
 import "../chunk-Z5PL3K7C.js";
 import "../chunk-NKXSILEW.js";

package/dist/bin/pushary-setup.js

@@ -24,8 +24,8 @@ import {
 } from "../chunk-7EW3USQF.js";
 import {
   reportEvent
-} from "../chunk-V2WKECMG.js";
-import "../chunk-AUEPQATK.js";
+} from "../chunk-NRCQ5UUR.js";
+import "../chunk-ETDXSKR5.js";
 import "../chunk-DWED7BS3.js";
 import {
   isValidApiKey

package/dist/bin/pushary-stop-hook.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import {
   handleStop
-} from "../chunk-V2WKECMG.js";
-import "../chunk-AUEPQATK.js";
+} from "../chunk-NRCQ5UUR.js";
+import "../chunk-ETDXSKR5.js";
 import "../chunk-DWED7BS3.js";
 import "../chunk-Z5PL3K7C.js";
 import "../chunk-NKXSILEW.js";

package/dist/bin/pushary-stopfailure-hook.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import {
   handleStopFailure
-} from "../chunk-V2WKECMG.js";
-import "../chunk-AUEPQATK.js";
+} from "../chunk-NRCQ5UUR.js";
+import "../chunk-ETDXSKR5.js";
 import "../chunk-DWED7BS3.js";
 import "../chunk-Z5PL3K7C.js";
 import "../chunk-NKXSILEW.js";

package/dist/bin/pushary.js

@@ -26,7 +26,8 @@ Pushary Agent Hooks
 
 Commands:
   setup    Configure Claude Code, Codex, Gemini CLI, Hermes, or Cursor with Pushary
-  claude   Run Claude Code through Pushary (experimental wrapper; today a transparent passthrough)
+  claude   Run Claude Code through Pushary (transparent passthrough; add --remote to
+           drive it from your phone: reach and re-prompt it even while idle)
   doctor   Verify your Pushary installation is working
   clean    Remove all Pushary configuration (--yes for non-interactive)
   mode     Switch approval mode (push_only, push_first, terminal_only)
@@ -47,5 +48,6 @@ Usage:
   npx @pushary/agent-hooks@latest doctor
   npx @pushary/agent-hooks@latest mode push_only --for 30m
   npx @pushary/agent-hooks@latest wait 45
+  pushary claude --remote -p "start the refactor"   # drive from your phone (uses your existing Claude login; sets up on first run)
 `);
 }

package/dist/{chunk-AUEPQATK.js → chunk-ETDXSKR5.js}

@@ -158,16 +158,17 @@ var fetchModeState = async (apiKey, sessionId) => {
       headers: { "Authorization": `Bearer ${apiKey}` },
       signal: AbortSignal.timeout(3e3)
     });
-    if (!response.ok) return { mode: null, kill: false, policyVersion: null };
+    if (!response.ok) return { mode: null, kill: false, policyVersion: null, relayUrl: null };
     const data = await response.json();
     const mode = data.override?.mode;
     return {
       mode: isApprovalMode(mode) ? mode : null,
       kill: data.kill === true,
-      policyVersion: toPolicyVersion(data.policyVersion)
+      policyVersion: toPolicyVersion(data.policyVersion),
+      relayUrl: typeof data.relayUrl === "string" && data.relayUrl.length > 0 ? data.relayUrl : null
     };
   } catch {
-    return { mode: null, kill: false, policyVersion: null };
+    return { mode: null, kill: false, policyVersion: null, relayUrl: null };
   }
 };
 var fetchModeOverride = async (apiKey) => (await fetchModeState(apiKey)).mode;

package/dist/{chunk-V2WKECMG.js → chunk-NRCQ5UUR.js}

@@ -11,7 +11,7 @@ import {
   resolvePolicy,
   sendNotification,
   waitForAnswer
-} from "./chunk-AUEPQATK.js";
+} from "./chunk-ETDXSKR5.js";
 import {
   withRetry
 } from "./chunk-DWED7BS3.js";

package/dist/{chunk-7JSFIVNA.js → chunk-V2TSLWTV.js}

@@ -11,7 +11,7 @@ import {
   readLastUserPrompt,
   savePendingQuestion,
   throttlePass
-} from "./chunk-V2WKECMG.js";
+} from "./chunk-NRCQ5UUR.js";
 import {
   askUser,
   cancelQuestion,
@@ -26,7 +26,7 @@ import {
   resolvePolicy,
   sendNotification,
   waitForAnswer
-} from "./chunk-AUEPQATK.js";
+} from "./chunk-ETDXSKR5.js";
 import {
   isGatingMoment,
   recordKeylessMoment

package/dist/src/index.d.ts

@@ -33,6 +33,7 @@ interface ModeState {
     readonly mode: ApprovalMode | null;
     readonly kill: boolean;
     readonly policyVersion: string | null;
+    readonly relayUrl: string | null;
 }
 declare const fetchModeState: (apiKey: string, sessionId?: string) => Promise<ModeState>;
 declare const fetchModeOverride: (apiKey: string) => Promise<ApprovalMode | null>;

package/dist/src/index.js

@@ -1,6 +1,6 @@
 import {
   handlePreToolUse
-} from "../chunk-7JSFIVNA.js";
+} from "../chunk-V2TSLWTV.js";
 import "../chunk-7EW3USQF.js";
 import "../chunk-KQYIHZ5E.js";
 import {
@@ -8,7 +8,7 @@ import {
   handlePostToolUse,
   handleStop,
   reportEvent
-} from "../chunk-V2WKECMG.js";
+} from "../chunk-NRCQ5UUR.js";
 import {
   askUser,
   cancelQuestion,
@@ -17,7 +17,7 @@ import {
   getPolicy,
   resolvePolicy,
   waitForAnswer
-} from "../chunk-AUEPQATK.js";
+} from "../chunk-ETDXSKR5.js";
 import "../chunk-R5AJNXZS.js";
 import "../chunk-DWED7BS3.js";
 import "../chunk-Z5PL3K7C.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushary/agent-hooks",
-  "version": "0.40.0",
+  "version": "0.43.0",
   "description": "Permission hooks for AI coding agents: route tool approvals through Pushary push notifications",
   "keywords": [
     "pushary",
@@ -72,7 +72,7 @@
   "scripts": {
     "build": "node scripts/bundle-plugin.mjs && tsup",
     "dev": "tsup --watch",
-    "test": "bun test src/api.test.ts && bun test src/claude-config.test.ts && bun test src/config.test.ts && bun test src/mcp-http.test.ts && bun test src/retry.test.ts && bun test src/usage.test.ts && bun test src/validate.test.ts && bun test src/policy.test.ts && bun test src/npm.test.ts && bun test src/identity.test.ts && bun test src/pending.test.ts && bun test src/events.test.ts && bun test src/describe.test.ts && bun test src/reapply.test.ts && bun test src/suggestions.test.ts && bun test src/safe-commands.test.ts && bun test src/hook.test.ts && bun test src/codex-adapter.test.ts && bun test src/codex-config.test.ts && bun test src/gemini-adapter.test.ts && bun test src/gemini-config.test.ts && bun test src/instruction-file.test.ts && bun test src/pairing.test.ts && bun test src/wait-ladder.test.ts && bun test src/ledger.test.ts && bun test src/wrapper/wrapper.test.ts && bun test src/wrapper/messageQueue.test.ts && bun test src/wrapper/approver.test.ts && bun test src/wrapper/remoteLoop.test.ts"
+    "test": "bun test src/api.test.ts && bun test src/claude-config.test.ts && bun test src/config.test.ts && bun test src/mcp-http.test.ts && bun test src/retry.test.ts && bun test src/usage.test.ts && bun test src/validate.test.ts && bun test src/policy.test.ts && bun test src/npm.test.ts && bun test src/identity.test.ts && bun test src/pending.test.ts && bun test src/events.test.ts && bun test src/describe.test.ts && bun test src/reapply.test.ts && bun test src/suggestions.test.ts && bun test src/safe-commands.test.ts && bun test src/hook.test.ts && bun test src/codex-adapter.test.ts && bun test src/codex-config.test.ts && bun test src/gemini-adapter.test.ts && bun test src/gemini-config.test.ts && bun test src/instruction-file.test.ts && bun test src/pairing.test.ts && bun test src/wait-ladder.test.ts && bun test src/ledger.test.ts && bun test src/wrapper/wrapper.test.ts && bun test src/wrapper/messageQueue.test.ts && bun test src/wrapper/approver.test.ts && bun test src/wrapper/remoteLoop.test.ts && bun test src/wrapper/spawnClaude.test.ts && bun test src/wrapper/wsProtocol.test.ts && bun test src/wrapper/relayClient.test.ts"
   },
   "dependencies": {
     "@inquirer/prompts": "^8.4.2",