pushary 1.9.136 → 1.9.137

package/dist/{chunk-FAF5RDWT.js → chunk-MD63J3T7.js}

@@ -34,9 +34,136 @@ import {
   isRecord
 } from "./chunk-DL67HX3D.js";
 
+// src/daemon-entry-guard.ts
+import { mkdirSync, readFileSync } from "fs";
+import { basename, dirname, join } from "path";
+var DAEMON_ENTRY_GUARD_SOURCE = [
+  "const { existsSync } = require('node:fs')",
+  "if (process.argv[1] && !existsSync(process.argv[1])) process.exit(0)",
+  ""
+].join("\n");
+var DAEMON_ENTRY_GUARD_FILE = "daemon-entry-guard.cjs";
+var NODE_EXECUTABLE = /^node(?:\.exe)?$/i;
+var ENTRY_GUARD_PRELOAD_FLAG = "--require";
+var UNGUARDED = { kind: "unguarded" };
+var daemonEntryGuardPath = (stateDir) => join(stateDir, DAEMON_ENTRY_GUARD_FILE);
+var entryGuardApplies = (platform, execPath) => platform === "darwin" && NODE_EXECUTABLE.test(basename(execPath));
+var holdsDaemonEntryGuard = (path) => {
+  try {
+    return readFileSync(path, "utf8") === DAEMON_ENTRY_GUARD_SOURCE;
+  } catch {
+    return false;
+  }
+};
+var writeDaemonEntryGuardAt = (path) => {
+  if (holdsDaemonEntryGuard(path)) return { kind: "in-place" };
+  try {
+    mkdirSync(dirname(path), { recursive: true, mode: 448 });
+    writeFileAtomic(path, DAEMON_ENTRY_GUARD_SOURCE, 384);
+    return { kind: "in-place" };
+  } catch (error) {
+    return { kind: "failed", detail: error instanceof Error ? error.message : String(error) };
+  }
+};
+var writeDaemonEntryGuard = (input) => {
+  if (!entryGuardApplies(input.platform, input.execPath)) return UNGUARDED;
+  const path = daemonEntryGuardPath(input.stateDir);
+  const written = writeDaemonEntryGuardAt(path);
+  if (written.kind === "in-place") return { kind: "guarded", path };
+  input.warn(`[pushary] could not write ${path}, so the background service was installed without its uninstall guard: ${written.detail}
+`);
+  return UNGUARDED;
+};
+
+// src/diagnostics/service-runtime.ts
+var unescapeXml = (value) => value.replaceAll("&quot;", '"').replaceAll("&apos;", "'").replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&amp;", "&");
+var unquoteSystemdExecutable = (value) => value.replace(/\\(["\\])|%(%)/g, (_match, escaped, percent) => escaped ?? percent ?? "");
+var unquoteSystemdArgument = (value) => value.replace(/\\(["\\])|%(%)|\$(\$)/g, (_match, escaped, percent, dollar) => escaped ?? percent ?? dollar ?? "");
+var readServiceExecPath = (contents, platform) => {
+  if (platform === "darwin") {
+    const program = contents.match(/<key>ProgramArguments<\/key>\s*<array>\s*<string>([^<]*)<\/string>/)?.[1];
+    return program ? unescapeXml(program) : null;
+  }
+  if (platform === "linux") {
+    const exec = contents.match(/^ExecStart="((?:[^"\\]|\\.)*)"/m)?.[1];
+    return exec ? unquoteSystemdExecutable(exec) : null;
+  }
+  if (platform === "win32") {
+    const command = contents.match(/<Command>([^<]*)<\/Command>/)?.[1];
+    return command ? unescapeXml(command) : null;
+  }
+  return null;
+};
+var readLaunchdProgramArguments = (contents) => {
+  const array = contents.match(/<key>ProgramArguments<\/key>\s*<array>([\s\S]*?)<\/array>/)?.[1] ?? "";
+  return [...array.matchAll(/<string>([^<]*)<\/string>/g)].map((match) => unescapeXml(match[1] ?? ""));
+};
+var systemdExecStartArguments = (contents) => {
+  const line = contents.match(/^ExecStart=(.*)$/m)?.[1] ?? "";
+  return [...line.matchAll(/"((?:[^"\\]|\\.)*)"/g)].map((match, index) => (index === 0 ? unquoteSystemdExecutable : unquoteSystemdArgument)(match[1] ?? ""));
+};
+var windowsTaskArguments = (contents) => {
+  const args = unescapeXml(contents.match(/<Arguments>([^<]*)<\/Arguments>/)?.[1] ?? "");
+  return [...args.matchAll(/"([^"]*)"/g)].map((match) => match[1] ?? "");
+};
+var serviceArguments = (contents, platform) => {
+  if (platform === "darwin") return readLaunchdProgramArguments(contents);
+  if (platform === "linux") return systemdExecStartArguments(contents);
+  if (platform === "win32") return windowsTaskArguments(contents);
+  return [];
+};
+var readServiceDaemonEntry = (contents, platform) => serviceArguments(contents, platform).at(-1) ?? null;
+var readServiceEntryGuard = (contents, platform) => {
+  if (platform !== "darwin") return null;
+  const [, flag, guard] = readLaunchdProgramArguments(contents);
+  return flag === ENTRY_GUARD_PRELOAD_FLAG && guard !== void 0 ? guard : null;
+};
+var serviceStartFileChecks = (contents, platform, exists) => {
+  const checks = [];
+  const entry = readServiceDaemonEntry(contents, platform);
+  if (entry !== null) {
+    const present = exists(entry);
+    checks.push({
+      label: "Remote-control service entry",
+      passed: present,
+      detail: present ? entry : `${entry} is gone, so the background service starts nothing at login; run \`pushary daemon install\` from the Pushary install you use`
+    });
+  }
+  const guard = readServiceEntryGuard(contents, platform);
+  if (guard !== null && !exists(guard)) {
+    checks.push({
+      label: "Remote-control service start guard",
+      passed: false,
+      detail: `${guard} is gone, so the background service cannot start; run \`pushary daemon install\` to restore it`
+    });
+  }
+  return checks;
+};
+var MANAGER_SEGMENTS = [
+  [".nvm", "nvm"],
+  ["nvm", "nvm"],
+  ["fnm", "fnm"],
+  [".fnm", "fnm"],
+  [".volta", "volta"],
+  ["volta", "volta"],
+  [".asdf", "asdf"],
+  ["asdf", "asdf"],
+  ["Cellar", "homebrew"]
+];
+var versionManagerOf = (execPath) => {
+  const segments = execPath.split(/[/\\]/);
+  for (const segment of segments) {
+    const hit = MANAGER_SEGMENTS.find(([name]) => name === segment);
+    if (hit) return hit[1];
+  }
+  return null;
+};
+var describeVersionManagerPin = (execPath, manager) => `The background service is pinned to ${execPath}, which ${manager} manages. Switching or upgrading Node strands it; run pushary daemon install afterwards.`;
+var describeServiceNodeRisk = (manager) => manager === "homebrew" ? "a Homebrew version folder; brew upgrade strands the service, and `pushary daemon install` repins it to the stable link" : `managed by ${manager}; a version switch strands the service`;
+
 // src/daemon-lifecycle.ts
-import { dirname, join, win32 as win32Path } from "path";
-import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync } from "fs";
+import { dirname as dirname2, join as join2, win32 as win32Path } from "path";
+import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, realpathSync, renameSync, statSync, unlinkSync, writeFileSync } from "fs";
 import { createHash, randomUUID } from "crypto";
 import { homedir, uptime, userInfo } from "os";
 import { execFileSync } from "child_process";
@@ -55,7 +182,7 @@ var remoteProofIsFresh = (timestamp, now) => {
 };
 var daemonHasRemoteProof = (status, now = Date.now()) => status.kind === "running" && remoteProofIsFresh(status.lastSuccessfulHeartbeatAt, now) && remoteProofIsFresh(status.lastSuccessfulControlAt, now);
 var readServiceDefinitionFile = (path) => {
-  const bytes = readFileSync(path);
+  const bytes = readFileSync2(path);
   const encoding = bytes.length >= 2 && bytes[0] === 255 && bytes[1] === 254 ? "utf16le" : "utf-8";
   return { contents: bytes.toString(encoding), encoding };
 };
@@ -105,9 +232,9 @@ var daemonServiceManagerAvailable = (options = {}) => {
   }
 };
 var DAEMON_STATE_FILE = "daemon-state.json";
