pushary 1.8.0

package/dist/chunk-EX3GAPA4.js

@@ -0,0 +1,44 @@
+import {
+  createIo
+} from "./chunk-U4TMAANR.js";
+import {
+  describeKeyCheck,
+  keyCheckFromResponse
+} from "./chunk-2ABTSGFT.js";
+import {
+  EXIT
+} from "./chunk-KZERVKTD.js";
+
+// src/cli/report-key.ts
+var { dim, yellow } = createIo();
+var printKeyCheck = (check, baseUrl) => {
+  const report = describeKeyCheck(check, baseUrl);
+  console.log(`  ${yellow("!")} ${report.message}`);
+  for (const line of report.next) console.log(`  ${dim(line)}`);
+  return report;
+};
+var exitIfKeyFailure = async (response, baseUrl) => {
+  const check = await keyCheckFromResponse(response, baseUrl);
+  if (!check) return;
+  const report = printKeyCheck(check, baseUrl);
+  process.exit(report.exitCode);
+};
+var responseDetail = async (response) => {
+  try {
+    const body = await response.json();
+    const text = [body.error, body.message].find((part) => typeof part === "string" && part);
+    if (typeof text === "string") return text;
+  } catch {
+  }
+  return response.statusText || `HTTP ${response.status}`;
+};
+var exitOnFailedResponse = async (response, baseUrl) => {
+  await exitIfKeyFailure(response, baseUrl);
+  console.log(`  ${yellow("!")} Failed: ${await responseDetail(response)}`);
+  process.exit(EXIT.FAILED);
+};
+
+export {
+  printKeyCheck,
+  exitOnFailedResponse
+};

package/dist/chunk-EYK3GSRH.js

