pushary 1.8.0

package/dist/chunk-WE2J62NC.js

@@ -0,0 +1,1131 @@
+import {
+  needsShell,
+  spawnClaude
+} from "./chunk-XHKBHWLX.js";
+import {
+  readControlMode
+} from "./chunk-P7WQEVWA.js";
+import {
+  getMachineId
+} from "./chunk-LXQ5FBBD.js";
+import {
+  pusharyDir,
+  resolveGlobalBinary
+} from "./chunk-A2A2YTMG.js";
+import {
+  readJsonSafe,
+  writeFileAtomic,
+  writeJsonAtomic,
+  writeJsonAtomicDurable
+} from "./chunk-T7E75EKA.js";
+import {
+  getApiKey
+} from "./chunk-GPEGOGRJ.js";
+import {
+  CLI_PACKAGE_NAMES,
+  cmdShimTarget,
+  getPackageVersion,
+  globalPackageFolder,
+  globalRootFor
+} from "./chunk-NQTHFF4W.js";
+
+// src/daemon-lifecycle.ts
+import { dirname, join, win32 as win32Path } from "path";
+import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, unlinkSync, writeFileSync } from "fs";
+import { createHash, randomUUID } from "crypto";
+import { homedir, userInfo } from "os";
+import { execFileSync } from "child_process";
+var daemonNeedsHandoff = (status) => status.kind === "version-mismatch" || status.kind === "configuration-mismatch" || status.kind === "unresponsive" && status.processAlive === true;
+var DAEMON_REMOTE_PROOF_MAX_AGE_MS = 18e4;
+var DAEMON_REMOTE_PROOF_CLOCK_SKEW_MS = 3e4;
+var remoteProofIsFresh = (timestamp, now) => {
+  if (timestamp === null) return false;
+  const age = now - Date.parse(timestamp);
+  return Number.isFinite(age) && age >= -DAEMON_REMOTE_PROOF_CLOCK_SKEW_MS && age < DAEMON_REMOTE_PROOF_MAX_AGE_MS;
+};
+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 encoding = bytes.length >= 2 && bytes[0] === 255 && bytes[1] === 254 ? "utf16le" : "utf-8";
+  return { contents: bytes.toString(encoding), encoding };
+};
+var runDaemonServiceCommand = (command, args) => execFileSync(command, [...args], {
+  encoding: "utf-8",
+  stdio: ["ignore", "pipe", "pipe"],
+  windowsHide: true
+});
+var commandFailureOutput = (error) => {
+  const failure = error;
+  return [failure.stdout, failure.stderr, failure.message].map((value) => Buffer.isBuffer(value) ? value.toString("utf-8") : typeof value === "string" ? value : "").filter(Boolean).join("\n");
+};
+var isExpectedProbeFailure = (probe, error) => {
+  const failure = error;
+  const status = typeof failure.status === "number" ? failure.status : typeof failure.code === "number" ? failure.code : null;
+  const exitMatches = probe.negativeExitCodes === void 0 || status !== null && probe.negativeExitCodes.includes(status);
+  const outputMatches = probe.negativeOutputPattern === void 0 || probe.negativeOutputPattern.test(commandFailureOutput(error));
+  return (probe.negativeExitCodes !== void 0 || probe.negativeOutputPattern !== void 0) && exitMatches && outputMatches;
+};
+var daemonServiceManagerAvailable = (options = {}) => {
+  const platform = options.platform ?? process.platform;
+  const run = options.run ?? runDaemonServiceCommand;
+  try {
+    if (platform === "darwin") {
+      const uid = options.uid ?? process.getuid?.();
+      if (uid === void 0) return false;
+      run("launchctl", ["print", `gui/${uid}`]);
+      return true;
+    }
+    if (platform === "linux") {
+      run("systemctl", ["--user", "show-environment"]);
+      return true;
+    }
+    if (platform === "win32") {
+      run("sc.exe", ["query", "Schedule"]);
+      run("powershell.exe", [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        "Get-Command Get-ScheduledTask -ErrorAction Stop | Out-Null"
+      ]);
+      return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+};
+var statePath = (dir) => join(dir, "daemon-state.json");
+var lockPath = (dir) => join(dir, "daemon.lock");
+var targetPath = (dir) => join(dir, "daemon-target.json");
+var DAEMON_LEASE_RENEW_INTERVAL_MS = 3e4;
+var LOCAL_LEASE_TIMEOUT_MS = DAEMON_LEASE_RENEW_INTERVAL_MS * 3;
+var buildDaemonLaunch = (input) => input.siblingEntry ? { command: input.execPath, args: [input.siblingEntry], shell: false } : {
+  command: input.daemonBinary,
+  args: [],
+  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 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 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>
+  <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>
+</dict>
+</plist>
+`;
+    const bootstrap = { command: "launchctl", args: ["bootstrap", domain, definitionPath] };
+    return {
+      definitionPath,
+      contents,
+      install: [
+        { command: "launchctl", args: ["bootout", domain, definitionPath], ignoreFailure: true },
+        bootstrap,
+        { command: "launchctl", args: ["enable", target] },
+        { command: "launchctl", args: ["kickstart", "-k", target] }
+      ],
+      start: [{ command: "launchctl", args: ["kickstart", "-k", target] }],
+      stop: [{ command: "launchctl", args: ["kill", "SIGTERM", target], ignoreFailure: true }],
+      disable: [{ command: "launchctl", args: ["disable", target] }],
+      canDisableWhenUnregistered: true,
+      uninstall: [{ command: "launchctl", args: ["bootout", domain, definitionPath], ignoreFailure: true }],
+      registrationProbe: {
+        command: "launchctl",
+        args: ["print", target],
+        negativeExitCodes: [113]
+      },
+      enabledProbe: {
+        command: "launchctl",
+        args: ["print-disabled", domain],
+        disabledOutputPattern: new RegExp(`"${label}"\\s*=>\\s*disabled`)
+      },
+      runningProbe: {
+        command: "launchctl",
+        args: ["print", target],
+        outputPattern: /\bstate = running\b/,
+        negativeExitCodes: [113]
+      }
+    };
+  }
+  if (input.platform === "linux") {
+    const unit = "pushary-daemon.service";
+    const definitionPath = join(input.homeDir, ".config", "systemd", "user", unit);
+    const contents = `[Unit]
+Description=Pushary phone-to-agent daemon
+After=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${systemdQuote(input.execPath)} ${systemdQuote(input.daemonEntry)}
+Environment=${systemdQuote(`PATH=${input.pathEnv}`)}
+Restart=on-failure
+RestartSec=10
+
+[Install]
+WantedBy=default.target
+`;
+    return {
+      definitionPath,
+      contents,
+      install: [
+        { command: "systemctl", args: ["--user", "daemon-reload"] },
+        { command: "systemctl", args: ["--user", "enable", "--now", unit] }
+      ],
+      start: [{ command: "systemctl", args: ["--user", "start", unit] }],
+      stop: [{ command: "systemctl", args: ["--user", "stop", unit], ignoreFailure: true }],
+      disable: [{ command: "systemctl", args: ["--user", "disable", unit] }],
+      uninstall: [
+        { command: "systemctl", args: ["--user", "disable", "--now", unit], ignoreFailure: true }
+      ],
+      registrationProbe: {
+        command: "systemctl",
+        args: ["--user", "is-enabled", unit],
+        negativeOutputPattern: /^(?:disabled|not-found)\s*$/m
+      },
+      runningProbe: {
+        command: "systemctl",
+        args: ["--user", "is-active", unit],
+        negativeOutputPattern: /^(?:inactive|failed|unknown)\s*$/m
+      },
+      reloadAfterUninstall: { command: "systemctl", args: ["--user", "daemon-reload"] }
+    };
+  }
+  if (input.platform === "win32") {
+    const taskName = "Pushary Daemon";
+    const username = process.env.USERNAME?.trim() || userInfo().username;
+    const domain = process.env.USERDOMAIN?.trim();
+    const userId = input.userId?.trim() || (domain ? `${domain}\\${username}` : username);
+    const definitionPath = win32Path.join(input.stateDir, "pushary-daemon-task.xml");
+    const supervisorPath = win32Path.join(win32Path.dirname(input.daemonEntry), "pushary-daemon-supervisor.js");
+    const supervised = (input.entryExists ?? existsSync)(supervisorPath);
+    const args = supervised ? `&quot;${xml(supervisorPath)}&quot; &quot;${xml(input.daemonEntry)}&quot;` : `&quot;${xml(input.daemonEntry)}&quot;`;
+    const contents = `\uFEFF<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.4" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <RegistrationInfo><Description>Pushary phone-to-agent daemon</Description></RegistrationInfo>
+  <Triggers><LogonTrigger><UserId>${xml(userId)}</UserId><Enabled>true</Enabled></LogonTrigger></Triggers>
+  <Principals><Principal id="Author"><UserId>${xml(userId)}</UserId><LogonType>InteractiveToken</LogonType><RunLevel>LeastPrivilege</RunLevel></Principal></Principals>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <StartWhenAvailable>true</StartWhenAvailable>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>
+    <RestartOnFailure><Interval>PT1M</Interval><Count>999</Count></RestartOnFailure>
+  </Settings>
+  <Actions Context="Author">
+    <Exec>
+      <Command>${xml(input.execPath)}</Command>
+      <Arguments>${args}</Arguments>
+      <WorkingDirectory>${xml(input.homeDir)}</WorkingDirectory>
+    </Exec>
+  </Actions>
+</Task>
+`;
+    return {
+      definitionPath,
+      contents,
+      encoding: "utf16le",
+      install: [
+        { command: "schtasks.exe", args: ["/Create", "/TN", taskName, "/XML", definitionPath, "/F"] },
+        { command: "schtasks.exe", args: ["/Run", "/TN", taskName] }
+      ],
+      start: [{ command: "schtasks.exe", args: ["/Run", "/TN", taskName] }],
+      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 }],
+      registrationProbe: {
+        command: "powershell.exe",
+        args: [
+          "-NoProfile",
+          "-NonInteractive",
+          "-Command",
+          "$task = @(Get-ScheduledTask -ErrorAction Stop) | Where-Object { $_.TaskName -eq 'Pushary Daemon' -and $_.TaskPath -eq '\\' } | Select-Object -First 1; if ($null -eq $task) { exit 3 }"
+        ],
+        negativeExitCodes: [3]
+      },
+      enabledProbe: {
+        command: "powershell.exe",
+        args: [
+          "-NoProfile",
+          "-NonInteractive",
+          "-Command",
+          "$task = @(Get-ScheduledTask -ErrorAction Stop) | Where-Object { $_.TaskName -eq 'Pushary Daemon' -and $_.TaskPath -eq '\\' } | Select-Object -First 1; if ($null -eq $task) { exit 3 }; if ($null -eq $task.Settings -or $null -eq $task.Settings.Enabled) { exit 5 }; if (-not $task.Settings.Enabled) { exit 4 }"
+        ],
+        negativeExitCodes: [3, 4]
+      },
+      runningProbe: {
+        command: "powershell.exe",
+        args: [
+          "-NoProfile",
+          "-NonInteractive",
+          "-Command",
+          "$task = @(Get-ScheduledTask -ErrorAction Stop) | Where-Object { $_.TaskName -eq 'Pushary Daemon' -and $_.TaskPath -eq '\\' } | Select-Object -First 1; if ($null -eq $task) { exit 3 }; if ($task.State -ne 'Running') { exit 4 }"
+        ],
+        negativeExitCodes: [3, 4]
+      }
+    };
+  }
+  return null;
+};
+var WINDOWS_DAEMON_ENTRY_SEGMENTS = ["dist", "bin", "pushary-daemon.js"];
+var WINDOWS_CMD_SHIM = /\.cmd$/i;
+var readTextFile = (path) => readFileSync(path, "utf8");
+var windowsShimTarget = (shim, readFile) => {
+  if (!WINDOWS_CMD_SHIM.test(shim)) return void 0;
+  try {
+    return cmdShimTarget(win32Path.dirname(shim), readFile(shim));
+  } catch {
+    return void 0;
+  }
+};
+var windowsPackageDaemonEntries = (globalPrefix) => {
+  const root = globalRootFor(globalPrefix, "win32");
+  return CLI_PACKAGE_NAMES.map((name) => win32Path.join(globalPackageFolder(root, name, "win32"), ...WINDOWS_DAEMON_ENTRY_SEGMENTS));
+};
+var windowsDaemonEntryCandidates = (shim, readFile) => {
+  const shimEntry = windowsShimTarget(shim, readFile);
+  const packageEntries = windowsPackageDaemonEntries(win32Path.dirname(shim));
+  return shimEntry === void 0 ? packageEntries : [shimEntry, ...packageEntries];
+};
+var resolveDaemonServiceDefinition = (options = {}) => {
+  const platform = options.platform ?? process.platform;
+  const exists = options.entryExists ?? existsSync;
+  const globalBinary = options.globalBinary ?? resolveGlobalBinary("pushary-daemon");
+  let daemonEntry = options.daemonEntry;
+  if (!daemonEntry && globalBinary) {
+    if (platform === "win32") {
+      daemonEntry = windowsDaemonEntryCandidates(globalBinary, options.readFile ?? readTextFile).find((candidate) => exists(candidate));
+    } else {
+      try {
+        const candidate = (options.realpath ?? realpathSync)(globalBinary);
+        if (exists(candidate)) daemonEntry = candidate;
+      } catch {
+      }
+    }
+  }
+  if (!daemonEntry || !exists(daemonEntry)) return null;
+  const homeDir = options.homeDir ?? homedir();
+  return buildDaemonService({
+    platform,
+    homeDir,
+    stateDir: options.stateDir ?? pusharyDir(),
+    execPath: options.execPath ?? process.execPath,
+    daemonEntry,
+    pathEnv: options.pathEnv ?? process.env.PATH ?? "",
+    uid: options.uid ?? process.getuid?.(),
+    entryExists: exists
+  });
+};
+var runDaemonServiceSteps = (steps, run) => {
+  for (const step of steps) {
+    try {
+      run(step.command, step.args);
+    } catch (err) {
+      if (!step.ignoreFailure) throw err;
+    }
+  }
+};
+var applyDaemonService = (action, definition, options = {}) => {
+  const run = options.run ?? runDaemonServiceCommand;
+  try {
+    if (action === "install") {
+      writeFileAtomic(definition.definitionPath, definition.contents, 384, definition.encoding);
+    }
+    const steps = action === "uninstall" ? [...definition.stop, ...definition.uninstall] : definition[action];
+    runDaemonServiceSteps(steps, run);
+    if (action === "uninstall") {
+      const state = probeDaemonServiceState(definition, run);
+      if (state.kind !== "ok") throw new Error(`Could not verify native background service is absent: ${state.detail}`);
+      if (state.registered) throw new Error("Native background service remains registered");
+      if (state.running) throw new Error("Native background service remains active");
+      safeUnlink(definition.definitionPath);
+      const reload = definition.reloadAfterUninstall;
+      if (reload) run(reload.command, reload.args);
+    }
+    return { kind: "ok" };
+  } catch (err) {
+    return { kind: "failed", detail: err instanceof Error ? err.message : String(err) };
+  }
+};
+var DAEMON_ACTIONS = /* @__PURE__ */ new Set([
+  "install",
+  "start",
+  "stop",
+  "restart",
+  "status",
+  "uninstall",
+  "foreground"
+]);
+var parseDaemonAction = (argv) => {
+  const args = argv[0] === "daemon" ? argv.slice(1) : argv;
+  const action = args[0] ?? "foreground";
+  return DAEMON_ACTIONS.has(action) ? action : null;
+};
+var manageDaemonService = (action, options = {}) => {
+  const definition = action === "uninstall" || action === "stop" ? buildDaemonService({
+    platform: options.platform ?? process.platform,
+    homeDir: options.homeDir ?? homedir(),
+    stateDir: options.stateDir ?? pusharyDir(),
+    execPath: options.execPath ?? process.execPath,
+    daemonEntry: options.daemonEntry ?? process.execPath,
+    pathEnv: options.pathEnv ?? process.env.PATH ?? "",
+    uid: options.uid ?? process.getuid?.()
+  }) : resolveDaemonServiceDefinition(options);
+  if (!definition) {
+    return {
+      kind: "unavailable",
+      detail: "Could not find the globally installed daemon entry. Run Pushary setup again."
+    };
+  }
+  if (action === "uninstall" && !daemonServiceManagerAvailable(options)) {
+    return { kind: "failed", detail: "Native background-service manager is unavailable" };
+  }
+  return applyDaemonService(action, definition, { run: options.run });
+};
+var nominalDaemonService = (options) => buildDaemonService({
+  platform: options.platform ?? process.platform,
+  homeDir: options.homeDir ?? homedir(),
+  stateDir: options.stateDir ?? pusharyDir(),
+  execPath: options.execPath ?? process.execPath,
+  daemonEntry: options.daemonEntry ?? process.execPath,
+  pathEnv: options.pathEnv ?? process.env.PATH ?? "",
+  uid: options.uid ?? process.getuid?.()
+});
+var hasDaemonServiceDefinition = (options = {}) => {
+  const definition = nominalDaemonService(options);
+  return definition !== null && existsSync(definition.definitionPath);
+};
+var daemonServiceDefinitionPath = (options = {}) => nominalDaemonService(options)?.definitionPath ?? null;
+var readInstalledDaemonService = (options = {}) => {
+  const definition = nominalDaemonService(options);
+  if (!definition) return null;
+  try {
+    return {
+      path: definition.definitionPath,
+      contents: readFileSync(definition.definitionPath, definition.encoding ?? "utf-8")
+    };
+  } catch {
+    return null;
+  }
+};
+var spawnDetachedDaemon = (plan, options = {}) => {
+  const spawnImpl = options.spawnImpl ?? spawnClaude;
+  const child = spawnImpl(plan.command, plan.args, {
+    detached: true,
+    stdio: "ignore",
+    windowsHide: true,
+    shell: plan.shell
+  });
+  child.once?.("error", () => {
+  });
+  child.unref();
+  return typeof child.pid === "number" ? child.pid : null;
+};
+var processIsAlive = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+};
+var isString = (value) => typeof value === "string" && value.length > 0;
+var isTimestamp = (value) => isString(value) && Number.isFinite(Date.parse(value));
+var daemonConfigurationId = (apiKey) => createHash("sha256").update(apiKey).digest("hex").slice(0, 16);
+var currentConfigurationId = () => {
+  try {
+    return daemonConfigurationId(getApiKey());
+  } catch {
+    return null;
+  }
+};
+var parseDaemonLastError = (value) => {
+  if (typeof value !== "object" || value === null) return null;
+  const error = value;
+  return isString(error.message) && isTimestamp(error.at) ? { message: error.message, at: error.at } : null;
+};
+var parseDaemonState = (value) => {
+  if (typeof value !== "object" || value === null) return null;
+  const state = value;
+  if (!isString(state.instanceId) || !Number.isInteger(state.pid) || state.pid <= 0 || !isString(state.version) || !(state.configurationId === void 0 || state.configurationId === null || isString(state.configurationId)) || !isString(state.machineId) || !isTimestamp(state.startedAt) || !isTimestamp(state.updatedAt) || !(state.lastSuccessfulHeartbeatAt === null || isTimestamp(state.lastSuccessfulHeartbeatAt)) || !(state.lastSuccessfulControlAt === void 0 || state.lastSuccessfulControlAt === null || isTimestamp(state.lastSuccessfulControlAt))) return null;
+  return {
+    instanceId: state.instanceId,
+    pid: state.pid,
+    version: state.version,
+    configurationId: state.configurationId ?? null,
+    machineId: state.machineId,
+    startedAt: state.startedAt,
+    updatedAt: state.updatedAt,
+    lastSuccessfulHeartbeatAt: state.lastSuccessfulHeartbeatAt,
+    lastSuccessfulControlAt: state.lastSuccessfulControlAt ?? null,
+    lastError: parseDaemonLastError(state.lastError)
+  };
+};
+var parseLockOwner = (value) => {
+  if (typeof value !== "object" || value === null) return null;
+  const owner = value;
+  return isString(owner.instanceId) && Number.isInteger(owner.pid) && owner.pid > 0 ? { instanceId: owner.instanceId, pid: owner.pid } : null;
+};
+var readDaemonStatus = (options = {}) => {
+  const dir = options.dir ?? pusharyDir();
+  const installedVersion = options.installedVersion ?? getPackageVersion();
+  const state = readJsonSafe(statePath(dir));
+  if (state.kind === "missing") {
+    return {
+      kind: "absent",
+      installedVersion,
+      machineId: null,
+      pid: null,
+      processAlive: null,
+      daemonVersion: null,
+      startedAt: null,
+      updatedAt: null,
+      lastSuccessfulHeartbeatAt: null,
+      lastSuccessfulControlAt: null,
+      lastError: null
+    };
+  }
+  const value = state.kind === "ok" ? parseDaemonState(state.value) : null;
+  if (value) {
+    const alive = (options.isProcessAlive ?? processIsAlive)(value.pid);
+    const fresh = (options.now ?? Date.now)() - Date.parse(value.updatedAt) <= LOCAL_LEASE_TIMEOUT_MS;
+    const expectedConfigurationId2 = options.configurationId === void 0 ? currentConfigurationId() : options.configurationId;
+    return {
+      kind: !alive || !fresh ? "unresponsive" : value.version !== installedVersion ? "version-mismatch" : expectedConfigurationId2 !== null && value.configurationId !== null && value.configurationId !== expectedConfigurationId2 ? "configuration-mismatch" : "running",
+      installedVersion,
+      machineId: value.machineId,
+      pid: value.pid,
+      processAlive: alive,
+      daemonVersion: value.version,
+      startedAt: value.startedAt,
+      updatedAt: value.updatedAt,
+      lastSuccessfulHeartbeatAt: value.lastSuccessfulHeartbeatAt,
+      lastSuccessfulControlAt: value.lastSuccessfulControlAt,
+      lastError: value.lastError
+    };
+  }
+  return {
+    kind: "invalid",
+    installedVersion,
+    machineId: null,
+    pid: null,
+    processAlive: null,
+    daemonVersion: null,
+    startedAt: null,
+    updatedAt: null,
+    lastSuccessfulHeartbeatAt: null,
+    lastSuccessfulControlAt: null,
+    lastError: null
+  };
+};
+var safeUnlink = (path) => {
+  try {
+    unlinkSync(path);
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+};
+var requestDaemonVersion = (version, options = {}) => {
+  const dir = options.dir ?? pusharyDir();
+  const now = options.now ?? Date.now;
+  writeJsonAtomic(targetPath(dir), { version, requestedAt: new Date(now()).toISOString() }, 384);
+};
+var acquireDaemonLease = (options = {}) => {
+  const dir = options.dir ?? pusharyDir();
+  const installedVersion = options.installedVersion ?? getPackageVersion();
+  const machineId = options.machineId ?? getMachineId();
+  const pid = options.pid ?? process.pid;
+  const now = options.now ?? Date.now;
+  const instanceId = randomUUID();
+  const startedAt = new Date(now()).toISOString();
+  const writeLock = () => {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(lockPath(dir), JSON.stringify({ instanceId, pid }), { flag: "wx", mode: 384 });
+  };
+  try {
+    writeLock();
+  } catch (err) {
+    if (err.code !== "EEXIST") {
+      return { kind: "unavailable", detail: err instanceof Error ? err.message : String(err) };
+    }
+    const status = readDaemonStatus(options);
+    if (status.kind === "running" || status.kind === "version-mismatch" || status.kind === "configuration-mismatch") {
+      return { kind: "already-running", status };
+    }
+    const lock = readJsonSafe(lockPath(dir));
+    const owner = lock.kind === "ok" ? parseLockOwner(lock.value) : null;
+    if (!owner) return { kind: "unavailable", detail: "daemon lock is invalid" };
+    if ((options.isProcessAlive ?? processIsAlive)(owner.pid)) {
+      return { kind: "unavailable", detail: "daemon owner is still running or starting" };
+    }
+    const stale = join(dir, `daemon.lock.${instanceId}.stale`);
+    let ownsReplacement = false;
+    try {
+      renameSync(lockPath(dir), stale);
+      writeLock();
+      ownsReplacement = true;
+      safeUnlink(statePath(dir));
+      safeUnlink(stale);
+    } catch (retryError) {
+      if (ownsReplacement) safeUnlink(lockPath(dir));
+      try {
+        safeUnlink(stale);
+      } catch {
+      }
+      return { kind: "unavailable", detail: retryError instanceof Error ? retryError.message : String(retryError) };
+    }
+  }
+  const state = {
+    instanceId,
+    pid,
+    version: installedVersion,
+    configurationId: options.configurationId === void 0 ? currentConfigurationId() : options.configurationId,
+    machineId,
+    startedAt,
+    updatedAt: startedAt,
+    lastSuccessfulHeartbeatAt: null,
+    lastSuccessfulControlAt: null,
+    lastError: null
+  };
+  try {
+    writeJsonAtomic(statePath(dir), state, 384);
+  } catch (err) {
+    safeUnlink(lockPath(dir));
+    return { kind: "unavailable", detail: err instanceof Error ? err.message : String(err) };
+  }
+  let currentState = state;
+  const isOwner = () => {
+    const owner = readJsonSafe(lockPath(dir));
+    return owner.kind === "ok" && owner.value.instanceId === instanceId;
+  };
+  const updateState = (next) => {
+    if (!isOwner()) return;
+    try {
+      writeJsonAtomic(statePath(dir), next, 384);
+      currentState = next;
+    } catch {
+    }
+  };
+  return {
+    kind: "acquired",
+    lease: {
+      isOwner,
+      renew: (at = now()) => {
+        updateState({ ...currentState, updatedAt: new Date(at).toISOString() });
+      },
+      recordSuccessfulHeartbeat: (at = now()) => {
+        const timestamp = new Date(at).toISOString();
+        updateState({
+          ...currentState,
+          updatedAt: timestamp,
+          lastSuccessfulHeartbeatAt: timestamp
+        });
+      },
+      recordSuccessfulControl: (at = now()) => {
+        const timestamp = new Date(at).toISOString();
+        updateState({
+          ...currentState,
+          updatedAt: timestamp,
+          lastSuccessfulControlAt: timestamp
+        });
+      },
+      recordError: (message, at = now()) => {
+        const timestamp = new Date(at).toISOString();
+        updateState({
+          ...currentState,
+          updatedAt: timestamp,
+          lastError: { message: message.slice(0, 240), at: timestamp }
+        });
+      },
+      shouldYield: () => {
+        if (!isOwner()) return true;
+        const target = readJsonSafe(targetPath(dir));
+        return target.kind === "ok" && (typeof target.value.version === "string" && target.value.version !== installedVersion || isTimestamp(target.value.requestedAt) && Date.parse(target.value.requestedAt) > Date.parse(startedAt));
+      },
+      release: () => {
+        if (!isOwner()) return;
+        safeUnlink(statePath(dir));
+        safeUnlink(lockPath(dir));
+      }
+    }
+  };
+};
+var hasConfiguration = () => {
+  try {
+    getApiKey();
+    return true;
+  } catch {
+    return false;
+  }
+};
+var wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var requestDaemonHandoff = async (initial, options = {}) => {
+  const now = options.now ?? Date.now;
+  const requestedAt = Math.max(
+    now(),
+    initial.startedAt === null ? 0 : Date.parse(initial.startedAt) + 1
+  );
+  requestDaemonVersion(options.installedVersion ?? initial.installedVersion, {
+    dir: options.dir,
+    now: () => requestedAt
+  });
+  if (initial.pid === null || initial.processAlive !== true) return initial;
+  const sleep = options.sleep ?? wait;
+  const pollIntervalMs = options.pollIntervalMs ?? 50;
+  const attempts = Math.max(1, Math.ceil((options.waitTimeoutMs ?? 5e3) / pollIntervalMs));
+  let status = initial;
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    await sleep(pollIntervalMs);
+    status = readDaemonStatus(options);
+    if (status.pid !== initial.pid || status.processAlive !== true) break;
+  }
+  return status;
+};
+var stopDaemonRunning = async (options = {}) => {
+  const dir = options.dir ?? pusharyDir();
+  const initial = readDaemonStatus(options);
+  if (initial.pid === null || initial.processAlive !== true) {
+    safeUnlink(statePath(dir));
+    safeUnlink(lockPath(dir));
+    return { kind: "absent" };
+  }
+  let status;
+  try {
+    status = await requestDaemonHandoff(initial, options);
+  } catch (err) {
+    return { kind: "unavailable", detail: err instanceof Error ? err.message : String(err) };
+  }
+  if (status.pid === initial.pid && status.processAlive === true) {
+    return { kind: "unavailable", detail: "daemon did not stop" };
+  }
+  safeUnlink(statePath(dir));
+  safeUnlink(lockPath(dir));
+  return { kind: "stopped" };
+};
+var needsLoginPath = (dir) => join(dir, "daemon-needs-login.json");
+var isLoginReason = (value) => value === "key_rejected" || value === "plan_inactive";
+var parseDaemonNeedsLogin = (value) => {
+  if (typeof value !== "object" || value === null) return null;
+  const record = value;
+  if (!isLoginReason(record.reason) || !isTimestamp(record.at)) return null;
+  if (!(record.configurationId === null || isString(record.configurationId))) return null;
+  return { reason: record.reason, at: record.at, configurationId: record.configurationId };
+};
+var expectedConfigurationId = (options) => options.configurationId === void 0 ? currentConfigurationId() : options.configurationId;
+var writeDaemonNeedsLogin = (reason, options = {}) => {
+  const record = {
+    reason,
+    at: new Date((options.now ?? Date.now)()).toISOString(),
+    configurationId: expectedConfigurationId(options)
+  };
+  writeJsonAtomic(needsLoginPath(options.dir ?? pusharyDir()), record, 384);
+  return record;
+};
+var readDaemonNeedsLogin = (options = {}) => {
+  const stored = readJsonSafe(needsLoginPath(options.dir ?? pusharyDir()));
+  const record = stored.kind === "ok" ? parseDaemonNeedsLogin(stored.value) : null;
+  if (!record) return { kind: "none" };
+  return record.configurationId === expectedConfigurationId(options) ? { kind: "blocked", record } : { kind: "stale", record };
+};
+var clearDaemonNeedsLogin = (options = {}) => {
+  const path = needsLoginPath(options.dir ?? pusharyDir());
+  if (!existsSync(path)) return false;
+  safeUnlink(path);
+  return true;
+};
+var describeDaemonLoginBlock = (record) => record.reason === "key_rejected" ? `this machine's key was rejected at ${record.at}; run \`pushary login\` to sign in again` : `this workspace had no active plan at ${record.at}; pick one at pushary.com/dashboard/settings?tab=billing, then run \`pushary login\``;
+var recoverDaemonAfterLogin = (options = {}) => {
+  const cleared = clearDaemonNeedsLogin(options);
+  if (!cleared || readControlMode(join(options.dir ?? pusharyDir(), "config.json")) === "off" || !hasDaemonServiceDefinition(options)) {
+    return { cleared, restarted: false, detail: null };
+  }
+  const started = manageDaemonService("start", options);
+  return started.kind === "ok" ? { cleared, restarted: true, detail: null } : { cleared, restarted: false, detail: started.detail };
+};
+var deactivateDaemonService = async (action, options) => {
+  const platform = options.platform ?? process.platform;
+  const supported = ["darwin", "linux", "win32"].includes(platform);
+  const managerAvailable = supported && daemonServiceManagerAvailable(options);
+  const absenceMustBeProven = options.requireAbsenceProof || hasDaemonServiceDefinition(options);
+  const service = supported && !managerAvailable && absenceMustBeProven ? { kind: "failed", detail: "Native background-service manager is unavailable" } : managerAvailable ? manageDaemonService(action, options) : { kind: "ok" };
+  const stopped = await stopDaemonRunning(options);
+  const failures = [
+    service.kind === "ok" ? null : service.detail,
+    stopped.kind === "unavailable" ? stopped.detail : null
+  ].filter((detail) => detail !== null);
+  return failures.length > 0 ? { kind: "failed", detail: failures.join("; ") } : { kind: "ok" };
+};
+var stopDaemonService = async (options = {}) => deactivateDaemonService("stop", options);
+var disableDaemonService = async (options = {}) => deactivateDaemonService("uninstall", options);
+var parseDaemonServiceTransaction = (value) => {
+  if (typeof value !== "object" || value === null) return null;
+  const transaction = value;
+  if (transaction.version !== 1 || transaction.phase !== "prepared" && transaction.phase !== "committed" || typeof transaction.definitionPath !== "string" || !(transaction.previousContents === null || typeof transaction.previousContents === "string") || !(transaction.previousEncoding === void 0 || typeof transaction.previousEncoding === "string") || typeof transaction.previousRegistered !== "boolean" || !(transaction.previousEnabled === void 0 || typeof transaction.previousEnabled === "boolean") || typeof transaction.previousRunning !== "boolean") return null;
+  return {
+    ...transaction,
+    previousEnabled: typeof transaction.previousEnabled === "boolean" ? transaction.previousEnabled : transaction.previousRegistered
+  };
+};
+var probeDaemonServiceState = (definition, run) => {
+  let registered = true;
+  try {
+    run(definition.registrationProbe.command, definition.registrationProbe.args);
+  } catch (err) {
+    if (!isExpectedProbeFailure(definition.registrationProbe, err)) {
+      return {
+        kind: "failed",
+        detail: `Could not inspect native service registration: ${commandFailureOutput(err) || String(err)}`
+      };
+    }
+    registered = false;
+  }
+  let enabled = registered;
+  const enabledProbe = definition.enabledProbe;
+  if (enabledProbe) {
+    try {
+      const output = run(enabledProbe.command, enabledProbe.args);
+      enabled = !(enabledProbe.disabledOutputPattern && typeof output === "string" && enabledProbe.disabledOutputPattern.test(output));
+    } catch (err) {
+      if (!isExpectedProbeFailure(enabledProbe, err)) {
+        return {
+          kind: "failed",
+          detail: `Could not inspect whether the native service is enabled: ${commandFailureOutput(err) || String(err)}`
+        };
+      }
+      enabled = false;
+    }
+  }
+  try {
+    const output = run(definition.runningProbe.command, definition.runningProbe.args);
+    const running = definition.runningProbe.outputPattern ? typeof output === "string" && definition.runningProbe.outputPattern.test(output) : true;
+    return { kind: "ok", registered, enabled, running };
+  } catch (err) {
+    if (!isExpectedProbeFailure(definition.runningProbe, err)) {
+      return {
+        kind: "failed",
+        detail: `Could not inspect whether the native service is running: ${commandFailureOutput(err) || String(err)}`
+      };
+    }
+    return { kind: "ok", registered, enabled, running: false };
+  }
+};
+var previousEncoding = (snapshot) => snapshot.previousEncoding ?? "utf-8";
+var restoreDaemonServiceSnapshot = (definition, snapshot, run) => {
+  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));
+  } catch (err) {
+    return {
+      kind: "failed",
+      detail: `could not restore the previous definition: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  if (!snapshot.previousRegistered) {
+    const reload = definition.reloadAfterUninstall;
+    if (snapshot.previousContents !== null && reload) {
+      try {
+        run(reload.command, reload.args);
+      } catch (err) {
+        return { kind: "failed", detail: `could not reload the previous definition: ${commandFailureOutput(err) || String(err)}` };
+      }
+    }
+    if (snapshot.previousRunning) {
+      const started = applyDaemonService("start", definition, { run });
+      if (started.kind !== "ok") return started;
+    }
+    if (!snapshot.previousEnabled && definition.canDisableWhenUnregistered) {
+      try {
+        runDaemonServiceSteps(definition.disable, run);
+      } catch (err) {
+        return { kind: "failed", detail: `could not restore the previous disabled state: ${commandFailureOutput(err) || String(err)}` };
+      }
+    }
+    const state2 = probeDaemonServiceState(definition, run);
+    if (state2.kind !== "ok") return { kind: "failed", detail: state2.detail };
+    if (state2.registered || state2.enabled !== snapshot.previousEnabled || state2.running !== snapshot.previousRunning) {
+      return { kind: "failed", detail: "could not restore the previous unregistered service state" };
+    }
+    return { kind: "ok" };
+  }
+  if (snapshot.previousContents === null) {
+    return { kind: "failed", detail: "the previous registered service had no recoverable definition" };
+  }
+  const restored = applyDaemonService("install", {
+    ...definition,
+    contents: snapshot.previousContents,
+    encoding: previousEncoding(snapshot)
+  }, { run });
+  if (restored.kind !== "ok") return restored;
+  if (!snapshot.previousRunning) applyDaemonService("stop", definition, { run });
+  if (!snapshot.previousEnabled) {
+    try {
+      runDaemonServiceSteps(definition.disable, run);
+    } catch (err) {
+      return { kind: "failed", detail: `could not restore the previous disabled state: ${commandFailureOutput(err) || String(err)}` };
+    }
+  }
+  const state = probeDaemonServiceState(definition, run);
+  if (state.kind !== "ok") return { kind: "failed", detail: state.detail };
+  if (!state.registered) return { kind: "failed", detail: "the previous service is no longer registered" };
+  if (state.enabled !== snapshot.previousEnabled) {
+    return { kind: "failed", detail: "could not restore whether the previous service was enabled" };
+  }
+  if (state.running !== snapshot.previousRunning) {
+    return {
+      kind: "failed",
+      detail: snapshot.previousRunning ? "the previous service did not restart" : "could not restore the previous stopped state"
+    };
+  }
+  return { kind: "ok" };
+};
+var recoverDaemonServiceTransaction = (definition, path, run) => {
+  const stored = readJsonSafe(path);
+  if (stored.kind === "missing") return { kind: "ok" };
+  if (stored.kind !== "ok") {
+    return { kind: "failed", detail: `transaction receipt is ${stored.kind}` };
+  }
+  const transaction = parseDaemonServiceTransaction(stored.value);
+  if (!transaction) return { kind: "failed", detail: "transaction receipt is invalid" };
+  if (transaction.definitionPath !== definition.definitionPath) {
+    return { kind: "failed", detail: "transaction receipt belongs to a different service definition" };
+  }
+  if (transaction.phase === "prepared") {
+    const restored = restoreDaemonServiceSnapshot(definition, transaction, run);
+    if (restored.kind !== "ok") return restored;
+  }
+  try {
+    safeUnlink(path);
+  } catch (err) {
+    return { kind: "failed", detail: `could not clear transaction receipt: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  return { kind: "ok" };
+};
+var replaceDaemonService = async (options = {}) => {
+  const definition = resolveDaemonServiceDefinition(options);
+  if (!definition) {
+    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);
+  if (recovered.kind !== "ok") {
+    return { kind: "failed", detail: `Could not recover interrupted service replacement: ${recovered.detail}` };
+  }
+  let previousContents = null;
+  let previousDefinitionEncoding = "utf-8";
+  try {
+    if (existsSync(definition.definitionPath)) {
+      const previous = readServiceDefinitionFile(definition.definitionPath);
+      previousContents = previous.contents;
+      previousDefinitionEncoding = previous.encoding;
+    }
+  } catch (err) {
+    return { kind: "failed", detail: `Could not snapshot the existing service: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  const previousState = probeDaemonServiceState(definition, run);
+  if (previousState.kind !== "ok") return { kind: "failed", detail: previousState.detail };
+  if ((previousState.registered || previousState.running) && previousContents === null) {
+    return { kind: "failed", detail: "Could not replace an active native service with no recoverable definition" };
+  }
+  const transaction = {
+    version: 1,
+    phase: "prepared",
+    definitionPath: definition.definitionPath,
+    previousContents,
+    previousEncoding: previousDefinitionEncoding,
+    previousRegistered: previousState.registered,
+    previousEnabled: previousState.enabled,
+    previousRunning: previousState.running
+  };
+  try {
+    writeJsonAtomicDurable(transactionPath, transaction, 384);
+  } catch (err) {
+    return { kind: "failed", detail: `Could not persist the service rollback snapshot: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  const stopped = await stopDaemonRunning(options);
+  if (stopped.kind === "unavailable") {
+    try {
+      safeUnlink(transactionPath);
+    } catch (err) {
+      return {
+        kind: "failed",
+        detail: `${stopped.detail}; could not clear unused rollback evidence: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+    return stopped;
+  }
+  let installed = applyDaemonService("install", definition, { run });
+  if (installed.kind === "ok") {
+    const sleep = options.sleep ?? wait;
+    const pollIntervalMs = Math.max(1, options.pollIntervalMs ?? 50);
+    const now = options.now ?? Date.now;
+    const deadline = now() + Math.max(0, options.waitTimeoutMs ?? 5e3);
+    let state = probeDaemonServiceState(definition, run);
+    while (state.kind === "ok" && (!state.registered || !state.enabled || !state.running) && now() < deadline) {
+      await sleep(pollIntervalMs);
+      state = probeDaemonServiceState(definition, run);
+    }
+    if (state.kind !== "ok") {
+      installed = { kind: "failed", detail: state.detail };
+    } else if (!state.registered || !state.enabled || !state.running) {
+      installed = {
+        kind: "failed",
+        detail: !state.registered ? "Service registration verification failed" : !state.enabled ? "Service enable verification failed" : "Service start verification failed"
+      };
+    }
+  }
+  if (installed.kind === "ok") {
+    try {
+      writeJsonAtomicDurable(transactionPath, { ...transaction, phase: "committed" }, 384);
+    } catch (err) {
+      const detail = `Could not commit the service replacement: ${err instanceof Error ? err.message : String(err)}`;
+      const recovered2 = recoverDaemonServiceTransaction(definition, transactionPath, run);
+      return recovered2.kind === "ok" ? { kind: "failed", detail } : {
+        kind: "failed",
+        detail: `${detail}; recovery failed: ${recovered2.detail}`
+      };
+    }
+    try {
+      safeUnlink(transactionPath);
+      return installed;
+    } catch (err) {
+      return {
+        kind: "failed",
+        detail: `Service replacement committed but its receipt could not be cleared: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+  }
+  const restored = restoreDaemonServiceSnapshot(definition, transaction, run);
+  if (restored.kind !== "ok") {
+    return { kind: "failed", detail: `${installed.detail}; rollback failed: ${restored.detail}` };
+  }
+  try {
+    safeUnlink(transactionPath);
+  } catch (err) {
+    return {
+      kind: "failed",
+      detail: `${installed.detail}; previous service restored but recovery evidence could not be cleared: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  return {
+    kind: "failed",
+    detail: `${installed.detail}; ${transaction.previousRegistered ? "previous service restored" : "previous service state restored"}`
+  };
+};
+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 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");
+  const plan = buildDaemonLaunch({
+    siblingEntry,
+    execPath: options.execPath ?? process.execPath,
+    daemonBinary,
+    platform
+  });
+  spawnDetachedDaemon(plan, { spawnImpl: options.spawnImpl });
+};
+var ensureDaemonRunning = async (options = {}) => {
+  const initial = readDaemonStatus(options);
+  if (!(options.configured ?? hasConfiguration)()) {
+    return { kind: "not-configured", status: initial, detail: "Pushary is not configured on this machine" };
+  }
+  if (initial.kind === "running") return { kind: "running", status: initial };
+  const loginBlock = readDaemonNeedsLogin(options);
+  if (loginBlock.kind === "blocked") {
+    return { kind: "unavailable", status: initial, detail: describeDaemonLoginBlock(loginBlock.record) };
+  }
+  let handoffStatus;
+  try {
+    handoffStatus = await requestDaemonHandoff(initial, options);
+  } catch (err) {
+    return {
+      kind: "unavailable",
+      status: initial,
+      detail: err instanceof Error ? err.message : String(err)
+    };
+  }
+  const sleep = options.sleep ?? wait;
+  const pollIntervalMs = options.pollIntervalMs ?? 50;
+  const attempts = Math.max(1, Math.ceil((options.waitTimeoutMs ?? 5e3) / pollIntervalMs));
+  if (handoffStatus.kind === "running") return { kind: "running", status: handoffStatus };
+  if (daemonNeedsHandoff(handoffStatus)) {
+    return { kind: "unavailable", status: handoffStatus, detail: "unhealthy daemon did not yield" };
+  }
+  try {
+    (options.spawnDaemon ?? (() => launchInstalledDaemon(options)))();
+  } catch (err) {
+    return {
+      kind: "unavailable",
+      status: initial,
+      detail: err instanceof Error ? err.message : String(err)
+    };
+  }
+  let status = initial;
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    status = readDaemonStatus(options);
+    if (status.kind === "running") return { kind: "started", status };
+    await sleep(pollIntervalMs);
+  }
+  return { kind: "unavailable", status, detail: `daemon did not become healthy (${status.kind})` };
+};
+var waitForDaemonRemoteProof = async (options = {}) => {
+  const sleep = options.sleep ?? wait;
+  const pollIntervalMs = options.pollIntervalMs ?? 250;
+  const attempts = Math.max(1, Math.ceil((options.waitTimeoutMs ?? 5e3) / pollIntervalMs));
+  let status = readDaemonStatus(options);
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    status = readDaemonStatus(options);
+    if (daemonHasRemoteProof(status)) return status;
+    if (attempt + 1 < attempts) await sleep(pollIntervalMs);
+  }
+  return status;
+};
+
+export {
+  daemonHasRemoteProof,
+  daemonServiceManagerAvailable,
+  DAEMON_LEASE_RENEW_INTERVAL_MS,
+  parseDaemonAction,
+  manageDaemonService,
+  hasDaemonServiceDefinition,
+  daemonServiceDefinitionPath,
+  readInstalledDaemonService,
+  readDaemonStatus,
+  acquireDaemonLease,
+  requestDaemonHandoff,
+  stopDaemonRunning,
+  writeDaemonNeedsLogin,
+  readDaemonNeedsLogin,
+  clearDaemonNeedsLogin,
+  describeDaemonLoginBlock,
+  recoverDaemonAfterLogin,
+  stopDaemonService,
+  disableDaemonService,
+  replaceDaemonService,
+  ensureDaemonRunning,
+  waitForDaemonRemoteProof
+};