@pushary/agent-hooks 1.9.0 → 1.9.1

package/dist/bin/pushary-upgrade.js

@@ -1,35 +1,45 @@
 #!/usr/bin/env node
+import {
+  FINISH_UPGRADE_FLAG,
+  finishGlobalUpgrade,
+  finishUpgradeWithLock,
+  readGlobalUpgradeSubject,
+  runAutoUpdate,
+  upgradeInstalledPackage,
+  withUpgradeLock
+} from "../chunk-QQJCDRD3.js";
+import {
+  installWithUpgradeLock
+} from "../chunk-QXL27RY6.js";
 import {
   describeCodexTrustConfirmation
-} from "../chunk-7LLNRCOK.js";
+} from "../chunk-VQLWYKX7.js";
 import {
   ensureCodexTrustAfterReapply,
   reapplyAllAgents
-} from "../chunk-XXVMUMKT.js";
-import "../chunk-JW7DKTT6.js";
+} from "../chunk-SWGY5WNX.js";
+import "../chunk-KR5JASA4.js";
 import {
   waitForMachineReadiness
-} from "../chunk-7TQQSQZ7.js";
-import "../chunk-MQJWO3AA.js";
+} from "../chunk-AKCJ5SNO.js";
+import "../chunk-6Q4NM2LW.js";
 import {
   detectProviderLiveCapabilities,
   expectedLaunchCapabilities,
   hasSpawnProvider,
   resolveControlPolicy
-} from "../chunk-CFAD2LTH.js";
+} from "../chunk-IITCMJ4G.js";
 import "../chunk-RIVNNBEK.js";
 import {
   AUTO_UPDATE_DISABLE_ENV,
   describeAutoUpdateCheck,
-  globalInstallLocation,
   hasPendingUpgradeFinish,
   isAutoUpdateDisabledByEnv,
   parseAutoUpdateFlag,
   readAutoUpdateState,
-  updateAutoUpdateState,
-  upgradeEntryFor
-} from "../chunk-P25O4K3J.js";
-import "../chunk-NAJ3UV4E.js";
+  updateAutoUpdateState
+} from "../chunk-CE4UH4AP.js";
+import "../chunk-5K43TBK4.js";
 import {
   daemonHasRemoteProof,
   daemonServiceManagerAvailable,
@@ -40,444 +50,82 @@ import {
   replaceDaemonService,
   stopDaemonService,
   waitForDaemonRemoteProof
-} from "../chunk-LQESQPIT.js";
-import "../chunk-YFS4HYCI.js";
+} from "../chunk-PEGKBNGN.js";
+import "../chunk-D3RS57MN.js";
 import "../chunk-XHKBHWLX.js";
 import "../chunk-6ICPEJY5.js";
-import "../chunk-VYNTRHB6.js";
+import "../chunk-RNDFGHSQ.js";
 import "../chunk-POFBE6ZY.js";
 import {
   exitOnHelpFlag
-} from "../chunk-K75TP4JY.js";
+} from "../chunk-JGQ2ANHQ.js";
 import {
   readControlMode
-} from "../chunk-ZRHA4PGN.js";
-import "../chunk-VV4SBPCQ.js";
+} from "../chunk-RJ7ECJSZ.js";
+import "../chunk-J7JXA2LX.js";
 import {
   EXIT
 } from "../chunk-KZERVKTD.js";
