@pushary/agent-hooks 0.83.2 → 0.84.0

package/dist/chunk-CCH775Y6.js

@@ -0,0 +1,343 @@
+import {
+  needsShell,
+  spawnClaude
+} from "./chunk-XHKBHWLX.js";
+import {
+  resolveGlobalBinary
+} from "./chunk-VT4IVERX.js";
+import {
+  pusharyDir
+} from "./chunk-SEAHGHCE.js";
+import {
+  getMachineId
+} from "./chunk-RN3NOEJF.js";
+import {
+  getPackageVersion
+} from "./chunk-DINDL2CF.js";
+import {
+  readJsonSafe,
+  writeJsonAtomic
+} from "./chunk-6MTNS63X.js";
+import {
+  getApiKey
+} from "./chunk-2UMNXADU.js";
+
+// src/daemon-lifecycle.ts
+import { dirname, join } from "path";
+import { existsSync, mkdirSync, renameSync, unlinkSync, writeFileSync } from "fs";
+import { createHash, randomUUID } from "crypto";
+var daemonNeedsHandoff = (status) => status.kind === "version-mismatch" || status.kind === "configuration-mismatch" || status.kind === "unresponsive" && status.processAlive === true;
+var statePath = (dir) => join(dir, "daemon-state.json");
+var lockPath = (dir) => join(dir, "daemon.lock");
+var targetPath = (dir) => join(dir, "daemon-target.json");
+var DAEMON_LEASE_RENEW_INTERVAL_MS = 3e4;
+var LOCAL_LEASE_TIMEOUT_MS = DAEMON_LEASE_RENEW_INTERVAL_MS * 3;
+var buildDaemonLaunch = (input) => input.siblingEntry ? { command: input.execPath, args: [input.siblingEntry], shell: false } : {
+  command: input.daemonBinary,
+  args: [],
+  shell: needsShell(input.daemonBinary, input.platform ?? process.platform)
+};
+var spawnDetachedDaemon = (plan, options = {}) => {
+  const spawnImpl = options.spawnImpl ?? spawnClaude;
+  const child = spawnImpl(plan.command, plan.args, {
+    detached: true,
+    stdio: "ignore",
+    windowsHide: true,
+    shell: plan.shell
+  });
+  child.once?.("error", () => {
+  });
+  child.unref();
+  return typeof child.pid === "number" ? child.pid : null;
+};
+var processIsAlive = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+};
+var isString = (value) => typeof value === "string" && value.length > 0;
+var isTimestamp = (value) => isString(value) && Number.isFinite(Date.parse(value));
+var currentConfigurationId = () => {
+  try {
+    return createHash("sha256").update(getApiKey()).digest("hex").slice(0, 16);
+  } catch {
+    return null;
+  }
+};
+var parseDaemonState = (value) => {
+  if (typeof value !== "object" || value === null) return null;
+  const state = value;
+  if (!isString(state.instanceId) || !Number.isInteger(state.pid) || state.pid <= 0 || !isString(state.version) || !(state.configurationId === void 0 || state.configurationId === null || isString(state.configurationId)) || !isString(state.machineId) || !isTimestamp(state.startedAt) || !isTimestamp(state.updatedAt) || !(state.lastSuccessfulHeartbeatAt === null || isTimestamp(state.lastSuccessfulHeartbeatAt))) return null;
+  return {
+    instanceId: state.instanceId,
+    pid: state.pid,
+    version: state.version,
+    configurationId: state.configurationId ?? null,
+    machineId: state.machineId,
+    startedAt: state.startedAt,
+    updatedAt: state.updatedAt,
+    lastSuccessfulHeartbeatAt: state.lastSuccessfulHeartbeatAt
+  };
+};
+var parseLockOwner = (value) => {
+  if (typeof value !== "object" || value === null) return null;
+  const owner = value;
+  return isString(owner.instanceId) && Number.isInteger(owner.pid) && owner.pid > 0 ? { instanceId: owner.instanceId, pid: owner.pid } : null;
+};
+var readDaemonStatus = (options = {}) => {
+  const dir = options.dir ?? pusharyDir();
+  const installedVersion = options.installedVersion ?? getPackageVersion();
+  const state = readJsonSafe(statePath(dir));
+  if (state.kind === "missing") {
+    return {
+      kind: "absent",
+      installedVersion,
+      machineId: null,
+      pid: null,
+      processAlive: null,
+      daemonVersion: null,
+      startedAt: null,
+      updatedAt: null,
+      lastSuccessfulHeartbeatAt: null
+    };
+  }
+  const value = state.kind === "ok" ? parseDaemonState(state.value) : null;
+  if (value) {
+    const alive = (options.isProcessAlive ?? processIsAlive)(value.pid);
+    const fresh = (options.now ?? Date.now)() - Date.parse(value.updatedAt) <= LOCAL_LEASE_TIMEOUT_MS;
+    const expectedConfigurationId = options.configurationId === void 0 ? currentConfigurationId() : options.configurationId;
+    return {
+      kind: !alive || !fresh ? "unresponsive" : value.version !== installedVersion ? "version-mismatch" : expectedConfigurationId !== null && value.configurationId !== null && value.configurationId !== expectedConfigurationId ? "configuration-mismatch" : "running",
+      installedVersion,
+      machineId: value.machineId,
+      pid: value.pid,
+      processAlive: alive,
+      daemonVersion: value.version,
+      startedAt: value.startedAt,
+      updatedAt: value.updatedAt,
+      lastSuccessfulHeartbeatAt: value.lastSuccessfulHeartbeatAt
+    };
+  }
+  return {
+    kind: "invalid",
+    installedVersion,
+    machineId: null,
+    pid: null,
+    processAlive: null,
+    daemonVersion: null,
+    startedAt: null,
+    updatedAt: null,
+    lastSuccessfulHeartbeatAt: null
+  };
+};
+var safeUnlink = (path) => {
+  try {
+    unlinkSync(path);
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+};
+var requestDaemonVersion = (version, options = {}) => {
+  const dir = options.dir ?? pusharyDir();
+  const now = options.now ?? Date.now;
+  writeJsonAtomic(targetPath(dir), { version, requestedAt: new Date(now()).toISOString() }, 384);
+};
+var acquireDaemonLease = (options = {}) => {
+  const dir = options.dir ?? pusharyDir();
+  const installedVersion = options.installedVersion ?? getPackageVersion();
+  const machineId = options.machineId ?? getMachineId();
+  const pid = options.pid ?? process.pid;
+  const now = options.now ?? Date.now;
+  const instanceId = randomUUID();
+  const startedAt = new Date(now()).toISOString();
+  const writeLock = () => {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(lockPath(dir), JSON.stringify({ instanceId, pid }), { flag: "wx", mode: 384 });
+  };
+  try {
+    writeLock();
+  } catch (err) {
+    if (err.code !== "EEXIST") {
+      return { kind: "unavailable", detail: err instanceof Error ? err.message : String(err) };
+    }
+    const status = readDaemonStatus(options);
+    if (status.kind === "running" || status.kind === "version-mismatch" || status.kind === "configuration-mismatch") {
+      return { kind: "already-running", status };
+    }
+    const lock = readJsonSafe(lockPath(dir));
+    const owner = lock.kind === "ok" ? parseLockOwner(lock.value) : null;
+    if (!owner) return { kind: "unavailable", detail: "daemon lock is invalid" };
+    if ((options.isProcessAlive ?? processIsAlive)(owner.pid)) {
+      return { kind: "unavailable", detail: "daemon owner is still running or starting" };
+    }
+    const stale = join(dir, `daemon.lock.${instanceId}.stale`);
+    let ownsReplacement = false;
+    try {
+      renameSync(lockPath(dir), stale);
+      writeLock();
+      ownsReplacement = true;
+      safeUnlink(statePath(dir));
+      safeUnlink(stale);
+    } catch (retryError) {
+      if (ownsReplacement) safeUnlink(lockPath(dir));
+      try {
+        safeUnlink(stale);
+      } catch {
+      }
+      return { kind: "unavailable", detail: retryError instanceof Error ? retryError.message : String(retryError) };
+    }
+  }
+  const state = {
+    instanceId,
+    pid,
+    version: installedVersion,
+    configurationId: options.configurationId === void 0 ? currentConfigurationId() : options.configurationId,
+    machineId,
+    startedAt,
+    updatedAt: startedAt,
+    lastSuccessfulHeartbeatAt: null
+  };
+  try {
+    writeJsonAtomic(statePath(dir), state, 384);
+  } catch (err) {
+    safeUnlink(lockPath(dir));
+    return { kind: "unavailable", detail: err instanceof Error ? err.message : String(err) };
+  }
+  let currentState = state;
+  const isOwner = () => {
+    const owner = readJsonSafe(lockPath(dir));
+    return owner.kind === "ok" && owner.value.instanceId === instanceId;
+  };
+  const updateState = (next) => {
+    if (!isOwner()) return;
+    try {
+      writeJsonAtomic(statePath(dir), next, 384);
+      currentState = next;
+    } catch {
+    }
+  };
+  return {
+    kind: "acquired",
+    lease: {
+      isOwner,
+      renew: (at = now()) => {
+        updateState({ ...currentState, updatedAt: new Date(at).toISOString() });
+      },
+      recordSuccessfulHeartbeat: (at = now()) => {
+        const timestamp = new Date(at).toISOString();
+        updateState({
+          ...currentState,
+          updatedAt: timestamp,
+          lastSuccessfulHeartbeatAt: timestamp
+        });
+      },
+      shouldYield: () => {
+        if (!isOwner()) return true;
+        const target = readJsonSafe(targetPath(dir));
+        return target.kind === "ok" && (typeof target.value.version === "string" && target.value.version !== installedVersion || isTimestamp(target.value.requestedAt) && Date.parse(target.value.requestedAt) > Date.parse(startedAt));
+      },
+      release: () => {
+        if (!isOwner()) return;
+        safeUnlink(statePath(dir));
+        safeUnlink(lockPath(dir));
+      }
+    }
+  };
+};
+var hasConfiguration = () => {
+  try {
+    getApiKey();
+    return true;
+  } catch {
+    return false;
+  }
+};
+var wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var requestDaemonHandoff = async (initial, options = {}) => {
+  const now = options.now ?? Date.now;
+  const requestedAt = Math.max(
+    now(),
+    initial.startedAt === null ? 0 : Date.parse(initial.startedAt) + 1
+  );
+  requestDaemonVersion(options.installedVersion ?? initial.installedVersion, {
+    dir: options.dir,
+    now: () => requestedAt
+  });
+  if (initial.pid === null || initial.processAlive !== true) return initial;
+  const sleep = options.sleep ?? wait;
+  const pollIntervalMs = options.pollIntervalMs ?? 50;
+  const attempts = Math.max(1, Math.ceil((options.waitTimeoutMs ?? 5e3) / pollIntervalMs));
+  let status = initial;
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    await sleep(pollIntervalMs);
+    status = readDaemonStatus(options);
+    if (status.pid !== initial.pid || status.processAlive !== true) break;
+  }
+  return status;
+};
+var launchInstalledDaemon = (options) => {
+  const entryExists = options.entryExists ?? existsSync;
+  const argvEntry = process.argv[1];
+  const candidate = options.daemonEntry !== void 0 ? options.daemonEntry : argvEntry ? join(dirname(argvEntry), "pushary-daemon.js") : null;
+  const siblingEntry = candidate && entryExists(candidate) ? candidate : null;
+  const platform = options.platform ?? process.platform;
+  const daemonBinary = options.daemonBinary ?? resolveGlobalBinary("pushary-daemon") ?? (platform === "win32" ? "pushary-daemon.cmd" : "pushary-daemon");
+  const plan = buildDaemonLaunch({
+    siblingEntry,
+    execPath: options.execPath ?? process.execPath,
+    daemonBinary,
+    platform
+  });
+  spawnDetachedDaemon(plan, { spawnImpl: options.spawnImpl });
+};
+var ensureDaemonRunning = async (options = {}) => {
+  const initial = readDaemonStatus(options);
+  if (!(options.configured ?? hasConfiguration)()) {
+    return { kind: "not-configured", status: initial, detail: "Pushary is not configured on this machine" };
+  }
+  if (initial.kind === "running") return { kind: "running", status: initial };
+  let handoffStatus;
+  try {
+    handoffStatus = await requestDaemonHandoff(initial, options);
+  } catch (err) {
+    return {
+      kind: "unavailable",
+      status: initial,
+      detail: err instanceof Error ? err.message : String(err)
+    };
+  }
+  const sleep = options.sleep ?? wait;
+  const pollIntervalMs = options.pollIntervalMs ?? 50;
+  const attempts = Math.max(1, Math.ceil((options.waitTimeoutMs ?? 5e3) / pollIntervalMs));
+  if (handoffStatus.kind === "running") return { kind: "running", status: handoffStatus };
+  if (daemonNeedsHandoff(handoffStatus)) {
+    return { kind: "unavailable", status: handoffStatus, detail: "unhealthy daemon did not yield" };
+  }
+  try {
+    (options.spawnDaemon ?? (() => launchInstalledDaemon(options)))();
+  } catch (err) {
+    return {
+      kind: "unavailable",
+      status: initial,
+      detail: err instanceof Error ? err.message : String(err)
+    };
+  }
+  let status = initial;
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    status = readDaemonStatus(options);
+    if (status.kind === "running") return { kind: "started", status };
+    await sleep(pollIntervalMs);
+  }
+  return { kind: "unavailable", status, detail: `daemon did not become healthy (${status.kind})` };
+};
+
+export {
+  DAEMON_LEASE_RENEW_INTERVAL_MS,
+  readDaemonStatus,
+  acquireDaemonLease,
+  requestDaemonHandoff,
+  ensureDaemonRunning
+};

