bitsnap 0.0.0-stage → 0.1.0

package/dist/cli.js

@@ -0,0 +1,1685 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { randomUUID } from "crypto";
+
+// src/args.ts
+import { parseArgs } from "util";
+
+// src/errors.ts
+var EXIT = { ok: 0, error: 1, auth: 2, network: 3 };
+var CliError = class extends Error {
+  details;
+  constructor(details) {
+    super(details.message);
+    this.name = "CliError";
+    this.details = details;
+  }
+  get exitCode() {
+    switch (this.details.kind) {
+      case "auth":
+        return EXIT.auth;
+      case "network":
+        return EXIT.network;
+      default:
+        return EXIT.error;
+    }
+  }
+  /** The body printed to stderr with --json. */
+  toJSON() {
+    const { kind, message, detail, hint, reason, code: code2, status, requestId, metadata } = this.details;
+    const error = { kind, message };
+    if (detail !== void 0) error.detail = detail;
+    if (hint !== void 0) error.hint = hint;
+    if (reason !== void 0) error.reason = reason;
+    if (code2 !== void 0) error.code = code2;
+    if (status !== void 0) error.status = status;
+    if (requestId !== void 0) error.requestId = requestId;
+    if (metadata !== void 0 && Object.keys(metadata).length > 0) {
+      error.metadata = metadata;
+    }
+    return { error };
+  }
+};
+function usageError(message, hint) {
+  return new CliError({ kind: "usage", message, hint });
+}
+var LOGIN_HINT = "Run `bitsnap login --key <key>` or set BITSNAP_API_KEY. Keys live in Settings \u2192 Developer.";
+var REASON_INFO = {
+  missing_credentials: {
+    message: "No API key was sent.",
+    hint: LOGIN_HINT,
+    kind: "auth"
+  },
+  invalid_credentials: {
+    message: "The API key is unknown, revoked, expired or malformed.",
+    hint: "Create a new key in Settings \u2192 Developer, then run `bitsnap login --key <key>`.",
+    kind: "auth"
+  },
+  missing_scope: {
+    message: (m) => m.scope ? `This key lacks the scope \`${m.scope}\`.` : "This key lacks a scope this command needs.",
+    hint: "Add the scope to the key in Settings \u2192 Developer, or use another key."
+  },
+  writes_disabled: {
+    message: "Writes are turned off for this key.",
+    hint: "Turn on writes for this key in Settings \u2192 Developer."
+  },
+  pii_scope_required: {
+    message: "Searching customer data needs the `customers:pii` scope.",
+    hint: "Add `customers:pii` to the key in Settings \u2192 Developer, or drop --search."
+  },
+  test_mode_only: {
+    message: "This command works only with a test key (bs_test_\u2026).",
+    hint: "Log in with a test key: `bitsnap login --key bs_test_\u2026`."
+  },
+  browser_origin_not_allowed: {
+    message: "The API refuses requests that carry an Origin header.",
+    hint: "Call the API from a server or the CLI, never from a browser."
+  },
+  invalid_request: {
+    message: "The API rejected the request.",
+    hint: "Check the value of the field named in the message."
+  },
+  invalid_cursor: {
+    message: "The cursor is not one this API returned.",
+    hint: "Pass the `nextCursor` of a previous page unchanged."
+  },
+  invalid_idempotency_key: {
+    message: "The idempotency key is invalid.",
+    hint: "Use 1-255 printable ASCII characters, or omit --idempotency-key."
+  },
+  discount_not_allowed: {
+    message: "That discount is not allowed for this key.",
+    hint: "Use a smaller percentage discount."
+  },
+  product_not_found: {
+    message: "No such product in this project.",
+    hint: "List ids with `bitsnap products list --drafts`."
+  },
+  order_not_found: {
+    message: "No such order in this project and environment.",
+    hint: "List ids with `bitsnap orders list`. Test and live orders are separate."
+  },
+  coupon_not_found: {
+    message: "No such coupon in this project.",
+    hint: "List coupons with `bitsnap coupons list`."
+  },
+  coupon_code_not_found: {
+    message: "No such coupon code in this project.",
+    hint: "List coupons with `bitsnap coupons list`."
+  },
+  webhook_not_found: {
+    message: "No such webhook endpoint in this environment.",
+    hint: "List endpoints with `bitsnap webhooks list`."
+  },
+  coupon_code_taken: {
+    message: "That coupon code is already used in the project.",
+    hint: "Pick another code."
+  },
+  revision_conflict: {
+    message: "The product changed since the revision you sent.",
+    hint: "Fetch it again and retry."
+  },
+  idempotency_key_reused: {
+    message: "That idempotency key was already used with a different request.",
+    hint: "Use a new --idempotency-key, or send the same request again."
+  },
+  idempotency_key_in_progress: {
+    message: "A request with that idempotency key is still running.",
+    hint: "Retry in a few seconds with the same --idempotency-key."
+  },
+  product_not_purchasable: {
+    message: "A product in the cart cannot be bought.",
+    hint: "Publish the product, check its stock and price, then retry."
+  },
+  checkout_unavailable: {
+    message: "The shop has no way to take this payment.",
+    hint: "Set up a payment gateway (the test gateway for test keys) in the dashboard."
+  },
+  order_not_settleable: {
+    message: "The test order is not waiting for a payment.",
+    hint: "Only an open test order of the Bitsnap test gateway can be settled. Create a new one with `bitsnap checkout create` and a test key."
+  },
+  product_moderation_hidden: {
+    message: "The product was hidden by moderation and cannot be published.",
+    hint: "Contact Bitsnap support."
+  },
+  rate_limited: {
+    message: "Too many requests.",
+    hint: "Slow down and retry in a few seconds."
+  },
+  daily_write_limit: {
+    message: "The key spent its daily write budget.",
+    hint: "The budget resets at 00:00 UTC."
+  },
+  method_not_found: {
+    message: "The API has no such method.",
+    hint: "Update the CLI: `npm i -g bitsnap@latest`."
+  },
+  service_unavailable: {
+    message: "A Bitsnap dependency is down.",
+    hint: "Retry in a minute."
+  },
+  internal: {
+    message: "Bitsnap failed on its side.",
+    hint: "Retry; if it persists report the request id."
+  }
+};
+function stripReasonPrefix(message) {
+  return message.replace(/^\[[a-z_]+\]\s*/, "");
+}
+function reasonOfMessage(message) {
+  return /^\[([a-z_]+)\]/.exec(message)?.[1];
+}
+function reasonFromDetails(details) {
+  if (!Array.isArray(details)) return {};
+  for (const entry of details) {
+    const debug = entry?.debug;
+    if (debug && typeof debug.reason === "string") {
+      const metadata = debug.metadata && typeof debug.metadata === "object" ? debug.metadata : void 0;
+      return { reason: debug.reason, metadata };
+    }
+  }
+  return {};
+}
+function apiErrorFromResponse(status, body, requestId) {
+  const parsed = body && typeof body === "object" ? body : {};
+  const rawMessage = typeof parsed.message === "string" ? parsed.message : void 0;
+  const code2 = typeof parsed.code === "string" ? parsed.code : void 0;
+  const fromDetails = reasonFromDetails(parsed.details);
+  const reason = fromDetails.reason ?? (rawMessage ? reasonOfMessage(rawMessage) : void 0);
+  const metadata = fromDetails.metadata ?? {};
+  const detail = rawMessage ? stripReasonPrefix(rawMessage) : void 0;
+  const info = reason ? REASON_INFO[reason] : void 0;
+  let kind = info?.kind ?? "api";
+  if (status === 401 || code2 === "unauthenticated") kind = "auth";
+  if (info) {
+    const message = typeof info.message === "function" ? info.message(metadata) : info.message;
+    return new CliError({
+      kind,
+      message,
+      detail: detail && detail !== message ? detail : void 0,
+      hint: info.hint,
+      reason,
+      code: code2,
+      status,
+      requestId,
+      metadata
+    });
+  }
+  const fallback = detail ?? (status === 401 ? "The API key was refused." : `The API answered with HTTP ${status}.`);
+  return new CliError({
+    kind,
+    message: fallback,
+    hint: kind === "auth" ? LOGIN_HINT : void 0,
+    reason,
+    code: code2,
+    status,
+    requestId,
+    metadata
+  });
+}
+function networkError(host, cause) {
+  const reason = cause instanceof Error ? cause.message : String(cause);
+  const nested = cause instanceof Error && cause.cause instanceof Error ? `: ${cause.cause.message}` : "";
+  return new CliError({
+    kind: "network",
+    message: `Could not reach ${host} (${reason}${nested}).`,
+    hint: "Check your connection and the --host / BITSNAP_HOST value, then retry."
+  });
+}
+
+// src/args.ts
+var GLOBAL_OPTIONS = {
+  json: {
+    type: "boolean",
+    description: "Machine-readable output: JSON on stdout, errors as JSON on stderr."
+  },
+  host: {
+    type: "string",
+    value: "<url>",
+    description: "API host. Default: BITSNAP_HOST, the stored host, or https://bitsnap.pl."
+  },
+  "idempotency-key": {
+    type: "string",
+    value: "<key>",
+    description: "Idempotency-Key for write commands. Default: a random UUID."
+  },
+  help: { type: "boolean", short: "h", description: "Show help for the command." }
+};
+function parseOptions(args, specs, allowPositionals) {
+  const all = { ...GLOBAL_OPTIONS, ...specs };
+  const options = {};
+  for (const [name, spec] of Object.entries(all)) {
+    options[name] = {
+      type: spec.type,
+      ...spec.short ? { short: spec.short } : {},
+      ...spec.multiple ? { multiple: true } : {}
+    };
+  }
+  try {
+    const { values, positionals } = parseArgs({
+      args,
+      options,
+      allowPositionals,
+      strict: true
+    });
+    for (const [name, spec] of Object.entries(specs)) {
+      if (spec.required && values[name] === void 0 && values.help !== true) {
+        throw usageError(`Missing required option --${name}.`, `Run with --help for usage.`);
+      }
+    }
+    return { values, positionals };
+  } catch (error) {
+    if (error instanceof CliError) throw error;
+    const message = error instanceof Error ? error.message : String(error);
+    throw usageError(message.split("\n")[0] ?? message, "Run with --help for usage.");
+  }
+}
+function str(values, name) {
+  const value = values[name];
+  return typeof value === "string" ? value : void 0;
+}
+function flag(values, name) {
+  return values[name] === true;
+}
+function list(values, name) {
+  const value = values[name];
+  if (Array.isArray(value)) return value.filter((v) => typeof v === "string");
+  return typeof value === "string" ? [value] : [];
+}
+function int(values, name, range = {}) {
+  const raw = str(values, name);
+  if (raw === void 0) return void 0;
+  if (!/^-?\d+$/.test(raw)) throw usageError(`--${name} must be a whole number, got "${raw}".`);
+  const value = Number(raw);
+  if (range.min !== void 0 && value < range.min) {
+    throw usageError(`--${name} must be at least ${range.min}.`);
+  }
+  if (range.max !== void 0 && value > range.max) {
+    throw usageError(`--${name} must be at most ${range.max}.`);
+  }
+  return value;
+}
+
+// src/client.ts
+var REQUEST_TIMEOUT_MS = 3e4;
+var ApiClient = class {
+  constructor(rt, auth) {
+    this.rt = rt;
+    this.auth = auth;
+  }
+  rt;
+  auth;
+  requireKey() {
+    if (!this.auth.apiKey) {
+      throw new CliError({
+        kind: "auth",
+        message: "No API key configured.",
+        hint: "Run `bitsnap login --key <key>` or set BITSNAP_API_KEY. Keys live in Settings \u2192 Developer."
+      });
+    }
+    return this.auth.apiKey;
+  }
+  headers(extra = {}) {
+    return {
+      Authorization: `Bearer ${this.requireKey()}`,
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      "X-Bitsnap-Client": `bitsnap-cli@${this.rt.version}`,
+      ...extra
+    };
+  }
+  /** `POST /api/v1/bitsnap.v1.<service>/<method>` with Connect JSON. */
+  async rpc(service, method, body = {}, options = {}) {
+    const extra = {};
+    if (options.write) {
+      extra["Idempotency-Key"] = options.idempotencyKey ?? this.rt.randomUUID();
+    }
+    return this.request(`/api/v1/bitsnap.v1.${service}/${method}`, {
+      method: "POST",
+      headers: this.headers(extra),
+      body: JSON.stringify(body)
+    });
+  }
+  /** A plain REST call of the dev endpoints (`/api/v1/webhooks/trigger`). */
+  async rest(path, init) {
+    const extra = {};
+    if (init.write) {
+      extra["Idempotency-Key"] = init.idempotencyKey ?? this.rt.randomUUID();
+    }
+    return this.request(path, {
+      method: init.method,
+      headers: this.headers(extra),
+      body: init.body === void 0 ? void 0 : JSON.stringify(init.body)
+    });
+  }
+  /** An unauthenticated GET that returns the body as text (OpenAPI document). */
+  async getText(path, accept) {
+    const response = await this.send(path, {
+      method: "GET",
+      headers: { Accept: accept, "X-Bitsnap-Client": `bitsnap-cli@${this.rt.version}` }
+    });
+    const text = await response.text();
+    if (!response.ok) {
+      throw apiErrorFromResponse(response.status, safeJson(text), response.headers.get("x-request-id") ?? void 0);
+    }
+    return text;
+  }
+  url(path) {
+    return this.auth.host + path;
+  }
+  /** fetch with the timeout and the network error mapping. */
+  async send(path, init) {
+    try {
+      return await this.rt.fetch(this.url(path), {
+        ...init,
+        signal: init.signal ?? AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+      });
+    } catch (error) {
+      throw networkError(this.auth.host, error);
+    }
+  }
+  async request(path, init) {
+    const response = await this.send(path, init);
+    const requestId = response.headers.get("x-request-id") ?? void 0;
+    let text;
+    try {
+      text = await response.text();
+    } catch (error) {
+      throw networkError(this.auth.host, error);
+    }
+    const body = safeJson(text);
+    if (!response.ok) throw apiErrorFromResponse(response.status, body, requestId);
+    return {
+      body: body ?? {},
+      requestId,
+      replayed: response.headers.get("idempotent-replayed") === "true"
+    };
+  }
+};
+function safeJson(text) {
+  if (text === "") return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+
+// src/commands.ts
+import { writeFileSync as writeFileSync2 } from "fs";
+import { resolve } from "path";
+
+// src/config.ts
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var DEFAULT_HOST = "https://bitsnap.pl";
+function configPath(env) {
+  const xdg = env.XDG_CONFIG_HOME;
+  const base = xdg && xdg !== "" ? xdg : join(env.HOME || homedir(), ".config");
+  return join(base, "bitsnap", "config.json");
+}
+function readConfig(env) {
+  const path = configPath(env);
+  if (!existsSync(path)) return {};
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    throw new CliError({
+      kind: "usage",
+      message: `The config file ${path} is not valid JSON.`,
+      hint: "Run `bitsnap logout`, then `bitsnap login --key <key>` again."
+    });
+  }
+}
+function writeConfig(env, config) {
+  const path = configPath(env);
+  const dir = dirname(path);
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  const temp = `${path}.${process.pid}.tmp`;
+  writeFileSync(temp, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
+  chmodSync(temp, 384);
+  renameSync(temp, path);
+  return path;
+}
+function removeConfig(env) {
+  const path = configPath(env);
+  if (!existsSync(path)) return false;
+  rmSync(path);
+  return true;
+}
+function maskKey(key) {
+  const prefix = /^(bs_test_|bs_live_|bsat_|api_)/.exec(key)?.[1] ?? "";
+  const rest = key.slice(prefix.length);
+  if (rest.length <= 8) return `${prefix}\u2026`;
+  return `${prefix}\u2026${rest.slice(-4)}`;
+}
+function keyEnvironment(key) {
+  if (key.startsWith("bs_test_")) return "test";
+  if (key.startsWith("bs_live_") || key.startsWith("api_")) return "live";
+  return "unknown";
+}
+function normalizeHost(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw usageError(`"${value}" is not a valid host URL.`, "Use e.g. --host https://bitsnap.pl");
+  }
+  if (url.protocol !== "https:" && url.protocol !== "http:") {
+    throw usageError(`"${value}" must start with http:// or https://.`);
+  }
+  return url.origin;
+}
+function resolveAuth(rt, hostFlag) {
+  const stored = readConfig(rt.env);
+  const envKey = rt.env.BITSNAP_API_KEY?.trim();
+  const apiKey = envKey ? envKey : stored.apiKey;
+  const source = envKey ? "env" : stored.apiKey ? "config" : "none";
+  const host = normalizeHost(
+    hostFlag || rt.env.BITSNAP_HOST || stored.host || DEFAULT_HOST
+  );
+  return { apiKey, host, source };
+}
+
+// src/sse.ts
+var SseParser = class {
+  buffer = "";
+  event = "";
+  data = [];
+  id;
+  /** The `id:` of the last event that had one; send it as `Last-Event-ID` when reconnecting. */
+  lastEventId;
+  skipLeadingLF = false;
+  push(chunk) {
+    if (this.skipLeadingLF && chunk.startsWith("\n")) chunk = chunk.slice(1);
+    if (chunk.length > 0) this.skipLeadingLF = false;
+    this.buffer += chunk;
+    const messages = [];
+    let start = 0;
+    for (let i = 0; i < this.buffer.length; i++) {
+      const char = this.buffer[i];
+      if (char !== "\n" && char !== "\r") continue;
+      const line = this.buffer.slice(start, i);
+      if (char === "\r") {
+        if (i + 1 < this.buffer.length) {
+          if (this.buffer[i + 1] === "\n") i++;
+        } else {
+          this.skipLeadingLF = true;
+        }
+      }
+      start = i + 1;
+      const message = this.line(line);
+      if (message) messages.push(message);
+    }
+    this.buffer = this.buffer.slice(start);
+    return messages;
+  }
+  line(line) {
+    if (line === "") {
+      const hasData = this.data.length > 0;
+      const message = hasData ? { id: this.id, event: this.event || "message", data: this.data.join("\n") } : void 0;
+      if (hasData && this.id !== void 0) this.lastEventId = this.id;
+      this.event = "";
+      this.data = [];
+      this.id = void 0;
+      return message;
+    }
+    if (line.startsWith(":")) return void 0;
+    const colon = line.indexOf(":");
+    const field = colon === -1 ? line : line.slice(0, colon);
+    let value = colon === -1 ? "" : line.slice(colon + 1);
+    if (value.startsWith(" ")) value = value.slice(1);
+    switch (field) {
+      case "event":
+        this.event = value;
+        break;
+      case "data":
+        this.data.push(value);
+        break;
+      case "id":
+        if (!value.includes("\0")) this.id = value;
+        break;
+      default:
+        break;
+    }
+    return void 0;
+  }
+};
+
+// src/listen.ts
+var EVENTS_PATH = "/api/v1/webhooks/events";
+var FORWARD_TIMEOUT_MS = 15e3;
+var SSE_FAILURES_BEFORE_POLL = 3;
+var FAILURES_BEFORE_GIVING_UP = 8;
+var MAX_BACKOFF_MS = 15e3;
+var SEEN_LIMIT = 1e3;
+async function forwardEvent(rt, forward, event) {
+  const target = new URL(forward);
+  target.searchParams.set("sig", event.signature);
+  const started = Date.now();
+  try {
+    const response = await rt.fetch(target, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Content-Signature": event.signature
+      },
+      body: event.payload,
+      signal: AbortSignal.timeout(FORWARD_TIMEOUT_MS)
+    });
+    const durationMs = Date.now() - started;
+    const result = {
+      url: forward,
+      status: response.status,
+      ok: response.ok,
+      durationMs
+    };
+    if (!response.ok) {
+      const text = (await response.text().catch(() => "")).slice(0, 500);
+      if (text !== "") result.body = text;
+    } else {
+      await response.body?.cancel().catch(() => void 0);
+    }
+    return result;
+  } catch (error) {
+    const cause = error instanceof Error ? error.message : String(error);
+    const nested = error instanceof Error && error.cause instanceof Error ? ` (${error.cause.message})` : "";
+    return { url: forward, error: `${cause}${nested}`, durationMs: Date.now() - started };
+  }
+}
+async function listenForWebhooks(rt, client, printer, options) {
+  client.requireKey();
+  const controller2 = new AbortController();
+  const stop = () => controller2.abort();
+  if (rt.signal?.aborted) controller2.abort();
+  rt.signal?.addEventListener("abort", stop, { once: true });
+  let timedOut = false;
+  const timer = options.timeoutSeconds === void 0 ? void 0 : setTimeout(() => {
+    timedOut = true;
+    controller2.abort();
+  }, options.timeoutSeconds * 1e3);
+  let lastEventId;
+  let announced = false;
+  let received = 0;
+  let mode = options.poll ? "poll" : "sse";
+  let sseFailures = 0;
+  let failures = 0;
+  const seen = /* @__PURE__ */ new Set();
+  const finished = () => controller2.signal.aborted || options.maxEvents !== void 0 && received >= options.maxEvents;
+  const announce = (ready) => {
+    if (announced) return;
+    announced = true;
+    if (printer.json) {
+      printer.ndjson({ type: "ready", ...ready, host: client.auth.host, mode });
+      return;
+    }
+    printer.line(`Listening for test webhook events on ${client.auth.host}` + (ready.projectId ? ` (project ${ready.projectId})` : "") + ".");
+    printer.line(`Signing secret: ${ready.secret}`);
+    printer.line(
+      "For local dev set BITSNAP_WEBHOOK_SECRET to this value in your app's env so it can verify the forwarded events."
+    );
+    if (options.forward) printer.line(`Forwarding events to ${options.forward}`);
+    printer.line("Press Ctrl+C to stop.");
+  };
+  const handle = async (event) => {
+    if (seen.has(event.id)) return;
+    seen.add(event.id);
+    if (seen.size > SEEN_LIMIT) seen.delete(seen.values().next().value);
+    if (event.id) lastEventId = event.id;
+    received++;
+    const forwarded = options.forward ? await forwardEvent(rt, options.forward, event) : void 0;
+    if (printer.json) {
+      const record = {
+        type: "event",
+        id: event.id,
+        event: event.event,
+        signature: event.signature,
+        payload: event.payload
+      };
+      if (forwarded) record.forward = forwarded;
+      printer.ndjson(record);
+      return;
+    }
+    let text = `${(/* @__PURE__ */ new Date()).toISOString().slice(11, 19)}  ${event.event}  ${event.id}`;
+    if (forwarded) {
+      text += "error" in forwarded ? `  -> ${forwarded.url} failed: ${forwarded.error}` : `  -> ${forwarded.url} ${forwarded.status} (${forwarded.durationMs} ms)`;
+    }
+    printer.line(text);
+    if (forwarded && "body" in forwarded && forwarded.body) {
+      printer.line(`    ${forwarded.body.replace(/\s+/g, " ").slice(0, 200)}`);
+    }
+  };
+  const connectHeaders = (accept) => client.headers({
+    Accept: accept,
+    ...lastEventId ? { "Last-Event-ID": lastEventId } : {}
+  });
+  const failResponse = async (response) => {
+    const text = await response.text().catch(() => "");
+    throw apiErrorFromResponse(
+      response.status,
+      safeJson(text),
+      response.headers.get("x-request-id") ?? void 0
+    );
+  };
+  const runSse = async () => {
+    const response = await client.send(EVENTS_PATH, {
+      method: "GET",
+      headers: connectHeaders("text/event-stream"),
+      signal: controller2.signal
+    });
+    if (!response.ok) await failResponse(response);
+    const type = response.headers.get("content-type") ?? "";
+    if (!type.includes("text/event-stream") || !response.body) {
+      await response.body?.cancel().catch(() => void 0);
+      throw new CliError({
+        kind: "network",
+        message: `The server did not answer with an event stream (content-type "${type}").`
+      });
+    }
+    const parser = new SseParser();
+    if (lastEventId) parser.lastEventId = lastEventId;
+    const decoder = new TextDecoder();
+    const reader = response.body.getReader();
+    let gotReady = false;
+    try {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        for (const message of parser.push(decoder.decode(value, { stream: true }))) {
+          if (message.event === "ready") {
+            const ready = safeJson(message.data);
+            if (ready && typeof ready === "object" && typeof ready.secret === "string") {
+              gotReady = true;
+              failures = 0;
+              sseFailures = 0;
+              announce(ready);
+            }
+          } else {
+            const event = safeJson(message.data);
+            if (event && typeof event === "object" && typeof event.payload === "string") {
+              await handle({ ...event, id: event.id ?? message.id ?? "" });
+            }
+          }
+          if (finished()) return;
+        }
+      }
+    } finally {
+      await reader.cancel().catch(() => void 0);
+    }
+    if (!gotReady) {
+      throw new CliError({ kind: "network", message: "The event stream ended before it was ready." });
+    }
+  };
+  const runPoll = async () => {
+    const started = Date.now();
+    const response = await client.send(`${EVENTS_PATH}?mode=poll&wait=25`, {
+      method: "GET",
+      headers: connectHeaders("application/json"),
+      signal: controller2.signal
+    });
+    if (!response.ok) await failResponse(response);
+    const body = safeJson(await response.text());
+    if (!body || typeof body !== "object" || typeof body.secret !== "string") {
+      throw new CliError({ kind: "network", message: "Unexpected answer from the poll endpoint." });
+    }
+    failures = 0;
+    announce({ secret: body.secret });
+    for (const event of body.events ?? []) {
+      await handle(event);
+      if (finished()) return;
+    }
+    if ((body.events ?? []).length === 0 && Date.now() - started < 500) {
+      await rt.sleep(1e3, controller2.signal);
+    }
+  };
+  try {
+    while (!finished()) {
+      try {
+        if (mode === "sse") {
+          const connectedAt = Date.now();
+          await runSse();
+          if (!finished() && Date.now() - connectedAt < 2e3) {
+            await rt.sleep(1e3, controller2.signal);
+          }
+        } else {
+          await runPoll();
+        }
+      } catch (error) {
+        if (finished()) break;
+        if (!isTransient(error)) throw error;
+        failures++;
+        if (mode === "sse") sseFailures++;
+        if (failures >= FAILURES_BEFORE_GIVING_UP) throw error;
+        if (mode === "sse" && sseFailures >= SSE_FAILURES_BEFORE_POLL) {
+          mode = "poll";
+          if (printer.json) printer.ndjson({ type: "status", state: "polling" });
+          else printer.note("Event stream unavailable; switching to long polling.");
+        } else {
+          if (printer.json) printer.ndjson({ type: "status", state: "reconnecting" });
+          else printer.note("Connection lost; reconnecting\u2026");
+        }
+        await rt.sleep(Math.min(1e3 * 2 ** (failures - 1), MAX_BACKOFF_MS), controller2.signal);
+      }
+    }
+  } finally {
+    if (timer) clearTimeout(timer);
+    rt.signal?.removeEventListener("abort", stop);
+  }
+  if (timedOut && options.maxEvents !== void 0 && received < options.maxEvents) {
+    throw new CliError({
+      kind: "timeout",
+      message: `Timed out after ${options.timeoutSeconds} s with ${received} of ${options.maxEvents} events.`,
+      hint: "Trigger an event with `bitsnap webhooks trigger` or `bitsnap payments settle <orderId>`."
+    });
+  }
+}
+function isTransient(error) {
+  if (error instanceof CliError) {
+    const { kind, status } = error.details;
+    if (kind === "network") return true;
+    return kind === "api" && status !== void 0 && (status >= 500 || status === 429 || status === 408);
+  }
+  return !(error instanceof DOMException && error.name === "AbortError");
+}
+
+// src/output.ts
+var Printer = class {
+  constructor(rt, json) {
+    this.rt = rt;
+    this.json = json;
+  }
+  rt;
+  json;
+  /** One result document: pretty JSON with --json, otherwise `human()` lines. */
+  result(value, human) {
+    if (this.json) {
+      this.rt.stdout.write(JSON.stringify(value, null, 2) + "\n");
+      return;
+    }
+    const text = human();
+    const lines = Array.isArray(text) ? text : [text];
+    this.rt.stdout.write(lines.join("\n") + "\n");
+  }
+  /** One compact JSON line (NDJSON) on stdout. */
+  ndjson(value) {
+    this.rt.stdout.write(JSON.stringify(value) + "\n");
+  }
+  line(text) {
+    this.rt.stdout.write(text + "\n");
+  }
+  /** Progress notes for humans; never printed with --json. */
+  note(text) {
+    if (!this.json) this.rt.stderr.write(text + "\n");
+  }
+};
+function table(headers, rows) {
+  const widths = headers.map(
+    (header, column) => Math.max(header.length, ...rows.map((row) => (row[column] ?? "").length))
+  );
+  const format = (cells) => cells.map((cell, column) => cell.padEnd(widths[column] ?? 0)).join("  ").trimEnd();
+  return [format(headers), ...rows.map(format)];
+}
+function formatMoney(money) {
+  if (!money) return "-";
+  return `${(money.amount / 100).toFixed(2)} ${money.currency}`;
+}
+function enumLabel(value, prefix) {
+  if (!value) return "-";
+  return value.replace(prefix, "").toLowerCase();
+}
+
+// src/commands.ts
+var CURSOR_OPTION = {
+  type: "string",
+  value: "<cursor>",
+  description: "The nextCursor of the previous page."
+};
+function idempotencyKey(ctx) {
+  return str(ctx.values, "idempotency-key");
+}
+function onePositional(ctx, name) {
+  const [value, ...rest] = ctx.positionals;
+  if (value === void 0 || value === "") {
+    throw usageError(`Missing <${name}> argument.`, "Run with --help for usage.");
+  }
+  if (rest.length > 0) throw usageError(`Unexpected argument "${rest[0]}".`);
+  return value;
+}
+function noPositionals(ctx) {
+  if (ctx.positionals.length > 0) {
+    throw usageError(`Unexpected argument "${ctx.positionals[0]}".`, "Run with --help for usage.");
+  }
+}
+function envLabel(environment) {
+  return enumLabel(environment, "ENVIRONMENT_");
+}
+var PRODUCT_STATUSES = {
+  draft: "PRODUCT_STATUS_DRAFT",
+  unpublished: "PRODUCT_STATUS_UNPUBLISHED",
+  published: "PRODUCT_STATUS_PUBLISHED"
+};
+var ORDER_STATUSES = {
+  created: "ORDER_STATUS_CREATED",
+  paid: "ORDER_STATUS_PAID",
+  unpaid: "ORDER_STATUS_UNPAID",
+  canceled: "ORDER_STATUS_CANCELED",
+  sent: "ORDER_STATUS_SENT",
+  completed: "ORDER_STATUS_COMPLETED",
+  issue: "ORDER_STATUS_ISSUE",
+  returned: "ORDER_STATUS_RETURNED",
+  in_progress: "ORDER_STATUS_IN_PROGRESS"
+};
+function enumValue(option, raw, prefix, choices) {
+  const key = raw.toLowerCase().replace(/-/g, "_").replace(prefix.toLowerCase(), "");
+  const found = choices[key];
+  if (!found) {
+    throw usageError(
+      `--${option} must be one of: ${Object.keys(choices).join(", ")}. Got "${raw}".`
+    );
+  }
+  return found;
+}
+function parseTime(option, raw, end = false) {
+  if (/^\d{4}-\d{2}-\d{2}$/.test(raw)) {
+    const day = /* @__PURE__ */ new Date(`${raw}T00:00:00Z`);
+    if (Number.isNaN(day.getTime())) throw usageError(`--${option} "${raw}" is not a valid date.`);
+    if (end) day.setUTCDate(day.getUTCDate() + 1);
+    return day.toISOString().replace(".000Z", "Z");
+  }
+  const parsed = new Date(raw);
+  if (Number.isNaN(parsed.getTime()) || !/^\d{4}-\d{2}-\d{2}T/.test(raw)) {
+    throw usageError(
+      `--${option} "${raw}" is not a date.`,
+      "Use YYYY-MM-DD or an RFC 3339 timestamp like 2026-10-30T12:00:00Z."
+    );
+  }
+  return parsed.toISOString().replace(".000Z", "Z");
+}
+function replayedNote(ctx, replayed) {
+  if (replayed) ctx.printer.note("(replayed: this idempotency key was already used)");
+}
+var COMMANDS = [
+  {
+    path: ["login"],
+    summary: "Store an API key and verify it with the API.",
+    options: {
+      key: {
+        type: "string",
+        value: "<key>",
+        description: "The API key (bs_test_\u2026 or bs_live_\u2026). Default: BITSNAP_API_KEY."
+      }
+    },
+    output: "GetAccount response + { key (masked), host, configPath }",
+    examples: [
+      "bitsnap login --key bs_test_01ABC\u2026",
+      "BITSNAP_API_KEY=bs_test_01ABC\u2026 bitsnap login --json"
+    ],
+    async run(ctx) {
+      noPositionals(ctx);
+      const key = (str(ctx.values, "key") ?? ctx.rt.env.BITSNAP_API_KEY ?? "").trim();
+      if (key === "") {
+        throw usageError(
+          "No API key given.",
+          "Pass --key <key> or set BITSNAP_API_KEY. Create a key in Settings \u2192 Developer. The CLI never prompts."
+        );
+      }
+      if (/\s/.test(key)) throw usageError("The API key must not contain whitespace.");
+      const auth = resolveAuth(ctx.rt, str(ctx.values, "host"));
+      const client = new ApiClient(ctx.rt, { ...auth, apiKey: key, source: "none" });
+      const { body } = await client.rpc("AccountService", "GetAccount");
+      const path = writeConfig(ctx.rt.env, {
+        apiKey: key,
+        host: auth.host,
+        projectId: body.projectId,
+        projectName: body.projectName,
+        environment: body.environment
+      });
+      const result = { ...body, key: maskKey(key), host: auth.host, configPath: path };
+      ctx.printer.result(result, () => [
+        `Logged in to ${body.projectName} (${body.projectId}) in ${envLabel(body.environment)} mode.`,
+        `Key: ${maskKey(key)}  Host: ${auth.host}`,
+        `Saved to ${path}`,
+        ...ctx.rt.env.BITSNAP_API_KEY && ctx.rt.env.BITSNAP_API_KEY.trim() !== key ? ["Note: BITSNAP_API_KEY is set and wins over the stored key."] : []
+      ]);
+    }
+  },
+  {
+    path: ["logout"],
+    summary: "Delete the stored API key.",
+    options: {},
+    output: "{ ok, removed, configPath }",
+    examples: ["bitsnap logout"],
+    async run(ctx) {
+      noPositionals(ctx);
+      const removed = removeConfig(ctx.rt.env);
+      const path = configPath(ctx.rt.env);
+      ctx.printer.result(
+        { ok: true, removed, configPath: path },
+        () => removed ? [
+          `Removed ${path}.`,
+          ...ctx.rt.env.BITSNAP_API_KEY ? ["BITSNAP_API_KEY is still set in this environment."] : []
+        ] : "No stored credentials."
+      );
+    }
+  },
+  {
+    path: ["whoami"],
+    summary: "Show the project, environment and scopes of the current key.",
+    options: {},
+    output: "GetAccount response + { key (masked), keySource: env|config, host }",
+    examples: ["bitsnap whoami --json"],
+    async run(ctx) {
+      noPositionals(ctx);
+      const client = ctx.client();
+      const key = client.requireKey();
+      const { body } = await client.rpc("AccountService", "GetAccount");
+      const result = { ...body, key: maskKey(key), keySource: client.auth.source, host: client.auth.host };
+      ctx.printer.result(result, () => [
+        `Project:     ${body.projectName} (${body.projectId})`,
+        `Environment: ${envLabel(body.environment)}`,
+        `Credential:  ${enumLabel(body.credentialType, "CREDENTIAL_TYPE_")}  ${maskKey(key)} (from ${client.auth.source})`,
+        `Writes:      ${body.canWrite ? "enabled" : "disabled"}`,
+        `Scopes:      ${body.scopes.join(", ") || "-"}`,
+        `Host:        ${client.auth.host}`
+      ]);
+    }
+  },
+  {
+    path: ["products", "list"],
+    summary: "List products, newest first.",
+    options: {
+      search: { type: "string", value: "<text>", description: "Only products whose name contains this." },
+      limit: { type: "string", value: "<1-100>", description: "Page size. Default 50." },
+      drafts: { type: "boolean", description: "Include draft and unpublished products." },
+      cursor: CURSOR_OPTION
+    },
+    output: "{ products: Product[], nextCursor }",
+    examples: ["bitsnap products list --drafts --limit 20 --json"],
+    async run(ctx) {
+      noPositionals(ctx);
+      const request = {};
+      const search = str(ctx.values, "search");
+      if (search) request.search = search;
+      const limit = int(ctx.values, "limit", { min: 1, max: 100 });
+      if (limit !== void 0) request.limit = limit;
+      const cursor = str(ctx.values, "cursor");
+      if (cursor) request.cursor = cursor;
+      if (flag(ctx.values, "drafts")) request.includeDrafts = true;
+      const { body } = await ctx.client().rpc("ProductsService", "ListProducts", request);
+      ctx.printer.result(body, () => {
+        if (body.products.length === 0) return "No products.";
+        const rows = body.products.map((p) => [
+          p.id,
+          p.name,
+          enumLabel(p.status, "PRODUCT_STATUS_"),
+          formatMoney(p.price),
+          p.availableQuantity === void 0 ? "-" : String(p.availableQuantity)
+        ]);
+        return [
+          ...table(["ID", "NAME", "STATUS", "PRICE", "STOCK"], rows),
+          ...body.nextCursor ? [`More: --cursor ${body.nextCursor}`] : []
+        ];
+      });
+    }
+  },
+  {
+    path: ["products", "get"],
+    summary: "Show one product with its variants.",
+    args: "<id>",
+    options: {},
+    output: "{ product: Product }",
+    examples: ["bitsnap products get prodv2_abc --json"],
+    async run(ctx) {
+      const id = onePositional(ctx, "id");
+      const { body } = await ctx.client().rpc("ProductsService", "GetProduct", { id });
+      const p = body.product;
+      ctx.printer.result(body, () => [
+        `${p.name} (${p.id})`,
+        `Status:   ${enumLabel(p.status, "PRODUCT_STATUS_")}`,
+        `Price:    ${formatMoney(p.price)}`,
+        `Stock:    ${p.availableQuantity === void 0 ? "not tracked" : p.availableQuantity}`,
+        `Revision: ${p.revision}`,
+        `Images:   ${p.images.length === 0 ? "-" : p.images.join(", ")}`,
+        ...p.variants.length > 0 ? [
+          "Variants:",
+          ...table(
+            ["  ID", "NAME", "PRICE", "STOCK"],
+            p.variants.map((v) => [
+              `  ${v.id}`,
+              v.name,
+              formatMoney(v.price),
+              v.availableQuantity === void 0 ? "-" : String(v.availableQuantity)
+            ])
+          )
+        ] : []
+      ]);
+    }
+  },
+  {
+    path: ["products", "create"],
+    summary: "Create a product (a draft unless --status says otherwise).",
+    options: {
+      name: { type: "string", value: "<name>", description: "Product name.", required: true },
+      price: {
+        type: "string",
+        value: "<minor units>",
+        description: "Price in minor units: 4900 = 49.00 PLN.",
+        required: true
+      },
+      currency: { type: "string", value: "<ISO 4217>", description: "Currency. Default PLN." },
+      status: { type: "string", value: "<draft|published|unpublished>", description: "Initial status. Default draft." },
+      stock: { type: "string", value: "<n>", description: "Units that can be sold. Default: not tracked." },
+      image: { type: "string", multiple: true, value: "<url>", description: "Image URL; repeat for more." }
+    },
+    output: "{ product: Product }",
+    examples: [
+      "bitsnap products create --name 'Ebook' --price 4900 --status published --json",
+      "bitsnap products create --name Shirt --price 8900 --image https://example.com/a.png --image https://example.com/b.png"
+    ],
+    async run(ctx) {
+      noPositionals(ctx);
+      const price = int(ctx.values, "price", { min: 0 });
+      const request = {
+        name: str(ctx.values, "name"),
+        price: { amount: price, currency: (str(ctx.values, "currency") ?? "PLN").toUpperCase() }
+      };
+      const status = str(ctx.values, "status");
+      if (status) request.status = enumValue("status", status, "PRODUCT_STATUS_", PRODUCT_STATUSES);
+      const stock = int(ctx.values, "stock", { min: 0 });
+      if (stock !== void 0) request.availableQuantity = stock;
+      const images = list(ctx.values, "image");
+      if (images.length > 0) request.images = images;
+      const { body, replayed } = await ctx.client().rpc("ProductsService", "CreateProduct", request, {
+        write: true,
+        idempotencyKey: idempotencyKey(ctx)
+      });
+      replayedNote(ctx, replayed);
+      ctx.printer.result(body, () => [
+        `Created ${body.product.name} (${body.product.id}) as ${enumLabel(body.product.status, "PRODUCT_STATUS_")}.`
+      ]);
+    }
+  },
+  {
+    path: ["orders", "list"],
+    summary: "List orders of the key's environment, newest first.",
+    options: {
+      status: {
+        type: "string",
+        multiple: true,
+        value: `<${Object.keys(ORDER_STATUSES).join("|")}>`,
+        description: "Only orders in this status; repeat for several."
+      },
+      limit: { type: "string", value: "<n>", description: "Page size." },
+      cursor: CURSOR_OPTION
+    },
+    output: "{ orders: Order[], nextCursor, totalCount }",
+    examples: ["bitsnap orders list --status paid --limit 10 --json"],
+    async run(ctx) {
+      noPositionals(ctx);
+      const request = {};
+      const statuses = list(ctx.values, "status").map(
+        (s) => enumValue("status", s, "ORDER_STATUS_", ORDER_STATUSES)
+      );
+      if (statuses.length > 0) request.statuses = statuses;
+      const limit = int(ctx.values, "limit", { min: 1, max: 100 });
+      if (limit !== void 0) request.limit = limit;
+      const cursor = str(ctx.values, "cursor");
+      if (cursor) request.cursor = cursor;
+      const { body } = await ctx.client().rpc("OrdersService", "ListOrders", request);
+      ctx.printer.result(body, () => {
+        if (body.orders.length === 0) return "No orders.";
+        const rows = body.orders.map((o) => [
+          o.id,
+          enumLabel(o.status, "ORDER_STATUS_"),
+          envLabel(o.environment),
+          formatMoney(o.total),
+          o.customer?.email ?? "-",
+          o.createdAt ?? "-"
+        ]);
+        return [
+          ...table(["ID", "STATUS", "ENV", "TOTAL", "CUSTOMER", "CREATED"], rows),
+          `${body.totalCount} total${body.nextCursor ? `; more: --cursor ${body.nextCursor}` : ""}`
+        ];
+      });
+    }
+  },
+  {
+    path: ["orders", "get"],
+    summary: "Show one order.",
+    args: "<id>",
+    options: {},
+    output: "{ order: Order }",
+    examples: ["bitsnap orders get ord_123 --json"],
+    async run(ctx) {
+      const id = onePositional(ctx, "id");
+      const { body } = await ctx.client().rpc("OrdersService", "GetOrder", { id });
+      const o = body.order;
+      ctx.printer.result(body, () => [
+        `Order ${o.id}: ${enumLabel(o.status, "ORDER_STATUS_")} (${envLabel(o.environment)})`,
+        `Total:    ${formatMoney(o.total)}`,
+        `Customer: ${o.customer?.email || "-"}`,
+        `Gateway:  ${o.paymentGateway || "-"}`,
+        `Created:  ${o.createdAt ?? "-"}`,
+        ...o.items.map((i) => `  ${i.quantity} \xD7 ${i.name} (${i.productId}) ${formatMoney(i.unitPrice)}`)
+      ]);
+    }
+  },
+  {
+    path: ["coupons", "list"],
+    summary: "List coupons and their codes.",
+    options: {},
+    output: "{ coupons: Coupon[] }",
+    examples: ["bitsnap coupons list --json"],
+    async run(ctx) {
+      noPositionals(ctx);
+      const { body } = await ctx.client().rpc("CouponsService", "ListCoupons");
+      ctx.printer.result(body, () => {
+        if (body.coupons.length === 0) return "No coupons.";
+        return table(
+          ["ID", "NAME", "DISCOUNT", "CODES"],
+          body.coupons.map((c) => [
+            c.id,
+            c.name,
+            c.discount?.percentOff !== void 0 ? `${c.discount.percentOff}%` : formatMoney(c.discount?.amountOff),
+            c.codes.map((code2) => code2.code).join(", ") || "-"
+          ])
+        );
+      });
+    }
+  },
+  {
+    path: ["checkout", "create"],
+    summary: "Create a checkout link for a product (test key: a test-mode order).",
+    options: {
+      product: { type: "string", value: "<id>", description: "Product id." },
+      variant: { type: "string", value: "<id>", description: "Variant id; replaces --product as the item." },
+      quantity: { type: "string", value: "<n>", description: "Units. Default 1." },
+      "success-url": { type: "string", value: "<url>", description: "Where the buyer goes after paying (https, or http://localhost for test keys)." },
+      "cancel-url": { type: "string", value: "<url>", description: "Where the buyer goes when they cancel." },
+      email: { type: "string", value: "<email>", description: "Prefill the buyer's email." },
+      reference: { type: "string", value: "<text>", description: "Your own reference, stored with the order (max 200)." }
+    },
+    output: "{ url, orderId, environment }",
+    examples: [
+      "bitsnap checkout create --product prodv2_abc --success-url http://localhost:3000/thanks --json"
+    ],
+    async run(ctx) {
+      noPositionals(ctx);
+      const product = str(ctx.values, "product");
+      const variant = str(ctx.values, "variant");
+      const productId = variant ?? product;
+      if (!productId) {
+        throw usageError("Give --product <id> (and optionally --variant <id>).");
+      }
+      const quantity = int(ctx.values, "quantity", { min: 1 }) ?? 1;
+      const request = {
+        items: [{ productId, quantity }]
+      };
+      const email = str(ctx.values, "email");
+      if (email) request.customerEmail = email;
+      const successUrl = str(ctx.values, "success-url");
+      if (successUrl) request.successUrl = successUrl;
+      const cancelUrl = str(ctx.values, "cancel-url");
+      if (cancelUrl) request.cancelUrl = cancelUrl;
+      const reference = str(ctx.values, "reference");
+      if (reference) request.clientReferenceId = reference;
+      const { body, replayed } = await ctx.client().rpc("CheckoutService", "CreateCheckoutLink", request, {
+        write: true,
+        idempotencyKey: idempotencyKey(ctx)
+      });
+      replayedNote(ctx, replayed);
+      if (!ctx.printer.json) {
+        ctx.printer.note(
+          `Order ${body.orderId || "(created after payment)"} in ${envLabel(body.environment)} mode.`
+        );
+      }
+      ctx.printer.result(body, () => body.url);
+    }
+  },
+  {
+    path: ["payments", "settle"],
+    summary: "Settle a test-mode order as paid (or failed). Test keys only.",
+    args: "<orderId>",
+    options: {
+      fail: { type: "boolean", description: "Settle the payment as failed instead of paid." }
+    },
+    output: "{ orderId, outcome }",
+    examples: ["bitsnap payments settle ord_123 --json", "bitsnap payments settle ord_123 --fail"],
+    async run(ctx) {
+      const orderId = onePositional(ctx, "orderId");
+      const client = ctx.client();
+      const key = client.requireKey();
+      if (keyEnvironment(key) === "live") {
+        throw new CliError({
+          kind: "usage",
+          message: "payments settle works only with a test key; the current key is a live key.",
+          hint: "Log in with a test key (bs_test_\u2026): `bitsnap login --key bs_test_\u2026`. Nothing was sent.",
+          reason: "test_mode_only"
+        });
+      }
+      const outcome = flag(ctx.values, "fail") ? "TEST_PAYMENT_OUTCOME_FAILED" : "TEST_PAYMENT_OUTCOME_PAID";
+      const { body, replayed } = await client.rpc(
+        "CheckoutService",
+        "SettleTestPayment",
+        { orderId, outcome },
+        { write: true, idempotencyKey: idempotencyKey(ctx) }
+      );
+      replayedNote(ctx, replayed);
+      ctx.printer.result(
+        body,
+        () => `Order ${body.orderId} settled as ${enumLabel(body.outcome, "TEST_PAYMENT_OUTCOME_")}.`
+      );
+    }
+  },
+  {
+    path: ["webhooks", "list"],
+    summary: "List webhook endpoints of the key's environment.",
+    options: {},
+    output: "{ webhooks: Webhook[] }",
+    examples: ["bitsnap webhooks list --json"],
+    async run(ctx) {
+      noPositionals(ctx);
+      const { body } = await ctx.client().rpc("WebhooksService", "ListWebhooks");
+      ctx.printer.result(body, () => {
+        if (body.webhooks.length === 0) return "No webhook endpoints.";
+        return table(
+          ["ID", "NAME", "URL", "EVENTS"],
+          body.webhooks.map((w) => [w.id, w.name || "-", w.url, w.events.join(",") || "ALL"])
+        );
+      });
+    }
+  },
+  {
+    path: ["webhooks", "create"],
+    summary: "Create a webhook endpoint. The signing secret is shown once.",
+    options: {
+      url: { type: "string", value: "<https url>", description: "Public https URL events are sent to.", required: true },
+      name: { type: "string", value: "<label>", description: "Optional label." },
+      event: { type: "string", multiple: true, value: "<EVENT>", description: "Event type, e.g. TRANSACTION_SUCCESS; repeat for more. Default: ALL." }
+    },
+    output: "{ webhook: Webhook, signingSecret }",
+    examples: ["bitsnap webhooks create --url https://example.com/api/webhooks --event TRANSACTION_SUCCESS --json"],
+    async run(ctx) {
+      noPositionals(ctx);
+      const request = {
+        url: str(ctx.values, "url")
+      };
+      const name = str(ctx.values, "name");
+      if (name) request.name = name;
+      const events = list(ctx.values, "event");
+      if (events.length > 0) request.events = events;
+      const { body, replayed } = await ctx.client().rpc("WebhooksService", "CreateWebhook", request, {
+        write: true,
+        idempotencyKey: idempotencyKey(ctx)
+      });
+      replayedNote(ctx, replayed);
+      ctx.printer.result(body, () => [
+        `Created ${body.webhook.id} -> ${body.webhook.url}`,
+        `Signing secret: ${body.signingSecret}`,
+        "Store it as BITSNAP_WEBHOOK_SECRET; it is not shown again."
+      ]);
+    }
+  },
+  {
+    path: ["webhooks", "delete"],
+    summary: "Delete a webhook endpoint.",
+    args: "<id>",
+    options: {},
+    output: "{}  (the API's empty answer)",
+    examples: ["bitsnap webhooks delete wh_k3j2h --json"],
+    async run(ctx) {
+      const id = onePositional(ctx, "id");
+      const { body, replayed } = await ctx.client().rpc("WebhooksService", "DeleteWebhook", { id }, {
+        write: true,
+        idempotencyKey: idempotencyKey(ctx)
+      });
+      replayedNote(ctx, replayed);
+      ctx.printer.result(body, () => `Deleted ${id}.`);
+    }
+  },
+  {
+    path: ["webhooks", "listen"],
+    summary: "Stream test-mode webhook events to this terminal and optionally to a local server.",
+    options: {
+      forward: {
+        type: "string",
+        value: "<url>",
+        description: "POST each event to this URL with X-Content-Signature and ?sig=, e.g. http://localhost:3000/api/webhooks."
+      },
+      poll: { type: "boolean", description: "Use long polling instead of the event stream." },
+      "max-events": { type: "string", value: "<n>", description: "Exit 0 after n events." },
+      timeout: {
+        type: "string",
+        value: "<seconds>",
+        description: "Stop after this many seconds (exit 1 if --max-events was not reached)."
+      }
+    },
+    output: "NDJSON, one object per line: { type: ready, secret, projectId?, host, mode } | { type: event, id, event, signature, payload (exact string), forward? } | { type: status, state }",
+    examples: [
+      "bitsnap webhooks listen --forward http://localhost:3000/api/webhooks",
+      "bitsnap webhooks listen --json --max-events 1 --timeout 120"
+    ],
+    async run(ctx) {
+      noPositionals(ctx);
+      const forward = str(ctx.values, "forward");
+      if (forward !== void 0) {
+        let url;
+        try {
+          url = new URL(forward);
+        } catch {
+        }
+        if (!url || url.protocol !== "http:" && url.protocol !== "https:") {
+          throw usageError(`--forward "${forward}" must be an http(s) URL.`, "Example: http://localhost:3000/api/webhooks");
+        }
+      }
+      await listenForWebhooks(ctx.rt, ctx.client(), ctx.printer, {
+        forward,
+        poll: flag(ctx.values, "poll"),
+        maxEvents: int(ctx.values, "max-events", { min: 1 }),
+        timeoutSeconds: int(ctx.values, "timeout", { min: 1 })
+      });
+    }
+  },
+  {
+    path: ["webhooks", "trigger"],
+    summary: "Send a sample event to your webhook endpoints and listeners (test keys only).",
+    args: "[event]",
+    options: {},
+    output: "{ eventId, event, deliveredTo }",
+    examples: ["bitsnap webhooks trigger TRANSACTION_SUCCESS --json"],
+    async run(ctx) {
+      if (ctx.positionals.length > 1) throw usageError(`Unexpected argument "${ctx.positionals[1]}".`);
+      const event = (ctx.positionals[0] ?? "TRANSACTION_SUCCESS").toUpperCase();
+      const { body, replayed } = await ctx.client().rest("/api/v1/webhooks/trigger", {
+        method: "POST",
+        body: { event },
+        write: true,
+        idempotencyKey: idempotencyKey(ctx)
+      });
+      replayedNote(ctx, replayed);
+      ctx.printer.result(
+        body,
+        () => `Triggered ${body.event} (${body.eventId}); delivered to ${body.deliveredTo} receiver(s).`
+      );
+    }
+  },
+  {
+    path: ["openapi"],
+    summary: "Download the OpenAPI document of the public API (no key needed).",
+    options: {
+      format: { type: "string", value: "<yaml|json>", description: "Default yaml; json with --json." },
+      out: { type: "string", value: "<file>", description: "Write to this file instead of stdout." }
+    },
+    output: "the JSON document; with --out: { ok, path, format, bytes }",
+    examples: ["bitsnap openapi --out openapi.yaml", "bitsnap openapi --format json --out openapi.json --json"],
+    async run(ctx) {
+      noPositionals(ctx);
+      const raw = str(ctx.values, "format") ?? (ctx.printer.json ? "json" : "yaml");
+      if (raw !== "yaml" && raw !== "json") throw usageError(`--format must be yaml or json, got "${raw}".`);
+      const auth = resolveAuth(ctx.rt, str(ctx.values, "host"));
+      const client = new ApiClient(ctx.rt, auth);
+      const text = await client.getText(
+        `/api/v1/openapi.${raw}`,
+        raw === "json" ? "application/json" : "application/yaml"
+      );
+      const out = str(ctx.values, "out");
+      if (out) {
+        const path = resolve(out);
+        writeFileSync2(path, text.endsWith("\n") ? text : text + "\n");
+        ctx.printer.result({ ok: true, path, format: raw, bytes: Buffer.byteLength(text) }, () => `Wrote ${path}`);
+        return;
+      }
+      ctx.rt.stdout.write(text.endsWith("\n") ? text : text + "\n");
+    }
+  },
+  {
+    path: ["stats"],
+    summary: "Sales summary for a time range (default: the last 30 days).",
+    options: {
+      from: { type: "string", value: "<date>", description: "Start, YYYY-MM-DD or RFC 3339 (inclusive)." },
+      to: { type: "string", value: "<date>", description: "End; a plain date means the end of that day." }
+    },
+    output: "{ from, to, orders, unitsSold, revenue: Money[], daily: [{ date, units, revenue }] }",
+    examples: ["bitsnap stats --from 2026-10-01 --to 2026-10-30 --json"],
+    async run(ctx) {
+      noPositionals(ctx);
+      const request = {};
+      const from = str(ctx.values, "from");
+      if (from) request.from = parseTime("from", from);
+      const to = str(ctx.values, "to");
+      if (to) request.to = parseTime("to", to, true);
+      const { body } = await ctx.client().rpc("StatsService", "GetSalesSummary", request);
+      ctx.printer.result(body, () => [
+        `${body.from ?? "?"} \u2192 ${body.to ?? "?"}`,
+        `Orders: ${body.orders}   Units: ${body.unitsSold}   Revenue: ${body.revenue.map((m) => formatMoney(m)).join(", ") || "-"}`,
+        ...body.daily.length > 0 ? table(
+          ["DATE", "UNITS", "REVENUE"],
+          body.daily.map((d) => [d.date, String(d.units), d.revenue.map((m) => formatMoney(m)).join(", ") || "-"])
+        ) : []
+      ]);
+    }
+  }
+];
+
+// src/main.ts
+var BOOLEAN_GLOBALS = /* @__PURE__ */ new Set(["--json", "--help", "-h", "--version", "-v"]);
+function findCommand(args) {
+  const words = [];
+  const rest = [];
+  let collecting = true;
+  for (const arg of args) {
+    if (collecting && !arg.startsWith("-") && words.length < 2) {
+      words.push(arg);
+      continue;
+    }
+    if (arg.startsWith("-") && !BOOLEAN_GLOBALS.has(arg)) collecting = false;
+    rest.push(arg);
+  }
+  for (let length = Math.min(words.length, 2); length >= 1; length--) {
+    const path = words.slice(0, length);
+    const command = COMMANDS.find((c) => c.path.length === length && c.path.every((w, i) => w === path[i]));
+    if (command) return { command, rest: [...words.slice(length), ...rest], words };
+  }
+  return { rest: [...words, ...rest], words };
+}
+function optionHelp(specs) {
+  const rows = Object.entries(specs).map(([name, spec]) => {
+    const short = spec.short ? `-${spec.short}, ` : "";
+    const value = spec.type === "string" ? ` ${spec.value ?? "<value>"}` : "";
+    return [`  ${short}--${name}${value}`, spec.description + (spec.required ? " (required)" : "")];
+  });
+  const width = Math.max(...rows.map(([left]) => (left ?? "").length));
+  return rows.map(([left, right]) => `${(left ?? "").padEnd(width)}  ${right}`);
+}
+function commandLine(command) {
+  return ["bitsnap", ...command.path, ...command.args ? [command.args] : []].join(" ");
+}
+function commandHelp(command) {
+  return [
+    `${commandLine(command)}`,
+    "",
+    command.summary,
+    "",
+    "Options:",
+    ...optionHelp({ ...command.options, ...GLOBAL_OPTIONS }),
+    "",
+    `--json output: ${command.output}`,
+    "",
+    "Examples:",
+    ...command.examples.map((example) => `  ${example}`)
+  ].join("\n");
+}
+function groupHelp(group) {
+  const commands = COMMANDS.filter((c) => c.path[0] === group);
+  return [
+    `bitsnap ${group} <command>`,
+    "",
+    ...commands.map((c) => `  ${commandLine(c).replace("bitsnap ", "").padEnd(34)}${c.summary}`),
+    "",
+    `Run \`bitsnap ${group} <command> --help\` for options.`
+  ].join("\n");
+}
+function rootHelp(version) {
+  return [
+    `bitsnap ${version} - command-line tool for the Bitsnap public API`,
+    "",
+    "Usage: bitsnap <command> [options]",
+    "",
+    "Commands:",
+    ...COMMANDS.map((c) => `  ${commandLine(c).replace("bitsnap ", "").padEnd(34)}${c.summary}`),
+    "",
+    "Global options:",
+    ...optionHelp(GLOBAL_OPTIONS),
+    "",
+    "Environment:",
+    "  BITSNAP_API_KEY   API key; wins over the stored one.",
+    "  BITSNAP_HOST      API host. Default https://bitsnap.pl.",
+    "  XDG_CONFIG_HOME   Config dir; the file is <dir>/bitsnap/config.json (mode 0600).",
+    "",
+    "Exit codes: 0 ok, 1 API or usage error, 2 auth error, 3 network error.",
+    'With --json, results go to stdout as JSON and errors to stderr as {"error":{\u2026}}.',
+    "The CLI never prompts. Docs: https://docs.bitsnap.pl"
+  ].join("\n");
+}
+function helpJson(version) {
+  return {
+    version,
+    globalOptions: Object.entries(GLOBAL_OPTIONS).map(([name, spec]) => ({ name, type: spec.type, description: spec.description })),
+    exitCodes: { ok: 0, error: 1, auth: 2, network: 3 },
+    commands: COMMANDS.map((c) => ({
+      command: commandLine(c).replace("bitsnap ", ""),
+      summary: c.summary,
+      options: Object.entries(c.options).map(([name, spec]) => ({
+        name,
+        type: spec.type,
+        multiple: spec.multiple === true,
+        required: spec.required === true,
+        description: spec.description
+      })),
+      output: c.output,
+      examples: c.examples
+    }))
+  };
+}
+function renderError(error, json) {
+  if (json) return JSON.stringify(error.toJSON()) + "\n";
+  const { message, detail, hint, reason, requestId } = error.details;
+  const lines = [`Error: ${message}${reason ? ` [${reason}]` : ""}`];
+  if (detail) lines.push(`  ${detail}`);
+  if (hint) lines.push(`Hint: ${hint}`);
+  if (requestId) lines.push(`Request id: ${requestId}`);
+  return lines.join("\n") + "\n";
+}
+async function main(argv, rt) {
+  const json = argv.includes("--json");
+  const printer = new Printer(rt, json);
+  try {
+    const { command, rest, words } = findCommand(argv);
+    if (!command) {
+      const wantsVersion = rest.includes("--version") || rest.includes("-v");
+      if (wantsVersion && words.length === 0) {
+        printer.result({ version: rt.version }, () => rt.version);
+        return EXIT.ok;
+      }
+      const wantsHelp = words.length === 0 || rest.includes("--help") || rest.includes("-h");
+      const group = words[0];
+      if (group && COMMANDS.some((c) => c.path[0] === group) && words.length === 1 && wantsHelp) {
+        printer.result(
+          { commands: helpJson(rt.version).commands.filter((c) => c.command.startsWith(group + " ")) },
+          () => groupHelp(group)
+        );
+        return EXIT.ok;
+      }
+      if (words.length === 0 && wantsHelp) {
+        printer.result(helpJson(rt.version), () => rootHelp(rt.version));
+        return EXIT.ok;
+      }
+      if (group && COMMANDS.some((c) => c.path[0] === group)) {
+        throw usageError(`Unknown command "${words.join(" ")}".`, `Run \`bitsnap ${group} --help\`.`);
+      }
+      throw usageError(`Unknown command "${words.join(" ")}".`, "Run `bitsnap --help` for the list.");
+    }
+    const { values, positionals } = parseOptions(rest, command.options, true);
+    if (values.help === true) {
+      printer.result(
+        {
+          command: commandLine(command).replace("bitsnap ", ""),
+          summary: command.summary,
+          options: helpJson(rt.version).commands.find((c) => c.command === commandLine(command).replace("bitsnap ", ""))?.options,
+          output: command.output,
+          examples: command.examples
+        },
+        () => commandHelp(command)
+      );
+      return EXIT.ok;
+    }
+    let client;
+    const ctx = {
+      rt,
+      printer,
+      values,
+      positionals,
+      client() {
+        const host = typeof values.host === "string" ? values.host : void 0;
+        client ??= new ApiClient(rt, resolveAuth(rt, host));
+        return client;
+      }
+    };
+    await command.run(ctx);
+    return EXIT.ok;
+  } catch (error) {
+    const cliError = error instanceof CliError ? error : new CliError({
+      kind: "api",
+      message: `Unexpected error: ${error instanceof Error ? error.message : String(error)}`
+    });
+    rt.stderr.write(renderError(cliError, json));
+    return cliError.exitCode;
+  }
+}
+
+// src/cli.ts
+for (const stream of [process.stdout, process.stderr]) {
+  stream.on("error", (error) => {
+    if (error.code === "EPIPE") process.exit(0);
+    throw error;
+  });
+}
+var controller = new AbortController();
+for (const signal of ["SIGINT", "SIGTERM"]) {
+  process.once(signal, () => controller.abort());
+}
+var runtime = {
+  env: process.env,
+  fetch: globalThis.fetch,
+  stdout: process.stdout,
+  stderr: process.stderr,
+  isTTY: process.stdout.isTTY === true,
+  randomUUID,
+  sleep: (ms, signal) => new Promise((resolve2) => {
+    const timer = setTimeout(resolve2, ms);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timer);
+        resolve2();
+      },
+      { once: true }
+    );
+  }),
+  signal: controller.signal,
+  version: true ? "0.1.0" : "0.0.0-dev"
+};
+var code = await main(process.argv.slice(2), runtime);
+process.exitCode = code;