@@ -0,0 +1,143 @@
+import {
+  AGENT_CHOICES
+} from "./chunk-ZVSKMPBZ.js";
+import {
+  isBridgeLocator
+} from "./chunk-C2WCPBF7.js";
+import {
+  pusharyHookExecutable
+} from "./chunk-6J2JC2RT.js";
+import {
+  BELL_HOOK_BINARY
+} from "./chunk-OKXS7WDZ.js";
+
+// src/setup/hook-ownership.ts
+var commandsIn = (value) => {
+  if (Array.isArray(value)) return value.flatMap(commandsIn);
+  if (!value || typeof value !== "object") return [];
+  return Object.entries(value).flatMap(([key, item]) => key === "command" && typeof item === "string" ? [item] : commandsIn(item));
+};
+var isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var hasPaidPusharyCommand = (value) => commandsIn(value).some((command) => {
+  const executable = pusharyHookExecutable(command);
+  const name = executable?.split(/[/\\]/).pop()?.replace(/\.(cmd|exe|mjs)$/i, "");
+  return executable !== null && !isBridgeLocator(executable) && name !== BELL_HOOK_BINARY;
+});
+var hasAppCommand = (value) => commandsIn(value).some((command) => {
+  const executable = pusharyHookExecutable(command);
+  return executable !== null && isBridgeLocator(executable);
+});
+var mcpBearerKey = (document, containerKey, headersKey) => {
+  const servers = isRecord(document?.[containerKey]) ? document[containerKey] : null;
+  const pushary = isRecord(servers?.pushary) ? servers.pushary : null;
+  const headers = isRecord(pushary?.[headersKey]) ? pushary[headersKey] : null;
+  const authorization = headers?.Authorization;
+  const match = typeof authorization === "string" ? authorization.trim().match(/^Bearer\s+(\S+)$/) : null;
+  return match?.[1] ?? null;
+};
+var captureMcpServer = (document, containerKey) => {
+  const container = document[containerKey];
+  const servers = isRecord(container) ? container : null;
+  if (!servers && Object.hasOwn(document, containerKey)) {
+    return { present: false, containerValue: structuredClone(container) };
+  }
+  return servers && Object.hasOwn(servers, "pushary") ? { present: true, value: structuredClone(servers.pushary) } : { present: false };
+};
+var restoreMcpServer = (document, containerKey, snapshot) => {
+  const before = JSON.stringify(document);
+  const existing = isRecord(document[containerKey]) ? document[containerKey] : null;
+  if (snapshot.present) {
+    const servers = existing ?? {};
+    servers.pushary = structuredClone(snapshot.value);
+    document[containerKey] = servers;
+  } else if (Object.hasOwn(snapshot, "containerValue")) {
+    document[containerKey] = structuredClone(snapshot.containerValue);
+  } else if (existing && Object.hasOwn(existing, "pushary")) {
+    delete existing.pushary;
+    if (Object.keys(existing).length === 0) delete document[containerKey];
+  }
+  return JSON.stringify(document) !== before;
+};
+var captureHookTakeover = (agent, document) => {
+  const hooks = isRecord(document?.hooks) ? document.hooks : null;
+  if (!hooks) return null;
+  const captured = {};
+  for (const [event, entries] of Object.entries(hooks)) {
+    if (!Array.isArray(entries)) continue;
+    const appEntries = entries.flatMap((value, index) => isRecord(value) && hasAppCommand(value) ? [{ index, value: structuredClone(value) }] : []);
+    if (appEntries.length > 0) captured[event] = appEntries;
+  }
+  return Object.keys(captured).length > 0 ? { version: 1, agent, hooks: captured } : null;
+};
+var isHookTakeoverReceipt = (value) => {
+  if (!isRecord(value) || value.version !== 1 || typeof value.agent !== "string" || !AGENT_CHOICES.includes(value.agent) || !isRecord(value.hooks)) return false;
+  const expectsMcp = ["claude_code", "codex", "gemini_cli", "vscode"].includes(value.agent);
+  if (value.mcpServer !== void 0 !== expectsMcp) return false;
+  if (value.codexTrust !== void 0 !== (value.agent === "codex")) return false;
+  if (value.codexTrust !== void 0 && !isRecord(value.codexTrust)) return false;
+  if (value.mcpServer !== void 0 && (!isRecord(value.mcpServer) || typeof value.mcpServer.present !== "boolean" || value.mcpServer.present && !Object.hasOwn(value.mcpServer, "value"))) return false;
+  return Object.values(value.hooks).every((entries) => Array.isArray(entries) && entries.length > 0 && entries.every((item) => isRecord(item) && Number.isInteger(item.index) && item.index >= 0 && isRecord(item.value)));
+};
+var restoreHookTakeover = (document, receipt) => {
+  const before = JSON.stringify(document);
+  const appOwnsNow = hookOwnerOf(document) === "app";
+  const hooks = isRecord(document.hooks) ? document.hooks : {};
+  for (const [event, value] of Object.entries(hooks)) {
+    if (!Array.isArray(value)) continue;
+    const kept = value.filter((entry) => !hasPaidPusharyCommand(entry));
+    if (kept.length === 0) delete hooks[event];
+    else hooks[event] = kept;
+  }
+  if (!appOwnsNow) {
+    for (const [event, snapshots] of Object.entries(receipt.hooks)) {
+      const entries = Array.isArray(hooks[event]) ? [...hooks[event]] : [];
+      for (const snapshot of snapshots) {
+        entries.splice(Math.min(snapshot.index, entries.length), 0, structuredClone(snapshot.value));
+      }
+      hooks[event] = entries;
+    }
+  }
+  document.hooks = hooks;
+  return JSON.stringify(document) !== before;
+};
+var hookOwnerOf = (document, appAvailable = true, hooksKeyPath = ["hooks"]) => {
+  const hooks = hooksKeyPath.reduce(
+    (node, key) => node && typeof node === "object" ? node[key] : void 0,
+    document
+  );
+  const executables = commandsIn(hooks).map(pusharyHookExecutable).filter((executable) => executable !== null);
+  if (appAvailable && executables.some(isBridgeLocator)) return "app";
+  if (executables.some((executable) => !isBridgeLocator(executable))) return "cli";
+  return "none";
+};
+var planHooks = (context) => {
+  if (context.owner !== "app") return "install";
+  if (context.takeOverHooks) return "install";
+  return "keep";
+};
+var describeAppOwnership = (agentName) => `The Pushary Mac app owns ${agentName}'s hooks.`;
+var KEEP_HINT = "Kept with the app's account. Pass --take-over-hooks to have the CLI own them instead.";
+var OWNER_LABELS = {
+  app: "the Pushary Mac app",
+  cli: "the CLI"
+};
+var describeHookOwnership = (entries, names) => {
+  const owned = entries.filter((entry) => entry.owner !== "none");
+  if (owned.length === 0) return null;
+  const parts = owned.map((entry) => `${names[entry.agent]} by ${OWNER_LABELS[entry.owner]}${entry.kept ? " (kept)" : ""}`);
+  return `Hooks: ${parts.join(", ")}.`;
+};
+
+export {
+  mcpBearerKey,
+  captureMcpServer,
+  restoreMcpServer,
+  captureHookTakeover,
+  isHookTakeoverReceipt,
+  restoreHookTakeover,
+  hookOwnerOf,
+  planHooks,
+  describeAppOwnership,
+  KEEP_HINT,
+  describeHookOwnership
+};

