pushary 1.9.0 → 1.9.1

package/dist/chunk-QQJCDRD3.js

@@ -0,0 +1,242 @@
+import {
+  claimUpgradeLock,
+  finishWithUpgradeLock,
+  installWithUpgradeLock,
+  releaseAutoUpdateLock
+} from "./chunk-QXL27RY6.js";
+import {
+  describeAutoUpdateCheck,
+  globalInstallLocation,
+  hasPendingUpgradeFinish,
+  readAutoUpdateState,
+  updateAutoUpdateState,
+  upgradeEntryFor
+} from "./chunk-CE4UH4AP.js";
+import {
+  EXIT
+} from "./chunk-KZERVKTD.js";
+import {
+  autoUpdateLock,
+  autoUpdateLog,
+  autoUpdateState,
+  execNpm,
+  fetchLatestPublishedVersion,
+  npmErrorMessage,
+  readGlobalCliInstallAt,
+  readGlobalPrefix
+} from "./chunk-ZMKEKWNR.js";
+import {
+  NPX_LATEST_COMMAND
+} from "./chunk-FVOCQSBG.js";
+import {
+  commandsPackage,
+  globalUpgradeEntry,
+  isNewerVersion,
+  isReleaseVersion,
+  isSameMajorVersion,
+  ownPackageRoot,
+  packageVersionAt
+} from "./chunk-XEIV5QOT.js";
+
+// src/global-upgrade.ts
+import { existsSync } from "fs";
+
+// src/auto-update-run.ts
+import { closeSync, mkdirSync, openSync, statSync, writeSync } from "fs";
+import { dirname } 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) => {
+  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 = 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 (!existsSync(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) };
+};
+
+export {
+  FINISH_UPGRADE_FLAG,
+  runAutoUpdate,
+  globalUpgradeSubject,
+  readGlobalUpgradeSubject,
+  finishGlobalUpgrade,
+  withUpgradeLock,
+  finishUpgradeWithLock,
+  upgradeInstalledPackage
+};

package/dist/chunk-QXL27RY6.js

@@ -0,0 +1,175 @@
+import {
+  autoUpdateLock,
+  installPackageGlobally,
+  npmErrorMessage
+} from "./chunk-ZMKEKWNR.js";
+import {
+  writeJsonAtomic
+} from "./chunk-T7E75EKA.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 ownsUpgradeLock = (lockPath) => {
+  try {
+    return heldLocks.has(canonicalLockPath(lockPath));
+  } catch {
+    return false;
+  }
+};
+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);
+};
+
+export {
+  claimUpgradeLock,
+  ownsUpgradeLock,
+  releaseAutoUpdateLock,
+  finishWithUpgradeLock,
+  installWithUpgradeLock
+};

package/dist/{chunk-ZRHA4PGN.js → chunk-RJ7ECJSZ.js}

@@ -1,6 +1,6 @@
 import {
   resolveInstallSourceFor
-} from "./chunk-US3RDXK7.js";
+} from "./chunk-6QSDNXGM.js";
 import {
   backupFile,
   readJsonSafe,
@@ -9,7 +9,7 @@ import {
 } from "./chunk-T7E75EKA.js";
 import {
   configFilePath
-} from "./chunk-EG46RJRF.js";
+} from "./chunk-4SB46XLF.js";
 
 // src/shell-alias.ts
 import { homedir } from "os";

package/dist/{chunk-VYNTRHB6.js → chunk-RNDFGHSQ.js}

@@ -1,6 +1,6 @@
 import {
   PRETOOLUSE_GATED_TOOLS
-} from "./chunk-4PCF34AB.js";
+} from "./chunk-XEIV5QOT.js";
 
 // src/claude-tools.ts
 var POSTTOOLUSE_MIRROR_ONLY_TOOLS = ["TodoWrite", "Task", "WebFetch", "WebSearch"];

package/dist/{chunk-4GMZOGH4.js → chunk-RS4ZOFSF.js}

