@pushary/agent-hooks 0.60.0 → 0.62.0

package/dist/chunk-3O27ZSRE.js

@@ -0,0 +1,569 @@
+import {
+  generateKeypair,
+  openSealedKey,
+  publicKeyFingerprint
+} from "./chunk-3EGEA4KH.js";
+import {
+  callMcpTool
+} from "./chunk-HNTKTK5B.js";
+
+// src/reach.ts
+var reachVerdict = (channels) => {
+  const { yours, site } = channels;
+  if (yours === null || site === null) {
+    return channels.phoneReachable || channels.webActive > 0 ? { kind: "yours" } : { kind: "nobody" };
+  }
+  if (yours.phoneReachable) return { kind: "yours" };
+  const solo = site.otherMembers === 0;
+  if (solo) {
+    return site.phoneReachable || site.webActive > 0 ? { kind: "yours" } : { kind: "nobody" };
+  }
+  if (site.appDevices === 0 && site.webActive === 0) return { kind: "nobody" };
+  if (site.webActive > 0 && !yours.webAttributable) {
+    return { kind: "unattributable", otherMembers: site.otherMembers };
+  }
+  return { kind: "others", otherMembers: site.otherMembers };
+};
+var reachesYou = (channels) => reachVerdict(channels).kind === "yours";
+var plural = (count, one, many = `${one}s`) => `${count} ${count === 1 ? one : many}`;
+var describeReach = (channels) => {
+  const verdict = reachVerdict(channels);
+  if (verdict.kind === "nobody") return "nothing can receive an approval";
+  const parts = [];
+  const own = channels.yours;
+  if (verdict.kind === "yours" && own !== null && own.appDevices > 0) {
+    const platforms = own.appPlatforms.length > 0 ? ` (${own.appPlatforms.join(", ")})` : "";
+    parts.push(`${plural(own.appDevices, "app device")}${platforms}`);
+  } else if (channels.appDevices > 0) {
+    const platforms = channels.appPlatforms.length > 0 ? ` (${channels.appPlatforms.join(", ")})` : "";
+    parts.push(`${plural(channels.appDevices, "app device")}${platforms}`);
+  }
+  if (channels.webPhone > 0) parts.push(`${plural(channels.webPhone, "browser")} on a phone`);
+  if (channels.webDesktop > 0) parts.push(`${plural(channels.webDesktop, "browser")} on a desktop`);
+  const summary = parts.length > 0 ? parts.join(", ") : "a device";
+  if (verdict.kind === "others") return `${summary}, none of them yours`;
+  if (verdict.kind === "unattributable") return `${summary}, and no way to tell whose`;
+  return summary;
+};
+
+// src/cli/human.ts
+var stream = process.stdout;
+var setHumanStream = (target) => {
+  stream = target;
+};
+var writeHuman = (text) => {
+  stream.write(text);
+};
+
+// src/onboarding.ts
+import qrcodeTerminal from "qrcode-terminal";
+
+// src/setup/verify.ts
+var plural2 = (count, one) => `${count} ${one}${count === 1 ? "" : "s"}`;
+var describeRecipients = (push, channels) => {
+  const parts = [];
+  if (push.app > 0) {
+    const platforms = channels.yours?.appPlatforms ?? channels.appPlatforms;
+    const suffix = platforms.length > 0 ? ` (${platforms.join(", ")})` : "";
+    parts.push(`${plural2(push.app, "app device")}${suffix}`);
+  }
+  if (push.web > 0) parts.push(plural2(push.web, "browser"));
+  return parts.length > 0 ? parts.join(" and ") : plural2(push.total, "device");
+};
+var classifyDelivery = (channels, push) => {
+  if (push.total <= 0) return { kind: "no-recipients" };
+  const verdict = reachVerdict(channels);
+  if (verdict.kind === "yours" && (push.app > 0 || channels.yours === null || channels.site?.otherMembers === 0)) {
+    return { kind: "delivered", recipients: push.total, deviceLabel: describeRecipients(push, channels) };
+  }
+  if (verdict.kind === "unattributable") {
+    return { kind: "unattributable", recipients: push.total, otherMembers: verdict.otherMembers };
+  }
+  if (verdict.kind === "others") {
+    return { kind: "others-only", recipients: push.total, otherMembers: verdict.otherMembers };
+  }
+  if (verdict.kind === "yours") {
+    const otherMembers = channels.site?.otherMembers ?? 0;
+    return { kind: "unattributable", recipients: push.total, otherMembers };
+  }
+  return { kind: "delivered", recipients: push.total, deviceLabel: describeRecipients(push, channels) };
+};
+var sendTestNotification = async (apiKey) => {
+  const result = await callMcpTool(apiKey, "send_notification", {
+    title: "Pushary is connected",
+    body: "Your AI agent can now reach you right here.",
+    agentName: "Pushary setup"
+  }, { timeoutMs: 2e4 });
+  const toCount = (value) => typeof value === "number" && Number.isFinite(value) ? value : 0;
+  const app = toCount(result.delivery?.mobile?.recipients);
+  const web = toCount(result.delivery?.web?.recipients);
+  return { app, web, total: typeof result.sent === "number" ? result.sent : app + web };
+};
+var verifyDelivery = async (apiKey, channels, deps = {}) => {
+  const send = deps.send ?? sendTestNotification;
+  try {
+    return classifyDelivery(channels, await send(apiKey));
+  } catch (err) {
+    return { kind: "error", detail: err instanceof Error ? err.message : "send failed" };
+  }
+};
+var describeVerifyOutcome = (outcome) => {
+  switch (outcome.kind) {
+    case "delivered":
+      return { ok: true, message: `Delivered to ${outcome.deviceLabel}. Push works.`, next: [] };
+    case "no-recipients":
+      return {
+        ok: false,
+        message: "Nothing to deliver to. Agents are configured; approvals will fall back to the terminal.",
+        next: [
+          "Run pushary connect to add your phone.",
+          "Then pushary doctor --roundtrip to test a real approval."
+        ]
+      };
+    case "others-only":
+      return {
+        ok: false,
+        message: `Delivered to ${plural2(outcome.recipients, "device")} on this site, none of them yours.`,
+        next: [
+          `Approvals for your agent would wake one of your ${plural2(outcome.otherMembers, "teammate")}.`,
+          "Run pushary connect to add your own phone."
+        ]
+      };
+    case "unattributable":
+      return {
+        ok: false,
+        message: `Delivered to ${plural2(outcome.recipients, "device")} on this site, and no way to tell whose.`,
+        next: [
+          "Browser subscriptions carry no owner, and this site has other members.",
+          "Install the Pushary app with pushary connect, or run pushary doctor --roundtrip to prove it reaches you."
+        ]
+      };
+    case "error":
+      return {
+        ok: false,
+        message: `Could not send the test notification (${outcome.detail}).`,
+        next: ["Agents are configured. Run pushary doctor once the connection is back."]
+      };
+  }
+};
+
+// src/onboarding.ts
+var dim = (s) => `\x1B[2m${s}\x1B[0m`;
+var bold = (s) => `\x1B[1m${s}\x1B[0m`;
+var green = (s) => `\x1B[32m${s}\x1B[0m`;
+var cyan = (s) => `\x1B[36m${s}\x1B[0m`;
+var yellow = (s) => `\x1B[33m${s}\x1B[0m`;
+var check = green("\u2713");
+var apiBase = () => process.env.PUSHARY_API_URL?.trim() || process.env.PUSHARY_BASE_URL?.trim() || "https://pushary.com";
+var EXIT_ABORTED = 130;
+var CONNECT_POLL_INTERVAL_MS = 2500;
+var CONNECT_TIMEOUT_MS = 18e4;
+var EMPTY_CHANNELS = {
+  appDevices: 0,
+  appPlatforms: [],
+  webActive: 0,
+  webPhone: 0,
+  webDesktop: 0,
+  phoneReachable: false,
+  precise: true,
+  yours: null,
+  site: null
+};
+var authHeaders = (apiKey) => ({
+  "Content-Type": "application/json",
+  Authorization: `Bearer ${apiKey}`
+});
+var getJson = async (url, apiKey) => {
+  try {
+    const res = await fetch(url, { headers: authHeaders(apiKey), signal: AbortSignal.timeout(1e4) });
+    const body = await res.json().catch(() => null);
+    if (!res.ok) return { kind: "http", status: res.status, body };
+    if (!body) return { kind: "http", status: res.status, body: null };
+    return { kind: "ok", body };
+  } catch (err) {
+    return { kind: "network", detail: err instanceof Error ? err.message : "network error" };
+  }
+};
+var fetchSite = async (apiKey) => {
+  const result = await getJson(`${apiBase()}/api/v1/server/site`, apiKey);
+  if (result.kind !== "ok") return null;
+  const data = result.body;
+  if (typeof data.slug !== "string" || typeof data.subscribeUrl !== "string") return null;
+  return { slug: data.slug, name: typeof data.name === "string" ? data.name : data.slug, subscribeUrl: data.subscribeUrl };
+};
+var num = (value) => typeof value === "number" && Number.isFinite(value) ? value : 0;
+var strings = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+var record = (value) => typeof value === "object" && value !== null ? value : {};
+var parseOwnerCounts = (value) => {
+  if (typeof value !== "object" || value === null) return null;
+  const raw = value;
+  const app = record(raw.app);
+  return {
+    appDevices: num(app.devices),
+    appPlatforms: strings(app.platforms),
+    phoneReachable: raw.phoneReachable === true,
+    webAttributable: raw.webAttributable === true
+  };
+};
+var parseSiteCounts = (value) => {
+  if (typeof value !== "object" || value === null) return null;
+  const raw = value;
+  const app = record(raw.app);
+  const web = record(raw.web);
+  return {
+    appDevices: num(app.devices),
+    appPlatforms: strings(app.platforms),
+    webActive: num(web.active),
+    webPhone: num(web.phone),
+    webDesktop: num(web.desktop),
+    phoneReachable: raw.phoneReachable === true,
+    otherMembers: num(raw.otherMembers)
+  };
+};
+var parseChannels = (data) => {
+  const app = record(data.app);
+  const web = record(data.web);
+  return {
+    appDevices: num(app.devices),
+    appPlatforms: strings(app.platforms),
+    webActive: num(web.active),
+    webPhone: num(web.phone),
+    webDesktop: num(web.desktop),
+    phoneReachable: data.phoneReachable === true,
+    precise: true,
+    yours: parseOwnerCounts(data.yours),
+    site: parseSiteCounts(data.site)
+  };
+};
+var SUBSCRIPTION_REQUIRED = "subscription_required";
+var fetchChannels = async (apiKey) => {
+  const result = await getJson(`${apiBase()}/api/v1/server/channels`, apiKey);
+  if (result.kind === "ok") return { kind: "ok", status: parseChannels(result.body) };
+  if (result.kind === "network") return { kind: "unreachable", detail: result.detail };
+  if (result.status === 401) return { kind: "unauthorized" };
+  if (result.status === 403) {
+    return result.body?.code === SUBSCRIPTION_REQUIRED ? { kind: "locked" } : { kind: "unreachable", detail: "HTTP 403" };
+  }
+  if (result.status !== 404) return { kind: "unreachable", detail: `HTTP ${result.status}` };
+  const legacy = await getJson(`${apiBase()}/api/v1/server/subscribers/count`, apiKey);
+  if (legacy.kind === "network") return { kind: "unreachable", detail: legacy.detail };
+  if (legacy.kind === "http") {
+    if (legacy.status === 401) return { kind: "unauthorized" };
+    return { kind: "unreachable", detail: `HTTP ${legacy.status}` };
+  }
+  const active = num(legacy.body.active);
+  return {
+    kind: "ok",
+    status: { ...EMPTY_CHANNELS, webActive: active, phoneReachable: active > 0, precise: false }
+  };
+};
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var startSpinner = (getLabel) => {
+  const frames = ["   ", ".  ", ".. ", "..."];
+  let i = 0;
+  const interval = setInterval(() => {
+    writeHuman(`\r  ${dim(frames[i++ % frames.length])} ${getLabel()}`);
+  }, 200);
+  return (finalGlyph, finalLabel) => {
+    clearInterval(interval);
+    writeHuman(`\r  ${finalGlyph} ${finalLabel}\x1B[K
+`);
+  };
+};
+var printQr = (url) => new Promise((resolve, reject) => {
+  try {
+    qrcodeTerminal.generate(url, { small: true }, (qr) => {
+      writeHuman("\n" + qr.split("\n").map((line) => "    " + line).join("\n") + "\n");
+      resolve();
+    });
+  } catch (err) {
+    reject(err);
+  }
+});
+var phoneFailure = (detail) => ({ reachesYou: false, outcome: null, detail });
+var waitForDevice = async (apiKey, baseline) => {
+  const deadline = Date.now() + CONNECT_TIMEOUT_MS;
+  let consecutiveFailures = 0;
+  let warned = false;
+  const stop = startSpinner(() => {
+    const left = Math.max(0, Math.ceil((deadline - Date.now()) / 1e3));
+    return `Waiting for your phone ${dim(`(${left}s)`)}`;
+  });
+  try {
+    while (Date.now() < deadline) {
+      const probe = await fetchChannels(apiKey);
+      if (probe.kind === "unauthorized") {
+        stop(yellow("!"), "The server stopped accepting this key");
+        return { kind: "unauthorized" };
+      }
+      if (probe.kind === "locked") {
+        stop(yellow("!"), "This workspace has no active plan");
+        return { kind: "locked" };
+      }
+      if (probe.kind === "unreachable") {
+        consecutiveFailures += 1;
+        if (consecutiveFailures >= 3 && !warned) {
+          warned = true;
+          writeHuman(`\r  ${yellow("!")} Still trying. pushary.com is not answering ${dim(`(${probe.detail})`)}\x1B[K
+`);
+        }
+        await sleep(CONNECT_POLL_INTERVAL_MS);
+        continue;
+      }
+      consecutiveFailures = 0;
+      const channels = probe.status;
+      if (reachesYou(channels) || channels.webActive > baseline.webActive) {
+        stop(check, "Phone connected");
+        return { kind: "connected", channels };
+      }
+      await sleep(CONNECT_POLL_INTERVAL_MS);
+    }
+    stop(yellow("!"), "Didn't detect a connection yet");
+    return { kind: "timeout" };
+  } catch (err) {
+    stop(yellow("!"), `Couldn't check connection ${dim(`(${err instanceof Error ? err.message : "network error"})`)}`);
+    return { kind: "timeout" };
+  }
+};
+var sendAndConfirm = async (apiKey, channels) => {
+  const stopSend = startSpinner(() => "Sending a test notification");
+  const outcome = await verifyDelivery(apiKey, channels);
+  const report = describeVerifyOutcome(outcome);
+  stopSend(report.ok ? check : yellow("!"), report.message);
+  for (const line of report.next) console.log(`  ${dim(line)}`);
+  return { reachesYou: report.ok, outcome, detail: null };
+};
+var printCapabilityDelta = () => {
+  console.log(`  ${dim("Two ways to get approvals on your phone:")}`);
+  console.log();
+  console.log(`  ${bold("Pushary app")} ${dim("(iOS / Android)")}  ${cyan("pushary setup --connect app")}`);
+  console.log(`  ${dim("\u2022 Answers from the lock screen, and while the app is closed")}`);
+  console.log(`  ${dim("\u2022 Can start and steer agents remotely")}`);
+  console.log();
+  console.log(`  ${bold("Browser")} ${dim("(add to home screen)")}  ${dim("scan below")}`);
+  console.log(`  ${dim("\u2022 Works without installing an app")}`);
+  console.log(`  ${dim("\u2022 Answers require opening the page")}`);
+  console.log(`  ${dim("\u2022 iOS needs the page added to the home screen first")}`);
+};
+var printSiteOnlyWarning = (channels) => {
+  const others = channels.site?.otherMembers ?? 0;
+  console.log(`  ${yellow("!")} This site has ${channels.appDevices + channels.webActive} device(s), ${describeReach(channels)}.`);
+  console.log(`  ${dim(`Approvals for your agent would wake one of your ${others === 1 ? "teammate" : `${others} teammates`}.`)}`);
+  console.log(`  ${dim("Connect your own phone:")}`);
+};
+var connectDevice = async (apiKey, options = {}) => {
+  const probe = await fetchChannels(apiKey);
+  if (probe.kind !== "ok") return describeProbeFailure(probe);
+  const channels = probe.status;
+  if (reachesYou(channels)) {
+    console.log(`  ${check} ${describeExistingConnection(channels)}`);
+    return sendAndConfirm(apiKey, channels);
+  }
+  const site = await fetchSite(apiKey);
+  if (!site) {
+    console.log(`  ${yellow("!")} Couldn't load your subscribe link. Connect your phone later at ${cyan("pushary.com/download")}.`);
+    return phoneFailure("no_subscribe_link");
+  }
+  console.log();
+  if (channels.site !== null && channels.site.otherMembers > 0 && channels.phoneReachable) {
+    printSiteOnlyWarning(channels);
+  } else {
+    console.log(`  ${bold("Connect your phone")}`);
+    if (channels.webDesktop > 0) {
+      console.log(`  ${dim("A browser on this computer is subscribed, but no phone is connected yet.")}`);
+    }
+  }
+  console.log();
+  if (options.showCapabilities) printCapabilityDelta();
+  console.log();
+  console.log(`  ${dim("Scan this with your phone camera:")}`);
+  await printQr(site.subscribeUrl);
+  console.log(`  ${dim("or open")} ${cyan(site.subscribeUrl)}`);
+  console.log();
+  const waited = await waitForDevice(apiKey, channels);
+  if (waited.kind === "unauthorized") return phoneFailure("unauthorized");
+  if (waited.kind === "locked") return phoneFailure("locked");
+  if (waited.kind === "timeout") {
+    console.log(`  ${dim("No rush, open")} ${cyan(site.subscribeUrl)} ${dim("on your phone whenever you're ready.")}`);
+    return phoneFailure("timeout");
+  }
+  return sendAndConfirm(apiKey, waited.channels);
+};
+var describeProbeFailure = (probe) => {
+  if (probe.kind === "unauthorized") {
+    console.log(`  ${yellow("!")} The server rejected this key when checking for devices.`);
+    return phoneFailure("unauthorized");
+  }
+  if (probe.kind === "locked") {
+    console.log(`  ${yellow("!")} No approval can be delivered until the plan is active.`);
+    return phoneFailure("locked");
+  }
+  if (probe.kind === "unreachable") {
+    console.log(`  ${yellow("!")} Couldn't check your devices ${dim(`(${probe.detail})`)}`);
+    console.log(`  ${dim("Agents are configured. Run")} ${cyan("pushary doctor")} ${dim("when the connection is back.")}`);
+    return phoneFailure(probe.detail);
+  }
+  return phoneFailure("unknown");
+};
+var describeExistingConnection = (channels) => {
+  if (!channels.precise) return "A device is already connected";
+  const own = channels.yours;
+  if (own !== null && own.appDevices > 0) {
+    const platforms = own.appPlatforms.length > 0 ? ` ${dim(`(${own.appPlatforms.join(", ")})`)}` : "";
+    return `Pushary app connected${platforms}`;
+  }
+  if (channels.appDevices > 0) {
+    const platforms = channels.appPlatforms.length > 0 ? ` ${dim(`(${channels.appPlatforms.join(", ")})`)}` : "";
+    return `Pushary app connected${platforms}`;
+  }
+  return "Phone already connected";
+};
+var confirmAppConnection = async (apiKey) => {
+  const probe = await fetchChannels(apiKey);
+  if (probe.kind !== "ok") return describeProbeFailure(probe);
+  const channels = probe.status;
+  const ownedApp = channels.yours?.appDevices ?? channels.appDevices;
+  if (channels.precise && ownedApp === 0) {
+    console.log(`  ${yellow("!")} Paired, but the app hasn't registered for notifications yet.`);
+    console.log(`  ${dim("Open the Pushary app and allow notifications, then run")} ${cyan("pushary doctor")}${dim(".")}`);
+    return phoneFailure("app_not_registered");
+  }
+  return sendAndConfirm(apiKey, channels);
+};
+var printConnectInstructions = async (apiKey) => {
+  const probe = await fetchChannels(apiKey);
+  if (probe.kind !== "ok") return describeProbeFailure(probe);
+  const channels = probe.status;
+  if (reachesYou(channels)) {
+    console.log(`  ${check} ${describeExistingConnection(channels)}`);
+    return sendAndConfirm(apiKey, channels);
+  }
+  if (channels.site !== null && channels.site.otherMembers > 0 && channels.phoneReachable) {
+    printSiteOnlyWarning(channels);
+  }
+  const site = await fetchSite(apiKey);
+  const target = site?.subscribeUrl ?? "https://pushary.com/download";
+  console.log(`  ${dim("Connect your phone for push notifications at")} ${cyan(target)}`);
+  console.log(`  ${dim("or get the Pushary app at")} ${cyan("https://pushary.com/download")}`);
+  return phoneFailure("no_device");
+};
+var PAIR_POLL_INTERVAL_MS = 2e3;
+var PAIR_TIMEOUT_MS = 18e4;
+var startPairing = async (cliPublicKey) => {
+  try {
+    const res = await fetch(`${apiBase()}/api/mobile/pair/start`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ cliPublicKey }),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!res.ok) return null;
+    const data = await res.json().catch(() => null);
+    return data && typeof data.pairId === "string" ? data.pairId : null;
+  } catch {
+    return null;
+  }
+};
+var cancelPairing = async (pairId) => {
+  try {
+    await fetch(`${apiBase()}/api/mobile/pair/start`, {
+      method: "DELETE",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ pairId }),
+      signal: AbortSignal.timeout(5e3)
+    });
+  } catch {
+  }
+};
+var claimPairing = async (pairId) => {
+  try {
+    const res = await fetch(`${apiBase()}/api/mobile/pair/claim?id=${encodeURIComponent(pairId)}`, {
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!res.ok) return null;
+    return await res.json().catch(() => null);
+  } catch {
+    return null;
+  }
+};
+var buildPairLinks = (pairId, publicKeyB64, baseUrl = apiBase()) => {
+  const id = encodeURIComponent(pairId);
+  const pk = encodeURIComponent(publicKeyB64);
+  return {
+    universalLink: `${baseUrl.replace(/\/+$/, "")}/app/pair?id=${id}&pk=${pk}`,
+    deepLink: `pushary://pair?pk=${pk}&id=${id}`
+  };
+};
+var connectViaAppPairing = async () => {
+  const keypair = generateKeypair();
+  const pairId = await startPairing(keypair.publicKeyB64);
+  if (!pairId) {
+    console.log(`  ${yellow("!")} Couldn't start pairing. Check your connection and try again.`);
+    return null;
+  }
+  const { universalLink, deepLink } = buildPairLinks(pairId, keypair.publicKeyB64);
+  console.log();
+  console.log(`  ${bold("Connect your Pushary app")}`);
+  console.log(`  ${dim("Scan this with your phone camera:")}`);
+  await printQr(universalLink);
+  console.log(`  ${dim("No camera handy? Open this on the phone instead:")}`);
+  console.log(`  ${cyan(universalLink)}`);
+  console.log(`  ${dim("Confirm the app shows fingerprint")} ${cyan(publicKeyFingerprint(keypair.publicKeyB64))}`);
+  console.log(`  ${dim("Already have the app and it opened a browser? Use")} ${cyan(deepLink)}`);
+  console.log();
+  const deadline = Date.now() + PAIR_TIMEOUT_MS;
+  const stop = startSpinner(() => {
+    const left = Math.max(0, Math.ceil((deadline - Date.now()) / 1e3));
+    return `Waiting for the app to authorize ${dim(`(${left}s)`)}`;
+  });
+  let cancelled = false;
+  const onInterrupt = () => {
+    cancelled = true;
+    stop(yellow("!"), "Cancelled");
+    void cancelPairing(pairId).finally(() => process.exit(EXIT_ABORTED));
+  };
+  process.once("SIGINT", onInterrupt);
+  try {
+    while (Date.now() < deadline) {
+      if (cancelled) return null;
+      const claim = await claimPairing(pairId);
+      if (claim?.status === "authorized") {
+        let apiKey;
+        try {
+          apiKey = openSealedKey(claim.sealed, keypair);
+        } catch {
+          stop(yellow("!"), "Pairing failed to decrypt \u2014 re-run setup to try again");
+          await cancelPairing(pairId);
+          return null;
+        }
+        stop(check, "App connected");
+        return { apiKey, handle: claim.siteSlug };
+      }
+      if (claim?.status === "expired") {
+        stop(yellow("!"), "Pairing expired \u2014 re-run setup to try again");
+        return null;
+      }
+      await sleep(PAIR_POLL_INTERVAL_MS);
+    }
+    stop(yellow("!"), "Timed out waiting for the app");
+    await cancelPairing(pairId);
+    return null;
+  } catch (err) {
+    stop(yellow("!"), `Pairing error ${dim(`(${err instanceof Error ? err.message : "network"})`)}`);
+    await cancelPairing(pairId);
+    return null;
+  } finally {
+    process.off("SIGINT", onInterrupt);
+  }
+};
+
+export {
+  reachVerdict,
+  describeReach,
+  setHumanStream,
+  fetchChannels,
+  connectDevice,
+  confirmAppConnection,
+  printConnectInstructions,
+  connectViaAppPairing
+};

package/dist/{chunk-BE5X3WXL.js → chunk-5SO3CEGJ.js}

@@ -25,10 +25,7 @@ import {
   sendNotification,
   throttlePass,
   waitForAnswer
-} from "./chunk-WNRYRN2R.js";
-import {
-  getMachineId
-} from "./chunk-RN3NOEJF.js";
+} from "./chunk-HIIBSYFJ.js";
 import {
   isGatingMoment,
   recordKeylessMoment
@@ -42,10 +39,13 @@ import {
   scopeChangeReason,
   scopeRequiresHuman
 } from "./chunk-DQAN3JQP.js";
+import {
+  getMachineId
+} from "./chunk-RN3NOEJF.js";
 import {
   getApiKey,
   getBaseUrl
-} from "./chunk-NKXSILEW.js";
+} from "./chunk-2UMNXADU.js";
 
 // src/decision-episode.ts
 var EPISODE_PATH = "/api/agent/decision-episode";

package/dist/chunk-7QLSKOSU.js

@@ -0,0 +1,19 @@
+// src/cli/errors.ts
+var UsageError = class extends Error {
+  constructor(hint) {
+    super(hint);
+    this.hint = hint;
+    this.name = "UsageError";
+  }
+};
+var NetworkError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NetworkError";
+  }
+};
+
+export {
+  UsageError,
+  NetworkError
+};