package/dist/chunk-GMXKITVA.js

@@ -0,0 +1,70 @@
+import {
+  UsageError
+} from "./chunk-7QLSKOSU.js";
+
+// src/cli/flags.ts
+var normalize = (raw) => raw.replace(/^--?/, "");
+var known = (spec, name) => {
+  if (spec.bools.includes(name)) return "bool";
+  if (spec.values.includes(name)) return "value";
+  return void 0;
+};
+var rejectUnknownFlags = (args, allowed) => {
+  for (const token of args) {
+    if (token === "--") break;
+    if (!token.startsWith("-")) continue;
+    const name = token.includes("=") ? token.slice(0, token.indexOf("=")) : token;
+    if (!allowed.includes(name)) {
+      throw new UsageError(
+        `Unknown flag: ${name}${allowed.length > 0 ? `. This command accepts ${allowed.join(", ")}` : ". This command takes no flags"}`
+      );
+    }
+  }
+};
+var parseFlags = (argv, spec) => {
+  const bools = /* @__PURE__ */ new Set();
+  const values = /* @__PURE__ */ new Map();
+  const rest = [];
+  let command;
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+    if (token === "--") {
+      rest.push(...argv.slice(i + 1));
+      break;
+    }
+    if (!token.startsWith("-")) {
+      if (command === void 0) command = token;
+      else rest.push(token);
+      continue;
+    }
+    const inline = token.indexOf("=");
+    const name = normalize(inline === -1 ? token : token.slice(0, inline));
+    const kind = known(spec, name);
+    if (kind === void 0) {
+      throw new UsageError(`Unknown flag: ${token}`);
+    }
+    if (kind === "bool") {
+      if (inline !== -1) throw new UsageError(`${token.slice(0, inline)} does not take a value`);
+      bools.add(name);
+      continue;
+    }
+    if (inline !== -1) {
+      const value = token.slice(inline + 1);
+      if (value === "") throw new UsageError(`--${name} needs a value`);
+      values.set(name, value);
+      continue;
+    }
+    const next = argv[i + 1];
+    if (next === void 0 || next.startsWith("-")) {
+      throw new UsageError(`--${name} needs a value`);
+    }
+    values.set(name, next);
+    i++;
+  }
+  return { command, bools, values, rest };
+};
+
+export {
+  rejectUnknownFlags,
+  parseFlags
+};

package/dist/chunk-GPEGOGRJ.js

