@pushary/agent-hooks 1.7.3 → 1.8.0

package/dist/bin/pushary-upgrade.js

@@ -1,34 +1,34 @@
 #!/usr/bin/env node
 import {
   describeCodexTrustConfirmation
-} from "../chunk-AWVNAYGD.js";
+} from "../chunk-TY4JT7W3.js";
 import {
   ensureCodexTrustAfterReapply,
   reapplyAllAgents
-} from "../chunk-G6RRVJOG.js";
-import "../chunk-IPSRMLCJ.js";
-import "../chunk-RLW3JWDY.js";
+} from "../chunk-VQKRG3AC.js";
+import "../chunk-SIFVFP6T.js";
+import "../chunk-RHR6NARM.js";
 import {
   waitForMachineReadiness
-} from "../chunk-WGMW7OXW.js";
-import "../chunk-G3OMOTJ4.js";
+} from "../chunk-DE4Y6TCC.js";
+import "../chunk-AXPCESYO.js";
 import {
   detectProviderLiveCapabilities,
   hasSpawnProvider,
   resolveControlPolicy
-} from "../chunk-Y4ZH64UK.js";
+} from "../chunk-HQ6G3B5R.js";
 import {
   AUTO_UPDATE_DISABLE_ENV,
   describeAutoUpdateCheck,
-  globalInstallPrefix,
+  globalInstallLocation,
   hasPendingUpgradeFinish,
   isAutoUpdateDisabledByEnv,
   parseAutoUpdateFlag,
   readAutoUpdateState,
   updateAutoUpdateState,
   upgradeEntryFor
-} from "../chunk-KJXUIPS4.js";
-import "../chunk-WTJM7PSL.js";
+} from "../chunk-UI36QSBI.js";
+import "../chunk-6J2JC2RT.js";
 import {
   daemonHasRemoteProof,
   daemonServiceManagerAvailable,
@@ -39,24 +39,22 @@ import {
   replaceDaemonService,
   stopDaemonService,
   waitForDaemonRemoteProof
-} from "../chunk-ZKJ34T2F.js";
-import "../chunk-MIXWMA73.js";
-import {
-  needsShell
-} from "../chunk-XHKBHWLX.js";
-import "../chunk-EUGNVLMG.js";
+} from "../chunk-WE2J62NC.js";
+import "../chunk-3EVPNIBE.js";
+import "../chunk-XHKBHWLX.js";
+import "../chunk-EPCXUP3P.js";
 import "../chunk-POFBE6ZY.js";
 import {
   exitOnHelpFlag
-} from "../chunk-5S2VBSJI.js";
+} from "../chunk-HZVVNGEW.js";
 import {
   readControlMode
-} from "../chunk-D6OODZCM.js";
-import "../chunk-OVC5QXN5.js";
+} from "../chunk-P7WQEVWA.js";
+import "../chunk-LXQ5FBBD.js";
 import {
   EXIT
 } from "../chunk-KZERVKTD.js";
-import "../chunk-62CVUUNU.js";
+import "../chunk-DB3ONZB4.js";
 import {
   LATEST_TAG,
   autoUpdateLock,
@@ -68,35 +66,43 @@ import {
   execNpm,
   fetchLatestPublishedVersion,
   geminiSettings,
-  installAgentHooksGlobally,
+  installPackageGlobally,
   npmErrorMessage,
-  resolveGlobalBinary,
+  readGlobalCliInstallAt,
+  readGlobalPrefix,
   vscodePluginDir
-} from "../chunk-MZBRL5H5.js";
+} from "../chunk-A2A2YTMG.js";
 import "../chunk-T7E75EKA.js";
 import {
   getApiKey
-} from "../chunk-R6OYCUNK.js";
+} from "../chunk-GPEGOGRJ.js";
 import {
   NPX_LATEST_COMMAND
-} from "../chunk-YYCTF4Q5.js";
+} from "../chunk-E4FJTUH4.js";
 import {
+  CANONICAL_PACKAGE,
+  LEGACY_PACKAGE,
+  commandsPackage,
+  globalUpgradeEntry,
   isNewerVersion,
   isReleaseVersion,
   isSameMajorVersion,
   ownPackageRoot,
   packageVersionAt
-} from "../chunk-G4GLCLKK.js";
+} from "../chunk-NQTHFF4W.js";
 
 // bin/pushary-upgrade.ts