package/dist/chunk-DINDL2CF.js

@@ -0,0 +1,45 @@
+// src/cli/version.ts
+import { readFileSync } from "fs";
+import { dirname, join, parse } from "path";
+import { fileURLToPath } from "url";
+var PACKAGE_NAME = "@pushary/agent-hooks";
+var findOwnPackageJson = (start) => {
+  const { root } = parse(start);
+  let dir = start;
+  while (true) {
+    const candidate = join(dir, "package.json");
+    try {
+      const pkg = JSON.parse(readFileSync(candidate, "utf-8"));
+      if (pkg.name === PACKAGE_NAME) return candidate;
+    } catch {
+    }
+    if (dir === root) return void 0;
+    const parent = dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+};
+var getPackageVersion = () => {
+  try {
+    const found = findOwnPackageJson(dirname(fileURLToPath(import.meta.url)));
+    if (!found) return "0.0.0";
+    const pkg = JSON.parse(readFileSync(found, "utf-8"));
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+};
+var isNewerVersion = (candidate, current) => {
+  const a = candidate.split(".").map((part) => parseInt(part, 10) || 0);
+  const b = current.split(".").map((part) => parseInt(part, 10) || 0);
+  for (let i = 0; i < 3; i++) {
+    if ((a[i] ?? 0) > (b[i] ?? 0)) return true;
+    if ((a[i] ?? 0) < (b[i] ?? 0)) return false;
+  }
+  return false;
+};
+
+export {
+  getPackageVersion,
+  isNewerVersion
+};

package/dist/{chunk-TXF4QZSQ.js → chunk-DOXSWT4Q.js}

@@ -1,6 +1,6 @@
 import {
   HOOK_BUDGETS
-} from "./chunk-YWRJGYUH.js";
+} from "./chunk-MQMPG5X4.js";
 
 // src/gemini-config.ts
 var GEMINI_HOOK_BINARY = "pushary-gemini-hook";

package/dist/chunk-EVJ6ULHN.js

@@ -0,0 +1,153 @@
+import {
+  pusharyDir
+} from "./chunk-SEAHGHCE.js";
+import {
+  readJsonSafe
+} from "./chunk-6MTNS63X.js";
+
+// src/process-ownership.ts
+import { createHash, randomUUID } from "crypto";
+import { mkdirSync, readdirSync, unlinkSync, writeFileSync } from "fs";
+import { createConnection, createServer } from "net";
+import { join } from "path";
+var MAX_PROOF_BYTES = 1024;
+var ownershipDir = (options) => options.dir ?? join(pusharyDir(), "processes");
+var proofPath = (dir, sessionId) => join(dir, `${createHash("sha256").update(sessionId).digest("hex")}.json`);
+var isProof = (value) => {
+  if (!value || typeof value !== "object") return false;
+  const proof = value;
+  return typeof proof.sessionId === "string" && Number.isInteger(proof.pid) && proof.pid > 1 && Number.isInteger(proof.port) && proof.port > 0 && proof.port <= 65535 && typeof proof.token === "string" && proof.token.length > 0 && (proof.spawnId === void 0 || typeof proof.spawnId === "string");
+};
+var removeProof = (path, token) => {
+  const current = readJsonSafe(path);
+  if (current.kind !== "ok" || current.value.token !== token) return;
+  try {
+    unlinkSync(path);
+  } catch {
+  }
+};
+var processIsAlive = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+};
+var pruneProofs = (dir) => {
+  try {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+      const path = join(dir, entry.name);
+      const stored = readJsonSafe(path);
+      if (stored.kind !== "ok" || !isProof(stored.value) || !processIsAlive(stored.value.pid)) unlinkSync(path);
+    }
+  } catch {
+  }
+};
+var startProcessOwnership = (identity, options = {}) => {
+  const dir = ownershipDir(options);
+  const path = proofPath(dir, identity.sessionId);
+  const token = randomUUID();
+  let stopped = false;
+  let proof = null;
+  let settleReady = () => {
+  };
+  const server = createServer((socket) => {
+    let request = "";
+    socket.setTimeout(500, () => socket.destroy());
+    socket.on("error", () => {
+    });
+    socket.on("data", (chunk) => {
+      request += String(chunk);
+      if (!proof || request.length > token.length) socket.destroy();
+      else if (request.length === token.length) {
+        if (request === token) socket.end(JSON.stringify(proof));
+        else socket.destroy();
+      }
+    });
+  });
+  server.maxConnections = 4;
+  const ready = new Promise((resolve) => {
+    settleReady = resolve;
+    const resolveOnce = () => resolve();
+    server.once("error", resolveOnce);
+    server.listen(0, "127.0.0.1", () => {
+      server.off("error", resolveOnce);
+      server.on("error", () => {
+      });
+      if (stopped) {
+        server.close();
+        resolve();
+        return;
+      }
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        server.close();
+        resolve();
+        return;
+      }
+      try {
+        proof = { ...identity, port: address.port, token };
+        mkdirSync(dir, { recursive: true, mode: 448 });
+        pruneProofs(dir);
+        writeFileSync(path, JSON.stringify(proof), { encoding: "utf8", mode: 384 });
+        resolve();
+      } catch {
+        server.close();
+        resolve();
+      }
+    });
+  });
+  const cleanup = () => removeProof(path, token);
+  process.once("exit", cleanup);
+  return {
+    ready,
+    stop() {
+      if (stopped) return;
+      stopped = true;
+      settleReady();
+      process.off("exit", cleanup);
+      server.close();
+      cleanup();
+    }
+  };
+};
+var ownsLiveProcess = async (request, options = {}) => {
+  const stored = readJsonSafe(proofPath(ownershipDir(options), request.sessionId));
+  if (stored.kind !== "ok" || !isProof(stored.value)) return false;
+  const proof = stored.value;
+  if (proof.sessionId !== request.sessionId || proof.pid !== request.pid) return false;
+  if (request.spawnId && proof.spawnId !== request.spawnId) return false;
+  return new Promise((resolve) => {
+    let settled = false;
+    let raw = "";
+    const socket = createConnection({ host: "127.0.0.1", port: proof.port });
+    const finish = (owned) => {
+      if (settled) return;
+      settled = true;
+      socket.destroy();
+      resolve(owned);
+    };
+    socket.setTimeout(options.connectTimeoutMs ?? 500, () => finish(false));
+    socket.on("error", () => finish(false));
+    socket.on("connect", () => socket.write(proof.token));
+    socket.on("data", (chunk) => {
+      raw += String(chunk);
+      if (raw.length > MAX_PROOF_BYTES) finish(false);
+    });
+    socket.on("end", () => {
+      try {
+        const live = JSON.parse(raw);
+        finish(isProof(live) && live.token === proof.token && live.sessionId === proof.sessionId && live.pid === proof.pid && live.spawnId === proof.spawnId);
+      } catch {
+        finish(false);
+      }
+    });
+  });
+};
+
+export {
+  startProcessOwnership,
+  ownsLiveProcess
+};