@@ -0,0 +1,49 @@
+import {
+  NPX_LATEST_COMMAND
+} from "./chunk-E4FJTUH4.js";
+
+// src/config.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var configFilePath = () => process.env.PUSHARY_CONFIG_FILE?.trim() || join(homedir(), ".pushary", "config.json");
+var readKeyFromConfigFile = () => {
+  try {
+    const parsed = JSON.parse(readFileSync(configFilePath(), "utf-8"));
+    const key = typeof parsed.apiKey === "string" ? parsed.apiKey.trim() : "";
+    return key || void 0;
+  } catch {
+    return void 0;
+  }
+};
+var driftChecked = false;
+var warnOnKeyDrift = (envKey) => {
+  if (driftChecked || process.env.PUSHARY_SUPPRESS_KEY_DRIFT_WARNING === "1") return;
+  driftChecked = true;
+  const fileKey = readKeyFromConfigFile();
+  if (!fileKey || fileKey === envKey) return;
+  const short = (key) => key.split(".")[0] ?? key;
+  process.stderr.write(
+    `[pushary] PUSHARY_API_KEY in your environment (${short(envKey)}) differs from ${configFilePath()} (${short(fileKey)}). The environment one is being used. Run 'pushary doctor' for details, or set PUSHARY_SUPPRESS_KEY_DRIFT_WARNING=1 if this is deliberate.
+`
+  );
+};
+var getApiKey = () => {
+  const envKey = process.env.PUSHARY_API_KEY?.trim();
+  if (envKey) {
+    warnOnKeyDrift(envKey);
+    return envKey;
+  }
+  const fileKey = readKeyFromConfigFile();
+  if (fileKey) return fileKey;
+  throw new Error(
+    `PUSHARY_API_KEY is not set and no key was found in ~/.pushary/config.json. Run \`${NPX_LATEST_COMMAND} setup\`, or get your API key at https://pushary.com/sign-up?from=ai-coding`
+  );
+};
+var getBaseUrl = () => process.env.PUSHARY_BASE_URL?.trim() || process.env.PUSHARY_API_URL?.trim() || "https://pushary.com";
+
+export {
+  configFilePath,
+  getApiKey,
+  getBaseUrl
+};

package/dist/chunk-GU3EJCVV.js

@@ -0,0 +1,43 @@
+// src/diagnostics/service-runtime.ts
+var unescapeXml = (value) => value.replaceAll("&quot;", '"').replaceAll("&apos;", "'").replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&amp;", "&");
+var unquoteSystemd = (value) => value.replaceAll('\\"', '"').replaceAll("\\\\", "\\").replaceAll("%%", "%");
+var readServiceExecPath = (contents, platform) => {
+  if (platform === "darwin") {
+    const program = contents.match(/<key>ProgramArguments<\/key>\s*<array>\s*<string>([^<]*)<\/string>/)?.[1];
+    return program ? unescapeXml(program) : null;
+  }
+  if (platform === "linux") {
+    const exec = contents.match(/^ExecStart="((?:[^"\\]|\\.)*)"/m)?.[1];
+    return exec ? unquoteSystemd(exec) : null;
+  }
+  if (platform === "win32") {
+    const command = contents.match(/<Command>([^<]*)<\/Command>/)?.[1];
+    return command ? unescapeXml(command) : null;
+  }
+  return null;
+};
+var MANAGER_SEGMENTS = [
+  [".nvm", "nvm"],
+  ["nvm", "nvm"],
+  ["fnm", "fnm"],
+  [".fnm", "fnm"],
+  [".volta", "volta"],
+  ["volta", "volta"],
+  [".asdf", "asdf"],
+  ["asdf", "asdf"]
+];
+var versionManagerOf = (execPath) => {
+  const segments = execPath.split(/[/\\]/);
+  for (const segment of segments) {
+    const hit = MANAGER_SEGMENTS.find(([name]) => name === segment);
+    if (hit) return hit[1];
+  }
+  return null;
+};
+var describeVersionManagerPin = (execPath, manager) => `The background service is pinned to ${execPath}, which ${manager} manages. Switching Node versions strands it; run pushary daemon install afterwards.`;
+
+export {
+  readServiceExecPath,
+  versionManagerOf,
+  describeVersionManagerPin
+};