-import { existsSync } from "fs";
+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, statSync, unlinkSync, writeSync } from "fs";
+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;
@@ -129,10 +135,7 @@ var isStaleLock = (lockPath, now) => {
   const modifiedAt = statSync(lockPath, { throwIfNoEntry: false })?.mtimeMs;
   return modifiedAt !== void 0 && now - modifiedAt > LOCK_STALE_MS;
 };
-var acquireAutoUpdateLock = (lockPath, now) => {
-  mkdirSync(dirname(lockPath), { recursive: true });
-  if (tryCreateLock(lockPath, now) === "acquired") return "acquired";
-  if (!isStaleLock(lockPath, now)) return "held";
+var takeOverLock = (lockPath, now) => {
   try {
     unlinkSync(lockPath);
   } catch {
@@ -140,6 +143,38 @@ var acquireAutoUpdateLock = (lockPath, now) => {
   }
   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);
@@ -147,6 +182,28 @@ var releaseAutoUpdateLock = (lockPath) => {
     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;
@@ -183,7 +240,7 @@ 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.prefix), prefix: context.prefix, logPath: context.logPath });
+    context.finish({ entry: upgradeEntryFor(context.location), prefix: context.location.prefix, logPath: context.logPath });
     return { result: "updated", from, to };
   } catch {
     return pending;
@@ -197,16 +254,21 @@ var checkAndInstall = async (context) => {
   }
   const previous = readAutoUpdateState(context.statePath);
   const pendingFinish = hasPendingUpgradeFinish(previous, installed);
-  const latest = await fetchLatestPublishedVersion({ fetchImpl: context.fetchImpl });
+  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 ${latest} into ${context.prefix}`);
+  appendAutoUpdateLog(context.logPath, `${new Date(context.now()).toISOString()} installing ${context.location.packageName}@${latest} into ${context.location.prefix}`);
   try {
-    installAgentHooksGlobally({ version: latest, prefix: context.prefix, timeoutMs: INSTALL_TIMEOUT_MS }, context.runNpm);
+    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) };
@@ -225,8 +287,8 @@ var recordAutoUpdateCheck = (statePath, check, at) => updateAutoUpdateState(stat
 var runAutoUpdate = async (run = {}) => {
   if ((run.platform ?? process.platform) === "linux") return { kind: "linux" };
   const packageRoot = run.packageRoot ?? ownPackageRoot();
-  const prefix = packageRoot === void 0 ? null : globalInstallPrefix(packageRoot);
-  if (packageRoot === void 0 || prefix === null) return { kind: "not_global_install" };
+  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();
@@ -235,7 +297,7 @@ var runAutoUpdate = async (run = {}) => {
     const check = await checkAndInstall({
       packageRoot,
       statePath: run.statePath ?? autoUpdateState(),
-      prefix,
+      location,
       logPath,
       now,
       fetchImpl: run.fetchImpl ?? fetch,
@@ -251,6 +313,62 @@ var runAutoUpdate = async (run = {}) => {
   }
 };
 
+// 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 = () => {
@@ -258,43 +376,36 @@ var detectInstallModes = () => {
     {
       label: "Cursor plugin",
       upgrade: "updates itself through Cursor",
-      present: existsSync(cursorPluginDir())
+      present: existsSync2(cursorPluginDir())
     },
     {
       label: "VS Code plugin",
       upgrade: "npx @pushary/agent-hooks@latest setup --agents vscode",
-      present: existsSync(vscodePluginDir())
+      present: existsSync2(vscodePluginDir())
     },
     {
       label: "Codex config",
       upgrade: "npx @pushary/agent-hooks@latest setup --agents codex",
-      present: existsSync(codexConfigToml())
+      present: existsSync2(codexConfigToml())
     },
     {
       label: "Claude Code config",
       upgrade: "npx @pushary/agent-hooks@latest setup --agents claude_code",
-      present: existsSync(claudeJson())
+      present: existsSync2(claudeJson())
     },
     {
       label: "Gemini config",
       upgrade: "npx @pushary/agent-hooks@latest setup --agents gemini_cli",
-      present: existsSync(geminiSettings())
+      present: existsSync2(geminiSettings())
     },
     {
       label: "Hermes plugin (pip)",
       upgrade: "npx @pushary/agent-hooks@latest setup --agents hermes",
-      present: existsSync(join(homedir(), ".hermes"))
+      present: existsSync2(join(homedir(), ".hermes"))
     }
   ];
   return candidates.filter((candidate) => candidate.present).map(({ label, upgrade }) => ({ label, upgrade }));
 };
-var getInstalledVersion = () => {
-  try {
-    return execNpm("list -g --no-workspaces @pushary/agent-hooks --depth=0", { timeout: 1e4 }).toString().match(/@pushary\/agent-hooks@([\d.]+)/)?.[1] ?? "";
-  } catch {
-    return "";
-  }
-};
 var finishUpgrade = async () => {
   let apiKey;
   try {
@@ -395,27 +506,78 @@ var runAutomaticUpdate = async () => {
   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 finishGlobalUpgrade = () => {
-  const upgradedBinary = resolveGlobalBinary("pushary-upgrade");
-  if (!upgradedBinary) {
-    console.error("Upgrade installed, but the new pushary-upgrade binary could not be found on PATH.");
-    process.exit(1);
+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);
   }
-  try {
-    execFileSync2(upgradedBinary, [FINISH_UPGRADE_FLAG], {
-      stdio: "inherit",
-      shell: needsShell(upgradedBinary)
-    });
-    return true;
-  } catch {
-    console.error(FINISH_FAILED_MESSAGE);
-    process.exitCode = 1;
-    return false;
+};
+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 finishUpgrade();
+    await runUnderUpgradeLock(finishUpgrade);
     return;
   }
   const autoFlag = parseAutoUpdateFlag(process.argv.slice(2));
@@ -432,42 +594,6 @@ var main = async () => {
     await runAutomaticUpdate();
     return;
   }
-  const installed = getInstalledVersion();
-  if (!installed) {
-    const found = detectInstallModes();
-    console.log("No global install of @pushary/agent-hooks 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");
-    return;
-  }
-  const pendingFinish = hasPendingUpgradeFinish(readAutoUpdateState(autoUpdateState()), installed);
-  const latest = await fetchLatestPublishedVersion();
-  const newerPublished = latest !== void 0 && isNewerVersion(latest, installed);
-  if (pendingFinish && !newerPublished) {
-    if (!finishGlobalUpgrade()) return;
-    updateAutoUpdateState(autoUpdateState(), { lastResult: "updated", detail: void 0, announced: false });
-  }
-  if (latest && !isNewerVersion(latest, installed)) {
-    console.log(`Already on the latest version (${installed}).`);
-    return;
-  }
-  console.log(`Upgrading @pushary/agent-hooks ${installed} -> ${latest ?? "latest"}`);
-  try {
-    installAgentHooksGlobally({ version: LATEST_TAG, timeoutMs: 12e4 });
-  } catch (err) {
-    console.error(`Upgrade failed: ${npmErrorMessage(err)}`);
-    process.exit(1);
-  }
-  finishGlobalUpgrade();
+  await runUnderUpgradeLock(upgradeGlobalInstall);
 };
 main();

package/dist/bin/pushary-wait.js

@@ -4,33 +4,33 @@ import {
 } from "../chunk-CVWG2N3Y.js";
 import {
   exitOnFailedResponse
-} from "../chunk-PRNFSORD.js";
+} from "../chunk-EX3GAPA4.js";
 import {
   createIo
 } from "../chunk-U4TMAANR.js";
 import {
   exitOnHelpFlag
-} from "../chunk-5S2VBSJI.js";
+} from "../chunk-HZVVNGEW.js";
 import {
   rejectUnknownFlags
 } from "../chunk-GMXKITVA.js";
-import "../chunk-EEEJ2JIL.js";
-import "../chunk-DUQO4C4I.js";
-import "../chunk-OVC5QXN5.js";
+import "../chunk-2ABTSGFT.js";
+import "../chunk-2OY3ZZ5N.js";
+import "../chunk-LXQ5FBBD.js";
 import {
   UsageError
 } from "../chunk-7QLSKOSU.js";
 import {
   EXIT
 } from "../chunk-KZERVKTD.js";
-import "../chunk-MZBRL5H5.js";
+import "../chunk-A2A2YTMG.js";
 import "../chunk-T7E75EKA.js";
 import {
   getApiKey,
   getBaseUrl
-} from "../chunk-R6OYCUNK.js";
-import "../chunk-YYCTF4Q5.js";
-import "../chunk-G4GLCLKK.js";
+} from "../chunk-GPEGOGRJ.js";
+import "../chunk-E4FJTUH4.js";
+import "../chunk-NQTHFF4W.js";
 
 // bin/pushary-wait.ts
 exitOnHelpFlag("wait");

package/dist/bin/pushary.js

@@ -1,23 +1,23 @@
 #!/usr/bin/env node
 import {
   installNetworkDefaults
-} from "../chunk-DUQO4C4I.js";
-import "../chunk-OVC5QXN5.js";
+} from "../chunk-2OY3ZZ5N.js";
+import "../chunk-LXQ5FBBD.js";
 import "../chunk-7QLSKOSU.js";
 import {
   EXIT
 } from "../chunk-KZERVKTD.js";
-import "../chunk-MZBRL5H5.js";
+import "../chunk-A2A2YTMG.js";
 import "../chunk-T7E75EKA.js";
-import "../chunk-R6OYCUNK.js";
+import "../chunk-GPEGOGRJ.js";
 import {
   COMMANDS,
   isCommandName,
   renderHelp
-} from "../chunk-YYCTF4Q5.js";
+} from "../chunk-E4FJTUH4.js";
 import {
   getPackageVersion
-} from "../chunk-G4GLCLKK.js";
+} from "../chunk-NQTHFF4W.js";
 
 // src/cli/runtime.ts
 var supportsRuntime = (version) => {

package/dist/{chunk-EEEJ2JIL.js → chunk-2ABTSGFT.js}

@@ -1,6 +1,6 @@
 import {
   pusharyFetch
-} from "./chunk-DUQO4C4I.js";
+} from "./chunk-2OY3ZZ5N.js";
 import {
   NetworkError
 } from "./chunk-7QLSKOSU.js";
@@ -9,11 +9,11 @@ import {
 } from "./chunk-KZERVKTD.js";
 import {
   getBaseUrl
-} from "./chunk-R6OYCUNK.js";
+} from "./chunk-GPEGOGRJ.js";
 import {
   isValidApiKey,
   normalizeKeyScope
-} from "./chunk-G4GLCLKK.js";
+} from "./chunk-NQTHFF4W.js";
 
 // src/session.ts
 var samePusharyAccount = (left, right) => left.kind === "ok" && right.kind === "ok" && left.identity.workspaceId !== "" && left.identity.workspaceId === right.identity.workspaceId && left.identity.siteId === right.identity.siteId;

package/dist/{chunk-DUQO4C4I.js → chunk-2OY3ZZ5N.js}

@@ -1,16 +1,16 @@
 import {
   readExistingMachineId
-} from "./chunk-OVC5QXN5.js";
+} from "./chunk-LXQ5FBBD.js";
 import {
   NetworkError
 } from "./chunk-7QLSKOSU.js";
 import {
   getBaseUrl
-} from "./chunk-R6OYCUNK.js";
+} from "./chunk-GPEGOGRJ.js";
 import {
   clientContextHeaders,
   getPackageVersion
-} from "./chunk-G4GLCLKK.js";
+} from "./chunk-NQTHFF4W.js";
 
 // src/cli/net.ts
 import { createRequire } from "module";

package/dist/{chunk-MIXWMA73.js → chunk-3EVPNIBE.js}

@@ -1,16 +1,16 @@
 import {
   NOTIFICATION_MATCHED_TYPES,
   POSTTOOLUSE_MIRRORED_TOOLS
-} from "./chunk-EUGNVLMG.js";
+} from "./chunk-EPCXUP3P.js";
 import {
   isProtectedByScope,
   registerHookEntry
-} from "./chunk-MZBRL5H5.js";
+} from "./chunk-A2A2YTMG.js";
 import {
   CLAUDE_PRETOOLUSE_MATCHER,
   HOOK_BUDGETS,
   HOOK_LOCATOR_BINARY
-} from "./chunk-G4GLCLKK.js";
+} from "./chunk-NQTHFF4W.js";
 
 // src/gemini-config.ts
 var GEMINI_HOOK_BINARY = "pushary-gemini-hook";

package/dist/{chunk-WTJM7PSL.js → chunk-6J2JC2RT.js}

@@ -2,17 +2,17 @@ import {
   CLAUDE_HOOK_EVENTS,
   GEMINI_HOOK_EVENTS,
   hasGeminiHooks
-} from "./chunk-MIXWMA73.js";
+} from "./chunk-3EVPNIBE.js";
 import {
   CODEX_HOOK_EVENTS,
   hasCodexHooks,
   holdBudgetOf
-} from "./chunk-MZBRL5H5.js";
+} from "./chunk-A2A2YTMG.js";
 import {
   CURSOR_GATE_EVENTS,
   HOOK_LOCATOR_BINARY,
   hookCommandHoldBudget
-} from "./chunk-G4GLCLKK.js";
+} from "./chunk-NQTHFF4W.js";
 
 // src/diagnostics/wiring.ts
 var record = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;