-var statePath = (dir) => join(dir, DAEMON_STATE_FILE);
-var lockPath = (dir) => join(dir, "daemon.lock");
-var targetPath = (dir) => join(dir, "daemon-target.json");
+var statePath = (dir) => join2(dir, DAEMON_STATE_FILE);
+var lockPath = (dir) => join2(dir, "daemon.lock");
+var targetPath = (dir) => join2(dir, "daemon-target.json");
 var DAEMON_LEASE_RENEW_INTERVAL_MS = 3e4;
 var LOCAL_LEASE_TIMEOUT_MS = DAEMON_LEASE_RENEW_INTERVAL_MS * 3;
 var DAEMON_YIELD_CHECK_INTERVAL_MS = 2e3;
@@ -117,28 +244,38 @@ var buildDaemonLaunch = (input) => input.siblingEntry ? { command: input.execPat
   shell: needsShell(input.daemonBinary, input.platform ?? process.platform)
 };
 var xml = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
-var systemdQuote = (value) => `"${value.replaceAll("%", "%%").replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+var systemdQuotedEnvironment = (value) => `"${value.replaceAll("%", "%%").replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+var escapeSystemdSpecifiers = (value) => value.replaceAll("%", "%%");
+var systemdQuotedWord = (escaped) => `"${escaped.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+var systemdExecutableWord = (value) => systemdQuotedWord(escapeSystemdSpecifiers(value));
+var systemdArgumentWord = (value) => systemdQuotedWord(escapeSystemdSpecifiers(value).replaceAll("$", "$$$$"));
+var systemdExecLine = (executable, args) => [systemdExecutableWord(executable), ...args.map(systemdArgumentWord)].join(" ");
+var ENTRY_PRESENT_CHECK = "process.exit(require('node:fs').existsSync(process.argv[1]) ? 0 : 1)";
+var guardedLaunchdProgram = (input) => {
+  const guard = input.entryGuard ?? UNGUARDED;
+  return guard.kind === "guarded" ? [input.execPath, ENTRY_GUARD_PRELOAD_FLAG, guard.path, input.daemonEntry] : [input.execPath, input.daemonEntry];
+};
 var buildDaemonService = (input) => {
   if (input.platform === "darwin") {
     if (!Number.isInteger(input.uid) || input.uid < 0) return null;
     const label = "com.pushary.daemon";
     const domain = `gui/${input.uid}`;
     const target = `${domain}/${label}`;
-    const definitionPath = join(input.homeDir, "Library", "LaunchAgents", `${label}.plist`);
+    const definitionPath = join2(input.homeDir, "Library", "LaunchAgents", `${label}.plist`);
     const contents = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
   <key>Label</key><string>${label}</string>
   <key>ProgramArguments</key>
-  <array><string>${xml(input.execPath)}</string><string>${xml(input.daemonEntry)}</string></array>
+  <array>${guardedLaunchdProgram(input).map((argument) => `<string>${xml(argument)}</string>`).join("")}</array>
   <key>WorkingDirectory</key><string>${xml(input.homeDir)}</string>
   <key>EnvironmentVariables</key><dict><key>PATH</key><string>${xml(input.pathEnv)}</string></dict>
   <key>RunAtLoad</key><true/>
   <key>KeepAlive</key><dict><key>SuccessfulExit</key><false/></dict>
   <key>ThrottleInterval</key><integer>10</integer>
-  <key>StandardOutPath</key><string>${xml(join(input.stateDir, "daemon.log"))}</string>
-  <key>StandardErrorPath</key><string>${xml(join(input.stateDir, "daemon-error.log"))}</string>
+  <key>StandardOutPath</key><string>${xml(join2(input.stateDir, "daemon.log"))}</string>
+  <key>StandardErrorPath</key><string>${xml(join2(input.stateDir, "daemon-error.log"))}</string>
 </dict>
 </plist>
 `;