package/dist/chunk-HQ6G3B5R.js

@@ -0,0 +1,59 @@
+import {
+  resolveBinary,
+  resolveGlobalPackageVersion,
+  resolvePackageVersionFromBinary
+} from "./chunk-A2A2YTMG.js";
+import {
+  MANAGED_PROVIDERS
+} from "./chunk-NQTHFF4W.js";
+
+// src/live-capabilities.ts
+var CLAUDE_BRIDGE_CAPABILITY = "claude-bridge";
+var CLAUDE_RESUME_CAPABILITY = "claude-resume";
+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];
+};
+var providerLiveCapabilities = (probe) => [
+  ...probe.claude ? [CLAUDE_BRIDGE_CAPABILITY, CLAUDE_RESUME_CAPABILITY] : [],
+  ...probe.codex ? [CODEX_BRIDGE_CAPABILITY, CODEX_RESUME_CAPABILITY] : [],
+  ...geminiLiveCapabilities(probe.geminiVersion)
+];
+var hasSpawnProvider = (capabilities) => capabilities.some(
+  (capability) => capability === CLAUDE_BRIDGE_CAPABILITY || capability === CODEX_BRIDGE_CAPABILITY || capability === GEMINI_BRIDGE_CAPABILITY
+);
+var resolveControlPolicy = (input) => {
+  if (input.mode === "off") return "disabled";
+  if (input.mode === null && !input.servicePresent) return "preserve-absent";
+  if (input.providerAvailable && input.managerAvailable) return "enabled";
+  return input.servicePresent ? "legacy" : "unsupported";
+};
+var detectProviderLiveCapabilities = (providers = MANAGED_PROVIDERS) => {
+  const enabled = new Set(providers);
+  const geminiBin = enabled.has("gemini") ? resolveBinary("gemini") : void 0;
+  return providerLiveCapabilities({
+    claude: enabled.has("claude") && resolveBinary("claude") !== void 0,
+    codex: enabled.has("codex") && resolveBinary("codex") !== void 0,
+    geminiVersion: geminiBin ? resolvePackageVersionFromBinary(geminiBin, "@google/gemini-cli") ?? resolveGlobalPackageVersion("@google/gemini-cli") : void 0
+  });
+};
+
+export {
+  hasSpawnProvider,
+  resolveControlPolicy,
+  detectProviderLiveCapabilities
+};

package/dist/chunk-HZVVNGEW.js

@@ -0,0 +1,22 @@
+import {
+  EXIT
+} from "./chunk-KZERVKTD.js";
+import {
+  renderCommandHelp
+} from "./chunk-E4FJTUH4.js";
+import {
+  getPackageVersion
+} from "./chunk-NQTHFF4W.js";
+
+// src/cli/usage.ts
+var exitOnHelpFlag = (command) => {
+  const args = process.argv.slice(2);
+  if (!args.includes("--help") && !args.includes("-h")) return;
+  process.stdout.write(`${renderCommandHelp(command, getPackageVersion())}
+`);
+  process.exit(EXIT.OK);
+};
+
+export {
+  exitOnHelpFlag
+};

package/dist/chunk-IPVKH2ST.js

