@pushary/agent-hooks 0.60.0 → 0.61.0

package/dist/bin/pushary-stats.js

@@ -1,13 +1,18 @@
 #!/usr/bin/env node
+import {
+  exitOnHelpFlag
+} from "../chunk-HUJQSP4F.js";
+import "../chunk-SML23YOT.js";
 import {
   readLedgerSummary
 } from "../chunk-WLGEY4UX.js";
 import "../chunk-DQAN3JQP.js";
 import {
   getApiKey
-} from "../chunk-NKXSILEW.js";
+} from "../chunk-2UMNXADU.js";
 
 // bin/pushary-stats.ts
+exitOnHelpFlag("stats");
 var DAYS = 7;
 var summary = readLedgerSummary(DAYS);
 var connected = true;

package/dist/bin/pushary-status.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/bin/pushary-status.js

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+import {
+  describeReach,
+  fetchChannels,
+  reachVerdict
+} from "../chunk-GX64YGU3.js";
+import "../chunk-3EGEA4KH.js";
+import {
+  readKeySource
+} from "../chunk-B26DNXCA.js";
+import {
+  checkApiKey,
+  describeKeyCheck
+} from "../chunk-UKNAAVEE.js";
+import {
+  createIo
+} from "../chunk-TX7KBKT7.js";
+import "../chunk-7QLSKOSU.js";
+import "../chunk-BC3VCZ3E.js";
+import {
+  exitOnHelpFlag
+} from "../chunk-HUJQSP4F.js";
+import {
+  EXIT
+} from "../chunk-SML23YOT.js";
+import "../chunk-HNTKTK5B.js";
+import "../chunk-DQAN3JQP.js";
+import "../chunk-2UMNXADU.js";
+
+// src/status.ts
+var keySourceLine = (source) => {
+  if (source.kind === "none") {
+    return { label: "Key", value: "none found", ok: false };
+  }
+  const prefix = source.key ? source.key.split(".")[0] : "unknown";
+  const where = source.kind === "env" ? "$PUSHARY_API_KEY" : source.origin ?? "config file";
+  return { label: "Key", value: `${prefix} from ${where}`, ok: true };
+};
+var reachLine = (channels) => {
+  const verdict = reachVerdict(channels);
+  const line = describeReach(channels);
+  if (verdict.kind === "nobody") return { label: "Reachable", value: line, ok: false };
+  if (verdict.kind === "yours") {
+    const inPocket = (channels.yours?.phoneReachable ?? channels.phoneReachable) || channels.webPhone > 0;
+    return { label: "Reachable", value: line, ok: inPocket };
+  }
+  return { label: "Reachable", value: line, ok: false };
+};
+var siteLine = (channels) => {
+  const site = channels.site;
+  if (site === null || site.otherMembers === 0) return null;
+  const devices = site.appDevices + site.webActive;
+  return {
+    label: "Team",
+    value: `${devices} device${devices === 1 ? "" : "s"} across ${site.otherMembers + 1} members`,
+    ok: null
+  };
+};
+var buildStatusReport = (facts) => {
+  const lines = [keySourceLine(facts.source)];
+  if (facts.source.drift) {
+    lines.push({
+      label: "Key drift",
+      value: `$PUSHARY_API_KEY (${facts.source.drift.envPrefix}) differs from ${facts.source.drift.configPath} (${facts.source.drift.configPrefix}); the environment wins`,
+      ok: false
+    });
+  }
+  if (facts.source.kind === "none") {
+    return {
+      lines,
+      headline: "Not set up on this machine.",
+      next: ["Run `pushary setup` to connect an agent."],
+      exitCode: EXIT.NOT_CONFIGURED
+    };
+  }
+  const check = facts.keyCheck;
+  if (check && check.kind !== "ok") {
+    const report = describeKeyCheck(check);
+    lines.push({ label: "Server", value: report.message, ok: check.kind === "unreachable" ? null : false });
+    return { lines, headline: report.message, next: [...report.next], exitCode: report.exitCode };
+  }
+  if (check?.kind === "ok") {
+    const id = check.identity;
+    lines.push({ label: "Site", value: `${id.siteName || id.siteSlug} (${id.siteSlug})`, ok: true });
+    lines.push({
+      label: "Plan",
+      value: id.plan === id.surfacePlan ? `${id.plan} \xB7 ${id.subscriptionStatus}` : `${id.plan} (from ${id.surfacePlan}) \xB7 ${id.subscriptionStatus}`,
+      ok: true
+    });
+    if (id.workspaceMembers > 1) {
+      lines.push({
+        label: "Workspace",
+        value: `${id.workspaceMembers} members \u2014 some devices below may not be yours`,
+        ok: null
+      });
+    }
+  }
+  const channels = facts.channels?.kind === "ok" ? facts.channels.status : null;
+  if (channels) {
+    lines.push(reachLine(channels));
+    const site = siteLine(channels);
+    if (site) lines.push(site);
+  } else if (facts.channels && facts.channels.kind === "unreachable") {
+    lines.push({ label: "Reachable", value: `could not check (${facts.channels.detail})`, ok: null });
+  }
+  if (facts.source.drift) {
+    return {
+      lines,
+      headline: "Working, but two different keys are configured.",
+      next: [
+        "The shell export wins over the config file, and it may be the older one.",
+        "Run `pushary setup` to line them up, or open a new terminal."
+      ],
+      exitCode: EXIT.PROBLEMS_FOUND
+    };
+  }
+  if (facts.channels && facts.channels.kind === "unreachable") {
+    return {
+      lines,
+      headline: "Key is fine; could not read which devices are connected.",
+      next: ["Run `pushary status` again in a minute."],
+      exitCode: EXIT.UNREACHABLE
+    };
+  }
+  if (channels) {
+    const verdict = reachVerdict(channels);
+    if (verdict.kind !== "yours") {
+      return {
+        lines,
+        headline: verdict.kind === "nobody" ? "Configured, but no device can receive an approval." : verdict.kind === "others" ? "Configured, but the only devices here are your teammates'." : "Configured, and nothing proves an approval reaches you.",
+        next: verdict.kind === "nobody" ? ["Run `pushary connect` to add your phone, or install the Pushary app."] : ["Run `pushary connect` to add your own phone.", "Or `pushary doctor --roundtrip` to prove one of these is yours."],
+        exitCode: EXIT.NO_DEVICE
+      };
+    }
+    if (!(channels.yours?.phoneReachable ?? channels.phoneReachable) && channels.webPhone === 0) {
+      return {
+        lines,
+        headline: "Configured, but nothing in your pocket can receive an approval.",
+        next: ["Run `pushary connect` and connect your phone, or install the Pushary app."],
+        exitCode: EXIT.NO_DEVICE
+      };
+    }
+  }
+  return {
+    lines,
+    headline: "Ready.",
+    next: [],
+    exitCode: EXIT.OK
+  };
+};
+var statusJson = (facts, report) => ({
+  ok: report.exitCode === EXIT.OK,
+  headline: report.headline,
+  exitCode: report.exitCode,
+  keySource: facts.source.kind,
+  keyOrigin: facts.source.origin,
+  keyPrefix: facts.source.key ? facts.source.key.split(".")[0] : null,
+  drift: facts.source.drift ? {
+    env: facts.source.drift.envPrefix,
+    config: facts.source.drift.configPrefix,
+    configPath: facts.source.drift.configPath
+  } : null,
+  keyCheck: facts.keyCheck?.kind ?? null,
+  identity: facts.keyCheck?.kind === "ok" ? facts.keyCheck.identity : null,
+  channels: facts.channels?.kind === "ok" ? facts.channels.status : null,
+  channelsProbe: facts.channels?.kind ?? null
+});
+
+// bin/pushary-status.ts
+exitOnHelpFlag("status");
+var { bold, dim, green, red, yellow } = createIo();
+var args = process.argv.slice(2);
+var json = args.includes("--json");
+var main = async () => {
+  const source = readKeySource();
+  let keyCheck = null;
+  let channels = null;
+  if (source.key) {
+    keyCheck = await checkApiKey(source.key);
+    if (keyCheck.kind === "ok") channels = await fetchChannels(source.key);
+  }
+  const facts = { source, keyCheck, channels };
+  const report = buildStatusReport(facts);
+  if (json) {
+    process.stdout.write(`${JSON.stringify(statusJson(facts, report), null, 2)}
+`);
+    process.exit(report.exitCode);
+  }
+  const width = Math.max(...report.lines.map((line) => line.label.length)) + 2;
+  console.log();
+  console.log(`  ${bold("Pushary")}`);
+  console.log();
+  for (const line of report.lines) {
+    const icon = line.ok === true ? green("\u2713") : line.ok === false ? red("\u2717") : dim("\xB7");
+    console.log(`  ${icon} ${line.label.padEnd(width)}${line.value}`);
+  }
+  console.log();
+  console.log(`  ${report.exitCode === 0 ? green(bold(report.headline)) : yellow(bold(report.headline))}`);
+  for (const next of report.next) console.log(`  ${dim(next)}`);
+  console.log();
+  process.exit(report.exitCode);
+};
+main().catch((err) => {
+  console.error(`  ${yellow("!")} status failed: ${err instanceof Error ? err.message : String(err)}`);
+  process.exit(1);
+});

