@pushary/agent-hooks 0.83.2 → 0.84.1

package/dist/chunk-ERYKGH4J.js

@@ -0,0 +1,140 @@
+import {
+  buildTranscriptRecords,
+  decodePublicKey,
+  fetchAccountPublicKey,
+  generateSessionKey,
+  uploadTranscriptRecords,
+  wrapSessionKey
+} from "./chunk-GCKAWHFP.js";
+
+// src/live-session.ts
+var MAX_TRANSCRIPT_QUEUE = 100;
+var MAX_TRANSCRIPT_TEXT = 32 * 1024;
+var LIVE_SESSION_HEARTBEAT_MS = 6e4;
+var liveSessionSleep = (ms, signal) => new Promise((resolve) => {
+  if (signal.aborted) return resolve();
+  const timer = setTimeout(done, ms);
+  function done() {
+    clearTimeout(timer);
+    signal.removeEventListener("abort", done);
+    resolve();
+  }
+  signal.addEventListener("abort", done, { once: true });
+});
+var postLiveSession = (options, path, body) => {
+  const controller = new AbortController();
+  const abort = () => controller.abort();
+  const timeout = setTimeout(abort, options.requestTimeoutMs ?? 1e4);
+  if (options.signal.aborted) abort();
+  else options.signal.addEventListener("abort", abort, { once: true });
+  return fetch(`${options.baseUrl}${path}`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${options.apiKey}`, "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+    signal: controller.signal
+  }).finally(() => {
+    clearTimeout(timeout);
+    options.signal.removeEventListener("abort", abort);
+  });
+};
+var postLiveSessionUntilAccepted = async (options, path, body) => {
+  while (!options.signal.aborted) {
+    try {
+      const response = await postLiveSession(options, path, body);
+      if (response.ok) return;
+      if (response.status < 500 && response.status !== 429) {
+        throw new Error(`${path} rejected (${response.status})`);
+      }
+    } catch (error) {
+      if (options.signal.aborted) throw error;
+      if (error instanceof Error && error.message.startsWith(`${path} rejected`)) throw error;
+    }
+    await liveSessionSleep(options.pollIntervalMs ?? 2e3, options.signal);
+  }
+  throw new Error("Live session stopped before it linked");
+};
+var startLiveSessionHeartbeat = (options, body, intervalMs = LIVE_SESSION_HEARTBEAT_MS) => {
+  const timer = setInterval(() => {
+    if (!options.signal.aborted) {
+      void postLiveSession(options, "/api/agent/event", body).catch(() => {
+      });
+    }
+  }, intervalMs);
+  timer.unref();
+  return () => clearInterval(timer);
+};
+var LiveTranscriptRelay = class {
+  constructor(options, sessionId) {
+    this.options = options;
+    this.sessionId = sessionId;
+  }
+  queue = [];
+  sessionKey = null;
+  wrappedKey = null;
+  keyUploaded = false;
+  keyRejected = false;
+  flushing = null;
+  add(value) {
+    if (this.keyRejected) return;
+    const raw = JSON.stringify(value);
+    if (raw.length > MAX_TRANSCRIPT_TEXT) return;
+    if (this.queue.length === MAX_TRANSCRIPT_QUEUE) this.queue.shift();
+    this.queue.push(raw);
+    void this.flush();
+  }
+  async flush() {
+    if (this.flushing) return this.flushing;
+    if (this.queue.length === 0) return;
+    this.flushing = this.drainQueue().finally(() => {
+      this.flushing = null;
+    });
+    return this.flushing;
+  }
+  async drainQueue() {
+    while (this.queue.length > 0 && await this.flushBatch()) {
+    }
+  }
+  async flushBatch() {
+    try {
+      if (!this.sessionKey) {
+        const publicKey = await fetchAccountPublicKey(this.options.apiKey, this.options.baseUrl);
+        if (!publicKey) return false;
+        this.sessionKey = generateSessionKey();
+        this.wrappedKey = wrapSessionKey(this.sessionKey, decodePublicKey(publicKey));
+      }
+      const count = Math.min(this.queue.length, 50);
+      const records = buildTranscriptRecords(this.queue.slice(0, count), this.sessionKey).records;
+      if (records.length === 0) {
+        this.queue.splice(0, count);
+        return true;
+      }
+      const result = await uploadTranscriptRecords(this.options.apiKey, {
+        sessionId: this.sessionId,
+        machineId: this.options.machineId,
+        dataEncryptionKey: this.keyUploaded ? void 0 : this.wrappedKey ?? void 0,
+        records
+      }, this.options.baseUrl);
+      if (result.keyConflict) {
+        this.keyRejected = true;
+        this.queue.length = 0;
+        return false;
+      }
+      if (result.ok) {
+        this.keyUploaded ||= result.keyRegistered;
+        this.queue.splice(0, count);
+        return true;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+};
+
+export {
+  liveSessionSleep,
+  postLiveSession,
+  postLiveSessionUntilAccepted,
+  startLiveSessionHeartbeat,
+  LiveTranscriptRelay
+};

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-GCKAWHFP.js

@@ -0,0 +1,124 @@
+import {
+  getBaseUrl
+} from "./chunk-2UMNXADU.js";
+import {
+  redactSecrets
+} from "./chunk-MQMPG5X4.js";
+
+// src/crypto.ts
+import nacl from "tweetnacl";
+var EPH_PUB_LEN = nacl.box.publicKeyLength;
+var BOX_NONCE_LEN = nacl.box.nonceLength;
+var SECRETBOX_NONCE_LEN = nacl.secretbox.nonceLength;
+var SESSION_KEY_LEN = nacl.secretbox.keyLength;
+var toBase64 = (bytes) => Buffer.from(bytes).toString("base64");
+var fromBase64 = (value) => new Uint8Array(Buffer.from(value, "base64"));
+var utf8Encode = (text) => new Uint8Array(Buffer.from(text, "utf-8"));
+var decodePublicKey = (value) => fromBase64(value);
+var generateSessionKey = () => nacl.randomBytes(SESSION_KEY_LEN);
+var wrapSessionKey = (sessionKey, accountPublicKey) => {
+  const ephemeral = nacl.box.keyPair();
+  const nonce = nacl.randomBytes(BOX_NONCE_LEN);
+  const box = nacl.box(sessionKey, nonce, accountPublicKey, ephemeral.secretKey);
+  const bundle = new Uint8Array(EPH_PUB_LEN + BOX_NONCE_LEN + box.length);
+  bundle.set(ephemeral.publicKey, 0);
+  bundle.set(nonce, EPH_PUB_LEN);
+  bundle.set(box, EPH_PUB_LEN + BOX_NONCE_LEN);
+  return toBase64(bundle);
+};
+var encryptRecord = (plaintext, sessionKey) => {
+  const nonce = nacl.randomBytes(SECRETBOX_NONCE_LEN);
+  const box = nacl.secretbox(utf8Encode(plaintext), nonce, sessionKey);
+  const bundle = new Uint8Array(SECRETBOX_NONCE_LEN + box.length);
+  bundle.set(nonce, 0);
+  bundle.set(box, SECRETBOX_NONCE_LEN);
+  return toBase64(bundle);
+};
+
+// src/transcript-capture.ts
+import { createHash } from "crypto";
+var INTERNAL_TYPES = /* @__PURE__ */ new Set([
+  "file-history-snapshot",
+  "change",
+  "queue-operation",
+  "summary"
+]);
+var redactDeep = (value) => {
+  if (typeof value === "string") return redactSecrets(value);
+  if (Array.isArray(value)) return value.map(redactDeep);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [key, inner] of Object.entries(value)) {
+      out[key] = redactDeep(inner);
+    }
+    return out;
+  }
+  return value;
+};
+var localIdFor = (parsed, rawLine) => typeof parsed.uuid === "string" && parsed.uuid.length > 0 ? parsed.uuid : createHash("sha256").update(rawLine).digest("hex").slice(0, 32);
+var buildTranscriptRecords = (lines, sessionKey, seen = /* @__PURE__ */ new Set()) => {
+  const records = [];
+  const nextSeen = new Set(seen);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const type = typeof parsed.type === "string" ? parsed.type : "";
+    if (INTERNAL_TYPES.has(type)) continue;
+    const localId = localIdFor(parsed, trimmed);
+    if (nextSeen.has(localId)) continue;
+    nextSeen.add(localId);
+    const content = encryptRecord(JSON.stringify(redactDeep(parsed)), sessionKey);
+    records.push({ localId, content });
+  }
+  return { records, seen: nextSeen };
+};
+
+// src/transcript-api.ts
+var fetchAccountPublicKey = async (apiKey, baseUrl = getBaseUrl()) => {
+  try {
+    const res = await fetch(`${baseUrl}/api/agent/encryption-account`, {
+      headers: { Authorization: `Bearer ${apiKey}` },
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    return typeof data.publicKey === "string" && data.publicKey.length > 0 ? data.publicKey : null;
+  } catch {
+    return null;
+  }
+};
+var uploadTranscriptRecords = async (apiKey, params, baseUrl = getBaseUrl()) => {
+  try {
+    const res = await fetch(`${baseUrl}/api/agent/transcript`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+      body: JSON.stringify(params),
+      signal: AbortSignal.timeout(15e3)
+    });
+    const body = await res.json().catch(() => null);
+    const keyRegistered = body?.keyRegistered === true;
+    const keyConflict = body?.keyConflict === true;
+    return {
+      ok: res.ok && !keyConflict && (params.dataEncryptionKey === void 0 || keyRegistered),
+      keyRegistered,
+      keyConflict
+    };
+  } catch {
+    return { ok: false, keyRegistered: false, keyConflict: false };
+  }
+};
+
+export {
+  decodePublicKey,
+  generateSessionKey,
+  wrapSessionKey,
+  buildTranscriptRecords,
+  fetchAccountPublicKey,
+  uploadTranscriptRecords
+};

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-ILB6UOAF.js

@@ -0,0 +1,192 @@
+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,
+          flag: options.exclusive ? "wx" : "w"
+        });
+        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 withSpawnProcessOwnership = async (spawnId, run, options = {}) => {
+  if (!spawnId) return run();
+  const sessionId = `spawn:${spawnId}`;
+  const ownership = startProcessOwnership({
+    sessionId,
+    pid: process.pid,
+    spawnId
+  }, { ...options, exclusive: true });
+  await ownership.ready;
+  if (!await ownsLiveProcess({ sessionId, pid: process.pid, spawnId }, options)) {
+    ownership.stop();
+    throw new Error("Could not establish spawned process ownership");
+  }
+  try {
+    return await run();
+  } finally {
+    ownership.stop();
+  }
+};
+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 verifyProof(proof, options);
+};
+var findLiveProcessBySpawnId = async (spawnId, options = {}) => {
+  try {
+    const dir = ownershipDir(options);
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+      const stored = readJsonSafe(join(dir, entry.name));
+      if (stored.kind !== "ok" || !isProof(stored.value) || stored.value.spawnId !== spawnId) continue;
+      if (await verifyProof(stored.value, options)) return stored.value.pid;
+    }
+  } catch {
+  }
+  return null;
+};
+var verifyProof = (proof, options) => 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,
+  withSpawnProcessOwnership,
+  ownsLiveProcess,
+  findLiveProcessBySpawnId
+};

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";

package/dist/{chunk-YWRJGYUH.js → chunk-MQMPG5X4.js}

@@ -1,6 +1,30 @@
 // ../contracts/src/index.ts
 var APPROVAL_MODES = ["push_only", "terminal_only", "push_first", "notify_only"];
 var isApprovalMode = (value) => typeof value === "string" && APPROVAL_MODES.includes(value);
+var parseAgentQuestionAnswers = (questions, value) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  const answers = parsed;
+  if (Object.keys(answers).length !== questions.length) return null;
+  for (const question of questions) {
+    const answer = answers[question.question];
+    if (typeof answer !== "string" || answer.trim().length === 0) return null;
+    if (!question.multiSelect) continue;
+    try {
+      const selected = JSON.parse(answer);
+      if (!Array.isArray(selected)) continue;
+      const labels = new Set(question.options.map((option) => option.label));
+      if (selected.length === 0 || new Set(selected).size !== selected.length || !selected.every((label) => typeof label === "string" && labels.has(label))) return null;
+    } catch {
+    }
+  }
+  return answers;
+};
 var INSTALL_SOURCES = [
   /** `npx @pushary/agent-hooks@latest ...`, the documented one-liner. */
   "npx",
@@ -454,17 +478,18 @@ var verdictForPolicy = (policy) => {
   if (isAutoApprove(policy)) return "allow";
   return "requires_human";
 };
-var selectGoverningRule = (policies, toolName, args, repoKey) => {
+var selectGoverningRule = (policies, toolName, args, repoKey, sessionId) => {
   let best;
   let bestWeight = 0;
   let bestScoped = -1;
   let bestLength = -1;
   for (const candidate of policies) {
     if (!isRepoKeyMatch(candidate.repoKey, repoKey)) continue;
+    if (candidate.sessionId && candidate.sessionId !== sessionId) continue;
     const rank = matchToolPatternAny(candidate.tool, toolName, args);
     if (rank === "none") continue;
     const weight = matchRankWeight(rank);
-    const scoped = candidate.repoKey ? 1 : 0;
+    const scoped = candidate.sessionId ? 2 : candidate.repoKey ? 1 : 0;
     const length = rank === "prefix" ? candidate.tool.length : -1;
     const better = weight > bestWeight || weight === bestWeight && scoped > bestScoped || weight === bestWeight && scoped === bestScoped && length > bestLength;
     if (better) {
@@ -811,6 +836,7 @@ var isScopeContract = (value) => {
 
 export {
   isApprovalMode,
+  parseAgentQuestionAnswers,
   normalizeInstallSource,
   HOOK_BUDGETS,
   hookWaitDeadline,

package/dist/{chunk-3AGM3TDM.js → chunk-NJ7JT26G.js}

@@ -1,6 +1,6 @@
 import {
   isSafeReadOnlyCommand
-} from "./chunk-YWRJGYUH.js";
+} from "./chunk-MQMPG5X4.js";
 
 // src/ledger.ts
 import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync } from "fs";

package/dist/chunk-NRGRUOAR.js

@@ -0,0 +1,25 @@
+// src/live-capabilities.ts
+var CODEX_BRIDGE_CAPABILITY = "codex-bridge";
+var CODEX_RESUME_CAPABILITY = "codex-resume";
+var GEMINI_BRIDGE_CAPABILITY = "gemini-bridge";
+var GEMINI_RESUME_CAPABILITY = "gemini-resume";
+var GEMINI_BRIDGE_MIN_VERSION = [0, 40, 0];
+var version = (raw) => {
+  const match = raw?.match(/^(\d+)\.(\d+)\.(\d+)/);
+  return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null;
+};
+var geminiLiveCapabilities = (rawVersion) => {
+  const installed = version(rawVersion);
+  if (!installed) return [];
+  for (let index = 0; index < GEMINI_BRIDGE_MIN_VERSION.length; index++) {
+    if (installed[index] > GEMINI_BRIDGE_MIN_VERSION[index]) break;
+    if (installed[index] < GEMINI_BRIDGE_MIN_VERSION[index]) return [];
+  }
+  return [GEMINI_BRIDGE_CAPABILITY, GEMINI_RESUME_CAPABILITY];
+};
+
+export {
+  CODEX_BRIDGE_CAPABILITY,
+  CODEX_RESUME_CAPABILITY,
+  geminiLiveCapabilities
+};