package/dist/{chunk-QR6MVVQ7.js → chunk-F52SIIDG.js}

@@ -5,14 +5,14 @@ import {
   NetworkError
 } from "./chunk-7QLSKOSU.js";
 import {
-  isValidApiKey
-} from "./chunk-YWRJGYUH.js";
+  EXIT
+} from "./chunk-KZERVKTD.js";
 import {
   getBaseUrl
 } from "./chunk-2UMNXADU.js";
 import {
-  EXIT
-} from "./chunk-KZERVKTD.js";
+  isValidApiKey
+} from "./chunk-MQMPG5X4.js";
 
 // src/session.ts
 var IDENTITY_PATH = "/api/v1/server/identity";

package/dist/{chunk-26D2YMDU.js → chunk-FBGBJXVC.js}

@@ -1,7 +1,7 @@
 import {
   describeKeyCheck,
   keyCheckFromResponse
-} from "./chunk-QR6MVVQ7.js";
+} from "./chunk-F52SIIDG.js";
 import {
   createIo
 } from "./chunk-5RUIFDTP.js";

package/dist/{chunk-QF7WTF2C.js → chunk-HZNOAJGB.js}

@@ -1,9 +1,9 @@
 import {
   hasGeminiHooks
-} from "./chunk-TXF4QZSQ.js";
+} from "./chunk-DOXSWT4Q.js";
 import {
   hasCodexHooks
-} from "./chunk-EHLTWCDZ.js";
+} from "./chunk-SEAHGHCE.js";
 
 // src/diagnostics/wiring.ts
 var record = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;