-import "../chunk-US3RDXK7.js";
+import "../chunk-6QSDNXGM.js";
 import {
   LATEST_TAG,
-  autoUpdateLock,
-  autoUpdateLog,
   autoUpdateState,
   claudeJson,
   codexConfigToml,
   cursorPluginDir,
-  execNpm,
   fetchLatestPublishedVersion,
   geminiSettings,
-  installPackageGlobally,
-  npmErrorMessage,
-  readGlobalCliInstallAt,
-  readGlobalPrefix,
   vscodePluginDir
-} from "../chunk-R76C43H7.js";
-import {
-  writeJsonAtomic
-} from "../chunk-T7E75EKA.js";
+} from "../chunk-ZMKEKWNR.js";
+import "../chunk-T7E75EKA.js";
 import {
   getApiKey
-} from "../chunk-EG46RJRF.js";
+} from "../chunk-4SB46XLF.js";
 import {
   NPX_LATEST_COMMAND
-} from "../chunk-SDSKTRIV.js";
+} from "../chunk-FVOCQSBG.js";
 import {
   CANONICAL_PACKAGE,
   LEGACY_PACKAGE,
-  commandsPackage,
-  getPackageVersion,
-  globalUpgradeEntry,
-  isNewerVersion,
-  isReleaseVersion,
-  isSameMajorVersion,
-  ownPackageRoot,
-  packageVersionAt
-} from "../chunk-4PCF34AB.js";
-
-// src/upgrade-lock.ts
-import { fork } from "child_process";
-import { createHash } from "crypto";
-import { existsSync, mkdirSync, readFileSync, realpathSync, unlinkSync } from "fs";
-import { createServer, Server } from "net";
-import { basename, dirname, join } from "path";
-var LOCK_HOST = "127.0.0.1";
-var LOCK_PORT_START = 49152;
-var LOCK_PORT_COUNT = 16384;
-var INHERITED_LOCK_ENV = "PUSHARY_UPGRADE_LOCK";
-var LOCK_READY = "pushary-upgrade-lock-ready";
-var LOCK_HANDLE = "pushary-upgrade-lock-handle";
-var HANDOFF_TIMEOUT_MS = 1e4;
-var FINISH_TIMEOUT_MS = 5 * 60 * 1e3;
-var KERNEL_LOCK_FORMAT = "kernel-v1";
-var heldLocks = /* @__PURE__ */ new Map();
-var canonicalLockPath = (path) => {
-  mkdirSync(dirname(path), { recursive: true });
-  return join(realpathSync(dirname(path)), basename(path));
-};
-var lockPort = (path) => LOCK_PORT_START + createHash("sha256").update(path).digest().readUInt32BE(0) % LOCK_PORT_COUNT;
-var readLockRecord = (path) => {
-  try {
-    const value = JSON.parse(readFileSync(path, "utf8"));
-    const pid = value && typeof value === "object" && "pid" in value ? value.pid : void 0;
-    return {
-      pid: typeof pid === "number" && Number.isInteger(pid) && pid > 0 ? pid : void 0,
-      installationPending: value !== null && typeof value === "object" && "installationPending" in value && value.installationPending === true,
-      usesKernelLock: value !== null && typeof value === "object" && "format" in value && value.format === KERNEL_LOCK_FORMAT
-    };
-  } catch {
-    return { pid: void 0, usesKernelLock: false, installationPending: false };
-  }
-};
-var isProcessAlive = (pid) => {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return !(error instanceof Error && "code" in error && error.code === "ESRCH");
-  }
-};
-var rejectConnection = (socket) => {
-  socket.destroy();
-};
-var inheritLock = (path) => new Promise((resolve) => {
-  const done = (claim) => {
-    clearTimeout(timer);
-    process.off("message", receive);
-    process.off("disconnect", disconnected);
-    resolve(claim);
-  };
-  const disconnected = () => done({ kind: "unavailable", reason: "Upgrade parent disconnected before transferring its lock" });
-  const receive = (message, handle) => {
-    if (message !== LOCK_HANDLE || !(handle instanceof Server)) return;
-    const address = handle.address();
-    if (address === null || typeof address === "string" || address.port !== lockPort(path) || address.address !== LOCK_HOST) {
-      handle.close();
-      done({ kind: "unavailable", reason: "Invalid inherited upgrade lock" });
-      return;
-    }
-    handle.on("connection", rejectConnection);
-    heldLocks.set(path, handle);
-    done({ kind: "inherited" });
-    process.disconnect?.();
-  };
-  const timer = setTimeout(() => done({ kind: "unavailable", reason: "Upgrade lock handoff timed out" }), HANDOFF_TIMEOUT_MS);
-  process.on("message", receive);
-  process.once("disconnect", disconnected);
-  if (!process.send || !process.connected) return disconnected();
-  process.send(LOCK_READY, (error) => {
-    if (error) disconnected();
-  });
-});
-var claimUpgradeLock = async (request = {}) => {
-  let server;
-  try {
-    const path = canonicalLockPath(request.lockPath ?? autoUpdateLock());
-    const inheritedPath = process.env[INHERITED_LOCK_ENV];
-    delete process.env[INHERITED_LOCK_ENV];
-    if (inheritedPath === path && !heldLocks.has(path)) return await inheritLock(path);
-    server = createServer(rejectConnection);
-    const listener = server;
-    await new Promise((resolve, reject) => {
-      listener.once("error", reject);
-      listener.listen({ host: LOCK_HOST, port: lockPort(path), exclusive: true }, resolve);
-    });
-    const record = readLockRecord(path);
-    if (record.installationPending) {
-      server.close();
-      return { kind: "unavailable", reason: `An earlier installation did not finish safely. Stop its npm processes (or restart the computer), then remove ${path} and retry the upgrade.` };
-    }
-    if (existsSync(path) && !record.usesKernelLock && (record.pid === void 0 || (request.isAlive ?? isProcessAlive)(record.pid))) {
-      server.close();
-      return { kind: "held", holderPid: record.pid };
-    }
-    writeJsonAtomic(path, { pid: process.pid, format: KERNEL_LOCK_FORMAT }, 384);
-    heldLocks.set(path, server);
-    return { kind: "acquired" };
-  } catch (error) {
-    server?.close();
-    if (error instanceof Error && "code" in error && error.code === "EADDRINUSE") {
-      return { kind: "held", holderPid: readLockRecord(request.lockPath ?? autoUpdateLock()).pid };
-    }
-    return { kind: "unavailable", reason: npmErrorMessage(error) };
-  }
-};
-var releaseAutoUpdateLock = (lockPath) => {
-  const path = canonicalLockPath(lockPath);
-  const server = heldLocks.get(path);
-  if (!server) return;
-  heldLocks.delete(path);
-  try {
-    const record = readLockRecord(path);
-    if (record.pid === process.pid && !record.installationPending) unlinkSync(path);
-  } finally {
-    server.close();
-  }
-};
-var finishWithUpgradeLock = (request) => new Promise((resolve, reject) => {
-  const path = canonicalLockPath(request.lockPath ?? autoUpdateLock());
-  const server = heldLocks.get(path);
-  if (!server) return reject(new Error("Cannot finish an upgrade without its lock"));
-  const child = fork(request.entry, [...request.args], {
-    execArgv: [],
-    stdio: request.stdio ?? ["inherit", "inherit", "inherit", "ipc"],
-    env: { ...process.env, ...request.env, [INHERITED_LOCK_ENV]: path }
-  });
-  const timer = setTimeout(() => child.kill("SIGKILL"), FINISH_TIMEOUT_MS);
-  child.on("message", (message) => {
-    if (message === LOCK_READY) child.send(LOCK_HANDLE, server, (error) => {
-      if (error) child.kill();
-    });
-  });
-  child.once("error", (error) => {
-    clearTimeout(timer);
-    reject(error);
-  });
-  child.once("exit", (code, signal) => {
-    clearTimeout(timer);
-    if (code === 0) resolve();
-    else reject(new Error(`Upgrade finish exited with ${signal ?? code}`));
-  });
-});
-var installWithUpgradeLock = (request, lockPath = autoUpdateLock(), runNpm) => {
-  const path = canonicalLockPath(lockPath);
-  if (!heldLocks.has(path)) throw new Error("Cannot install an upgrade without its lock");
-  writeJsonAtomic(path, { pid: process.pid, format: KERNEL_LOCK_FORMAT, installationPending: true }, 384);
-  installPackageGlobally(request, runNpm);
-  writeJsonAtomic(path, { pid: process.pid, format: KERNEL_LOCK_FORMAT }, 384);
-};
+  getPackageVersion
+} from "../chunk-XEIV5QOT.js";
 
 // bin/pushary-upgrade.ts
