@pushary/agent-hooks 0.83.2 → 0.84.0

package/dist/bin/pushary-daemon.js

@@ -2,43 +2,66 @@
 import {
   HEARTBEAT_INTERVAL_MS,
   sendHeartbeat
-} from "../chunk-GQLB2GBJ.js";
+} from "../chunk-MHBC2XUP.js";
+import {
+  DAEMON_LEASE_RENEW_INTERVAL_MS,
+  acquireDaemonLease,
+  readDaemonStatus,
+  requestDaemonHandoff
+} from "../chunk-CCH775Y6.js";
+import {
+  CODEX_BRIDGE_CAPABILITY,
+  CODEX_RESUME_CAPABILITY,
+  geminiLiveCapabilities
+} from "../chunk-NRGRUOAR.js";
+import {
+  ownsLiveProcess
+} from "../chunk-EVJ6ULHN.js";
 import {
   spawnClaude
 } from "../chunk-XHKBHWLX.js";
 import {
-  resolveGlobalBinary
-} from "../chunk-MUEW424A.js";
+  resolveBinary,
+  resolveGlobalPackageVersion,
+  resolvePackageVersionFromBinary
+} from "../chunk-VT4IVERX.js";
+import "../chunk-SEAHGHCE.js";
 import {
   getMachineId
 } from "../chunk-RN3NOEJF.js";
 import {
   exitOnHelpFlag
-} from "../chunk-RRZZ7TFJ.js";
-import "../chunk-ZUKH2NPJ.js";
+} from "../chunk-J4KFVOCQ.js";
+import "../chunk-MGJBC6DD.js";
+import "../chunk-DINDL2CF.js";
+import "../chunk-6MTNS63X.js";
+import {
+  EXIT
+} from "../chunk-KZERVKTD.js";
 import {
   getApiKey,
   getBaseUrl
 } from "../chunk-2UMNXADU.js";
-import {
-  EXIT
-} from "../chunk-KZERVKTD.js";
+import "../chunk-MQMPG5X4.js";
 
 // src/spawn-daemon.ts
-import { spawn } from "child_process";
+import { execFileSync, spawn } from "child_process";
 import { existsSync } from "fs";
 import { basename, dirname, join } from "path";
 
 // src/stop-requests.ts
 var STOP_CAPABILITY = "stop";
+var STOP_ACK_CAPABILITY = "stop-ack";
+var windowsTaskkillArgs = (pid) => ["/PID", String(pid), "/T", "/F"];
 var isStopRequest = (value) => {
   if (!value || typeof value !== "object") return false;
   const candidate = value;
-  return typeof candidate.sessionId === "string" && candidate.sessionId.length > 0 && typeof candidate.pid === "number" && Number.isInteger(candidate.pid) && candidate.pid > 1;
+  return (candidate.id === void 0 || typeof candidate.id === "string" && candidate.id.length > 0 && candidate.id.length <= 64) && (candidate.spawnId === void 0 || typeof candidate.spawnId === "string" && candidate.spawnId.length > 0 && candidate.spawnId.length <= 64) && typeof candidate.sessionId === "string" && candidate.sessionId.length > 0 && typeof candidate.pid === "number" && Number.isInteger(candidate.pid) && candidate.pid > 1;
 };
 var parseStopRequests = (value) => Array.isArray(value) ? value.filter(isStopRequest) : [];
 var applyStop = (request, deps) => {
   if (request.pid === deps.selfPid) return "skipped_self";
+  if (!deps.ownsProcess(request)) return "refused";
   try {
     deps.kill(request.pid, "SIGTERM");
     return "stopped";
@@ -47,17 +70,71 @@ var applyStop = (request, deps) => {
     return code === "ESRCH" ? "already_gone" : "refused";
   }
 };
+var applyStopAndVerify = async (request, deps, attempts = 100, intervalMs = 100) => {
+  if (!deps.isAlive(request.pid)) return "already_gone";
+  if (!await deps.ownsProcess(request)) return "refused";
+  const outcome = applyStop(request, { ...deps, ownsProcess: () => true });
+  if (outcome !== "stopped") return outcome;
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    await deps.sleep(intervalMs);
+    if (!deps.isAlive(request.pid)) return "stopped";
+  }
+  return "signal_sent";
+};
 
 // src/spawn-daemon.ts
 var DRAIN_PATH = "/api/agent/spawn/drain";