package/dist/bin/pushary-stop-hook.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import {
   handleStop
-} from "../chunk-WNRYRN2R.js";
+} from "../chunk-VFBYRR2N.js";
 import "../chunk-RN3NOEJF.js";
-import "../chunk-DWED7BS3.js";
+import "../chunk-HNTKTK5B.js";
 import "../chunk-DQAN3JQP.js";
-import "../chunk-NKXSILEW.js";
+import "../chunk-2UMNXADU.js";
 
 // bin/pushary-stop-hook.ts
 var main = async () => {

package/dist/bin/pushary-stopfailure-hook.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import {
   handleStopFailure
-} from "../chunk-WNRYRN2R.js";
+} from "../chunk-VFBYRR2N.js";
 import "../chunk-RN3NOEJF.js";
-import "../chunk-DWED7BS3.js";
+import "../chunk-HNTKTK5B.js";
 import "../chunk-DQAN3JQP.js";
-import "../chunk-NKXSILEW.js";
+import "../chunk-2UMNXADU.js";
 
 // bin/pushary-stopfailure-hook.ts
 var main = async () => {

package/dist/bin/pushary-suggestions.js

@@ -1,14 +1,19 @@
 #!/usr/bin/env node
+import {
+  createIo
+} from "../chunk-TX7KBKT7.js";
+import {
+  exitOnHelpFlag
+} from "../chunk-HUJQSP4F.js";
+import "../chunk-SML23YOT.js";
 import {
   getApiKey,
   getBaseUrl
-} from "../chunk-NKXSILEW.js";
+} from "../chunk-2UMNXADU.js";
 
 // bin/pushary-suggestions.ts