@@ -157,6 +294,8 @@ var buildDaemonService = (input) => {
       disable: [{ command: "launchctl", args: ["disable", target] }],
       canDisableWhenUnregistered: true,
       uninstall: [{ command: "launchctl", args: ["bootout", domain, definitionPath], ignoreFailure: true }],
+      platform: input.platform,
+      startGuardPath: daemonEntryGuardPath(input.stateDir),
       registrationProbe: {
         command: "launchctl",
         args: ["print", target],
@@ -177,15 +316,17 @@ var buildDaemonService = (input) => {
   }
   if (input.platform === "linux") {
     const unit = "pushary-daemon.service";
-    const definitionPath = join(input.homeDir, ".config", "systemd", "user", unit);
+    const definitionPath = join2(input.homeDir, ".config", "systemd", "user", unit);
     const contents = `[Unit]
 Description=Pushary phone-to-agent daemon
 After=network-online.target
+ConditionPathExists=${escapeSystemdSpecifiers(input.daemonEntry)}
 
 [Service]
 Type=simple
-ExecStart=${systemdQuote(input.execPath)} ${systemdQuote(input.daemonEntry)}
-Environment=${systemdQuote(`PATH=${input.pathEnv}`)}
+ExecCondition=${systemdExecLine(input.execPath, ["-e", ENTRY_PRESENT_CHECK, input.daemonEntry])}
+ExecStart=${systemdExecLine(input.execPath, [input.daemonEntry])}
+Environment=${systemdQuotedEnvironment(`PATH=${input.pathEnv}`)}
 Restart=on-failure
 RestartSec=10
 KillMode=process
@@ -216,7 +357,9 @@ WantedBy=default.target
         args: ["--user", "is-active", unit],
         negativeOutputPattern: /^(?:inactive|failed|unknown|activating|deactivating)\s*$/m
       },
-      reloadAfterUninstall: { command: "systemctl", args: ["--user", "daemon-reload"] }
+      reloadAfterUninstall: { command: "systemctl", args: ["--user", "daemon-reload"] },
+      platform: input.platform,
+      startGuardPath: null
     };
   }
   if (input.platform === "win32") {
@@ -262,6 +405,8 @@ WantedBy=default.target
       stop: [{ command: "schtasks.exe", args: ["/End", "/TN", taskName], ignoreFailure: true }],
       disable: [{ command: "schtasks.exe", args: ["/Change", "/TN", taskName, "/Disable"] }],
       uninstall: [{ command: "schtasks.exe", args: ["/Delete", "/TN", taskName, "/F"], ignoreFailure: true }],
+      platform: input.platform,
+      startGuardPath: null,
       registrationProbe: {
         command: "powershell.exe",
         args: [
@@ -297,7 +442,7 @@ WantedBy=default.target
   return null;
 };
 var WINDOWS_DAEMON_ENTRY_SEGMENTS = ["dist", "bin", "pushary-daemon.js"];
-var readTextFile = (path) => readFileSync(path, "utf8");
+var readTextFile = (path) => readFileSync2(path, "utf8");
 var windowsPackageDaemonEntries = (globalPrefix) => {
   const root = globalRootFor(globalPrefix, "win32");
   return CLI_PACKAGE_NAMES.map((name) => win32Path.join(globalPackageFolder(root, name, "win32"), ...WINDOWS_DAEMON_ENTRY_SEGMENTS));
@@ -316,7 +461,8 @@ var serviceNodeFor = (execPath, exists) => {
   const linked = homebrewLinkedNodeFor(execPath);
   return linked !== null && exists(linked) ? linked : execPath;
 };
-var resolveDaemonServiceDefinition = (options = {}) => {
+var serviceExecPathFor = (options) => serviceNodeFor(options.execPath ?? process.execPath, options.entryExists ?? existsSync);
+var resolveDaemonServiceInput = (options) => {
   const platform = options.platform ?? process.platform;
   const exists = options.entryExists ?? existsSync;
   const globalBinary = options.globalBinary ?? resolveGlobalBinary("pushary-daemon");
@@ -333,18 +479,22 @@ var resolveDaemonServiceDefinition = (options = {}) => {
     }
   }
   if (!daemonEntry || !exists(daemonEntry)) return null;
-  const homeDir = options.homeDir ?? homedir();
-  return buildDaemonService({
+  return {
     platform,
-    homeDir,
+    homeDir: options.homeDir ?? homedir(),
     stateDir: options.stateDir ?? pusharyDir(),
-    execPath: serviceNodeFor(options.execPath ?? process.execPath, exists),
+    execPath: serviceExecPathFor(options),
     daemonEntry,
     pathEnv: options.pathEnv ?? process.env.PATH ?? "",
     uid: options.uid ?? process.getuid?.(),
     entryExists: exists
-  });
+  };
 };
+var resolveDaemonServiceDefinition = (options = {}) => {
+  const input = resolveDaemonServiceInput(options);
+  return input ? buildDaemonService(input) : null;
+};
+var daemonEntryGuardPathFor = (options = {}) => entryGuardApplies(options.platform ?? process.platform, serviceExecPathFor(options)) ? daemonEntryGuardPath(options.stateDir ?? pusharyDir()) : null;
 var runDaemonServiceSteps = (steps, run) => {
   for (const step of steps) {
     try {
@@ -409,7 +559,17 @@ var manageDaemonService = (action, options = {}) => {
   if (action === "uninstall" && !daemonServiceManagerAvailable(options)) {
     return { kind: "failed", detail: "Native background-service manager is unavailable" };
   }
-  return applyDaemonService(action, definition, { run: options.run });
+  const applied = applyDaemonService(action, definition, { run: options.run });
+  return action === "uninstall" && applied.kind === "ok" ? removeEntryGuardOf(definition) : applied;
+};
+var removeEntryGuardOf = (definition) => {
+  if (!definition.startGuardPath) return { kind: "ok" };
+  try {
+    safeUnlink(definition.startGuardPath);
+    return { kind: "ok" };
+  } catch (err) {
+    return { kind: "failed", detail: `the background service is removed, but its start guard ${definition.startGuardPath} could not be: ${err instanceof Error ? err.message : String(err)}` };
+  }
 };
 var nominalDaemonService = (options) => buildDaemonService({
   platform: options.platform ?? process.platform,
@@ -431,7 +591,7 @@ var readInstalledDaemonService = (options = {}) => {
   try {
     return {
       path: definition.definitionPath,
-      contents: readFileSync(definition.definitionPath, definition.encoding ?? "utf-8")
+      contents: readFileSync2(definition.definitionPath, definition.encoding ?? "utf-8")
     };
   } catch {
     return null;
@@ -595,7 +755,7 @@ var acquireDaemonLease = (options = {}) => {
   const instanceId = randomUUID();
   const startedAt = new Date(now()).toISOString();
   const writeLock = () => {
-    mkdirSync(dir, { recursive: true });
+    mkdirSync2(dir, { recursive: true });
     writeFileSync(lockPath(dir), JSON.stringify({ instanceId, pid }), { flag: "wx", mode: 384 });
   };
   try {
@@ -619,7 +779,7 @@ var acquireDaemonLease = (options = {}) => {
     if (owner && ownerIsFromThisBoot && (options.isProcessAlive ?? processIsAlive)(owner.pid)) {
       return { kind: "unavailable", detail: "daemon owner is still running or starting" };
     }
-    const stale = join(dir, `daemon.lock.${instanceId}.stale`);
+    const stale = join2(dir, `daemon.lock.${instanceId}.stale`);
     let ownsReplacement = false;
     try {
       renameSync(lockPath(dir), stale);
@@ -763,8 +923,16 @@ var stopDaemonRunning = async (options = {}) => {
   safeUnlink(lockPath(dir));
   return { kind: "stopped" };
 };
+var writeEntryGuardForService = (input, options) => writeDaemonEntryGuard({
+  stateDir: input.stateDir,
+  platform: input.platform,
+  execPath: input.execPath,
+  warn: options.warn ?? ((message) => {
+    process.stderr.write(message);
+  })
+});
 var DAEMON_LOGIN_REASONS = ["key_rejected", "plan_inactive", "key_missing", "mac_signed_out"];
-var needsLoginPath = (dir) => join(dir, "daemon-needs-login.json");
+var needsLoginPath = (dir) => join2(dir, "daemon-needs-login.json");
 var isLoginReason = (value) => DAEMON_LOGIN_REASONS.includes(value);
 var parseDaemonNeedsLogin = (value) => {
   if (typeof value !== "object" || value === null) return null;
@@ -804,7 +972,7 @@ var DAEMON_LOGIN_BLOCK_DESCRIPTIONS = {
 var describeDaemonLoginBlock = (record) => DAEMON_LOGIN_BLOCK_DESCRIPTIONS[record.reason](record.at);
 var recoverDaemonAfterLogin = (options = {}) => {
   const cleared = clearDaemonNeedsLogin(options);
-  if (!cleared || readControlMode(join(options.dir ?? pusharyDir(), "config.json")) === "off" || !hasDaemonServiceDefinition(options)) {
+  if (!cleared || readControlMode(join2(options.dir ?? pusharyDir(), "config.json")) === "off" || !hasDaemonServiceDefinition(options)) {
     return { cleared, restarted: false, detail: null };
   }
   const started = manageDaemonService("start", options);
@@ -878,12 +1046,26 @@ var probeDaemonServiceState = (definition, run) => {
   }
 };
 var previousEncoding = (snapshot) => snapshot.previousEncoding ?? "utf-8";
+var launchdEntryGuardArguments = (guard) => `<string>${xml(ENTRY_GUARD_PRELOAD_FLAG)}</string><string>${xml(guard)}</string>`;
+var restorableContents = (definition, contents) => {
+  const guard = definition.startGuardPath;
+  if (!guard || contents === null || readServiceEntryGuard(contents, definition.platform) !== guard) {
+    return { kind: "ready", contents };
+  }
+  const written = writeDaemonEntryGuardAt(guard);
+  if (written.kind === "in-place") return { kind: "ready", contents };
+  const unguarded = contents.replace(launchdEntryGuardArguments(guard), "");
+  return readServiceEntryGuard(unguarded, definition.platform) === null ? { kind: "ready", contents: unguarded } : { kind: "failed", detail: `could not write the start guard ${guard} the previous service names (${written.detail}), or restore that service without it` };
+};
 var restoreDaemonServiceSnapshot = (definition, snapshot, run) => {
+  const restorable = restorableContents(definition, snapshot.previousContents);
+  if (restorable.kind !== "ready") return restorable;
+  const previousContents = restorable.contents;
   const removed = applyDaemonService("uninstall", definition, { run });
   if (removed.kind !== "ok") return removed;
   try {
-    if (snapshot.previousContents === null) safeUnlink(definition.definitionPath);
-    else writeFileAtomic(definition.definitionPath, snapshot.previousContents, 384, previousEncoding(snapshot));
+    if (previousContents === null) safeUnlink(definition.definitionPath);
+    else writeFileAtomic(definition.definitionPath, previousContents, 384, previousEncoding(snapshot));
   } catch (err) {
     return {
       kind: "failed",
@@ -892,7 +1074,7 @@ var restoreDaemonServiceSnapshot = (definition, snapshot, run) => {
   }
   if (!snapshot.previousRegistered) {
     const reload = definition.reloadAfterUninstall;
-    if (snapshot.previousContents !== null && reload) {
+    if (previousContents !== null && reload) {
       try {
         run(reload.command, reload.args);
       } catch (err) {
@@ -917,12 +1099,12 @@ var restoreDaemonServiceSnapshot = (definition, snapshot, run) => {
     }
     return { kind: "ok" };
   }
-  if (snapshot.previousContents === null) {
+  if (previousContents === null) {
     return { kind: "failed", detail: "the previous registered service had no recoverable definition" };
   }
   const restored = applyDaemonService("install", {
     ...definition,
-    contents: snapshot.previousContents,
+    contents: previousContents,
     encoding: previousEncoding(snapshot)
   }, { run });
   if (restored.kind !== "ok") return restored;
@@ -971,19 +1153,22 @@ var recoverDaemonServiceTransaction = (definition, path, run) => {
   return { kind: "ok" };
 };
 var replaceDaemonService = async (options = {}) => {
-  const definition = resolveDaemonServiceDefinition(options);
-  if (!definition) {
+  const input = resolveDaemonServiceInput(options);
+  const unguarded = input ? buildDaemonService(input) : null;
+  if (!input || !unguarded) {
     return {
       kind: "unavailable",
       detail: "Could not find the globally installed daemon entry. Run Pushary setup again."
     };
   }
   const run = options.run ?? runDaemonServiceCommand;
-  const transactionPath = join(options.stateDir ?? options.dir ?? pusharyDir(), "daemon-service-transaction.json");
-  const recovered = recoverDaemonServiceTransaction(definition, transactionPath, run);
+  const transactionPath = join2(options.stateDir ?? options.dir ?? pusharyDir(), "daemon-service-transaction.json");
+  const recovered = recoverDaemonServiceTransaction(unguarded, transactionPath, run);
   if (recovered.kind !== "ok") {
     return { kind: "failed", detail: `Could not recover interrupted service replacement: ${recovered.detail}` };
   }
+  const definition = buildDaemonService({ ...input, entryGuard: writeEntryGuardForService(input, options) });
+  if (!definition) return { kind: "unavailable", detail: "Could not build the daemon service definition for this platform." };
   let previousContents = null;
   let previousDefinitionEncoding = "utf-8";
   try {
@@ -1088,7 +1273,7 @@ var replaceDaemonService = async (options = {}) => {
 var launchInstalledDaemon = (options) => {
   const entryExists = options.entryExists ?? existsSync;
   const argvEntry = process.argv[1];
-  const candidate = options.daemonEntry !== void 0 ? options.daemonEntry : argvEntry ? join(dirname(argvEntry), "pushary-daemon.js") : null;
+  const candidate = options.daemonEntry !== void 0 ? options.daemonEntry : argvEntry ? join2(dirname2(argvEntry), "pushary-daemon.js") : null;
   const siblingEntry = candidate && entryExists(candidate) ? candidate : null;
   const platform = options.platform ?? process.platform;
   const daemonBinary = options.daemonBinary ?? resolveGlobalBinary("pushary-daemon") ?? (platform === "win32" ? "pushary-daemon.cmd" : "pushary-daemon");
@@ -1163,6 +1348,11 @@ var waitForDaemonRemoteProof = async (options = {}) => {
 };
 
 export {
+  readServiceExecPath,
+  serviceStartFileChecks,
+  versionManagerOf,
+  describeVersionManagerPin,
+  describeServiceNodeRisk,
   daemonIsServing,
   daemonProcessIsThere,
   DAEMON_COLD_START_TIMEOUT_MS,
@@ -1172,6 +1362,7 @@ export {
   DAEMON_YIELD_CHECK_INTERVAL_MS,
   xml,
   serviceNodeFor,
+  daemonEntryGuardPathFor,
   parseDaemonAction,
   manageDaemonService,
   hasDaemonServiceDefinition,

package/dist/{chunk-O5T53LZ5.js → chunk-R6N6FREL.js}

@@ -23,7 +23,7 @@ import {
 import {
   isAdmitted,
   readAdmissionRules
-} from "./chunk-YURIU333.js";
+} from "./chunk-7XD56GXA.js";
 import {
   isDeferAnswer,
   oncePerSession

package/dist/{chunk-J42EAEX3.js → chunk-XR27HPYC.js}

@@ -61,7 +61,8 @@ var describeService = (effects) => {
   if (effects.controlMode === "off") return "skip     the phone-start background service (--control off)";
   const where = effects.serviceDefinitionPath ?? "the phone-start service definition";
   const condition = effects.controlMode === "on" ? "" : ", when a supported agent and a service manager are present";
-  return `write    ${where} and register it with the OS${condition}`;
+  const guard = effects.serviceStartGuardPath ? ` and its start guard ${effects.serviceStartGuardPath}` : "";
+  return `write    ${where}${guard} and register it with the OS${condition}`;
 };
 var describeSetupSideEffects = (effects) => [
   `run      npm install -g ${effects.globalPackage}@${effects.version} (the hooks run from the global copy; up to two minutes)`,

package/dist/{codex-app-cards-switch-Z7TMF2OR.js → codex-app-cards-switch-JU236CG2.js}

@@ -22,11 +22,11 @@ import {
   turnCodexAppCardsOff,
   turnCodexAppCardsOn,
   whyLaunchctlFailed
-} from "./chunk-EQZB5P6I.js";
-import "./chunk-RPFSVNH6.js";
+} from "./chunk-7NCI2DGB.js";
+import "./chunk-7VKW7OA5.js";
 import "./chunk-XCEN33UP.js";
 import "./chunk-QCGNGEGE.js";
-import "./chunk-FAF5RDWT.js";
+import "./chunk-MD63J3T7.js";
 import "./chunk-H6CL3T2S.js";
 import "./chunk-WNT4JHK3.js";
 import "./chunk-PNVTPEO5.js";

package/dist/{codex-desktop-launch-HKXGKL3T.js → codex-desktop-launch-LRQ4LU64.js}

@@ -11,7 +11,7 @@ import {
   installedCodexApp,
   shellQuoted,
   writeDesktopProxy
-} from "./chunk-RPFSVNH6.js";
+} from "./chunk-7VKW7OA5.js";
 import "./chunk-XCEN33UP.js";
 import {
   CODEX_APP_LAUNCH_VARIABLE

package/dist/src/index.js

@@ -1,19 +1,19 @@
 import {
   handlePreToolUse
-} from "../chunk-O5T53LZ5.js";
+} from "../chunk-R6N6FREL.js";
 import "../chunk-UP5QXEUU.js";
 import "../chunk-G73ACPR2.js";
 import "../chunk-2R4OVJHS.js";
 import "../chunk-HY4ATVCT.js";
 import "../chunk-YQQGIDBC.js";
-import "../chunk-YURIU333.js";
+import "../chunk-7XD56GXA.js";
 import "../chunk-NN43KGTN.js";
 import "../chunk-H2RE3IPK.js";
-import "../chunk-L7Q57R4J.js";
+import "../chunk-6WT5OIRM.js";
 import "../chunk-VAE5JBR5.js";
 import "../chunk-G66WIAST.js";
 import "../chunk-43DT3QWZ.js";
-import "../chunk-FAF5RDWT.js";
+import "../chunk-MD63J3T7.js";
 import "../chunk-TLK5YLIE.js";
 import {
   fetchModeOverride,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pushary",
-  "version": "1.9.136",
+  "version": "1.9.137",
   "description": "Human-in-the-loop (HITL) for AI agents: ask a person for approvals or answers by push notification. One command connects Claude Code, Codex, Cursor, Gemini CLI and more.",
   "keywords": [
     "pushary",

package/dist/chunk-GACQSKNG.js

@@ -1,75 +0,0 @@
-import {
-  configFilePath
-} from "./chunk-IKBTG3OT.js";
-import {
-  readJsonSafe,
-  writeJsonAtomic
-} from "./chunk-TODDEIYG.js";
-import {
-  readSetupOutcomeProperties
-} from "./chunk-DL67HX3D.js";
-
-// src/diagnostics/service-runtime.ts
-var unescapeXml = (value) => value.replaceAll("&quot;", '"').replaceAll("&apos;", "'").replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&amp;", "&");
-var unquoteSystemd = (value) => value.replaceAll('\\"', '"').replaceAll("\\\\", "\\").replaceAll("%%", "%");
-var readServiceExecPath = (contents, platform) => {
-  if (platform === "darwin") {
-    const program = contents.match(/<key>ProgramArguments<\/key>\s*<array>\s*<string>([^<]*)<\/string>/)?.[1];
-    return program ? unescapeXml(program) : null;
-  }
-  if (platform === "linux") {
-    const exec = contents.match(/^ExecStart="((?:[^"\\]|\\.)*)"/m)?.[1];
-    return exec ? unquoteSystemd(exec) : null;
-  }
-  if (platform === "win32") {
-    const command = contents.match(/<Command>([^<]*)<\/Command>/)?.[1];
-    return command ? unescapeXml(command) : null;
-  }
-  return null;
-};
-var MANAGER_SEGMENTS = [
-  [".nvm", "nvm"],
-  ["nvm", "nvm"],
-  ["fnm", "fnm"],
-  [".fnm", "fnm"],
-  [".volta", "volta"],
-  ["volta", "volta"],
-  [".asdf", "asdf"],
-  ["asdf", "asdf"],
-  ["Cellar", "homebrew"]
-];
-var versionManagerOf = (execPath) => {
-  const segments = execPath.split(/[/\\]/);
-  for (const segment of segments) {
-    const hit = MANAGER_SEGMENTS.find(([name]) => name === segment);
-    if (hit) return hit[1];
-  }
-  return null;
-};
-var describeVersionManagerPin = (execPath, manager) => `The background service is pinned to ${execPath}, which ${manager} manages. Switching or upgrading Node strands it; run pushary daemon install afterwards.`;
-var describeServiceNodeRisk = (manager) => manager === "homebrew" ? "a Homebrew version folder; brew upgrade strands the service, and `pushary daemon install` repins it to the stable link" : `managed by ${manager}; a version switch strands the service`;
-
-// src/setup/failure-record.ts
-import { dirname, join } from "path";
-var failurePath = () => join(dirname(configFilePath()), "last-setup-failure.json");
-var saveSetupFailure = (body, path = failurePath()) => {
-  const properties = readSetupOutcomeProperties(body);
-  if (properties.exitCode === null || properties.exitCode === 0) return;
-  writeJsonAtomic(path, { ...properties, recordedAt: (/* @__PURE__ */ new Date()).toISOString() }, 384);
-};
-var readSetupFailure = (path = failurePath()) => {
-  const result = readJsonSafe(path);
-  if (result.kind !== "ok" || typeof result.value !== "object" || result.value === null || Array.isArray(result.value)) return null;
-  const body = result.value;
-  if (!("recordedAt" in body) || typeof body.recordedAt !== "string" || body.recordedAt.length > 30 || !Number.isFinite(Date.parse(body.recordedAt))) return null;
-  return { ...readSetupOutcomeProperties({ ...body }), recordedAt: body.recordedAt };
-};
-
-export {
-  saveSetupFailure,
-  readSetupFailure,
-  readServiceExecPath,
-  versionManagerOf,
-  describeVersionManagerPin,
-  describeServiceNodeRisk
-};