@@ -0,0 +1,231 @@
+import {
+  readConfigFileKey
+} from "./chunk-P7WQEVWA.js";
+
+// src/bell/fleet.ts
+import { closeSync, constants, futimesSync, lstatSync, mkdirSync, openSync, readdirSync, unlinkSync } from "fs";
+import { createHash } from "crypto";
+import { tmpdir, userInfo } from "os";
+import { join } from "path";
+var ownerTag = () => {
+  try {
+    const { uid } = userInfo();
+    return typeof uid === "number" && uid >= 0 ? String(uid) : "shared";
+  } catch {
+    return "shared";
+  }
+};
+var BELL_DIR = join(tmpdir(), `pushary-bell-${ownerTag()}`);
+var DIR_MODE = 448;
+var FILE_MODE = 384;
+var SESSION_TTL_MS = 10 * 60 * 1e3;
+var sessionFile = (sessionId) => join(BELL_DIR, createHash("sha256").update(sessionId).digest("hex").slice(0, 16));
+var heartbeat = (sessionId, now = Date.now()) => {
+  try {
+    mkdirSync(BELL_DIR, { recursive: true, mode: DIR_MODE });
+    const fd = openSync(
+      sessionFile(sessionId),
+      constants.O_WRONLY | constants.O_CREAT | constants.O_NOFOLLOW,
+      FILE_MODE
+    );
+    try {
+      const seconds = now / 1e3;
+      futimesSync(fd, seconds, seconds);
+    } finally {
+      closeSync(fd);
+    }
+  } catch {
+  }
+};
+var liveAgentCount = (now = Date.now()) => {
+  try {
+    let live = 0;
+    for (const name of readdirSync(BELL_DIR)) {
+      const path = join(BELL_DIR, name);
+      try {
+        const entry = lstatSync(path);
+        if (!entry.isFile()) unlinkSync(path);
+        else if (now - entry.mtimeMs < SESSION_TTL_MS) live += 1;
+        else unlinkSync(path);
+      } catch {
+      }
+    }
+    return live;
+  } catch {
+    return 0;
+  }
+};
+var recordAndCount = (sessionId, now = Date.now()) => {
+  heartbeat(sessionId, now);
+  return Math.max(1, liveAgentCount(now));
+};
+
+// src/bell/ring.ts
+import { execFile } from "child_process";
+import { openSync as openSync2, writeSync, closeSync as closeSync2 } from "fs";
+var platformOf = (value = process.platform) => value === "darwin" || value === "linux" || value === "win32" ? value : "other";
+var writeBell = () => {
+  try {
+    const fd = openSync2("/dev/tty", "w");
+    try {
+      writeSync(fd, "\x07");
+      return true;
+    } finally {
+      closeSync2(fd);
+    }
+  } catch {
+    try {
+      process.stderr.write("\x07");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+var noticeCommand = (notice, platform = platformOf()) => {
+  const clean = (text) => text.replace(/["\\]/g, " ").replace(/\s+/g, " ").trim().slice(0, 120);
+  const title = clean(notice.title);
+  const body = clean(notice.body);
+  switch (platform) {
+    case "darwin":
+      return ["osascript", "-e", `display notification "${body}" with title "${title}"`];
+    case "linux":
+      return ["notify-send", title, body];
+    default:
+      return null;
+  }
+};
+var spawnNotifier = (argv) => {
+  const child = execFile(argv[0], argv.slice(1), { timeout: 5e3 }, () => {
+  });
+  child.unref?.();
+};
+var ring = (notice, deps = {}) => {
+  const bell = deps.bell ?? writeBell;
+  const notify = deps.notify ?? spawnNotifier;
+  const rang = bell();
+  const argv = noticeCommand(notice, deps.platform ?? platformOf());
+  if (!argv) return { rang, notified: false };
+  try {
+    notify(argv);
+    return { rang, notified: true };
+  } catch {
+    return { rang, notified: false };
+  }
+};
+
+// src/bell/upgrade.ts
+import { existsSync, mkdirSync as mkdirSync2, statSync, writeFileSync } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join2 } from "path";
+var DEFAULT_UPGRADE_THRESHOLD = 3;
+var UPGRADE_MARKER = join2(tmpdir2(), "pushary-bell-upgrade-shown");
+var ONCE_PER = 24 * 60 * 60 * 1e3;
+var upgradeThreshold = (env = process.env) => {
+  const raw = Number(env.PUSHARY_BELL_UPGRADE_AT);
+  if (!Number.isFinite(raw) || raw < 1) return DEFAULT_UPGRADE_THRESHOLD;
+  return Math.floor(raw);
+};
+var readLastShown = () => {
+  try {
+    return existsSync(UPGRADE_MARKER) ? statSync(UPGRADE_MARKER).mtimeMs : null;
+  } catch {
+    return null;
+  }
+};
+var writeLastShown = (at) => {
+  try {
+    mkdirSync2(tmpdir2(), { recursive: true });
+    writeFileSync(UPGRADE_MARKER, String(at), "utf-8");
+  } catch {
+  }
+};
+var upgradeLine = (context) => `  ${context.liveAgents} agents running. A bell can't tell you which one needs you, and it can't reach your pocket.
+  pushary connect`;
+var upgradeNotice = (context, deps = {}) => {
+  const env = deps.env ?? process.env;
+  if (env.PUSHARY_BELL_QUIET === "1" || env.PUSHARY_BELL_QUIET === "true") return null;
+  if (context.connected) return null;
+  if (context.liveAgents < upgradeThreshold(env)) return null;
+  const now = (deps.now ?? Date.now)();
+  const last = (deps.lastShown ?? readLastShown)();
+  if (last !== null && now - last < ONCE_PER) return null;
+  (deps.markShown ?? writeLastShown)(now);
+  return upgradeLine(context);
+};
+
+// src/bell/handler.ts
+import { basename } from "path";
+var FINISHED_NOTIFICATIONS = /* @__PURE__ */ new Set(["agent_completed"]);
+var BLOCKED_NOTIFICATIONS = /* @__PURE__ */ new Set(["idle_prompt", "agent_needs_input"]);
+var SUMMARY_MAX = 100;
+var summarize = (message, fallback) => {
+  if (typeof message !== "string") return fallback;
+  const collapsed = message.replace(/\s+/g, " ").trim();
+  return collapsed ? collapsed.slice(0, SUMMARY_MAX) : fallback;
+};
+var decideBell = (input) => {
+  const project = basename(input.cwd ?? process.cwd());
+  const notifType = input.notification_type ?? input.type ?? "";
+  if (FINISHED_NOTIFICATIONS.has(notifType)) {
+    return {
+      reason: "finished",
+      title: `${project}: done`,
+      body: summarize(input.message ?? input.last_assistant_message, "Your agent finished.")
+    };
+  }
+  if (BLOCKED_NOTIFICATIONS.has(notifType)) {
+    return {
+      reason: "needs-input",
+      title: `${project}: your agent needs you`,
+      body: summarize(input.message, "Waiting for your input.")
+    };
+  }
+  return null;
+};
+var handleBell = (input, deps = {}) => {
+  const idle = { rang: false, reason: null, liveAgents: 0, upgrade: null };
+  try {
+    const decision = decideBell(input);
+    if (!decision) return idle;
+    const count = deps.count ?? ((sessionId) => recordAndCount(sessionId));
+    const liveAgents = count(input.session_id || "default");
+    const result = (deps.ring ?? ring)({ title: decision.title, body: decision.body }, deps.ringDeps);
+    const notice = upgradeNotice(
+      {
+        agentName: decision.title,
+        liveAgents,
+        connected: (deps.connected ?? hasKey)()
+      },
+      deps.upgradeDeps
+    );
+    if (notice) (deps.write ?? writeStderr)(`
+${notice}
+`);
+    return { rang: result.rang, reason: decision.reason, liveAgents, upgrade: notice };
+  } catch {
+    return idle;
+  }
+};
+var writeStderr = (line) => {
+  try {
+    process.stderr.write(line);
+  } catch {
+  }
+};
+var hasKey = () => {
+  try {
+    if (process.env.PUSHARY_API_KEY?.trim()) return true;
+    return Boolean(readConfigFileKey());
+  } catch {
+    return false;
+  }
+};
+
+export {
+  liveAgentCount,
+  ring,
+  DEFAULT_UPGRADE_THRESHOLD,
+  upgradeThreshold,
+  handleBell
+};