+var ACK_PATH = "/api/agent/spawn/ack";
+var SPAWN_PROTOCOL_VERSION = 2;
 var FAST_POLL_MS = 3e3;
 var SLOW_POLL_MS = 3e4;
 var FAST_DECAY_TICKS = 3;
 var MAX_ERROR_BACKOFF_MS = 12e4;
 var MAX_ERROR_STREAK = 6;
 var REQUEST_TIMEOUT_MS = 1e4;
+var STOP_PROTOCOL_VERSION = 2;
 var MAX_SPAWNS_PER_WINDOW = 5;
 var SPAWN_WINDOW_MS = 6e4;
+var VERSION_CHECK_INTERVAL_MS = 2e3;
+var MAX_TRACKED_PROCESSES = 100;
+var MAX_COMPLETED_STOPS = 20;
+var daemonSignals = (platform = process.platform) => platform === "win32" ? ["SIGINT", "SIGTERM"] : ["SIGINT", "SIGTERM", "SIGHUP"];
+var parseSpawnClaim = (value) => {
+  if (typeof value !== "object" || value === null) return null;
+  const request = value;
+  if (typeof request.id !== "string" || typeof request.prompt !== "string") return null;
+  return {
+    id: request.id,
+    prompt: request.prompt,
+    ...typeof request.claimId === "string" ? { claimId: request.claimId } : {},
+    ...Number.isInteger(request.attemptCount) ? { attemptCount: request.attemptCount } : {},
+    ...typeof request.cwd === "string" ? { cwd: request.cwd } : {},
+    ...typeof request.agent === "string" ? { agent: request.agent } : {},
+    ...typeof request.model === "string" ? { model: request.model } : {},
+    ...typeof request.resumeSessionId === "string" ? { resumeSessionId: request.resumeSessionId } : {}
+  };
+};
+var stopAcknowledgement = (request, machineId, state) => request.id ? { stopId: request.id, machineId, state } : null;
+var spawnAcknowledgement = (request, machineId, outcome) => {
+  if (!request.claimId) return null;
+  return outcome.state === "started" ? {
+    spawnId: request.id,
+    claimId: request.claimId,
+    machineId,
+    state: "started",
+    pid: outcome.pid ?? null
+  } : {
+    spawnId: request.id,
+    claimId: request.claimId,
+    machineId,
+    state: "failed",
+    failure: {
+      code: "launch_failed",
+      message: outcome.message.slice(0, 240),
+      retryable: false
+    }
+  };
+};
 var DrainError = class extends Error {
   constructor(status) {
     super(`drain ${status}`);
@@ -71,7 +148,6 @@ var isAuthFailure = (err) => {
   if (candidate.name !== "DrainError") return false;
   return candidate.status === 401 || candidate.status === 403;
 };
-var NATIVE_AGENT_BINARIES = { codex: "codex", gemini: "gemini" };
 var isFlagShapedPrompt = (prompt) => prompt.trimStart().startsWith("-");
 var buildSpawnLaunch = (req, opts) => {
   if (isFlagShapedPrompt(req.prompt)) return null;
@@ -81,9 +157,20 @@ var buildSpawnLaunch = (req, opts) => {
     const claudeArgs = ["claude", "--remote", ...model, "-p", req.prompt];
     return opts.spawnDirect ? { direct: true, command: opts.execPath, args: [opts.siblingEntry, ...claudeArgs], agent } : { direct: false, command: opts.pusharyBin, args: claudeArgs, agent };
   }
-  const command = opts.resolveNative(NATIVE_AGENT_BINARIES[agent]);
-  const args = agent === "codex" ? ["exec", ...model, req.prompt] : [...model, "-p", req.prompt];
-  return { direct: false, command, args, agent };
+  if (agent === "codex") {
+    return {
+      direct: true,
+      command: opts.execPath,
+      args: [opts.codexBridgeEntry],
+      agent
+    };
+  }
+  return {
+    direct: true,
+    command: opts.execPath,
+    args: [opts.geminiBridgeEntry],
+    agent
+  };
 };
 var spawnRateAllows = (timestamps, now, maxPerWindow = MAX_SPAWNS_PER_WINDOW, windowMs = SPAWN_WINDOW_MS) => {
   while (timestamps.length > 0 && now - timestamps[0] > windowMs) timestamps.shift();
@@ -102,69 +189,226 @@ var runSpawnDaemon = async () => {
   }
   const machineId = getMachineId();
   const baseUrl = getBaseUrl();
-  const pusharyBin = resolveGlobalBinary("pushary") ?? "pushary";
+  const pusharyBin = resolveBinary("pushary") ?? "pushary";
+  const codexBin = resolveBinary("codex");
+  const geminiBin = resolveBinary("gemini");
+  const geminiCapabilities = geminiBin ? geminiLiveCapabilities(
+    resolvePackageVersionFromBinary(geminiBin, "@google/gemini-cli") ?? resolveGlobalPackageVersion("@google/gemini-cli")
+  ) : [];
   const siblingEntry = process.argv[1] ? join(dirname(process.argv[1]), "pushary.js") : "";
+  const codexBridgeEntry = process.argv[1] ? join(dirname(process.argv[1]), "pushary-codex-bridge.js") : "pushary-codex-bridge";
+  const geminiBridgeEntry = process.argv[1] ? join(dirname(process.argv[1]), "pushary-gemini-bridge.js") : "pushary-gemini-bridge";
   const spawnDirect = siblingEntry.length > 0 && existsSync(siblingEntry);
+  const existing = readDaemonStatus();
+  let handoff;
+  try {
+    handoff = await requestDaemonHandoff(existing);
+  } catch (err) {
+    stderr(`[pushary] daemon could not request a handoff: ${err instanceof Error ? err.message : String(err)}
+`);
+    return 1;
+  }
+  if (existing.pid !== null && handoff.pid === existing.pid && handoff.processAlive === true) {
+    stderr("[pushary] daemon could not replace the existing process; run `pushary doctor` for details\n");
+    return 1;
+  }
+  const lifecycle = acquireDaemonLease({ machineId });
+  if (lifecycle.kind === "already-running") {
+    stderr(`[pushary] daemon already online as pid ${lifecycle.status.pid ?? "unknown"}
+`);
+    return 0;
+  }
+  if (lifecycle.kind === "unavailable") {
+    stderr(`[pushary] daemon could not acquire its local lease: ${lifecycle.detail}
+`);
+    return 1;
+  }
+  const daemonLease = lifecycle.lease;
   let stopped = false;
   let idleTicks = 0;
   let errorStreak = 0;
   const spawnTimestamps = [];
+  const launchedProcesses = /* @__PURE__ */ new Map();
+  const completedStops = /* @__PURE__ */ new Map();
   let timer;
   let inflight;
   let fatalCode = null;
   let finish = () => {
   };
   let heartbeat;
+  let versionWatch;
+  let leaseRenewal;
   const launch = (req) => {
+    if (launchedProcesses.size >= MAX_TRACKED_PROCESSES) {
+      return Promise.reject(new Error("This daemon is already tracking 100 active sessions"));
+    }
     spawnTimestamps.push(Date.now());
     const cwd = req.cwd && existsSync(req.cwd) ? req.cwd : process.cwd();
-    const env = { ...process.env, PUSHARY_SPAWN_ID: req.id };
+    const env = {
+      ...process.env,
+      PUSHARY_SPAWN_ID: req.id,
+      PUSHARY_SPAWN_CLAIM_ID: req.claimId,
+      ...req.agent === "codex" || req.agent === "gemini" ? {
+        PUSHARY_BRIDGE_CWD: cwd,
+        PUSHARY_BRIDGE_PROMPT: req.prompt || void 0,
+        PUSHARY_BRIDGE_MODEL: req.model || void 0,
+        PUSHARY_BRIDGE_RESUME_SESSION_ID: req.resumeSessionId || void 0
+      } : {},
+      ...req.agent === "codex" ? {
+        PUSHARY_CODEX_COMMAND: codexBin ?? "codex"
+      } : {},
+      ...req.agent === "gemini" ? {
+        PUSHARY_GEMINI_COMMAND: geminiBin ?? "gemini"
+      } : {}
+    };
     const plan = buildSpawnLaunch(req, {
       spawnDirect,
       execPath: process.execPath,
       siblingEntry,
       pusharyBin,
-      resolveNative: (name) => resolveGlobalBinary(name) ?? name
+      codexBridgeEntry,
+      geminiBridgeEntry
     });
     if (!plan) {
-      stderr("[pushary] refused a phone-requested session: the prompt looks like a command-line flag\n");
-      return;
+      return Promise.reject(new Error("The prompt looks like a command-line flag"));
     }
-    try {
-      const child = plan.direct ? spawn(plan.command, plan.args, { cwd, detached: true, stdio: "ignore", env }) : spawnClaude(plan.command, plan.args, { cwd, detached: true, stdio: "ignore", env });
-      child.on("error", (err) => stderr(`[pushary] could not launch session: ${err.message}
-`));
-      child.unref();
-      stderr(`[pushary] launched a phone-requested ${plan.agent} session in ${basename(cwd)}
+    return new Promise((resolve, reject) => {
+      try {
+        const child = plan.direct ? spawn(plan.command, plan.args, { cwd, detached: true, stdio: "ignore", env }) : spawnClaude(plan.command, plan.args, { cwd, detached: true, stdio: "ignore", env });
+        let started = false;
+        child.once("error", (err) => {
+          if (!started) reject(err);
+          else stderr(`[pushary] launched session reported an error: ${err.message}
 `);
-    } catch (err) {
-      stderr(`[pushary] could not launch session: ${err instanceof Error ? err.message : String(err)}
+        });
+        child.once("spawn", () => {
+          started = true;
+          if (typeof child.pid === "number") {
+            launchedProcesses.set(child.pid, req.id);
+            child.once("close", () => launchedProcesses.delete(child.pid));
+          }
+          child.unref();
+          stderr(`[pushary] launched a phone-requested ${plan.agent} session in ${basename(cwd)}
 `);
-    }
+          resolve(typeof child.pid === "number" ? child.pid : null);
+        });
+      } catch (err) {
+        reject(err);
+      }
+    });
   };