@@ -14,18 +14,18 @@ import {
 } from "./chunk-U4TMAANR.js";
 import {
   callMcpTool
-} from "./chunk-CPBRXBLG.js";
+} from "./chunk-VH6763OR.js";
 import {
   reportedInstallSource
-} from "./chunk-US3RDXK7.js";
+} from "./chunk-6QSDNXGM.js";
 import {
   NPX_LATEST_COMMAND
-} from "./chunk-SDSKTRIV.js";
+} from "./chunk-FVOCQSBG.js";
 import {
   NO_PAIRING_COMPUTER,
   PAIR_TTL_SECONDS,
   isAnswerSource
-} from "./chunk-4PCF34AB.js";
+} from "./chunk-XEIV5QOT.js";
 
 // src/reach.ts
 var reachVerdict = (channels) => {

package/dist/{chunk-JOQEPWDH.js → chunk-SKEP3M6M.js}

@@ -3,11 +3,11 @@ import {
   decodePublicKey,
   generateSessionKey,
   wrapSessionKey
-} from "./chunk-MGXXQHCM.js";
+} from "./chunk-FJPC35OW.js";
 import {
   fetchTranscriptRecipients,
   uploadTranscriptRecords
-} from "./chunk-HSM5FIA3.js";
+} from "./chunk-PMS3EBD2.js";
 
 // src/live-session.ts
 var MAX_TRANSCRIPT_QUEUE = 100;

package/dist/{chunk-BG4QCOHQ.js → chunk-SPB3QRE7.js}

@@ -4,18 +4,18 @@ import {
 } from "./chunk-POFBE6ZY.js";
 import {
   isNetworkFailure
-} from "./chunk-P6VDRQF3.js";
+} from "./chunk-6JTTJIKJ.js";
 import {
   clientReportClaims
-} from "./chunk-R76C43H7.js";
+} from "./chunk-ZMKEKWNR.js";
 import {
   getApiKey,
   getBaseUrl
-} from "./chunk-EG46RJRF.js";
+} from "./chunk-4SB46XLF.js";
 import {
   CLIENT_REPORT_PATH,
   degradedLine
-} from "./chunk-4PCF34AB.js";
+} from "./chunk-XEIV5QOT.js";
 
 // src/client-report-claim.ts
 import { createHash } from "crypto";

package/dist/{chunk-XXVMUMKT.js → chunk-SWGY5WNX.js}

@@ -1,11 +1,11 @@
 import {
   ensureCodexTrustsPusharyHooks
-} from "./chunk-JW7DKTT6.js";
+} from "./chunk-KR5JASA4.js";
 import {
   addClaudeMcpServer,
   addPusharyHooks,
   addPusharyToolPermissions
-} from "./chunk-MQJWO3AA.js";
+} from "./chunk-6Q4NM2LW.js";
 import {
   detectClaudeVersion
 } from "./chunk-RIVNNBEK.js";
@@ -15,7 +15,7 @@ import {
   codexUnprovenHolds,
   codexWired,
   geminiWired
-} from "./chunk-NAJ3UV4E.js";
+} from "./chunk-5K43TBK4.js";
 import {
   CLAUDE_HOOK_BINARY,
   CLAUDE_HOOK_EVENTS,
@@ -26,7 +26,7 @@ import {
   needsReregistration,
   registrationSignatures,
   supportedClaudeEvents
-} from "./chunk-YFS4HYCI.js";
+} from "./chunk-D3RS57MN.js";
 import {
   formatVersion
 } from "./chunk-6ICPEJY5.js";
@@ -49,7 +49,7 @@ import {
   registrationHolderOf,
   resolveGlobalBinary,
   vscodePluginMcp
-} from "./chunk-R76C43H7.js";
+} from "./chunk-ZMKEKWNR.js";
 import {
   readJsonSafe,
   writeFileAtomic,

package/dist/{chunk-OXQKXZJ3.js → chunk-UPTEPARD.js}

@@ -1,9 +1,9 @@
 import {
   registerTranscript
-} from "./chunk-WFVNXGZ6.js";
+} from "./chunk-WWDPULS3.js";
 import {
   writeDegraded
-} from "./chunk-BG4QCOHQ.js";
+} from "./chunk-SPB3QRE7.js";
 
 // src/tool-hook-input.ts
 var OPTIONAL_TEXT_FIELDS = ["hook_event_name", "session_id", "cwd", "transcript_path", "tool_use_id", "permission_mode"];

package/dist/{chunk-IQUBCAEK.js → chunk-UYHLMBPQ.js}