package/dist/{chunk-RRZZ7TFJ.js → chunk-J4KFVOCQ.js}

@@ -1,7 +1,9 @@
 import {
-  getPackageVersion,
   renderCommandHelp
-} from "./chunk-ZUKH2NPJ.js";
+} from "./chunk-MGJBC6DD.js";
+import {
+  getPackageVersion
+} from "./chunk-DINDL2CF.js";
 import {
   EXIT
 } from "./chunk-KZERVKTD.js";

package/dist/{chunk-WDRRULBH.js → chunk-K7CSRGKZ.js}

@@ -1,15 +1,15 @@
+import {
+  resolveShellRc
+} from "./chunk-BC3VCZ3E.js";
 import {
   backupFile,
   readJsonSafe,
   writeFileAtomic,
   writeJsonAtomic
 } from "./chunk-6MTNS63X.js";
-import {
-  resolveShellRc
-} from "./chunk-BC3VCZ3E.js";
 import {
   resolveInstallSourceFor
-} from "./chunk-SAA3VBDK.js";
+} from "./chunk-437T77TY.js";
 import {
   configFilePath
 } from "./chunk-2UMNXADU.js";

package/dist/{chunk-ZUKH2NPJ.js → chunk-MGJBC6DD.js}

@@ -192,52 +192,9 @@ var renderCommandHelp = (name, version) => {
   ].join("\n");
 };
 