-  const runStop = (stop) => {
-    const outcome = applyStop(stop, { kill: process.kill.bind(process), selfPid: process.pid });
+  const runStop = async (stop) => {
+    const kill = process.platform === "win32" ? (pid) => {
+      execFileSync("taskkill", windowsTaskkillArgs(pid), { stdio: "ignore" });
+    } : process.kill.bind(process);
+    const outcome = stop.id ? completedStops.get(stop.id) ?? await apply() : await apply();
+    if (stop.id && !completedStops.has(stop.id)) {
+      if (completedStops.size === MAX_COMPLETED_STOPS) {
+        const oldest = completedStops.keys().next().value;
+        if (oldest) completedStops.delete(oldest);
+      }
+      completedStops.set(stop.id, outcome);
+    }
     const said = {
       stopped: `stopped session ${stop.sessionId}`,
       already_gone: `session ${stop.sessionId} had already exited`,
+      signal_sent: `sent the stop signal to session ${stop.sessionId}; shutdown is still finishing`,
       refused: `could not stop session ${stop.sessionId}, the system refused the signal`,
       skipped_self: `refused to stop session ${stop.sessionId}: that pid is this daemon`
     };
     stderr(`[pushary] ${said[outcome]}
 `);
+    const acknowledgement = stopAcknowledgement(stop, machineId, outcome);
+    if (acknowledgement) {
+      for (let attempt = 0; attempt < 3 && !stopped; attempt++) {
+        const response = await fetch(`${baseUrl}/api/agent/stop/ack`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` },
+          body: JSON.stringify(acknowledgement),
+          signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+        }).catch(() => null);
+        if (response?.ok) {
+          completedStops.delete(acknowledgement.stopId);
+          break;
+        }
+        if (attempt < 2) await new Promise((resolve) => setTimeout(resolve, 200 * (attempt + 1)));
+      }
+    }
+    async function apply() {
+      return applyStopAndVerify(stop, {
+        kill,
+        ownsProcess: (request) => {
+          const launched = request.spawnId ? launchedProcesses.get(request.pid) === request.spawnId : !request.id && launchedProcesses.has(request.pid);
+          return launched || ownsLiveProcess(request);
+        },
+        selfPid: process.pid,
+        sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+        isAlive: (pid) => {
+          try {
+            process.kill(pid, 0);
+            return true;
+          } catch (err) {
+            return err.code === "EPERM";
+          }
+        }
+      });
+    }
   };
   const drain = async (signal) => {
     const res = await fetch(`${baseUrl}${DRAIN_PATH}`, {
       method: "POST",
       headers: { "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` },
-      body: JSON.stringify({ machineId }),
+      body: JSON.stringify({ machineId, spawnProtocol: SPAWN_PROTOCOL_VERSION, stopProtocol: STOP_PROTOCOL_VERSION }),
       signal
     });
     if (!res.ok) throw new DrainError(res.status);
     const data = await res.json();
-    for (const stop of parseStopRequests(data.stops)) runStop(stop);
-    const spawn2 = data.spawn;
-    return spawn2 && typeof spawn2.prompt === "string" && typeof spawn2.id === "string" ? spawn2 : null;
+    const response = typeof data === "object" && data !== null ? data : {};
+    await Promise.all(parseStopRequests(response.stops).map(runStop));
+    return parseSpawnClaim(response.spawn);
+  };
+  const acknowledge = async (body) => {
+    if (!body) return;
+    let lastError;
+    for (let attempt = 0; attempt < 3 && !stopped; attempt++) {
+      const controller = new AbortController();
+      inflight = controller;
+      const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+      try {
+        const response = await fetch(`${baseUrl}${ACK_PATH}`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` },
+          body: JSON.stringify(body),
+          signal: controller.signal
+        });
+        if (response.ok) return;
+        const error = new Error(`spawn acknowledgement failed (${response.status})`);
+        if (response.status < 500) {
+          lastError = error;
+          break;
+        }
+        lastError = error;
+      } catch (err) {
+        lastError = err;
+      } finally {
+        clearTimeout(timeout);
+        if (inflight === controller) inflight = void 0;
+      }
+    }
+    throw lastError ?? new Error("spawn acknowledgement stopped");
+  };
+  const launchClaim = async (request) => {
+    let pid;
+    try {
+      pid = await launch(request);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      stderr(`[pushary] could not launch session: ${message}
+`);
+      await acknowledge(spawnAcknowledgement(request, machineId, { state: "failed", message }));
+      return;
+    }
+    await acknowledge(spawnAcknowledgement(request, machineId, { state: "started", pid }));
   };
   const nextDelay = () => {
     if (errorStreak > 0) return Math.min(SLOW_POLL_MS * 2 ** (errorStreak - 1), MAX_ERROR_BACKOFF_MS);
@@ -173,6 +417,10 @@ var runSpawnDaemon = async () => {
   const jitter = (ms) => Math.max(1, Math.round(ms * (0.85 + Math.random() * 0.3)));
   const tick = async () => {
     if (stopped) return;
+    if (!daemonLease.isOwner()) {
+      finish();
+      return;
+    }
     if (!spawnRateAllows(spawnTimestamps, Date.now())) {
       timer = setTimeout(tick, jitter(nextDelay()));
       return;
@@ -182,10 +430,14 @@ var runSpawnDaemon = async () => {
     const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
     try {
       const req = await drain(controller.signal);
+      if (!daemonLease.isOwner()) {
+        finish();
+        return;
+      }
       errorStreak = 0;
       if (req) {
         idleTicks = 0;
-        launch(req);
+        await launchClaim(req);
       } else {
         idleTicks++;
       }
@@ -211,14 +463,33 @@ var runSpawnDaemon = async () => {
     stopped = true;
     if (timer) clearTimeout(timer);
     if (heartbeat) clearInterval(heartbeat);
+    if (versionWatch) clearInterval(versionWatch);
+    if (leaseRenewal) clearInterval(leaseRenewal);
     inflight?.abort();
+    try {
+      daemonLease.release();
+    } catch (err) {
+      stderr(`[pushary] daemon could not release its local lease: ${err instanceof Error ? err.message : String(err)}
+`);
+    }
   };
   const beat = async () => {
     if (stopped) return;
+    if (!daemonLease.isOwner()) {
+      finish();
+      return;
+    }
     const result = await sendHeartbeat(apiKey, {
       repoKey: basename(process.cwd()),
-      capabilities: ["spawn", STOP_CAPABILITY]
+      capabilities: [
+        "spawn",
+        STOP_CAPABILITY,
+        STOP_ACK_CAPABILITY,
+        ...codexBin ? [CODEX_BRIDGE_CAPABILITY, CODEX_RESUME_CAPABILITY] : [],
+        ...geminiCapabilities
+      ]
     });
+    if (result.kind === "ok") daemonLease.recordSuccessfulHeartbeat();
     if (result.kind === "unauthorized" && !stopped) {
       fatalCode = EXIT.UNAUTHENTICATED;
       stderr("[pushary] daemon stopping: this machine's key was rejected. Run `pushary login` to sign in again.\n");
@@ -227,17 +498,18 @@ var runSpawnDaemon = async () => {
   };
   void beat();
   heartbeat = setInterval(() => void beat(), HEARTBEAT_INTERVAL_MS);
+  leaseRenewal = setInterval(() => daemonLease.renew(), DAEMON_LEASE_RENEW_INTERVAL_MS);
+  versionWatch = setInterval(() => {
+    if (daemonLease.shouldYield()) finish();
+  }, VERSION_CHECK_INTERVAL_MS);
   stderr(
     `[pushary] daemon online \u2014 this machine (${machineId}) can now be sent a new session from your phone. Ctrl-C to stop.
 `
   );
   timer = setTimeout(tick, FAST_POLL_MS);
-  const signals = ["SIGINT", "SIGTERM", "SIGHUP"];
+  const signals = daemonSignals();
   await new Promise((resolve) => {
-    const onSignal = () => {
-      teardown();
-      resolve();
-    };
+    const onSignal = () => finish();
     for (const signal of signals) process.on(signal, onSignal);
     finish = () => {
       teardown();

package/dist/bin/pushary-doctor.js

@@ -6,7 +6,10 @@ import {
   claudeWired,
   codexWired,
   geminiWired
-} from "../chunk-QF7WTF2C.js";
+} from "../chunk-HZNOAJGB.js";
+import {
+  readDaemonStatus
+} from "../chunk-CCH775Y6.js";
 import {
   agentProbes,
   detectAgent,
@@ -15,12 +18,16 @@ import {
   isDetected,
   isPluginRegistered,
   vscodeSettingsTargets
-} from "../chunk-UVAC2KHH.js";
+} from "../chunk-UXWEE3QI.js";
 import {
   GEMINI_HOOK_BINARY,
   hasGeminiHooks,
   missingGeminiHookEvents
-} from "../chunk-TXF4QZSQ.js";
+} from "../chunk-DOXSWT4Q.js";
+import "../chunk-XHKBHWLX.js";
+import {
+  execNpm
+} from "../chunk-VT4IVERX.js";
 import {
   claudeJson,
   claudeSettings,
@@ -39,62 +46,60 @@ import {
   readCodexMcpAuth,
   untrustedCodexHookEvents,
   vscodePluginDir
-} from "../chunk-EHLTWCDZ.js";
+} from "../chunk-SEAHGHCE.js";
 import {
   readLedgerSummary
-} from "../chunk-3AGM3TDM.js";
+} from "../chunk-NJ7JT26G.js";
+import {
+  getMachineId
+} from "../chunk-RN3NOEJF.js";
 import {
   describeReach,
   describeRoundTrip,
   fetchChannels,
   reachVerdict,
   verifyRoundTrip
-} from "../chunk-U27BZWFT.js";
+} from "../chunk-6LC4WSCL.js";
 import "../chunk-3EGEA4KH.js";
 import {
   checkApiKey,
   describeKeyCheck
-} from "../chunk-QR6MVVQ7.js";
+} from "../chunk-F52SIIDG.js";
 import {
   createIo
 } from "../chunk-5RUIFDTP.js";
 import {
   keyPrefix,
   readKeySource
-} from "../chunk-WDRRULBH.js";
-import "../chunk-6MTNS63X.js";
+} from "../chunk-K7CSRGKZ.js";
 import {
   parseFlags
 } from "../chunk-GMXKITVA.js";
+import {
+  exitOnHelpFlag
+} from "../chunk-J4KFVOCQ.js";
+import "../chunk-MGJBC6DD.js";
 import "../chunk-BC3VCZ3E.js";
+import {
+  getPackageVersion
+} from "../chunk-DINDL2CF.js";
+import "../chunk-6MTNS63X.js";
 import {
   callMcpTool,
   sendMcpRequest
 } from "../chunk-BSZYIAZL.js";
 import "../chunk-SAF6HGAA.js";
-import "../chunk-SAA3VBDK.js";
+import "../chunk-437T77TY.js";
 import {
   UsageError
 } from "../chunk-7QLSKOSU.js";
-import "../chunk-YWRJGYUH.js";
-import {
-  execNpm
-} from "../chunk-MUEW424A.js";
 import {
-  getMachineId
-} from "../chunk-RN3NOEJF.js";
-import {
-  exitOnHelpFlag
-} from "../chunk-RRZZ7TFJ.js";
-import {
-  getPackageVersion
-} from "../chunk-ZUKH2NPJ.js";
+  EXIT
+} from "../chunk-KZERVKTD.js";
 import {
   getBaseUrl
 } from "../chunk-2UMNXADU.js";
-import {
-  EXIT
-} from "../chunk-KZERVKTD.js";
+import "../chunk-MQMPG5X4.js";
 
 // bin/pushary-doctor.ts
 import { existsSync, readFileSync, writeFileSync } from "fs";
@@ -321,6 +326,23 @@ var main = async () => {
         break;
     }
   }
+  const daemon = readDaemonStatus();
+  const daemonOk = daemon.kind === "running";
+  const daemonFailure = daemonOk ? null : `local state is ${daemon.kind}`;
+  const daemonDetail = daemonFailure ? `${daemonFailure}; run \`pushary daemon\` in a terminal to inspect it` : null;
+  check(
+    daemonOk,
+    "Remote-control daemon",
+    [
+      daemonDetail,
+      daemon.kind,
+      `pid ${daemon.pid ?? "none"}`,
+      `daemon ${daemon.daemonVersion ?? "none"}`,
+      `installed ${daemon.installedVersion}`,
+      `machine ${daemon.machineId ?? "none"}`,
+      `heartbeat ${daemon.lastSuccessfulHeartbeatAt ?? "none yet"}`
+    ].filter((value) => value !== null).join(" \xB7 ")
+  );
   const CLAUDE_JSON = claudeJson();
   const claudeInPlay = claudeWired({
     claudeJson: readJson(CLAUDE_JSON),
@@ -799,6 +821,7 @@ var main = async () => {
       ok: exitCode === EXIT.OK,
       exitCode,
       keyCheck: keyVerdict?.kind ?? null,
+      daemon,
       passed: results.filter((r) => r.passed).length,
       failed: failed.length,
       checks: results.map((r) => ({ label: r.label, passed: r.passed, detail: r.detail ?? null }))

package/dist/bin/pushary-gemini-bridge.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node