-var dim = (s) => `\x1B[2m${s}\x1B[0m`;
-var green = (s) => `\x1B[32m${s}\x1B[0m`;
-var cyan = (s) => `\x1B[36m${s}\x1B[0m`;
-var red = (s) => `\x1B[31m${s}\x1B[0m`;
+exitOnHelpFlag("suggestions");
+var { dim, green, cyan, red } = createIo();
 var errorMessage = async (res) => {
   try {
     const body = await res.json();

package/dist/bin/pushary-upgrade.js

@@ -1,18 +1,22 @@
 #!/usr/bin/env node
-import {
-  execNpm,
-  npmErrorMessage,
-  resolveGlobalBinDir
-} from "../chunk-J7JWI3KU.js";
 import {
   addClaudeMcpServer,
   addPusharyHooks,
   addPusharyToolPermissions
 } from "../chunk-CAJZAFVS.js";
+import {
+  execNpm,
+  npmErrorMessage,
+  resolveGlobalBinDir
+} from "../chunk-MUEW424A.js";
+import {
+  exitOnHelpFlag
+} from "../chunk-HUJQSP4F.js";
+import "../chunk-SML23YOT.js";
 import "../chunk-DQAN3JQP.js";
 import {
   getApiKey
-} from "../chunk-NKXSILEW.js";
+} from "../chunk-2UMNXADU.js";
 
 // src/reapply.ts
 import { join, dirname } from "path";
@@ -64,6 +68,7 @@ var reapplyClaudeSettings = (apiKey, paths = {}) => {
 };
 
 // bin/pushary-upgrade.ts
+exitOnHelpFlag("upgrade");
 var getInstalledVersion = () => {
   try {
     return execNpm("list -g --no-workspaces @pushary/agent-hooks --depth=0", { timeout: 1e4 }).toString().match(/@pushary\/agent-hooks@([\d.]+)/)?.[1] ?? "";

package/dist/bin/pushary-wait.js

@@ -1,18 +1,30 @@
 #!/usr/bin/env node
+import {
+  exitOnFailedResponse
+} from "../chunk-R6C4USIV.js";
 import {
   describeWaitLadder
 } from "../chunk-IIENZE2J.js";
+import "../chunk-UKNAAVEE.js";
+import {
+  createIo
+} from "../chunk-TX7KBKT7.js";
+import "../chunk-7QLSKOSU.js";
+import {
+  exitOnHelpFlag
+} from "../chunk-HUJQSP4F.js";
+import {
+  EXIT
+} from "../chunk-SML23YOT.js";
+import "../chunk-DQAN3JQP.js";
 import {
   getApiKey,
   getBaseUrl
-} from "../chunk-NKXSILEW.js";
+} from "../chunk-2UMNXADU.js";
 
 // bin/pushary-wait.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`;
+exitOnHelpFlag("wait");
+var { dim, bold, green, cyan, yellow } = createIo();
 var MAX_WINDOW = 300;
 var printLadder = (data) => {
   console.log();
@@ -36,7 +48,7 @@ var printLadder = (data) => {
 };
 var fetchPolicy = async (baseUrl, headers) => {
   const res = await fetch(`${baseUrl}/api/mcp/policy`, { headers });
-  if (!res.ok) throw new Error(`policy fetch failed (${res.status})`);
+  if (!res.ok) await exitOnFailedResponse(res, baseUrl);
   return res.json();
 };
 var setWindow = async (baseUrl, headers, seconds) => {
@@ -45,10 +57,7 @@ var setWindow = async (baseUrl, headers, seconds) => {
     headers,
     body: JSON.stringify({ defaultPushFirstSeconds: seconds })
   });
-  if (!res.ok) {
-    const err = await res.json().catch(() => ({}));
-    throw new Error(err.error ?? res.statusText);
-  }
+  if (!res.ok) await exitOnFailedResponse(res, baseUrl);
   const data = await res.json();
   return data.defaultPushFirstSeconds;
 };
@@ -75,7 +84,7 @@ var main = async () => {
   if (!Number.isFinite(seconds) || seconds < 0 || seconds > MAX_WINDOW) {
     console.log(`  ${yellow("!")} Invalid window: ${arg} ${dim(`(use 0-${MAX_WINDOW} seconds, or "status" / "clear")`)}`);
     console.log(`  ${dim("Usage: pushary wait <seconds> | status | clear")}`);
-    return;
+    process.exit(EXIT.USAGE);
   }
   const value = await setWindow(baseUrl, headers, Math.trunc(seconds));
   console.log(`  ${green("\u2713")} Default push window set to ${cyan(`${value}s`)} ${dim("\u2014 ping your phone that long, then the terminal takes over")}`);

package/dist/bin/pushary.js

@@ -1,65 +1,47 @@
 #!/usr/bin/env node
+import {
+  COMMANDS,
+  EXIT,
+  getPackageVersion,
+  isCommandName,
+  renderHelp
+} from "../chunk-SML23YOT.js";
 
 // bin/pushary.ts
-var command = process.argv[2];
-if (command === "setup") {
-  await import("./pushary-setup.js");
-} else if (command === "hook") {
-  await import("./pushary-hook.js");
-} else if (command === "clean") {
-  await import("./pushary-clean.js");
-} else if (command === "doctor") {
-  await import("./pushary-doctor.js");
-} else if (command === "mode") {
-  await import("./pushary-mode.js");
-} else if (command === "wait") {
-  await import("./pushary-wait.js");
-} else if (command === "stats") {
-  await import("./pushary-stats.js");
-} else if (command === "suggestions") {
-  await import("./pushary-suggestions.js");
-} else if (command === "upgrade") {
-  await import("./pushary-upgrade.js");
-} else if (command === "claude") {
-  await import("./pushary-claude.js");
-} else if (command === "daemon") {
-  await import("./pushary-daemon.js");
-} else {
-  console.log(`
-Pushary Agent Hooks
-
-Commands:
-  setup    Configure Claude Code, Codex, Gemini CLI, Hermes, or Cursor with Pushary
-  claude   Run Claude Code through Pushary \u2014 the native terminal, and reachable from
-           your phone: send an instruction and it drives even a fully idle agent
-           (press Ctrl-] to take the terminal back). Add --remote to start headless.
-  daemon   Keep this machine reachable to START a new session from your phone, even
-           with nothing running. Leave it in a project dir; it launches a headless
-           'pushary claude --remote' when you send a prompt from the app.
-  doctor   Verify your Pushary installation is working
-  clean    Remove all Pushary configuration (--yes for non-interactive)
-  mode     Switch approval mode (push_only, push_first, terminal_only)
-  wait     Show or set the "wait for your phone" ladder (pushary wait 45)
-  stats    Show the approval moments your agents hit while not connected
-  suggestions  List rules mined from your own approvals; accept one with
-               'pushary suggestions accept <id>' to always-allow that pattern
-  upgrade  Update the globally installed hooks to the latest version
-  hook     Run as a PreToolUse hook (reads stdin, writes stdout)
-
-Setup options:
-  --key <pk_xxx.xxx>   Use this API key instead of prompting for one
-  --connect web        Connect your phone via the PWA QR code (default)
-  --connect app        Pair the native Pushary app, no key to paste
-  --skip-phone         Skip the phone connect step (CI or non-interactive shells)
-
-Usage:
-  npx @pushary/agent-hooks@latest setup
-  npx @pushary/agent-hooks@latest setup --key pk_xxx.xxx --skip-phone
-  npx @pushary/agent-hooks@latest doctor
-  npx @pushary/agent-hooks@latest mode push_only --for 30m
-  npx @pushary/agent-hooks@latest wait 45
-  pushary claude                                    # native terminal, reachable from your phone when idle
-  pushary claude --remote -p "start the refactor"   # start headless, drive entirely from your phone
-  pushary daemon                                    # keep this machine ready to spawn a session from your phone
+var LOADERS = {
+  setup: () => import("./pushary-setup.js"),
+  claude: () => import("./pushary-claude.js"),
+  daemon: () => import("./pushary-daemon.js"),
+  status: () => import("./pushary-status.js"),
+  login: () => import("./pushary-login.js"),
+  logout: () => import("./pushary-logout.js"),
+  connect: () => import("./pushary-connect.js"),
+  doctor: () => import("./pushary-doctor.js"),
+  clean: () => import("./pushary-clean.js"),
+  mode: () => import("./pushary-mode.js"),
+  wait: () => import("./pushary-wait.js"),
+  stats: () => import("./pushary-stats.js"),
+  suggestions: () => import("./pushary-suggestions.js"),
+  upgrade: () => import("./pushary-upgrade.js"),
+  hook: () => import("./pushary-hook.js")
+};
+var argv = process.argv.slice(2);
+var command = argv[0] ?? "";
+var wants = (...names) => argv.some((arg) => names.includes(arg));
+if (!command || wants("--help", "-h") && !isCommandName(command)) {
+  process.stdout.write(renderHelp(getPackageVersion()));
+  process.exit(EXIT.OK);
+}
+if (wants("--version", "-v") && !isCommandName(command)) {
+  process.stdout.write(`${getPackageVersion()}
+`);
+  process.exit(EXIT.OK);
+}
+if (!isCommandName(command)) {
+  process.stderr.write(`Unknown command: ${command}
+`);
+  process.stderr.write(`Run \`pushary --help\`. Available: ${COMMANDS.map((c) => c.name).join(", ")}
 `);
+  process.exit(EXIT.USAGE);
 }
+await LOADERS[command]();

package/dist/{chunk-NKXSILEW.js → chunk-2UMNXADU.js}

@@ -12,18 +12,34 @@ var readKeyFromConfigFile = () => {
     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) return envKey;
+  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 @pushary/agent-hooks setup`, or get your API key at https://pushary.com/sign-up?from=ai-coding"
   );
 };
-var getBaseUrl = () => process.env.PUSHARY_BASE_URL ?? "https://pushary.com";
+var getBaseUrl = () => process.env.PUSHARY_BASE_URL?.trim() || process.env.PUSHARY_API_URL?.trim() || "https://pushary.com";
 
 export {
+  configFilePath,
   getApiKey,
   getBaseUrl
 };

package/dist/chunk-3EGEA4KH.js

@@ -0,0 +1,44 @@
+// src/pairing.ts
+import crypto from "crypto";
+var X25519_SPKI_PREFIX = Buffer.from("302a300506032b656e032100", "hex");
+var HKDF_INFO = Buffer.from("pushary-pair-v1");
+var HEADER_BYTES = 32 + 12 + 16;
+var rawToPublicKey = (raw) => crypto.createPublicKey({
+  key: Buffer.concat([X25519_SPKI_PREFIX, raw]),
+  format: "der",
+  type: "spki"
+});
+var publicKeyToRaw = (key) => key.export({ format: "der", type: "spki" }).subarray(-32);
+var generateKeypair = () => {
+  const { publicKey, privateKey } = crypto.generateKeyPairSync("x25519");
+  const publicKeyRaw = publicKeyToRaw(publicKey);
+  return { publicKeyB64: publicKeyRaw.toString("base64"), publicKeyRaw, privateKey };
+};
+var publicKeyFingerprint = (b64) => {
+  const raw = Buffer.from(b64, "base64");
+  const digest = crypto.createHash("sha256").update(raw).digest("hex");
+  return (digest.slice(0, 8).match(/.{2}/g) ?? []).join(" ").toUpperCase();
+};
+var openSealedKey = (blobB64, keypair) => {
+  const blob = Buffer.from(blobB64, "base64");
+  if (blob.length <= HEADER_BYTES) throw new Error("sealed payload too short");
+  const ephemeralRaw = blob.subarray(0, 32);
+  const nonce = blob.subarray(32, 44);
+  const tag = blob.subarray(44, 60);
+  const ciphertext = blob.subarray(60);
+  const shared = crypto.diffieHellman({
+    privateKey: keypair.privateKey,
+    publicKey: rawToPublicKey(ephemeralRaw)
+  });
+  const salt = Buffer.concat([ephemeralRaw, keypair.publicKeyRaw]);
+  const key = Buffer.from(crypto.hkdfSync("sha256", shared, salt, HKDF_INFO, 32));
+  const decipher = crypto.createDecipheriv("aes-256-gcm", key, nonce);
+  decipher.setAuthTag(tag);
+  return Buffer.concat([decipher.update(ciphertext), decipher.final()]).toString("utf8");
+};
+
+export {
+  generateKeypair,
+  publicKeyFingerprint,
+  openSealedKey
+};

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
+};