@@ -1,7 +1,7 @@
 import {
   HOOK_HOLD_BUDGET_ENV,
   hookHoldBudgetProof
-} from "./chunk-4PCF34AB.js";
+} from "./chunk-XEIV5QOT.js";
 
 // src/hold-budget.ts
 var takeHookHoldBudget = (args = process.argv.slice(2), env = process.env) => {

package/dist/{chunk-K7DY2DQN.js → chunk-V4H33GBM.js}

@@ -1,17 +1,17 @@
 import {
   MCP_BRIDGE_BINARY
-} from "./chunk-MBNMO5IR.js";
+} from "./chunk-LJI7U6PM.js";
 import {
   openCodeConfigDirFrom
-} from "./chunk-HHNFGWR5.js";
+} from "./chunk-CGRPHFOV.js";
 import {
   KEY_FILE_MODE
-} from "./chunk-ZRHA4PGN.js";
+} from "./chunk-RJ7ECJSZ.js";
 import {
   NpmMissingError,
   codexHomeFrom,
   resolvePathBinary
-} from "./chunk-R76C43H7.js";
+} from "./chunk-ZMKEKWNR.js";
 import {
   readJsonSafe,
   writeFileAtomic,
@@ -19,10 +19,10 @@ import {
 } from "./chunk-T7E75EKA.js";
 import {
   NPX_LATEST_COMMAND
-} from "./chunk-SDSKTRIV.js";
+} from "./chunk-FVOCQSBG.js";
 import {
   HOOK_COMPATIBLE_PROFILES
-} from "./chunk-4PCF34AB.js";
+} from "./chunk-XEIV5QOT.js";
 
 // src/hermes-config.ts
 import { execFileSync } from "child_process";

package/dist/{chunk-CPBRXBLG.js → chunk-VH6763OR.js}

@@ -1,12 +1,12 @@
 import {
   keyCheckFromResponse
-} from "./chunk-75CEJ4WP.js";
+} from "./chunk-DMA3QUOB.js";
 import {
   installNetworkDefaults
-} from "./chunk-P6VDRQF3.js";
+} from "./chunk-6JTTJIKJ.js";
 import {
   getBaseUrl
-} from "./chunk-EG46RJRF.js";
+} from "./chunk-4SB46XLF.js";
 
 // src/retry.ts
 var isRetryable = (err) => {

package/dist/{chunk-7LLNRCOK.js → chunk-VQLWYKX7.js}

@@ -1,6 +1,6 @@
 import {
   NPX_LATEST_COMMAND
-} from "./chunk-SDSKTRIV.js";
+} from "./chunk-FVOCQSBG.js";
 
 // src/setup/codex-trust.ts
 var CODEX_TRUST_TELEMETRY = {

package/dist/{chunk-WFVNXGZ6.js → chunk-WWDPULS3.js}

@@ -6,38 +6,38 @@ import {
 } from "./chunk-SGZJ5LYH.js";
 import {
   hookOwnerOf
-} from "./chunk-OLG6FJV2.js";
+} from "./chunk-65TOHCXT.js";
 import {
   ensureDaemonRunning
-} from "./chunk-LQESQPIT.js";
+} from "./chunk-PEGKBNGN.js";
 import {
   buildTranscriptRecords,
   decodePublicKey,
   generateSessionKey,
   wrapSessionKey
-} from "./chunk-MGXXQHCM.js";
+} from "./chunk-FJPC35OW.js";
 import {
   fetchTranscriptRecipients,
   uploadTranscriptRecords
-} from "./chunk-HSM5FIA3.js";
+} from "./chunk-PMS3EBD2.js";
 import {
   transcriptEnvironmentPreference,
   transcriptsEnabled
-} from "./chunk-MBVV3RX3.js";
+} from "./chunk-7ER66HZH.js";
 import {
   readTranscriptPreference
-} from "./chunk-ZRHA4PGN.js";
+} from "./chunk-RJ7ECJSZ.js";
 import {
   codexHome,
   pusharyDir
-} from "./chunk-R76C43H7.js";
+} from "./chunk-ZMKEKWNR.js";
 import {
   writeJsonAtomic
 } from "./chunk-T7E75EKA.js";
 import {
   getApiKey,
   getBaseUrl
-} from "./chunk-EG46RJRF.js";
+} from "./chunk-4SB46XLF.js";
 
 // src/transcript-registration.ts
 import { createHash } from "crypto";