-// src/cli/version.ts
-import { readFileSync } from "fs";
-import { dirname, join, parse } from "path";
-import { fileURLToPath } from "url";
-var PACKAGE_NAME = "@pushary/agent-hooks";
-var findOwnPackageJson = (start) => {
-  const { root } = parse(start);
-  let dir = start;
-  while (true) {
-    const candidate = join(dir, "package.json");
-    try {
-      const pkg = JSON.parse(readFileSync(candidate, "utf-8"));
-      if (pkg.name === PACKAGE_NAME) return candidate;
-    } catch {
-    }
-    if (dir === root) return void 0;
-    const parent = dirname(dir);
-    if (parent === dir) return void 0;
-    dir = parent;
-  }
-};
-var getPackageVersion = () => {
-  try {
-    const found = findOwnPackageJson(dirname(fileURLToPath(import.meta.url)));
-    if (!found) return "0.0.0";
-    const pkg = JSON.parse(readFileSync(found, "utf-8"));
-    return pkg.version ?? "0.0.0";
-  } catch {
-    return "0.0.0";
-  }
-};
-var isNewerVersion = (candidate, current) => {
-  const a = candidate.split(".").map((part) => parseInt(part, 10) || 0);
-  const b = current.split(".").map((part) => parseInt(part, 10) || 0);
-  for (let i = 0; i < 3; i++) {
-    if ((a[i] ?? 0) > (b[i] ?? 0)) return true;
-    if ((a[i] ?? 0) < (b[i] ?? 0)) return false;
-  }
-  return false;
-};
-
 export {
   COMMANDS,
   isCommandName,
   renderHelp,
-  renderCommandHelp,
-  getPackageVersion,
-  isNewerVersion
+  renderCommandHelp
 };

package/dist/{chunk-GQLB2GBJ.js → chunk-MHBC2XUP.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-RN3NOEJF.js";
 import {
   getPackageVersion
-} from "./chunk-ZUKH2NPJ.js";
+} from "./chunk-DINDL2CF.js";
 import {
   getBaseUrl
 } from "./chunk-2UMNXADU.js";