@binaryandthread/cli 0.1.0

package/dist/chunk-DWTH7CNI.js

@@ -0,0 +1,1126 @@
+#!/usr/bin/env node
+import {
+  PLAIN,
+  colourMarker,
+  colourSwatch,
+  cyan,
+  dim,
+  header,
+  makeBrand
+} from "./chunk-P3LSUCEO.js";
+
+// ../store-client/dist/index.js
+var SENSITIVE_KEYS = /* @__PURE__ */ new Set([
+  "authorization",
+  "token",
+  "access_token",
+  "refresh_token",
+  "jwt",
+  "idempotency-key",
+  "x-publishable-api-key",
+  "password",
+  "secret",
+  "cookie",
+  "set-cookie"
+]);
+var MASK = "[REDACTED]";
+var BEARER_RE = /Bearer\s+[A-Za-z0-9._\-]+/gi;
+var EMAIL_RE = /([^\s@]+)@([^\s@]+\.[^\s@]+)/g;
+function maskEmail(email) {
+  const at = email.indexOf("@");
+  if (at <= 0) {
+    return email;
+  }
+  const local = email.slice(0, at);
+  const host = email.slice(at + 1);
+  const localMasked = local[0] + "*".repeat(Math.max(2, local.length - 1));
+  const hostMasked = host.length > 0 ? host[0] : "x";
+  return `${localMasked}@${hostMasked}`;
+}
+function redactString(s) {
+  return s.replace(BEARER_RE, "Bearer [REDACTED]").replace(
+    EMAIL_RE,
+    (_m, _l, _h) => maskEmail(`${_l}@${_h}`)
+  );
+}
+function redact(input, _seen) {
+  if (input == null) {
+    return input;
+  }
+  if (typeof input === "string") {
+    return redactString(input);
+  }
+  if (typeof input !== "object") {
+    return input;
+  }
+  const seen = _seen ?? /* @__PURE__ */ new WeakSet();
+  if (seen.has(input)) {
+    return input;
+  }
+  seen.add(input);
+  if (Array.isArray(input)) {
+    return input.map((v) => redact(v, seen));
+  }
+  const out = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (SENSITIVE_KEYS.has(key.toLowerCase())) {
+      out[key] = MASK;
+    } else if (key.toLowerCase() === "email" && typeof value === "string") {
+      out[key] = maskEmail(value);
+    } else {
+      out[key] = redact(value, seen);
+    }
+  }
+  return out;
+}
+var DEFAULT_RETRY = {
+  attempts: 3,
+  baseDelayMs: 200,
+  maxDelayMs: 2e3
+};
+var RETRY_AFTER_MAX_MS = 1e4;
+function parseRetryAfterMs(res) {
+  let raw = null;
+  try {
+    raw = res.headers?.get?.("retry-after") ?? null;
+  } catch {
+    return null;
+  }
+  if (!raw) {
+    return null;
+  }
+  const secs = Number(raw);
+  let ms;
+  if (Number.isFinite(secs)) {
+    ms = secs * 1e3;
+  } else {
+    const dateMs = Date.parse(raw);
+    if (!Number.isFinite(dateMs)) {
+      return null;
+    }
+    ms = dateMs - Date.now();
+  }
+  return Math.min(Math.max(0, ms), RETRY_AFTER_MAX_MS);
+}
+var RecoverableCartError = class extends Error {
+  recoverable = true;
+  status;
+  constructor(message, status) {
+    super(message);
+    this.name = "RecoverableCartError";
+    this.status = status;
+  }
+};
+var StoreApiError = class extends Error {
+  status;
+  path;
+  constructor(message, status, path) {
+    super(message);
+    this.name = "StoreApiError";
+    this.status = status;
+    this.path = path;
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function newUuid() {
+  const g = globalThis;
+  if (g.crypto?.randomUUID) {
+    return g.crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+var StoreClient = class {
+  baseUrl;
+  publishableKey;
+  jwt;
+  fetchImpl;
+  logger;
+  retry;
+  sleepImpl;
+  /** Cached resolved regions (read-only catalog optimisation). */
+  regionsCache = null;
+  constructor(opts) {
+    if (!opts.baseUrl) {
+      throw new Error("StoreClient: baseUrl is required");
+    }
+    if (!opts.publishableKey) {
+      throw new Error("StoreClient: publishableKey is required");
+    }
+    if (/^sk_/.test(opts.publishableKey)) {
+      throw new Error("StoreClient: refusing a secret key \u2014 the client carries only the publishable key (T6)");
+    }
+    this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
+    this.publishableKey = opts.publishableKey;
+    this.jwt = opts.jwt;
+    this.fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+    this.logger = opts.logger ?? console;
+    this.retry = { ...DEFAULT_RETRY, ...opts.retry ?? {} };
+    this.sleepImpl = opts.sleepImpl ?? sleep;
+  }
+  // ----- the request engine --------------------------------------------------
+  buildUrl(path, query) {
+    const url = new URL(this.baseUrl + path);
+    if (query) {
+      for (const [k, v] of Object.entries(query)) {
+        if (v !== void 0 && v !== null && v !== "") {
+          url.searchParams.set(k, String(v));
+        }
+      }
+    }
+    return url.toString();
+  }
+  baseHeaders() {
+    const headers = {
+      "Content-Type": "application/json",
+      "x-publishable-api-key": this.publishableKey
+    };
+    if (this.jwt) {
+      headers["Authorization"] = `Bearer ${this.jwt}`;
+    }
+    return headers;
+  }
+  backoffMs(attemptIndex) {
+    const exp = this.retry.baseDelayMs * 2 ** attemptIndex;
+    const capped = Math.min(exp, this.retry.maxDelayMs);
+    return Math.floor(Math.random() * (capped + 1));
+  }
+  async request(method, path, opts = {}) {
+    const headers = this.baseHeaders();
+    if (opts.idempotent) {
+      headers["Idempotency-Key"] = newUuid();
+    }
+    const url = this.buildUrl(path, opts.query);
+    const init = {
+      method,
+      headers,
+      ...opts.body !== void 0 ? { body: JSON.stringify(opts.body) } : {}
+    };
+    let lastErr;
+    for (let attempt = 0; attempt < this.retry.attempts; attempt++) {
+      let retryAfterMs = null;
+      try {
+        const res = await this.fetchImpl(url, init);
+        if (res.ok) {
+          const text = await res.text();
+          return text ? JSON.parse(text) : {};
+        }
+        let parsed = {};
+        try {
+          const t = await res.text();
+          parsed = t ? JSON.parse(t) : {};
+        } catch {
+          parsed = {};
+        }
+        if (opts.cartRecovery && (res.status === 404 || res.status === 409 || String(parsed.type ?? "").includes("cart.completed") || /cart.*complete/i.test(String(parsed.message ?? "")))) {
+          throw new RecoverableCartError(
+            `cart is stale or completed (HTTP ${res.status})`,
+            res.status
+          );
+        }
+        if (res.status === 429) {
+          retryAfterMs = parseRetryAfterMs(res);
+          lastErr = new StoreApiError(`rate limited (HTTP 429)`, 429, path);
+          this.logWarn("store.request.rate_limited", {
+            path,
+            attempt: attempt + 1,
+            retryAfterMs
+          });
+        } else if (res.status >= 400 && res.status < 500) {
+          if (!(opts.expected4xx ?? []).includes(res.status)) {
+            this.logError("store.request.client_error", { path, status: res.status, body: parsed });
+          }
+          throw new StoreApiError(
+            `request failed (HTTP ${res.status})`,
+            res.status,
+            path
+          );
+        } else {
+          lastErr = new StoreApiError(`upstream error (HTTP ${res.status})`, res.status, path);
+          this.logWarn("store.request.retryable", { path, status: res.status, attempt: attempt + 1 });
+        }
+      } catch (e) {
+        if (e instanceof RecoverableCartError) {
+          throw e;
+        }
+        if (e instanceof StoreApiError && e.status >= 400 && e.status < 500) {
+          throw e;
+        }
+        lastErr = e;
+        this.logWarn("store.request.network_retry", { path, attempt: attempt + 1 });
+      }
+      if (attempt < this.retry.attempts - 1) {
+        await this.sleepImpl(retryAfterMs ?? this.backoffMs(attempt));
+      }
+    }
+    this.logError("store.request.exhausted", { path, attempts: this.retry.attempts });
+    if (lastErr instanceof StoreApiError) {
+      throw lastErr;
+    }
+    throw new StoreApiError(
+      `request failed after ${this.retry.attempts} attempts: ${path}`,
+      0,
+      path
+    );
+  }
+  logWarn(event, ctx) {
+    this.logger.warn(event, redact(ctx));
+  }
+  logError(event, ctx) {
+    this.logger.error(event, redact(ctx));
+  }
+  // ----- regions (F-A2 / INV-11) ---------------------------------------------
+  async getRegions() {
+    const data = await this.request("GET", "/store/regions");
+    this.regionsCache = data.regions ?? [];
+    return this.regionsCache;
+  }
+  /**
+   * Resolve a region by country code, falling back to region #1.
+   * SEK is region #1 by configuration — NEVER a hardcoded literal.
+   */
+  async resolveRegion(countryCode) {
+    const regions = this.regionsCache ?? await this.getRegions();
+    if (regions.length === 0) {
+      throw new Error("no regions configured \u2014 cannot resolve a region for pricing");
+    }
+    if (countryCode) {
+      const cc = countryCode.toLowerCase();
+      const match = regions.find(
+        (r) => (r.countries ?? []).some((c) => (c.iso_2 ?? "").toLowerCase() === cc)
+      );
+      if (match) {
+        return match;
+      }
+    }
+    return regions[0];
+  }
+  // ----- products (region resolved BEFORE pricing) ---------------------------
+  async listProducts(opts) {
+    const region = opts?.region ?? await this.resolveRegion(opts?.countryCode);
+    const data = await this.request("GET", "/store/products", {
+      query: { region_id: region.id, limit: 100 }
+    });
+    return data.products ?? [];
+  }
+  async getProduct(handle, opts) {
+    const region = opts?.region ?? await this.resolveRegion(opts?.countryCode);
+    const data = await this.request("GET", "/store/products", {
+      query: { handle, region_id: region.id, limit: 1 }
+    });
+    return (data.products ?? [])[0] ?? null;
+  }
+  // ----- cart (mutations carry Idempotency-Key) ------------------------------
+  async createCart(region) {
+    const data = await this.request("POST", "/store/carts", {
+      idempotent: true,
+      body: { region_id: region.id }
+    });
+    return data.cart;
+  }
+  async addLineItem(cartId, variantId, quantity) {
+    const data = await this.request(
+      "POST",
+      `/store/carts/${encodeURIComponent(cartId)}/line-items`,
+      {
+        idempotent: true,
+        cartRecovery: true,
+        body: { variant_id: variantId, quantity }
+      }
+    );
+    return data.cart;
+  }
+  async getCart(cartId) {
+    const data = await this.request(
+      "GET",
+      `/store/carts/${encodeURIComponent(cartId)}`,
+      { cartRecovery: true }
+    );
+    return data.cart;
+  }
+  /** Remove a staged line item (bt unstage). Returns the updated cart (Medusa's `parent`). */
+  async removeLineItem(cartId, itemId) {
+    const data = await this.request(
+      "DELETE",
+      `/store/carts/${encodeURIComponent(cartId)}/line-items/${encodeURIComponent(itemId)}`,
+      { idempotent: true, cartRecovery: true }
+    );
+    return data.parent ?? data.cart;
+  }
+  /**
+   * Ensure the cart has a shipping method before checkout (BUG 1 — the headless
+   * /store/headless/checkout route guards on it, and neither client ever set one).
+   *
+   * - Idempotent: if the cart already carries a shipping method, no-op (no POST).
+   * - Lists options via the STANDARD store route GET /store/shipping-options?cart_id=…
+   *   (NOT a /headless route — standard routes are always available, no kill-switch).
+   * - Picks deterministically: exactly one → use it; several → the cheapest by amount.
+   * - The SE launch option is region-scoped (price_type:"flat"), so listing by cart_id
+   *   returns it without a shipping address being set first (confirmed: seed-shipping.ts).
+   *
+   * TODO(04.5): buyer-choice / intl multiple shipping options — today we auto-pick the
+   * cheapest; an explicit buyer chooser belongs to the Phase-6 international pass.
+   */
+  async ensureCartShippingMethod(cartId) {
+    const cart = await this.getCart(cartId);
+    if (cart.shipping_methods && cart.shipping_methods.length > 0) {
+      return cart;
+    }
+    const data = await this.request(
+      "GET",
+      "/store/shipping-options",
+      { query: { cart_id: cartId } }
+    );
+    const options = data.shipping_options ?? [];
+    if (options.length === 0) {
+      throw new Error(
+        "no shipping option is available for this cart \u2014 cannot attach a shipping method"
+      );
+    }
+    const chosen = options.length === 1 ? options[0] : [...options].sort(
+      (a, b) => (a.amount ?? Number.POSITIVE_INFINITY) - (b.amount ?? Number.POSITIVE_INFINITY)
+    )[0];
+    const res = await this.request(
+      "POST",
+      `/store/carts/${encodeURIComponent(cartId)}/shipping-methods`,
+      {
+        idempotent: true,
+        cartRecovery: true,
+        body: { option_id: chosen.id }
+      }
+    );
+    return res.cart;
+  }
+  // ----- headless contract (04.5-01) -----------------------------------------
+  async mintCheckout(cartId, email, channel = "cli") {
+    return this.request("POST", "/store/headless/checkout", {
+      idempotent: true,
+      body: { cart_id: cartId, email, channel }
+    });
+  }
+  async poll(sessionId) {
+    return this.request(
+      "GET",
+      `/store/headless/poll/${encodeURIComponent(sessionId)}`
+    );
+  }
+  /** JWT-bound: returns the authenticated customer's own profile (G2). */
+  async whoami() {
+    return this.request("GET", "/store/headless/whoami", { expected4xx: [401, 403] });
+  }
+  // ----- magic-link auth (04.5-05) -------------------------------------------
+  // Passwordless login — magic-link is the only grant (Medusa has no OAuth pairing-grant, G1).
+  // request-link emails a single-use link; verify exchanges the link's token for a customer-scoped
+  // JWT. The JWT is stored in the OS keychain by the CLI — never here, never in plaintext config (G7/G8).
+  /** Start a magic-link login. Returns a UNIFORM ack regardless of whether the email exists (G12). */
+  async requestMagicLink(email) {
+    return this.request("POST", "/store/headless/auth/request-link", {
+      idempotent: true,
+      body: { email }
+    });
+  }
+  /** Exchange a magic-link token for a customer-scoped JWT (the customer is materialized server-side). */
+  async verifyMagicLink(token) {
+    return this.request("POST", "/store/headless/auth/verify", {
+      idempotent: true,
+      body: { token }
+    });
+  }
+  async listDrops() {
+    const data = await this.request(
+      "GET",
+      "/store/headless/drops"
+    );
+    return data.drops ?? [];
+  }
+  /**
+   * File a developer bug report (d14 — `bt report` / MCP report_issue). Returns a correlation
+   * reference. Additive: no money/cart path. The backend redacts authoritatively; callers SHOULD
+   * pass an already-redacted context (the doctor snapshot). A mutation → carries an Idempotency-Key
+   * so a retry can't email the report twice.
+   */
+  async report(message, context) {
+    return this.request("POST", "/store/headless/report", {
+      idempotent: true,
+      body: { message, ...context !== void 0 ? { context } : {} }
+    });
+  }
+  /**
+   * The authenticated customer's order history (d13 — `bt log`). JWT-bound; the backend derives the
+   * customer from the bearer token and returns MINIMAL fields (status/timeline only — never
+   * email/address, F-H3). A guest (no/expired JWT) gets a 401 — the EXPECTED unauthenticated branch
+   * we turn into the honest empty history (`[]`), NOT an error to dump (BUG 3).
+   */
+  async listOrders() {
+    try {
+      const data = await this.request("GET", "/store/headless/orders", {
+        expected4xx: [401, 403]
+      });
+      return data.orders ?? [];
+    } catch (e) {
+      if (e instanceof StoreApiError && (e.status === 401 || e.status === 403)) {
+        return [];
+      }
+      throw e;
+    }
+  }
+  /**
+   * Guest order lookup — requires order display id + EXACT email (F-H1).
+   * The backend returns 404 on a mismatch (no enumeration); the client surfaces null.
+   */
+  async getOrder(displayId, email) {
+    try {
+      return await this.request("GET", "/store/orders", {
+        query: { display_id: String(displayId), email }
+      });
+    } catch (e) {
+      if (e instanceof StoreApiError && e.status === 404) {
+        return null;
+      }
+      throw e;
+    }
+  }
+};
+var BT_DEFAULT_STORE_URL = "https://backend-production-511f5.up.railway.app";
+var BT_DEFAULT_PUBLISHABLE_KEY = "pk_0d7d706860568a0414dff0436aadb9713a2609de3a1b153ef2a6f9694d23f907";
+var BLOB_HOST_ALLOWLIST = [
+  "blob.vercel-storage.com"
+  // matches the exact host + *.blob.vercel-storage.com (dot-delimited subdomains only)
+];
+function isAllowedImageHost(url) {
+  let host;
+  try {
+    host = new URL(url).hostname.toLowerCase();
+  } catch {
+    return false;
+  }
+  return BLOB_HOST_ALLOWLIST.some(
+    (allowed) => host === allowed || host.endsWith("." + allowed)
+  );
+}
+function displayColour(colour) {
+  const c = colour.trim();
+  if (!c) return c;
+  return c.charAt(0).toUpperCase() + c.slice(1).toLowerCase();
+}
+function variantColour(v) {
+  const opt = (v.options ?? []).find(
+    (o) => (o.option?.title ?? "").toLowerCase() === "colour" || (o.option?.title ?? "").toLowerCase() === "color"
+  );
+  if (opt && typeof opt.value === "string" && opt.value.trim()) {
+    return opt.value.trim().toLowerCase();
+  }
+  const title = (v.title ?? "").trim();
+  if (title.includes("/")) {
+    const parts = title.split("/").map((p) => p.trim());
+    const tail = parts[parts.length - 1];
+    if (tail) return tail.toLowerCase();
+  }
+  return null;
+}
+function productColours(p) {
+  const seen = [];
+  for (const v of p.variants ?? []) {
+    const c = variantColour(v);
+    if (c && !seen.includes(c)) {
+      seen.push(c);
+    }
+  }
+  return seen;
+}
+function sizesForColour(p, colour) {
+  const target = colour.trim().toLowerCase();
+  const sizes = [];
+  for (const v of p.variants ?? []) {
+    if (variantColour(v) !== target) continue;
+    const size = sizeOfVariant(v);
+    if (size && !sizes.includes(size)) {
+      sizes.push(size);
+    }
+  }
+  return sizes;
+}
+function sizeOfVariant(v) {
+  const opt = (v.options ?? []).find((o) => (o.option?.title ?? "").toLowerCase() === "size");
+  if (opt && typeof opt.value === "string" && opt.value.trim()) {
+    return opt.value.trim();
+  }
+  const title = (v.title ?? "").trim();
+  if (title.includes("/")) {
+    const head = title.split("/")[0]?.trim();
+    if (head) return head;
+  }
+  return title || null;
+}
+function findVariant(p, opts = {}) {
+  const variants = p.variants ?? [];
+  const size = opts.size?.trim().toLowerCase();
+  const colour = opts.colour?.trim().toLowerCase();
+  const sizeMatches = (v) => {
+    if (!size) return true;
+    return (sizeOfVariant(v) ?? "").toLowerCase() === size || (v.title ?? "").toLowerCase() === size;
+  };
+  const colourMatches = (v) => {
+    if (!colour) return true;
+    return variantColour(v) === colour;
+  };
+  if (size && colour) {
+    return variants.find((v) => sizeMatches(v) && colourMatches(v));
+  }
+  if (colour && !size) {
+    return variants.find((v) => colourMatches(v));
+  }
+  if (size && !colour) {
+    return variants.find((v) => sizeMatches(v)) ?? variants[0];
+  }
+  return variants[0];
+}
+function imageForColour(p, colour) {
+  const target = colour.trim().toLowerCase();
+  if (!target) return p.thumbnail ?? firstImageUrl(p.images) ?? null;
+  for (const v of p.variants ?? []) {
+    if (variantColour(v) !== target) continue;
+    const url = firstImageUrl(v.images);
+    if (url) return url;
+  }
+  for (const img of p.images ?? []) {
+    const tag = (img.metadata?.["colour"] ?? img.metadata?.["color"] ?? "").toString().toLowerCase();
+    if (tag === target) {
+      const u = (img.url ?? "").trim();
+      if (u) return u;
+    }
+  }
+  for (const img of p.images ?? []) {
+    const u = (img.url ?? "").trim();
+    if (u && new RegExp(`(^|[^a-z])${escapeRegex(target)}([^a-z]|$)`, "i").test(u)) {
+      return u;
+    }
+  }
+  return null;
+}
+function firstImageUrl(images) {
+  for (const img of images ?? []) {
+    const u = (img?.url ?? "").trim();
+    if (u) return u;
+  }
+  return null;
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/voice.ts
+var GLYPH = {
+  ok: "\u2713",
+  fail: "\u2717",
+  warn: "\u26A0",
+  gear: "\u2699",
+  arrow: "\u2192"
+};
+function noShout(s) {
+  return s.replace(/!+/g, ".");
+}
+function ok(msg) {
+  return `${GLYPH.ok}  ${noShout(msg)}`;
+}
+function warn(msg) {
+  return `${GLYPH.warn}  ${noShout(msg)}`;
+}
+function working(msg) {
+  return `${GLYPH.gear}  ${noShout(msg)}`;
+}
+function empty(msg) {
+  return noShout(msg);
+}
+function fail(spec) {
+  const lines = [];
+  lines.push(`${GLYPH.fail}  exit ${spec.code} \u2014 ${noShout(spec.what)}`);
+  if (spec.money) {
+    lines.push(`   ${noShout(spec.money)}`);
+  }
+  if (spec.fix) {
+    lines.push(`   fix ${GLYPH.arrow} ${noShout(spec.fix)}`);
+  }
+  if (spec.link) {
+    lines.push(`   link ${GLYPH.arrow} ${spec.link}`);
+  }
+  return lines.join("\n");
+}
+var CODENAMES = [
+  "tabs-over-spaces",
+  "vim-not-emacs",
+  "2-space-indent",
+  "trailing-comma"
+];
+function codename(_version) {
+  return CODENAMES[0];
+}
+function versionLine(version) {
+  return `bt ${version} "${codename(version)}"`;
+}
+
+// src/commands/shared.ts
+function brandOf(args) {
+  return args?.brand ?? PLAIN;
+}
+function fmtPrice(amount, currency) {
+  if (amount == null) {
+    return "\u2014";
+  }
+  const cur = (currency ?? "").toUpperCase();
+  return cur ? `${amount} ${cur}` : `${amount}`;
+}
+function firstPrice(p) {
+  const v = (p.variants ?? [])[0];
+  return {
+    amount: v?.calculated_price?.calculated_amount ?? null,
+    currency: v?.calculated_price?.currency_code ?? null
+  };
+}
+function stageMarker(channelStage) {
+  return channelStage === "next" ? "\u25CB on next" : "\u25CF in stock";
+}
+function displayName(p) {
+  const handle = (p.handle ?? p.id ?? "").toString();
+  const title = (p.title ?? "").toString().trim() || handle;
+  return { title, handle };
+}
+function lineColour(item) {
+  const vt = (item.variant_title ?? "").toString();
+  if (vt) {
+    const c = variantColour({ id: "x", title: vt });
+    if (c) return c;
+  }
+  return null;
+}
+function shortItemId(id) {
+  const s = (id ?? "").toString();
+  return s.length <= 6 ? s : s.slice(-6);
+}
+function formatCartLine(item, index, currency, brand) {
+  const style = brand ?? PLAIN;
+  const ref = `[${index + 1}]`;
+  const title = (item.title ?? item.product_title ?? "item").toString();
+  const idTag = item.id ? dimTag(style, ` (#${shortItemId(item.id)})`) : "";
+  const colour = lineColour(item);
+  const colourTag = colour ? ` \xB7 ${colour}` : "";
+  const price = item.total != null ? `   ${accentPrice(style, fmtPrice(item.total, currency))}` : "";
+  return `   ${ref} ${title}${colourTag}${idTag} \xB7 qty ${item.quantity}${price}`;
+}
+function dimTag(style, s) {
+  return style.color ? `\x1B[2m${s}\x1B[0m` : s;
+}
+function accentPrice(style, s) {
+  return style.color ? `\x1B[38;5;48m${s}\x1B[0m` : s;
+}
+function resolveLineItemRef(items, ref) {
+  const needle = (ref ?? "").trim();
+  if (!needle || items.length === 0) {
+    return null;
+  }
+  if (/^\d+$/.test(needle)) {
+    const idx = Number(needle) - 1;
+    if (idx >= 0 && idx < items.length) {
+      return items[idx];
+    }
+  }
+  const byId = items.find((li) => li.id === needle || shortItemId(li.id) === needle);
+  if (byId) {
+    return byId;
+  }
+  const lower = needle.toLowerCase();
+  const byTitle = items.find(
+    (li) => (li.title ?? li.product_title ?? "").toString().toLowerCase().includes(lower)
+  );
+  return byTitle ?? null;
+}
+
+// src/image-ladder.ts
+var DEFAULT_RENDER_HEIGHT = 28;
+function urlFloor(url) {
+  return `   ${url}`;
+}
+async function renderImage(blobUrl, opts = {}) {
+  const noColor = opts.noColor ?? Boolean(process.env.NO_COLOR);
+  if (!isAllowedImageHost(blobUrl)) {
+    return `   (image host not allowed \u2014 showing link only)
+${urlFloor(blobUrl)}`;
+  }
+  if (noColor || opts.forceNoRenderer) {
+    return urlFloor(blobUrl);
+  }
+  try {
+    const rendered = opts.renderer ? await opts.renderer(blobUrl) : await defaultRender(blobUrl, opts);
+    return `${rendered}
+${urlFloor(blobUrl)}`;
+  } catch {
+    return `   (image unavailable)
+${urlFloor(blobUrl)}`;
+  }
+}
+var IMAGE_FETCH_TIMEOUT_MS = 5e3;
+async function defaultRender(url, opts) {
+  const mod = await import("terminal-image");
+  const terminalImage = mod.default ?? mod;
+  const bufferFn = terminalImage.buffer;
+  if (!bufferFn) {
+    throw new Error("terminal-image.buffer unavailable");
+  }
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), IMAGE_FETCH_TIMEOUT_MS);
+  let res;
+  try {
+    res = await fetch(url, { signal: ctrl.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+  if (!res.ok) {
+    throw new Error(`blob fetch failed: HTTP ${res.status}`);
+  }
+  const buf = Buffer.from(await res.arrayBuffer());
+  return bufferFn(buf, {
+    height: opts.height ?? DEFAULT_RENDER_HEIGHT,
+    preserveAspectRatio: true,
+    preferNativeRender: true
+  });
+}
+
+// src/commands/browse.ts
+function productRow(p, stage, style) {
+  const { amount, currency } = firstPrice(p);
+  const { title, handle } = displayName(p);
+  const colours = colourMarker(productColours(p));
+  const parts = [
+    title.padEnd(22),
+    cyan(style, fmtPrice(amount, currency).padEnd(11)),
+    dim(style, handle.padEnd(34)),
+    stageMarker(stage)
+  ];
+  const row = parts.join(" ").trimEnd();
+  return colours ? `${row}
+   ${dim(style, colours)}` : row;
+}
+async function runBrowse(client, config, args) {
+  const style = brandOf(args);
+  const region = await client.resolveRegion(config.region);
+  const products = await client.listProducts({ region });
+  const rows = products.map((p) => ({
+    p,
+    stage: p.metadata?.["channel_stage"] ?? "main"
+  }));
+  let drops = [];
+  if (args.branch === "next") {
+    drops = await client.listDrops();
+  }
+  const lines = [];
+  if (rows.length === 0 && drops.length === 0) {
+    lines.push(empty("nothing in stock on this branch yet. main is the latest."));
+    lines.push("   peek at next \u2192 bt browse --branch=next");
+  } else {
+    lines.push(header(style, "bt browse \u2014 in stock"));
+    for (const { p, stage } of rows) {
+      lines.push(productRow(p, stage, style));
+    }
+    for (const d of drops) {
+      const dt = (d.title ?? d.handle ?? d.id).toString();
+      lines.push(
+        [
+          dt.padEnd(22),
+          cyan(style, fmtPrice(d.price, region.currency_code).padEnd(11)),
+          dim(style, (d.handle ?? d.id).padEnd(34)),
+          stageMarker(d.channel_stage)
+        ].join(" ").trimEnd()
+      );
+    }
+    if (drops.length > 0) {
+      lines.push("   on next, before the web \u2192 bt drops");
+    }
+    lines.push("   view one \u2192 bt view <handle>   \xB7   stage one \u2192 bt stage <handle> --size L");
+  }
+  return {
+    lines,
+    json: args.json ? products.map((p) => ({
+      id: p.id,
+      handle: p.handle,
+      title: p.title,
+      price: firstPrice(p).amount,
+      currency: firstPrice(p).currency,
+      colours: productColours(p),
+      channel_stage: p.metadata?.["channel_stage"] ?? "main"
+    })) : void 0
+  };
+}
+function registerBrowse(program, makeClient, loadConfig) {
+  program.command("browse").alias("ls").description("list what's in stock on a branch.").option("--branch <branch>", "main (live) or next (terminal-only drops)").option("--plain", "force the static table (skip the interactive picker)").action(async (opts) => {
+    const gOpts = program.opts();
+    const json = Boolean(gOpts.json);
+    const noColor = gOpts.color === false;
+    const brand = json ? makeBrand({ noColor: true }) : makeBrand({ noColor });
+    if (!json && !opts.plain && brand.color && process.stdout.isTTY) {
+      const { runInteractiveBrowse } = await import("./interactive-TFZOY3JU.js");
+      const handled = await runInteractiveBrowse(makeClient(), loadConfig(), { branch: opts.branch, brand });
+      if (handled) return;
+    }
+    const res = await runBrowse(makeClient(), loadConfig(), { branch: opts.branch, json, brand });
+    printResult(res, json);
+  });
+}
+function printResult(res, json) {
+  if (json && res.json !== void 0) {
+    process.stdout.write(JSON.stringify(res.json, null, 2) + "\n");
+    return;
+  }
+  process.stdout.write(res.lines.join("\n") + "\n");
+}
+
+// src/commands/view.ts
+async function runView(client, config, args) {
+  const style = brandOf(args);
+  const region = await client.resolveRegion(config.region);
+  const product = await client.getProduct(args.handle, { region });
+  if (!product) {
+    return {
+      lines: [
+        fail({
+          code: 1,
+          what: `variant ${args.handle} not found.`,
+          fix: "bt browse   (to see what's in stock)"
+        })
+      ]
+    };
+  }
+  const { title, handle } = displayName(product);
+  const colours = productColours(product);
+  const lines = [];
+  lines.push(header(style, title));
+  lines.push(`   ${dim(style, handle)}`);
+  if (product.description) {
+    lines.push(empty(`   ${product.description}`));
+  }
+  const fabric = product.metadata?.["fabric"] ?? null;
+  if (fabric) {
+    lines.push(`   fabric   ${fabric}`);
+  }
+  if (colours.length > 0) {
+    lines.push(`   colours  ${colours.map((c) => `${colourSwatch(c)} ${c}`).join(" \xB7 ")}`);
+    for (const c of colours) {
+      const sizes = sizesForColour(product, c);
+      lines.push(`   ${colourSwatch(c)} ${c.padEnd(6)} ${sizes.join("  ")}`);
+    }
+  } else {
+    const sizes = (product.variants ?? []).map((v) => v.title ?? "?");
+    lines.push(`   sizes    ${sizes.join("  ")}`);
+  }
+  const v0 = (product.variants ?? [])[0];
+  if (v0?.calculated_price) {
+    lines.push(
+      `   price    ${cyan(style, fmtPrice(v0.calculated_price.calculated_amount, v0.calculated_price.currency_code))} incl. VAT`
+    );
+  }
+  let imageUrl = product.thumbnail ?? null;
+  let blackNote = null;
+  if (args.colour) {
+    const wanted = args.colour.trim().toLowerCase();
+    const resolved = imageForColour(product, wanted);
+    if (resolved) {
+      imageUrl = resolved;
+    } else {
+      blackNote = `   ${displayColour(wanted)} available \u2014 showing the default mockup (no ${wanted} render on file).`;
+    }
+  }
+  if (imageUrl) {
+    const rendered = await renderImage(imageUrl, { noColor: args.noColor });
+    lines.push(rendered);
+  }
+  if (blackNote) {
+    lines.push(blackNote);
+  }
+  if (colours.length > 1 && !args.colour) {
+    const others = colours.filter((c) => c !== colours[0]).join(", ");
+    lines.push(`   see another colour \u2192 bt view ${handle} --colour ${others.split(",")[0]?.trim()}`);
+  }
+  return {
+    lines,
+    json: args.json ? {
+      id: product.id,
+      handle: product.handle,
+      title: product.title,
+      fabric,
+      colours,
+      thumbnail: product.thumbnail,
+      variants: (product.variants ?? []).map((v) => ({
+        id: v.id,
+        size: v.title,
+        price: v.calculated_price?.calculated_amount ?? null,
+        currency: v.calculated_price?.currency_code ?? null
+      }))
+    } : void 0
+  };
+}
+function registerView(program, makeClient, loadConfig) {
+  program.command("view").alias("show").argument("<handle>", "the product handle/slug").option("--colour <colour>", "render a specific colour's mockup (e.g. black)").description("render a design: specs + image (always with the link as the floor).").action(async (handle, opts) => {
+    const gOpts = program.opts();
+    const json = Boolean(gOpts.json);
+    const noColor = gOpts.color === false;
+    const brand = json ? makeBrand({ noColor: true }) : makeBrand({ noColor });
+    const res = await runView(makeClient(), loadConfig(), {
+      handle,
+      colour: opts.colour,
+      json,
+      noColor,
+      brand
+    });
+    printResult(res, json);
+  });
+}
+
+// src/commands/stage.ts
+async function runStage(client, config, args) {
+  const style = brandOf(args);
+  const region = await client.resolveRegion(config.region);
+  const product = await client.getProduct(args.handle, { region });
+  if (!product) {
+    return {
+      lines: [
+        fail({ code: 1, what: `variant ${args.handle} not found.`, fix: "bt browse" })
+      ]
+    };
+  }
+  const size = args.size ?? config.defaultSize;
+  const colours = productColours(product);
+  const colour = args.colour ?? config.defaultColour ?? (colours.length > 0 ? colours[0] : void 0);
+  const variant = findVariant(product, { size, colour });
+  if (!variant) {
+    const have = colours.length ? `  available colours: ${colours.join(", ")}.` : "";
+    return {
+      lines: [
+        fail({
+          code: 1,
+          what: `no variant for ${args.handle}${size ? `#size=${size}` : ""}${colour ? ` (${colour})` : ""}.`,
+          fix: `bt view ${args.handle}   (to see available sizes + colours)${have}`
+        })
+      ]
+    };
+  }
+  if (args.dryRun) {
+    const colourSuffix2 = colour ? ` (${colour})` : "";
+    return {
+      lines: [
+        ok(`dry-run \u2014 would stage ${product.handle ?? args.handle}${size ? `#${size}` : ""}${colourSuffix2} (nothing staged).`),
+        "   run without --dry-run to acquire the inventory lock."
+      ],
+      json: args.json ? {
+        dry_run: true,
+        would_stage: {
+          handle: product.handle ?? args.handle,
+          size: size ?? null,
+          colour: colour ?? null,
+          variant_id: variant.id
+        }
+      } : void 0
+    };
+  }
+  const lines = [];
+  let cartId = config.cart_id;
+  let recovered = false;
+  if (!cartId) {
+    const fresh = await client.createCart(region);
+    cartId = fresh.id;
+  }
+  try {
+    await client.addLineItem(cartId, variant.id, 1);
+  } catch (e) {
+    if (e instanceof RecoverableCartError) {
+      const fresh = await client.createCart(region);
+      cartId = fresh.id;
+      await client.addLineItem(cartId, variant.id, 1);
+      recovered = true;
+    } else {
+      throw e;
+    }
+  }
+  const cart = await client.getCart(cartId);
+  if (recovered) {
+    lines.push(
+      warn(
+        "your previous cart had expired or was already committed \u2014 created a fresh cart and re-added it."
+      )
+    );
+  }
+  const colourSuffix = colour ? ` (${colour})` : "";
+  lines.push(
+    ok(
+      `staged ${product.handle ?? args.handle}${size ? `#${size}` : ""}${colourSuffix} \xB7 inventory lock acquired (held 10m)`
+    )
+  );
+  (cart.items ?? []).forEach((item, i) => {
+    lines.push(formatCartLine(item, i, cart.currency_code, style));
+  });
+  const itemCount = (cart.items ?? []).reduce((n, li) => n + (li.quantity ?? 1), 0);
+  lines.push(`   ${itemCount} item${itemCount === 1 ? "" : "s"} staged \u2192 bt commit   (or bt buy to do both)`);
+  return {
+    // persist the cart_id atomically BEFORE returning (the router calls config.save)
+    save: { cart_id: cartId },
+    lines,
+    json: args.json ? { cart_id: cartId, recovered, colour: colour ?? null, items: cart.items ?? [], total: cart.total ?? null } : void 0
+  };
+}
+function registerStage(program, makeClient, loadConfig) {
+  program.command("stage").alias("add").argument("<handle>", "the product handle/slug").option("--size <size>", "garment size (default: your last commit's size)").option("--colour <colour>", "colour, e.g. white / black (default: the product's first colour)").option("--dry-run", "resolve the variant + show what would be staged, without staging").description("reserve stock \u2014 acquires an inventory lock, reserves nothing permanent.").action(async (handle, opts) => {
+    const gOpts = program.opts();
+    const json = Boolean(gOpts.json);
+    const brand = json ? makeBrand({ noColor: true }) : makeBrand({ noColor: gOpts.color === false });
+    const res = await runStage(makeClient(), loadConfig(), {
+      handle,
+      size: opts.size,
+      colour: opts.colour,
+      dryRun: opts.dryRun,
+      json,
+      brand
+    });
+    if (res.save) {
+      const { saveConfig } = await import("./config-FXGCWC6Y.js");
+      saveConfig(res.save);
+    }
+    printResult(res, json);
+  });
+}
+
+export {
+  redact,
+  RecoverableCartError,
+  StoreApiError,
+  StoreClient,
+  BT_DEFAULT_STORE_URL,
+  BT_DEFAULT_PUBLISHABLE_KEY,
+  productColours,
+  sizesForColour,
+  findVariant,
+  GLYPH,
+  ok,
+  warn,
+  working,
+  empty,
+  fail,
+  versionLine,
+  brandOf,
+  fmtPrice,
+  firstPrice,
+  stageMarker,
+  displayName,
+  lineColour,
+  formatCartLine,
+  resolveLineItemRef,
+  runView,
+  registerView,
+  runStage,
+  registerStage,
+  registerBrowse,
+  printResult
+};
+//# sourceMappingURL=chunk-DWTH7CNI.js.map