-import { existsSync as existsSync3 } from "fs";
+import { existsSync } from "fs";
 import { homedir } from "os";
-import { join as join2 } from "path";
-
-// src/global-upgrade.ts
-import { existsSync as existsSync2 } from "fs";
-
-// src/auto-update-run.ts
-import { closeSync, mkdirSync as mkdirSync2, openSync, statSync, writeSync } from "fs";
-import { dirname as dirname2 } from "path";
-var FINISH_UPGRADE_FLAG = "--finish-upgrade";
-var INSTALL_TIMEOUT_MS = 12e4;
-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 openAutoUpdateLog = (logPath) => {
-  mkdirSync2(dirname2(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 = async (request) => {
-  const handle = openAutoUpdateLog(request.logPath);
-  try {
-    await finishWithUpgradeLock({
-      entry: request.entry,
-      args: [FINISH_UPGRADE_FLAG],
-      lockPath: request.lockPath,
-      stdio: ["ignore", handle, handle, "ipc"],
-      env: { npm_config_prefix: request.prefix }
-    });
-  } 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 = async (context, from, to) => {
-  const pending = { result: "finish_pending", from, to, detail: incompleteFinishDetail(context.logPath) };
-  recordAutoUpdateCheck(context.statePath, pending, new Date(context.now()).toISOString());
-  try {
-    await context.finish({ lockPath: context.lockPath, 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 {
-    installWithUpgradeLock({
-      packageName: context.location.packageName,
-      version: latest,
-      prefix: context.location.prefix,
-      timeoutMs: INSTALL_TIMEOUT_MS
-    }, context.lockPath, context.runNpm);
-  } catch (error) {
-    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();
-  const claim = await claimUpgradeLock({ lockPath });
-  if (claim.kind === "unavailable") {
-    const at = new Date(now()).toISOString();
-    const state = recordAutoUpdateCheck(run.statePath ?? autoUpdateState(), { result: "failed", detail: claim.reason }, at);
-    appendAutoUpdateLog(logPath, `${at} ${describeAutoUpdateCheck(state)}`);
-    return { kind: "recorded", state };
-  }
-  if (claim.kind !== "acquired") return { kind: "locked" };
-  try {
-    const check = await checkAndInstall({
-      lockPath,
-      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) => finishWithUpgradeLock({ entry, args: [FINISH_UPGRADE_FLAG] });
-var finishGlobalUpgrade = async (subject, platform = process.platform, runFinish = finishWithThisNode) => {
-  const entry = globalUpgradeEntry(subject.prefix, subject.name, platform);
-  if (!existsSync2(entry)) return { kind: "entry_missing", entry };
-  try {
-    await 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 = await claimUpgradeLock(request);
-  if (claim.kind === "unavailable") return { kind: "refused", exitCode: EXIT.FAILED, message: `Could not lock the Pushary upgrade: ${claim.reason}` };
-  if (claim.kind === "held") return { kind: "refused", exitCode: EXIT.FAILED, message: describeHeldUpgradeLock(claim.holderPid) };
-  try {
-    await run();
-  } finally {
-    releaseAutoUpdateLock(request.lockPath ?? autoUpdateLock());
-  }
-  return { kind: "ran" };
-};
-var finishUpgradeWithLock = async (run, request) => {
-  const outcome = await withUpgradeLock(run, request);
-  if (outcome.kind === "refused") {
-    updateAutoUpdateState(request.statePath, { lastResult: "finish_pending", to: request.installedVersion, detail: outcome.message });
-  }
-  return outcome;
-};
-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 = await 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: await effects.finish(subject) };
-};
-
-// bin/pushary-upgrade.ts
+import { join } from "path";
 exitOnHelpFlag("upgrade");
 var detectInstallModes = () => {
   const candidates = [
     {
       label: "Cursor plugin",
       upgrade: "updates itself through Cursor",
-      present: existsSync3(cursorPluginDir())
+      present: existsSync(cursorPluginDir())
     },
     {
       label: "VS Code plugin",
       upgrade: `${NPX_LATEST_COMMAND} setup --agents vscode`,
-      present: existsSync3(vscodePluginDir())
+      present: existsSync(vscodePluginDir())
     },
     {
       label: "Codex config",
       upgrade: `${NPX_LATEST_COMMAND} setup --agents codex`,
-      present: existsSync3(codexConfigToml())
+      present: existsSync(codexConfigToml())
     },
     {
       label: "Claude Code config",
       upgrade: `${NPX_LATEST_COMMAND} setup --agents claude_code`,
-      present: existsSync3(claudeJson())
+      present: existsSync(claudeJson())
     },
     {
       label: "Gemini config",
       upgrade: `${NPX_LATEST_COMMAND} setup --agents gemini_cli`,
-      present: existsSync3(geminiSettings())
+      present: existsSync(geminiSettings())
     },
     {
       label: "Hermes plugin (pip)",
       upgrade: `${NPX_LATEST_COMMAND} setup --agents hermes`,
-      present: existsSync3(join2(homedir(), ".hermes"))
+      present: existsSync(join(homedir(), ".hermes"))
     }
   ];
   return candidates.filter((candidate) => candidate.present).map(({ label, upgrade }) => ({ label, upgrade }));

package/dist/bin/pushary-wait.js

@@ -4,33 +4,33 @@ import {
 } from "../chunk-CVWG2N3Y.js";
 import {
   exitOnFailedResponse
-} from "../chunk-2V64X5RE.js";
+} from "../chunk-LZMH4EGE.js";
 import {
   createIo
 } from "../chunk-U4TMAANR.js";
 import {
   exitOnHelpFlag
-} from "../chunk-K75TP4JY.js";
+} from "../chunk-JGQ2ANHQ.js";
 import {
   rejectUnknownFlags
 } from "../chunk-GMXKITVA.js";
-import "../chunk-75CEJ4WP.js";
-import "../chunk-P6VDRQF3.js";
-import "../chunk-VV4SBPCQ.js";
+import "../chunk-DMA3QUOB.js";
+import "../chunk-6JTTJIKJ.js";
+import "../chunk-J7JXA2LX.js";
 import {
   UsageError
 } from "../chunk-7QLSKOSU.js";
 import {
   EXIT
 } from "../chunk-KZERVKTD.js";
-import "../chunk-R76C43H7.js";
+import "../chunk-ZMKEKWNR.js";
 import "../chunk-T7E75EKA.js";
 import {
   getApiKey,
   getBaseUrl
-} from "../chunk-EG46RJRF.js";
-import "../chunk-SDSKTRIV.js";
-import "../chunk-4PCF34AB.js";
+} from "../chunk-4SB46XLF.js";
+import "../chunk-FVOCQSBG.js";
+import "../chunk-XEIV5QOT.js";
 
 // bin/pushary-wait.ts
 exitOnHelpFlag("wait");

package/dist/bin/pushary.js

@@ -1,23 +1,23 @@
 #!/usr/bin/env node
 import {
   installNetworkDefaults
-} from "../chunk-P6VDRQF3.js";
-import "../chunk-VV4SBPCQ.js";
+} from "../chunk-6JTTJIKJ.js";
+import "../chunk-J7JXA2LX.js";
 import "../chunk-7QLSKOSU.js";
 import {
   EXIT
 } from "../chunk-KZERVKTD.js";
-import "../chunk-R76C43H7.js";
+import "../chunk-ZMKEKWNR.js";
 import "../chunk-T7E75EKA.js";
-import "../chunk-EG46RJRF.js";
+import "../chunk-4SB46XLF.js";
 import {
   COMMANDS,
   isCommandName,
   renderHelp
-} from "../chunk-SDSKTRIV.js";
+} from "../chunk-FVOCQSBG.js";
 import {
   getPackageVersion
-} from "../chunk-4PCF34AB.js";
+} from "../chunk-XEIV5QOT.js";
 
 // src/cli/runtime.ts
 var supportsRuntime = (version) => {

package/dist/{chunk-EG46RJRF.js → chunk-4SB46XLF.js}

@@ -1,6 +1,6 @@
 import {
   NPX_LATEST_COMMAND
-} from "./chunk-SDSKTRIV.js";
+} from "./chunk-FVOCQSBG.js";
 
 // src/config.ts
 import { readFileSync } from "fs";

package/dist/{chunk-KETBIX7I.js → chunk-4XT4JXMG.js}

@@ -1,6 +1,6 @@
 import {
   readConfigFileKey
-} from "./chunk-ZRHA4PGN.js";
+} from "./chunk-RJ7ECJSZ.js";
 
 // src/bell/fleet.ts
 import { closeSync, constants, futimesSync, lstatSync, mkdirSync, openSync, readdirSync, unlinkSync } from "fs";

package/dist/{chunk-NAJ3UV4E.js → chunk-5K43TBK4.js}

@@ -2,17 +2,17 @@ import {
   CLAUDE_HOOK_EVENTS,
   GEMINI_HOOK_EVENTS,
   hasGeminiHooks
-} from "./chunk-YFS4HYCI.js";
+} from "./chunk-D3RS57MN.js";
 import {
   CODEX_HOOK_EVENTS,
   hasCodexHooks,
   holdBudgetOf
-} from "./chunk-R76C43H7.js";
+} from "./chunk-ZMKEKWNR.js";
 import {
   CURSOR_GATE_EVENTS,
   HOOK_LOCATOR_BINARY,
   hookCommandHoldBudget
-} from "./chunk-4PCF34AB.js";
+} from "./chunk-XEIV5QOT.js";
 
 // src/diagnostics/wiring.ts
 var record = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;

package/dist/{chunk-OLG6FJV2.js → chunk-65TOHCXT.js}

@@ -1,15 +1,15 @@
 import {
   AGENT_CHOICES
-} from "./chunk-ET6QSY3H.js";
+} from "./chunk-HU2LWGEE.js";
 import {
   isBridgeLocator
-} from "./chunk-TUZ7WKOF.js";
+} from "./chunk-LXWUYG7D.js";
 import {
   pusharyHookExecutable
-} from "./chunk-NAJ3UV4E.js";
+} from "./chunk-5K43TBK4.js";
 import {
   BELL_HOOK_BINARY
-} from "./chunk-RZXQFAWR.js";
+} from "./chunk-COSADFEH.js";
 
 // src/setup/hook-ownership.ts
 var commandsIn = (value) => {

package/dist/{chunk-P6VDRQF3.js → chunk-6JTTJIKJ.js}

@@ -1,16 +1,16 @@
 import {
   readExistingMachineId
-} from "./chunk-VV4SBPCQ.js";
+} from "./chunk-J7JXA2LX.js";
 import {
   NetworkError
 } from "./chunk-7QLSKOSU.js";
 import {
   getBaseUrl
-} from "./chunk-EG46RJRF.js";
+} from "./chunk-4SB46XLF.js";
 import {
   clientContextHeaders,
   getPackageVersion
-} from "./chunk-4PCF34AB.js";
+} from "./chunk-XEIV5QOT.js";
 
 // src/cli/net.ts
 import { createRequire } from "module";

package/dist/{chunk-3OFHFVPX.js → chunk-6L7TNZ43.js}

@@ -1,6 +1,6 @@
 import {
   pusharyDir
-} from "./chunk-R76C43H7.js";
+} from "./chunk-ZMKEKWNR.js";
 import {
   readJsonSafe
 } from "./chunk-T7E75EKA.js";