pushary 1.8.0

package/dist/bin/pushary-upgrade.js

@@ -0,0 +1,599 @@
+#!/usr/bin/env node
+import {
+  describeCodexTrustConfirmation
+} from "../chunk-TY4JT7W3.js";
+import {
+  ensureCodexTrustAfterReapply,
+  reapplyAllAgents
+} from "../chunk-VQKRG3AC.js";
+import "../chunk-SIFVFP6T.js";
+import "../chunk-RHR6NARM.js";
+import {
+  waitForMachineReadiness
+} from "../chunk-DE4Y6TCC.js";
+import "../chunk-AXPCESYO.js";
+import {
+  detectProviderLiveCapabilities,
+  hasSpawnProvider,
+  resolveControlPolicy
+} from "../chunk-HQ6G3B5R.js";
+import {
+  AUTO_UPDATE_DISABLE_ENV,
+  describeAutoUpdateCheck,
+  globalInstallLocation,
+  hasPendingUpgradeFinish,
+  isAutoUpdateDisabledByEnv,
+  parseAutoUpdateFlag,
+  readAutoUpdateState,
+  updateAutoUpdateState,
+  upgradeEntryFor
+} from "../chunk-UI36QSBI.js";
+import "../chunk-6J2JC2RT.js";
+import {
+  daemonHasRemoteProof,
+  daemonServiceManagerAvailable,
+  disableDaemonService,
+  ensureDaemonRunning,
+  hasDaemonServiceDefinition,
+  readDaemonStatus,
+  replaceDaemonService,
+  stopDaemonService,
+  waitForDaemonRemoteProof
+} from "../chunk-WE2J62NC.js";
+import "../chunk-3EVPNIBE.js";
+import "../chunk-XHKBHWLX.js";
+import "../chunk-EPCXUP3P.js";
+import "../chunk-POFBE6ZY.js";
+import {
+  exitOnHelpFlag
+} from "../chunk-HZVVNGEW.js";
+import {
+  readControlMode
+} from "../chunk-P7WQEVWA.js";
+import "../chunk-LXQ5FBBD.js";
+import {
+  EXIT
+} from "../chunk-KZERVKTD.js";
+import "../chunk-DB3ONZB4.js";
+import {
+  LATEST_TAG,
+  autoUpdateLock,
+  autoUpdateLog,
+  autoUpdateState,
+  claudeJson,
+  codexConfigToml,
+  cursorPluginDir,
+  execNpm,
+  fetchLatestPublishedVersion,
+  geminiSettings,
+  installPackageGlobally,
+  npmErrorMessage,
+  readGlobalCliInstallAt,
+  readGlobalPrefix,
+  vscodePluginDir
+} from "../chunk-A2A2YTMG.js";
+import "../chunk-T7E75EKA.js";
+import {
+  getApiKey
+} from "../chunk-GPEGOGRJ.js";
+import {
+  NPX_LATEST_COMMAND
+} from "../chunk-E4FJTUH4.js";
+import {
+  CANONICAL_PACKAGE,
+  LEGACY_PACKAGE,
+  commandsPackage,
+  globalUpgradeEntry,
+  isNewerVersion,
+  isReleaseVersion,
+  isSameMajorVersion,
+  ownPackageRoot,
+  packageVersionAt
+} from "../chunk-NQTHFF4W.js";
+
+// bin/pushary-upgrade.ts
+import { existsSync as existsSync2 } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+// src/global-upgrade.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { existsSync } from "fs";
+
+// src/auto-update-run.ts
+import { execFileSync } from "child_process";
+import { closeSync, mkdirSync, openSync, readFileSync, statSync, unlinkSync, writeSync } from "fs";
+import { dirname } from "path";
+var FINISH_UPGRADE_FLAG = "--finish-upgrade";
+var LOCK_STALE_MS = 10 * 60 * 1e3;
+var INSTALL_TIMEOUT_MS = 12e4;
+var FINISH_TIMEOUT_MS = 5 * 60 * 1e3;
+var LOG_LIMIT_BYTES = 256 * 1024;
+var UNREADABLE_INSTALLED_VERSION = "could not read the installed version";
+var UNREACHABLE_REGISTRY = "could not read the latest version from the npm registry";
+var MANUAL_UPGRADE_COMMAND = `${NPX_LATEST_COMMAND} upgrade`;
+var isAlreadyExists = (error) => error instanceof Error && "code" in error && error.code === "EEXIST";
+var createLock = (lockPath, now) => {
+  const handle = openSync(lockPath, "wx");
+  try {
+    writeSync(handle, `${JSON.stringify({ pid: process.pid, at: new Date(now).toISOString() })}
+`);
+  } finally {
+    closeSync(handle);
+  }
+};
+var tryCreateLock = (lockPath, now) => {
+  try {
+    createLock(lockPath, now);
+    return "acquired";
+  } catch (error) {
+    if (isAlreadyExists(error)) return "held";
+    throw error;
+  }
+};
+var isStaleLock = (lockPath, now) => {
+  const modifiedAt = statSync(lockPath, { throwIfNoEntry: false })?.mtimeMs;
+  return modifiedAt !== void 0 && now - modifiedAt > LOCK_STALE_MS;
+};
+var takeOverLock = (lockPath, now) => {
+  try {
+    unlinkSync(lockPath);
+  } catch {
+    return "held";
+  }
+  return tryCreateLock(lockPath, now);
+};
+var isAbandonedLock = (evidence) => evidence.stale || evidence.holderPid !== void 0 && !evidence.holderAlive;
+var lockHolderPid = (lockPath) => {
+  try {
+    const holder = JSON.parse(readFileSync(lockPath, "utf8"));
+    const pid = holder && typeof holder === "object" && "pid" in holder ? holder.pid : void 0;
+    return typeof pid === "number" && Number.isInteger(pid) && pid > 0 ? pid : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var isProcessAlive = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error instanceof Error && "code" in error && error.code === "EPERM";
+  }
+};
+var readLockHolder = (lockPath, now, isAlive) => {
+  const holderPid = lockHolderPid(lockPath);
+  return {
+    holderPid,
+    holderAlive: holderPid !== void 0 && isAlive(holderPid),
+    stale: isStaleLock(lockPath, now)
+  };
+};
+var acquireAutoUpdateLock = (lockPath, now) => {
+  mkdirSync(dirname(lockPath), { recursive: true });
+  if (tryCreateLock(lockPath, now) === "acquired") return "acquired";
+  if (!isStaleLock(lockPath, now)) return "held";
+  return takeOverLock(lockPath, now);
+};
+var releaseAutoUpdateLock = (lockPath) => {
+  try {
+    unlinkSync(lockPath);
+  } catch {
+    return;
+  }
+};
+var upgradeLockVerdict = (evidence) => {
+  if (evidence.holderPid !== void 0 && evidence.holderPid === evidence.parentPid) return "inherited";
+  if (isAbandonedLock(evidence)) return "take_over";
+  return "held";
+};
+var claimUpgradeLockAt = (lockPath, request) => {
+  const now = request.now ?? Date.now();
+  mkdirSync(dirname(lockPath), { recursive: true });
+  if (tryCreateLock(lockPath, now) === "acquired") return { kind: "acquired" };
+  const holder = readLockHolder(lockPath, now, request.isAlive ?? isProcessAlive);
+  const verdict = upgradeLockVerdict({ ...holder, parentPid: request.parentPid ?? process.ppid });
+  if (verdict === "inherited") return { kind: "inherited" };
+  if (verdict === "take_over" && takeOverLock(lockPath, now) === "acquired") return { kind: "acquired" };
+  return { kind: "held", holderPid: holder.holderPid };
+};
+var claimUpgradeLock = (request = {}) => {
+  try {
+    return claimUpgradeLockAt(request.lockPath ?? autoUpdateLock(), request);
+  } catch {
+    return { kind: "unavailable" };
+  }
+};
+var openAutoUpdateLog = (logPath) => {
+  mkdirSync(dirname(logPath), { recursive: true });
+  const size = statSync(logPath, { throwIfNoEntry: false })?.size ?? 0;
+  return openSync(logPath, size > LOG_LIMIT_BYTES ? "w" : "a");
+};
+var appendAutoUpdateLog = (logPath, line) => {
+  try {
+    const handle = openAutoUpdateLog(logPath);
+    try {
+      writeSync(handle, `${line}
+`);
+    } finally {
+      closeSync(handle);
+    }
+  } catch {
+    return;
+  }
+};
+var finishInNewInstall = (request) => {
+  const handle = openAutoUpdateLog(request.logPath);
+  try {
+    execFileSync(process.execPath, [request.entry, FINISH_UPGRADE_FLAG], {
+      stdio: ["ignore", handle, handle],
+      env: { ...process.env, npm_config_prefix: request.prefix },
+      timeout: FINISH_TIMEOUT_MS
+    });
+  } finally {
+    closeSync(handle);
+  }
+};
+var incompleteFinishDetail = (logPath) => `installed, but refreshing the agent configs did not finish cleanly; see ${logPath}`;
+var newMajorDetail = (latest) => `${latest} is a new major version; run ${MANUAL_UPGRADE_COMMAND}`;
+var finishInstalledUpgrade = (context, from, to) => {
+  const pending = { result: "finish_pending", from, to, detail: incompleteFinishDetail(context.logPath) };
+  recordAutoUpdateCheck(context.statePath, pending, new Date(context.now()).toISOString());
+  try {
+    context.finish({ entry: upgradeEntryFor(context.location), prefix: context.location.prefix, logPath: context.logPath });
+    return { result: "updated", from, to };
+  } catch {
+    return pending;
+  }
+};
+var isInstallableRelease = (latest, installed) => latest !== void 0 && isNewerVersion(latest, installed) && isSameMajorVersion(latest, installed);
+var checkAndInstall = async (context) => {
+  const installed = packageVersionAt(context.packageRoot);
+  if (installed === void 0 || !isReleaseVersion(installed)) {
+    return { result: "failed", from: installed, detail: UNREADABLE_INSTALLED_VERSION };
+  }
+  const previous = readAutoUpdateState(context.statePath);
+  const pendingFinish = hasPendingUpgradeFinish(previous, installed);
+  const latest = await fetchLatestPublishedVersion({ packageName: context.location.packageName, fetchImpl: context.fetchImpl });
+  if (pendingFinish && !isInstallableRelease(latest, installed)) return finishInstalledUpgrade(context, previous.from, installed);
+  if (latest === void 0) return { result: "failed", from: installed, detail: UNREACHABLE_REGISTRY };
+  if (!isNewerVersion(latest, installed)) return { result: "current", from: installed };
+  if (!isSameMajorVersion(latest, installed)) {
+    return { result: "needs_manual", from: installed, to: latest, detail: newMajorDetail(latest) };
+  }
+  appendAutoUpdateLog(context.logPath, `${new Date(context.now()).toISOString()} installing ${context.location.packageName}@${latest} into ${context.location.prefix}`);
+  try {
+    installPackageGlobally({
+      packageName: context.location.packageName,
+      version: latest,
+      prefix: context.location.prefix,
+      timeoutMs: INSTALL_TIMEOUT_MS
+    }, context.runNpm);
+  } catch (error) {
+    if (pendingFinish) return finishInstalledUpgrade(context, previous.from, installed);
+    return { result: "failed", from: installed, to: latest, detail: npmErrorMessage(error) };
+  }
+  return finishInstalledUpgrade(context, installed, latest);
+};
+var recordAutoUpdateCheck = (statePath, check, at) => updateAutoUpdateState(statePath, {
+  lastCheckAt: at,
+  lastResult: check.result,
+  from: check.from,
+  to: check.to,
+  at,
+  detail: check.detail,
+  announced: check.result === "updated" ? false : void 0
+});
+var runAutoUpdate = async (run = {}) => {
+  if ((run.platform ?? process.platform) === "linux") return { kind: "linux" };
+  const packageRoot = run.packageRoot ?? ownPackageRoot();
+  const location = packageRoot === void 0 ? null : globalInstallLocation(packageRoot);
+  if (packageRoot === void 0 || location === null) return { kind: "not_global_install" };
+  const now = run.now ?? Date.now;
+  const lockPath = run.lockPath ?? autoUpdateLock();
+  const logPath = run.logPath ?? autoUpdateLog();
+  if (acquireAutoUpdateLock(lockPath, now()) === "held") return { kind: "locked" };
+  try {
+    const check = await checkAndInstall({
+      packageRoot,
+      statePath: run.statePath ?? autoUpdateState(),
+      location,
+      logPath,
+      now,
+      fetchImpl: run.fetchImpl ?? fetch,
+      runNpm: run.runNpm ?? execNpm,
+      finish: run.finish ?? finishInNewInstall
+    });
+    const at = new Date(now()).toISOString();
+    const state = recordAutoUpdateCheck(run.statePath ?? autoUpdateState(), check, at);
+    appendAutoUpdateLog(logPath, `${at} ${describeAutoUpdateCheck(state)}`);
+    return { kind: "recorded", state };
+  } finally {
+    releaseAutoUpdateLock(lockPath);
+  }
+};
+
+// src/global-upgrade.ts
+var NOT_INSTALLED = { kind: "not_installed" };
+var globalUpgradeSubject = (prefix, install) => {
+  if (prefix === void 0) return NOT_INSTALLED;
+  const commands = commandsPackage(install);
+  if (commands?.version !== void 0) return { kind: "installed", prefix, name: commands.name, version: commands.version };
+  return install.kind === "both" ? { kind: "both_installed" } : NOT_INSTALLED;
+};
+var readGlobalUpgradeSubject = (platform = process.platform) => {
+  const prefix = readGlobalPrefix();
+  return globalUpgradeSubject(prefix, prefix === void 0 ? { kind: "unavailable" } : readGlobalCliInstallAt(prefix, platform));
+};
+var finishWithThisNode = (entry) => {
+  execFileSync2(process.execPath, [entry, FINISH_UPGRADE_FLAG], { stdio: "inherit" });
+};
+var finishGlobalUpgrade = (subject, platform = process.platform, runFinish = finishWithThisNode) => {
+  const entry = globalUpgradeEntry(subject.prefix, subject.name, platform);
+  if (!existsSync(entry)) return { kind: "entry_missing", entry };
+  try {
+    runFinish(entry);
+    return { kind: "finished" };
+  } catch {
+    return { kind: "failed" };
+  }
+};
+var describeHeldUpgradeLock = (holderPid) => `Another Pushary upgrade is already running${holderPid === void 0 ? "" : ` (pid ${holderPid})`}. Try again when it has finished.`;
+var withUpgradeLock = async (run, request = {}) => {
+  const claim = claimUpgradeLock(request);
+  if (claim.kind === "held") return { kind: "refused", exitCode: EXIT.FAILED, message: describeHeldUpgradeLock(claim.holderPid) };
+  try {
+    await run();
+  } finally {
+    if (claim.kind === "acquired") releaseAutoUpdateLock(request.lockPath ?? autoUpdateLock());
+  }
+  return { kind: "ran" };
+};
+var describeUpgradeStart = (subject, latest) => `Upgrading ${subject.name} ${subject.version} -> ${latest ?? "latest"}`;
+var upgradeInstalledPackage = async (subject, effects) => {
+  const pendingFinish = effects.hasPendingFinish(subject.version);
+  const latest = await effects.fetchLatest(subject.name);
+  const newerPublished = latest !== void 0 && isNewerVersion(latest, subject.version);
+  if (pendingFinish && !newerPublished) {
+    const finish = effects.finish(subject);
+    if (finish.kind !== "finished") return { kind: "pending_finish_failed", finish };
+    effects.recordFinished();
+  }
+  if (latest !== void 0 && !newerPublished) return { kind: "current", version: subject.version };
+  effects.announce(describeUpgradeStart(subject, latest));
+  try {
+    effects.install(subject.name);
+  } catch (error) {
+    return { kind: "install_failed", detail: npmErrorMessage(error) };
+  }
+  return { kind: "installed", finish: effects.finish(subject) };
+};
+
+// bin/pushary-upgrade.ts
+exitOnHelpFlag("upgrade");
+var detectInstallModes = () => {
+  const candidates = [
+    {
+      label: "Cursor plugin",
+      upgrade: "updates itself through Cursor",
+      present: existsSync2(cursorPluginDir())
+    },
+    {
+      label: "VS Code plugin",
+      upgrade: "npx @pushary/agent-hooks@latest setup --agents vscode",
+      present: existsSync2(vscodePluginDir())
+    },
+    {
+      label: "Codex config",
+      upgrade: "npx @pushary/agent-hooks@latest setup --agents codex",
+      present: existsSync2(codexConfigToml())
+    },
+    {
+      label: "Claude Code config",
+      upgrade: "npx @pushary/agent-hooks@latest setup --agents claude_code",
+      present: existsSync2(claudeJson())
+    },
+    {
+      label: "Gemini config",
+      upgrade: "npx @pushary/agent-hooks@latest setup --agents gemini_cli",
+      present: existsSync2(geminiSettings())
+    },
+    {
+      label: "Hermes plugin (pip)",
+      upgrade: "npx @pushary/agent-hooks@latest setup --agents hermes",
+      present: existsSync2(join(homedir(), ".hermes"))
+    }
+  ];
+  return candidates.filter((candidate) => candidate.present).map(({ label, upgrade }) => ({ label, upgrade }));
+};
+var finishUpgrade = async () => {
+  let apiKey;
+  try {
+    apiKey = getApiKey();
+  } catch {
+    apiKey = void 0;
+  }
+  const inspectedAgents = reapplyAllAgents(apiKey);
+  const codexTrust = await ensureCodexTrustAfterReapply(inspectedAgents);
+  const refreshed = inspectedAgents.filter((agent) => agent.result.reapplied);
+  const failedRefreshes = inspectedAgents.filter((agent) => agent.result.failed);
+  const configuredControlProviders = inspectedAgents.filter((agent) => agent.result.configured && (agent.id === "claude" || agent.id === "codex" || agent.id === "gemini")).map((agent) => agent.id);
+  const controlMode = readControlMode();
+  const daemonStatus = readDaemonStatus();
+  const serviceWasPresent = daemonStatus.kind !== "absent" || hasDaemonServiceDefinition();
+  const controlCapabilities = detectProviderLiveCapabilities(configuredControlProviders);
+  const controlPolicy = resolveControlPolicy({
+    mode: controlMode,
+    providerAvailable: hasSpawnProvider(controlCapabilities),
+    managerAvailable: daemonServiceManagerAvailable(),
+    servicePresent: serviceWasPresent
+  });
+  let daemonReady = true;
+  let legacyStopFailure = null;
+  if (controlPolicy === "disabled" && serviceWasPresent) {
+    daemonReady = (await disableDaemonService()).kind === "ok";
+  } else if (controlPolicy === "legacy") {
+    const stopped = await stopDaemonService();
+    legacyStopFailure = stopped.kind === "ok" ? null : stopped.detail;
+    daemonReady = false;
+  } else if (controlPolicy === "enabled") {
+    if (!apiKey) {
+      daemonReady = false;
+    } else {
+      const service = await replaceDaemonService();
+      const daemon = service.kind === "ok" ? await ensureDaemonRunning({ spawnDaemon: () => {
+      } }) : null;
+      const localProof = daemon?.kind === "running" || daemon?.kind === "started" ? await waitForDaemonRemoteProof() : null;
+      const serverProof = localProof && daemonHasRemoteProof(localProof) ? await waitForMachineReadiness(apiKey, ["spawn", ...controlCapabilities]) : null;
+      daemonReady = service.kind === "ok" && localProof !== null && daemonHasRemoteProof(localProof) && (serverProof?.kind === "ready" || serverProof?.kind === "unsupported");
+    }
+  } else if (controlMode === "on" && controlPolicy === "unsupported") {
+    daemonReady = false;
+  }
+  console.log();
+  if (refreshed.length > 0) {
+    console.log("Refreshed so the new hook set is active now:");
+    for (const agent of refreshed) {
+      const parts = [agent.result.hooks ? "hooks" : null, agent.result.mcp ? "MCP key" : null].filter(Boolean).join(" + ");
+      console.log(`  ${agent.label.padEnd(14)} ${parts}`);
+    }
+    if (!apiKey) {
+      console.log();
+      console.log("No key was readable here, so MCP entries kept the key they already had.");
+    }
+  } else if (failedRefreshes.length === 0) {
+    console.log("No agent config on this machine needed refreshing.");
+  }
+  if (codexTrust) {
+    console.log();
+    console.log(describeCodexTrustConfirmation(codexTrust));
+  }
+  console.log();
+  if (!daemonReady) {
+    console.error(controlPolicy === "disabled" ? "Upgrade installed, but the disabled background service could not be fully removed. Re-run setup with --control off." : controlPolicy === "legacy" ? legacyStopFailure ? `Upgrade installed, but the legacy background service could not be stopped: ${legacyStopFailure}. Run setup with --control off.` : "Upgrade installed and the legacy background service was stopped, but it cannot be safely adopted. Run setup with --control off, or restore its provider and native service manager." : controlPolicy === "enabled" && !apiKey ? "Upgrade installed, but phone-start could not be reconciled because no API key was readable. Re-run setup." : "Upgrade installed, but the background service did not start. Run: pushary daemon install");
+    process.exitCode = 1;
+    return;
+  }
+  if (failedRefreshes.length > 0) {
+    console.error(`Upgrade installed, but refreshing agent configuration failed for: ${failedRefreshes.map((agent) => agent.label).join(", ")}. Check the config files and run pushary upgrade again.`);
+    process.exitCode = 1;
+    return;
+  }
+  console.log(controlPolicy === "disabled" ? "Done. Your hooks use the new global install; phone-start remains disabled." : controlPolicy === "unsupported" || controlPolicy === "preserve-absent" ? "Done. Your hooks use the new global install; no background service was added." : "Done. Your hooks and background service use the new global install.");
+  console.log("Verify with: pushary doctor");
+};
+var AUTO_UPDATE_ON_MESSAGE = "Automatic updates are on. Pushary checks for a new version once a day, when an agent session starts.";
+var AUTO_UPDATE_OFF_MESSAGE = "Automatic updates are off. Turn them back on with: pushary upgrade --auto=on";
+var AUTO_UPDATE_RUN_MESSAGES = {
+  linux: `Automatic updates are paused on Linux to protect running sessions. When your sessions have finished, run: ${NPX_LATEST_COMMAND} upgrade`,
+  not_global_install: `This copy of Pushary is not a global npm install, so it does not update itself. Run: ${NPX_LATEST_COMMAND} upgrade`,
+  locked: "Another automatic update is already running."
+};
+var setAutomaticUpdates = (enabled) => {
+  updateAutoUpdateState(autoUpdateState(), { disabled: !enabled });
+  console.log(enabled ? AUTO_UPDATE_ON_MESSAGE : AUTO_UPDATE_OFF_MESSAGE);
+  if (enabled && isAutoUpdateDisabledByEnv(process.env)) {
+    console.log(`${AUTO_UPDATE_DISABLE_ENV} is set in this shell, and it keeps them off wherever it is set.`);
+  }
+};
+var runAutomaticUpdate = async () => {
+  const outcome = await runAutoUpdate();
+  if (outcome.kind !== "recorded") {
+    console.log(AUTO_UPDATE_RUN_MESSAGES[outcome.kind]);
+    return;
+  }
+  console.log(`Automatic update: ${describeAutoUpdateCheck(outcome.state)}`);
+  if (outcome.state.lastResult === "failed" || outcome.state.lastResult === "finish_pending") process.exitCode = 1;
+};
+var FINISH_FAILED_MESSAGE = "Upgrade installed, but refreshing the agent configs did not finish. Fix the problem printed above, then run pushary upgrade again.";
+var describeFinishFailure = (finish) => finish.kind === "entry_missing" ? `Upgrade installed, but the new pushary-upgrade entry was not found at ${finish.entry}.` : FINISH_FAILED_MESSAGE;
+var reportFinish = (finish) => {
+  if (finish.kind === "finished") return;
+  console.error(describeFinishFailure(finish));
+  process.exitCode = EXIT.FAILED;
+};
+var reportGlobalUpgrade = (outcome) => {
+  switch (outcome.kind) {
+    case "current":
+      console.log(`Already on the latest version (${outcome.version}).`);
+      return;
+    case "install_failed":
+      console.error(`Upgrade failed: ${outcome.detail}`);
+      process.exitCode = EXIT.FAILED;
+      return;
+    case "pending_finish_failed":
+    case "installed":
+      reportFinish(outcome.finish);
+  }
+};
+var BOTH_INSTALLED_MESSAGE = `Both ${CANONICAL_PACKAGE} and ${LEGACY_PACKAGE} are installed globally, and which one runs the Pushary commands could not be read, so nothing was upgraded. Check with: ${NPX_LATEST_COMMAND} doctor`;
+var reportNoGlobalInstall = () => {
+  const found = detectInstallModes();
+  console.log(`No global install of ${CANONICAL_PACKAGE} or ${LEGACY_PACKAGE} found, so there is nothing to upgrade here.`);
+  console.log();
+  if (found.length === 0) {
+    console.log("Nothing on this machine looks Pushary-configured either.");
+    console.log("  Set it up with:  npx @pushary/agent-hooks@latest setup");
+  } else {
+    console.log("What this machine does have:");
+    for (const mode of found) {
+      console.log(`  ${mode.label.padEnd(22)} ${mode.upgrade}`);
+    }
+  }
+  console.log();
+  console.log("Check the result with: pushary doctor");
+};
+var upgradeSubject = async (subject) => {
+  const outcome = await upgradeInstalledPackage(subject, {
+    fetchLatest: (packageName) => fetchLatestPublishedVersion({ packageName }),
+    hasPendingFinish: (installed) => hasPendingUpgradeFinish(readAutoUpdateState(autoUpdateState()), installed),
+    recordFinished: () => {
+      updateAutoUpdateState(autoUpdateState(), { lastResult: "updated", detail: void 0, announced: false });
+    },
+    announce: (line) => console.log(line),
+    install: (packageName) => installPackageGlobally({ packageName, version: LATEST_TAG, timeoutMs: 12e4 }),
+    finish: (installedSubject) => finishGlobalUpgrade(installedSubject)
+  });
+  reportGlobalUpgrade(outcome);
+};
+var upgradeGlobalInstall = async () => {
+  const subject = readGlobalUpgradeSubject();
+  if (subject.kind === "not_installed") {
+    reportNoGlobalInstall();
+    return;
+  }
+  if (subject.kind === "both_installed") {
+    console.error(BOTH_INSTALLED_MESSAGE);
+    process.exitCode = EXIT.FAILED;
+    return;
+  }
+  await upgradeSubject(subject);
+};
+var runUnderUpgradeLock = async (run) => {
+  const locked = await withUpgradeLock(run);
+  if (locked.kind === "ran") return;
+  console.error(locked.message);
+  process.exitCode = locked.exitCode;
+};
+var main = async () => {
+  if (process.argv.includes(FINISH_UPGRADE_FLAG)) {
+    await runUnderUpgradeLock(finishUpgrade);
+    return;
+  }
+  const autoFlag = parseAutoUpdateFlag(process.argv.slice(2));
+  if (autoFlag.kind === "invalid") {
+    console.error(`--auto takes on or off (got ${autoFlag.value || "nothing"}).`);
+    process.exitCode = EXIT.USAGE;
+    return;
+  }
+  if (autoFlag.kind === "set") {
+    setAutomaticUpdates(autoFlag.enabled);
+    return;
+  }
+  if (autoFlag.kind === "run") {
+    await runAutomaticUpdate();
+    return;
+  }
+  await runUnderUpgradeLock(upgradeGlobalInstall);
+};
+main();

package/dist/bin/pushary-wait.d.ts

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