hookwright 1.0.0

package/dist/cli.js

@@ -0,0 +1,2890 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// package.json
+var package_exports = {};
+__export(package_exports, {
+  default: () => package_default
+});
+var package_default;
+var init_package = __esm({
+  "package.json"() {
+    package_default = {
+      name: "hookwright",
+      version: "1.0.0",
+      description: "Build real, signed e-commerce webhooks from a live Shopify catalogue \u2014 interactive terminal UI, no backend",
+      keywords: [
+        "webhook",
+        "shopify",
+        "cashfree",
+        "testing",
+        "hmac",
+        "cli",
+        "ink",
+        "abandoned-cart",
+        "payload-generator"
+      ],
+      license: "MIT",
+      type: "module",
+      bin: {
+        hookwright: "dist/cli.js"
+      },
+      files: [
+        "dist",
+        "README.md",
+        "LICENSE"
+      ],
+      scripts: {
+        build: "node scripts/build.mjs",
+        dev: "node scripts/build.mjs --watch",
+        start: "npm run build --silent && node dist/cli.js",
+        test: "node --test test/*.test.mjs",
+        prepublishOnly: "npm run build && npm test"
+      },
+      engines: {
+        node: ">=20"
+      },
+      dependencies: {
+        "@inkjs/ui": "^2.0.0",
+        ink: "^7.1.1",
+        react: "^19.2.8"
+      },
+      devDependencies: {
+        esbuild: "^0.28.2"
+      }
+    };
+  }
+});
+
+// src/cli.jsx
+import React15 from "react";
+import { render } from "ink";
+
+// src/ui/App.jsx
+import React14, { useState as useState8 } from "react";
+import { useApp as useApp2 } from "ink";
+
+// src/ui/screens/Home.jsx
+import React2 from "react";
+import { Box as Box2, Text as Text2 } from "ink";
+import { Select } from "@inkjs/ui";
+
+// src/ui/components/Header.jsx
+import React from "react";
+import { Box, Text } from "ink";
+
+// src/ui/theme.js
+var palette = {
+  accent: "cyan",
+  ok: "green",
+  warn: "yellow",
+  bad: "red",
+  dim: "gray",
+  heading: "magenta"
+};
+var glyph = {
+  tick: "\u2714",
+  cross: "\u2716",
+  warn: "\u25B2",
+  dot: "\u2022",
+  arrow: "\u203A",
+  pointer: "\u276F"
+};
+function mask(value) {
+  const s = String(value ?? "");
+  if (!s) return "";
+  if (s.length <= 8) return "*".repeat(s.length);
+  return s.slice(0, 4) + "*".repeat(Math.max(4, s.length - 8)) + s.slice(-4);
+}
+function truncate(value, max = 52) {
+  const s = String(value ?? "");
+  return s.length > max ? s.slice(0, max - 1) + "\u2026" : s;
+}
+function money(value, currency) {
+  if (value == null) return "\u2014";
+  return `${Number(value).toFixed(2)} ${currency ?? ""}`.trim();
+}
+
+// src/ui/components/Header.jsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function Header({ title, subtitle, right }) {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsxs(Box, { borderStyle: "round", borderColor: palette.accent, paddingX: 1, justifyContent: "space-between", children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, color: palette.accent, children: title }),
+      right ? /* @__PURE__ */ jsx(Text, { color: palette.dim, children: truncate(right, 44) }) : null
+    ] }),
+    subtitle ? /* @__PURE__ */ jsx(Box, { paddingX: 1, children: /* @__PURE__ */ jsx(Text, { color: palette.dim, children: subtitle }) }) : null
+  ] });
+}
+function Section({ title, children }) {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
+    /* @__PURE__ */ jsx(Text, { bold: true, color: palette.heading, children: title }),
+    /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginTop: 0, children })
+  ] });
+}
+
+// src/config.mjs
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+var HOME = process.env.HOOKWRIGHT_HOME || process.env.HOOKFORGE_HOME || process.env.WEBHOOK_FORGE_HOME;
+var xdgConfig = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
+var xdgState = process.env.XDG_STATE_HOME || path.join(os.homedir(), ".local", "state");
+var LEGACY_NAMES = ["hookforge", "webhook-forge"];
+function pick(base, name) {
+  const preferred = path.join(base, name);
+  if (fs.existsSync(preferred)) return preferred;
+  for (const legacy of LEGACY_NAMES) {
+    const candidate = path.join(base, legacy);
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  return preferred;
+}
+var CONFIG_HOME = HOME || pick(xdgConfig, "hookwright");
+var STATE_HOME = HOME || pick(xdgState, "hookwright");
+var CONFIG_PATH = process.env.HOOKWRIGHT_CONFIG || process.env.HOOKFORGE_CONFIG || process.env.WEBHOOK_FORGE_CONFIG || path.join(CONFIG_HOME, "config.json");
+var STATE_DIR = STATE_HOME;
+var OUT_DIR = path.join(STATE_HOME, "payloads");
+var DEFAULT_CONFIG = {
+  shopify: {
+    domain: "",
+    accessToken: "",
+    apiVersion: "2024-10",
+    // cached from the last successful connection, for display only
+    shop: null
+  },
+  // One destination per provider — set globally in Setup, reused on every build.
+  targets: {
+    "cashfree-occ": { webhookUrl: "", webhookSecret: "" },
+    "razorpay-magic": { webhookUrl: "", webhookSecret: "" },
+    nitro: { webhookUrl: "", webhookSecret: "" }
+  },
+  customer: {
+    firstName: "",
+    lastName: "",
+    email: "",
+    phone: "",
+    address1: "",
+    address2: "",
+    city: "",
+    province: "",
+    provinceCode: "",
+    country: "",
+    countryCode: "IN",
+    zip: ""
+  },
+  allowedPhones: [],
+  defaults: {
+    platform: "shopify",
+    currency: "INR",
+    copyToClipboard: true,
+    utm: {
+      utm_source: "facebook",
+      utm_medium: "cpc",
+      utm_campaign: "abandoned-cart-test",
+      utm_content: "",
+      fbclid: ""
+    }
+  }
+};
+function deepMerge(base, extra) {
+  const out = Array.isArray(base) ? [...base] : { ...base };
+  for (const [k, v] of Object.entries(extra ?? {})) {
+    if (v && typeof v === "object" && !Array.isArray(v) && base?.[k] && typeof base[k] === "object" && !Array.isArray(base[k])) {
+      out[k] = deepMerge(base[k], v);
+    } else if (v !== void 0) {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+function resolveConfigPath(explicit) {
+  return explicit ? path.resolve(String(explicit)) : CONFIG_PATH;
+}
+function migrate(cfg) {
+  const legacy = cfg.target;
+  if (legacy && (legacy.webhookUrl || legacy.webhookSecret)) {
+    const existing = cfg.targets["cashfree-occ"];
+    if (!existing.webhookUrl && !existing.webhookSecret) {
+      cfg.targets["cashfree-occ"] = {
+        webhookUrl: legacy.webhookUrl ?? "",
+        webhookSecret: legacy.webhookSecret ?? ""
+      };
+    }
+  }
+  delete cfg.target;
+  return cfg;
+}
+function loadConfig(explicitPath) {
+  const file = resolveConfigPath(explicitPath);
+  if (!fs.existsSync(file)) return { ...structuredClone(DEFAULT_CONFIG), _new: true, _path: file };
+  try {
+    const raw = JSON.parse(fs.readFileSync(file, "utf8"));
+    return { ...migrate(deepMerge(DEFAULT_CONFIG, raw)), _path: file };
+  } catch (err) {
+    throw new Error(`${file} is not valid JSON: ${err.message}`);
+  }
+}
+function targetFor(cfg, providerId) {
+  return cfg.targets?.[providerId] ?? { webhookUrl: "", webhookSecret: "" };
+}
+function setTarget(cfg, providerId, patch) {
+  cfg.targets = cfg.targets ?? {};
+  cfg.targets[providerId] = { ...targetFor(cfg, providerId), ...patch };
+  return cfg;
+}
+function configuredTargets(cfg) {
+  return Object.entries(cfg.targets ?? {}).filter(([, t]) => t.webhookUrl);
+}
+function saveConfig(cfg, explicitPath) {
+  const file = resolveConfigPath(explicitPath ?? cfg._path);
+  const clean = { ...cfg };
+  delete clean._new;
+  delete clean._path;
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(clean, null, 2) + "\n", { mode: 384 });
+  try {
+    fs.chmodSync(file, 384);
+  } catch {
+  }
+  return file;
+}
+function applyShopDefaults(cfg, shop, productCount) {
+  const applied = [];
+  if (!shop) return applied;
+  cfg.shopify.shop = {
+    name: shop.name,
+    domain: shop.domain,
+    myshopifyDomain: shop.myshopify_domain,
+    currency: shop.currency,
+    countryCode: shop.country_code,
+    countryName: shop.country_name,
+    timezone: shop.iana_timezone,
+    plan: shop.plan_display_name,
+    email: shop.email,
+    productCount: productCount ?? null,
+    connectedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (shop.currency && cfg.defaults.currency !== shop.currency) {
+    cfg.defaults.currency = shop.currency;
+    applied.push(`currency set to ${shop.currency}`);
+  }
+  const fill = (path6, value, label) => {
+    if (!value) return;
+    const keys = path6.split(".");
+    const last = keys.pop();
+    const target = keys.reduce((a, k) => a[k], cfg);
+    if (!target[last]) {
+      target[last] = value;
+      applied.push(label);
+    }
+  };
+  fill("customer.countryCode", shop.country_code, `country code set to ${shop.country_code}`);
+  fill("customer.country", shop.country_name, `country set to ${shop.country_name}`);
+  fill("customer.province", shop.province, `province set to ${shop.province}`);
+  fill("customer.provinceCode", shop.province_code, `province code set to ${shop.province_code}`);
+  fill("customer.city", shop.city, `city set to ${shop.city}`);
+  fill("customer.zip", shop.zip, `zip set to ${shop.zip}`);
+  fill("customer.email", shop.email, `contact email set to ${shop.email}`);
+  fill("customer.phone", shop.phone, `test phone set to the store contact number`);
+  return applied;
+}
+function isShopifyConnected(cfg) {
+  return Boolean(cfg.shopify.domain && cfg.shopify.accessToken);
+}
+function canSend(cfg, providerId = "cashfree-occ") {
+  const target = targetFor(cfg, providerId);
+  return Boolean(target.webhookUrl && cfg.customer.phone);
+}
+function configStatus(cfg, providerId = "cashfree-occ") {
+  const target = targetFor(cfg, providerId);
+  return [
+    { key: "Shopify domain", value: cfg.shopify.domain, ok: Boolean(cfg.shopify.domain) },
+    { key: "Shopify token", value: cfg.shopify.accessToken, ok: Boolean(cfg.shopify.accessToken), secret: true },
+    { key: "Webhook URL", value: target.webhookUrl, ok: Boolean(target.webhookUrl) },
+    { key: "Webhook secret", value: target.webhookSecret, ok: Boolean(target.webhookSecret), secret: true },
+    { key: "Test phone", value: cfg.customer.phone, ok: Boolean(cfg.customer.phone) },
+    { key: "Ship-to country", value: cfg.customer.countryCode, ok: Boolean(cfg.customer.countryCode) }
+  ];
+}
+function isConfigured(cfg, providerId = "cashfree-occ") {
+  return configStatus(cfg, providerId).every((r) => r.ok);
+}
+
+// src/ui/screens/Home.jsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function Home({ config, onPick, onQuit }) {
+  const ready = canSend(config);
+  const shop = config.shopify.shop;
+  const options = [
+    { label: "Setup".padEnd(18) + (ready ? "Shopify and webhook destination" : "connect Shopify and set the webhook URL"), value: "setup" },
+    { label: "Integrations".padEnd(18) + "build and send a provider webhook", value: "integrations" },
+    { label: "History".padEnd(18) + "review or re-send a saved payload", value: "history" },
+    { label: "Doctor".padEnd(18) + "check credentials and connectivity", value: "doctor" },
+    { label: "Clear".padEnd(18) + "remove cached data", value: "clear" },
+    { label: "Quit".padEnd(18), value: "quit" }
+  ];
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx2(
+      Header,
+      {
+        title: "hookwright",
+        subtitle: "real catalogue \u2192 signed provider webhooks",
+        right: shop?.name ?? config.shopify.domain ?? "not connected"
+      }
+    ),
+    /* @__PURE__ */ jsx2(
+      Select,
+      {
+        visibleOptionCount: options.length,
+        options,
+        onChange: (value) => value === "quit" ? onQuit() : onPick(value)
+      }
+    ),
+    /* @__PURE__ */ jsx2(Box2, { marginTop: 1, children: /* @__PURE__ */ jsx2(Text2, { color: palette.dim, children: "\u2191\u2193 move \xB7 enter select \xB7 q quit" }) })
+  ] });
+}
+
+// src/ui/screens/Setup.jsx
+import React3 from "react";
+import { Box as Box3, Text as Text3, useInput } from "ink";
+import { Select as Select2 } from "@inkjs/ui";
+
+// src/providers/cashfree-occ.mjs
+import crypto from "node:crypto";
+
+// src/shopify/products.mjs
+function normalizeProduct(product) {
+  const variants = (product.variants ?? []).map((v) => ({
+    id: String(v.id),
+    title: v.title,
+    sku: v.sku || "",
+    price: v.price != null ? Number(v.price) : null,
+    available: v.inventory_quantity == null ? true : v.inventory_quantity > 0,
+    imageId: v.image_id ? String(v.image_id) : null
+  }));
+  const images = (product.images ?? []).map((img) => ({ id: String(img.id), src: img.src }));
+  const defaultImage = product.image?.src ?? images[0]?.src ?? "";
+  return {
+    id: String(product.id),
+    title: product.title,
+    handle: product.handle,
+    status: product.status,
+    vendor: product.vendor,
+    productType: product.product_type,
+    images,
+    image: defaultImage,
+    variants
+  };
+}
+function imageForVariant(product, variant) {
+  if (variant?.imageId) {
+    const hit = product.images.find((i) => i.id === variant.imageId);
+    if (hit) return hit.src;
+  }
+  return product.image;
+}
+function cartPermalink(domain, items) {
+  const parts = items.filter((i) => i.variantId).map((i) => `${i.variantId}:${i.quantity}`).join(",");
+  const clean = String(domain).replace(/^https?:\/\//i, "");
+  const scheme = /^(127\.0\.0\.1|localhost)(:\d+)?$/i.test(clean) ? "http" : "https";
+  return `${scheme}://${clean}/cart/${parts}`;
+}
+function money2(value) {
+  return Math.round(Number(value) * 100) / 100;
+}
+
+// src/providers/cashfree-occ.mjs
+var GATE_PATH = "type";
+var GATE_VALUE = "ABANDONED_CHECKOUT";
+var fieldMap = [
+  { source: "type", target: "\xABgate\xBB", required: true, note: `must equal ${GATE_VALUE}` },
+  { source: "event_time", target: "eventTime" },
+  { source: "data.cart_id", target: "cartId" },
+  { source: "data.cart_token", target: "cartToken" },
+  { source: "data.store_url", target: "storeUrl", required: true },
+  { source: "data.platform", target: "platform" },
+  { source: "data.email", target: "email" },
+  { source: "data.phone", target: "phone", required: true, note: "or shipping_address.phone; must parse to E.164" },
+  { source: "data.abandoned_checkout_url", target: "abandonedCheckoutUrl / checkoutUrl", required: true },
+  { source: "data.original_total_price", target: "pricing.originalTotalPrice" },
+  { source: "data.total_price", target: "pricing.totalPrice", required: true },
+  { source: "data.total_discount", target: "pricing.totalDiscount" },
+  { source: "data.customer.first_name", target: "customer.firstName" },
+  { source: "data.customer.last_name", target: "customer.lastName" },
+  { source: "data.customer.email", target: "customer.email" },
+  { source: "data.customer.shipping_address.customer_name", target: "customer.customerName" },
+  { source: "data.customer.shipping_address.phone", target: "phone fallback" },
+  { source: "data.customer.shipping_address.address1", target: "customer.address1" },
+  { source: "data.customer.shipping_address.address2", target: "customer.address2" },
+  { source: "data.customer.shipping_address.city", target: "customer.city" },
+  { source: "data.customer.shipping_address.province", target: "customer.province" },
+  { source: "data.customer.shipping_address.province_code", target: "customer.provinceCode" },
+  { source: "data.customer.shipping_address.country", target: "customer.country" },
+  { source: "data.customer.shipping_address.country_code", target: "customer.countryCode", required: true, note: "region code used to parse the phone" },
+  { source: "data.customer.shipping_address.zip", target: "customer.zip" },
+  { source: "data.line_items[0].name", target: "cart.productName", required: true },
+  { source: "data.line_items[0].currency", target: "pricing.currency", required: true, note: "currency is read off the FIRST line item, not the root" },
+  { source: "data.line_items[0].image_url", target: "cart.image", required: true, note: "first line item with an image wins" },
+  { source: "data.line_items[0].quantity", target: "cart.quantity" },
+  { source: "data.utm_parameters.utm_source", target: "utm.source" },
+  { source: "data.utm_parameters.utm_medium", target: "utm.medium" },
+  { source: "data.utm_parameters.utm_campaign", target: "utm.campaign" },
+  { source: "data.utm_parameters.utm_content", target: "utm.content" },
+  { source: "data.utm_parameters.fbclid", target: "utm.fbclid" }
+];
+function buildPayload(ctx) {
+  const { config, items, phone } = ctx;
+  const now = ctx.now ?? /* @__PURE__ */ new Date();
+  const currency = ctx.currency || config.defaults.currency;
+  const domain = config.shopify.domain;
+  const cust = config.customer;
+  const lineItems = items.map(({ product, variant, quantity }) => ({
+    name: product.title,
+    variant_id: variant ? Number(variant.id) : null,
+    variant_title: variant?.title ?? null,
+    reference: Number(product.id),
+    sku: variant?.sku || null,
+    quantity,
+    price: money2(variant?.price ?? 0),
+    currency,
+    image_url: imageForVariant(product, variant)
+  }));
+  const originalTotal = money2(lineItems.reduce((sum, li) => sum + li.price * li.quantity, 0));
+  const discount = money2(Math.min(ctx.discount ?? 0, originalTotal));
+  const total = money2(originalTotal - discount);
+  const checkoutUrl = cartPermalink(domain, items.map(({ variant, quantity }) => ({ variantId: variant?.id, quantity })));
+  return {
+    type: GATE_VALUE,
+    event_time: now.toISOString(),
+    data: {
+      cart_id: crypto.randomUUID(),
+      cart_token: crypto.randomBytes(16).toString("hex"),
+      store_url: domain,
+      platform: config.defaults.platform,
+      email: cust.email,
+      phone,
+      abandoned_checkout_url: checkoutUrl,
+      original_total_price: originalTotal,
+      total_price: total,
+      total_discount: discount,
+      customer: {
+        first_name: cust.firstName,
+        last_name: cust.lastName,
+        email: cust.email,
+        shipping_address: {
+          customer_name: `${cust.firstName} ${cust.lastName}`.trim(),
+          phone,
+          address1: cust.address1,
+          address2: cust.address2,
+          city: cust.city,
+          province: cust.province,
+          province_code: cust.provinceCode,
+          country: cust.country,
+          country_code: cust.countryCode,
+          zip: cust.zip
+        }
+      },
+      line_items: lineItems,
+      utm_parameters: { ...config.defaults.utm }
+    }
+  };
+}
+function sign({ body, secret, timestamp }) {
+  const ts = timestamp ?? String(Math.floor(Date.now() / 1e3));
+  const signature = crypto.createHmac("sha256", String(secret)).update(`${ts}${body}`).digest("base64");
+  return {
+    timestamp: ts,
+    signature,
+    headers: {
+      "content-type": "application/json",
+      "x-webhook-signature": signature,
+      "x-webhook-timestamp": ts
+    }
+  };
+}
+function webhookUrl(config) {
+  return String(targetFor(config, "cashfree-occ").webhookUrl ?? "").trim();
+}
+function webhookSecret(config) {
+  return String(targetFor(config, "cashfree-occ").webhookSecret ?? "");
+}
+var editableFields = [
+  { group: "Event", path: "event_time", label: "Event time", hint: "ISO timestamp of the abandonment" },
+  { group: "Cart", path: "data.cart_id", label: "Cart id" },
+  { group: "Cart", path: "data.cart_token", label: "Cart token" },
+  { group: "Cart", path: "data.store_url", label: "Store URL" },
+  { group: "Cart", path: "data.platform", label: "Platform" },
+  { group: "Cart", path: "data.abandoned_checkout_url", label: "Abandoned checkout URL", hint: "the link the shopper is sent back to" },
+  { group: "Pricing", path: "data.original_total_price", label: "Original total", type: "number" },
+  { group: "Pricing", path: "data.total_discount", label: "Discount", type: "number" },
+  { group: "Pricing", path: "data.total_price", label: "Total price", type: "number" },
+  { group: "Customer", path: "data.customer.first_name", label: "First name" },
+  { group: "Customer", path: "data.customer.last_name", label: "Last name" },
+  { group: "Customer", path: "data.email", label: "Email" },
+  { group: "Customer", path: "data.phone", label: "Phone", hint: "must parse to E.164 against the country code below" },
+  { group: "Shipping", path: "data.customer.shipping_address.customer_name", label: "Ship-to name" },
+  { group: "Shipping", path: "data.customer.shipping_address.address1", label: "Address line 1" },
+  { group: "Shipping", path: "data.customer.shipping_address.address2", label: "Address line 2", optional: true },
+  { group: "Shipping", path: "data.customer.shipping_address.city", label: "City" },
+  { group: "Shipping", path: "data.customer.shipping_address.province", label: "Province / state" },
+  { group: "Shipping", path: "data.customer.shipping_address.province_code", label: "Province code", optional: true },
+  { group: "Shipping", path: "data.customer.shipping_address.country", label: "Country" },
+  { group: "Shipping", path: "data.customer.shipping_address.country_code", label: "Country code", hint: "region used to parse the phone" },
+  { group: "Shipping", path: "data.customer.shipping_address.zip", label: "Zip / postcode" },
+  { group: "UTM", path: "data.utm_parameters.utm_source", label: "UTM source", optional: true },
+  { group: "UTM", path: "data.utm_parameters.utm_medium", label: "UTM medium", optional: true },
+  { group: "UTM", path: "data.utm_parameters.utm_campaign", label: "UTM campaign", optional: true },
+  { group: "UTM", path: "data.utm_parameters.utm_content", label: "UTM content", optional: true },
+  { group: "UTM", path: "data.utm_parameters.fbclid", label: "Facebook click id", optional: true }
+];
+var cashfree_occ_default = {
+  id: "cashfree-occ",
+  urlKey: "cashfree_occ",
+  label: "Cashfree One Click Checkout",
+  eventType: "cashfree_occ_abandoned_checkout",
+  gate: { path: GATE_PATH, value: GATE_VALUE },
+  signatureScheme: "base64 HMAC-SHA256 over `timestamp + body`",
+  signatureHeader: "x-webhook-signature",
+  fieldMap,
+  editableFields,
+  buildPayload,
+  sign,
+  webhookUrl,
+  webhookSecret
+};
+
+// src/providers/index.mjs
+var PROVIDER_META = [
+  {
+    id: "cashfree-occ",
+    label: "Cashfree One Click Checkout",
+    signature: "base64 HMAC-SHA256 over `timestamp + body`",
+    header: "x-webhook-signature",
+    available: true
+  },
+  {
+    id: "razorpay-magic",
+    label: "Razorpay Magic",
+    signature: "hex HMAC-SHA256 over the body",
+    header: "x-razorpay-signature",
+    available: false
+  },
+  {
+    id: "nitro",
+    label: "Nitro",
+    signature: "static bearer token",
+    header: "authorization",
+    available: false
+  }
+];
+var providers = {
+  [cashfree_occ_default.id]: cashfree_occ_default
+};
+function getProvider(id) {
+  const provider = providers[id];
+  if (!provider) {
+    throw new Error(`unknown provider "${id}" \u2014 available: ${Object.keys(providers).join(", ")}`);
+  }
+  return provider;
+}
+function listProviders() {
+  return Object.values(providers);
+}
+function listProviderMeta() {
+  return PROVIDER_META;
+}
+function metaFor(id) {
+  return PROVIDER_META.find((p) => p.id === id) ?? { id, label: id, available: Boolean(providers[id]) };
+}
+
+// src/ui/screens/Setup.jsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function Setup({ config, onPick, onBack }) {
+  const shopifyOk = isShopifyConnected(config);
+  const configured = configuredTargets(config).length;
+  const total = listProviderMeta().length;
+  const phoneOk = Boolean(config.customer.phone);
+  const shop = config.shopify.shop;
+  useInput((input, key) => {
+    if (key.escape) onBack();
+  });
+  const options = [
+    { label: "Shopify".padEnd(20) + (shopifyOk ? `connected \xB7 ${shop?.name ?? config.shopify.domain}` : "connect a store \u2014 domain + Admin API token"), value: "connect" },
+    { label: "Webhook".padEnd(20) + `destinations \xB7 ${configured} of ${total} set`, value: "webhook" },
+    { label: "Customer".padEnd(20) + (phoneOk ? `${config.customer.firstName} ${config.customer.lastName} \xB7 ${config.customer.phone}` : "shopper name, phone, shipping address"), value: "customer" },
+    { label: "Defaults".padEnd(20) + `currency ${config.defaults.currency} \xB7 platform ${config.defaults.platform}`, value: "defaults" },
+    { label: "Back".padEnd(20), value: "back" }
+  ];
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx3(Header, { title: "Setup", subtitle: "the product source and the webhook destination", right: "esc to go back" }),
+    /* @__PURE__ */ jsx3(Select2, { visibleOptionCount: options.length, options, onChange: (v) => v === "back" ? onBack() : onPick(v) }),
+    /* @__PURE__ */ jsx3(Box3, { marginTop: 1, children: /* @__PURE__ */ jsx3(Text3, { color: palette.dim, children: `${glyph.dot} shared by every integration \u2014 set it once` }) })
+  ] });
+}
+
+// src/ui/screens/Integrations.jsx
+import React4 from "react";
+import { Box as Box4, Text as Text4, useInput as useInput2 } from "ink";
+import { Select as Select3 } from "@inkjs/ui";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var PLANNED = listProviderMeta().filter((p) => !p.available);
+function Integrations({ config, onPick, onBack, onSetup }) {
+  const available = listProviders();
+  const ready = available.every((p) => canSend(config, p.id));
+  useInput2((input, key) => {
+    if (key.escape) onBack();
+  });
+  const options = [
+    ...available.map((p) => ({
+      label: p.label.padEnd(34) + (canSend(config, p.id) ? "ready" : "setup incomplete"),
+      value: p.id
+    })),
+    ...ready ? [] : [{ label: "Go to Setup".padEnd(34) + "connect Shopify and set the webhook URL", value: "__setup" }],
+    { label: "Back".padEnd(34), value: "__back" }
+  ];
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx4(Header, { title: "Integrations", subtitle: "pick the provider whose webhook you want to generate", right: "esc to go back" }),
+    /* @__PURE__ */ jsx4(
+      Select3,
+      {
+        visibleOptionCount: options.length,
+        options,
+        onChange: (v) => v === "__back" ? onBack() : v === "__setup" ? onSetup() : onPick(v)
+      }
+    ),
+    /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", marginTop: 1, children: PLANNED.map((p) => /* @__PURE__ */ jsx4(Text4, { color: palette.dim, children: `  ${glyph.dot} ${p.label.padEnd(32)} not yet available` }, p.id)) })
+  ] });
+}
+
+// src/ui/screens/Build.jsx
+import React7, { useEffect, useState } from "react";
+import { Box as Box7, Text as Text7, useApp, useInput as useInput3 } from "ink";
+import { Spinner, Select as Select4, MultiSelect, TextInput, ConfirmInput, Alert, Badge } from "@inkjs/ui";
+
+// src/ui/components/CheckList.jsx
+import React5 from "react";
+import { Box as Box5, Text as Text5 } from "ink";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function CheckList({ checks }) {
+  return /* @__PURE__ */ jsx5(Box5, { flexDirection: "column", children: checks.map((check, i) => {
+    const colour = check.ok ? palette.ok : check.warn ? palette.warn : palette.bad;
+    const mark = check.ok ? glyph.tick : check.warn ? glyph.warn : glyph.cross;
+    return /* @__PURE__ */ jsxs5(Box5, { children: [
+      /* @__PURE__ */ jsx5(Text5, { color: colour, children: ` ${mark} ` }),
+      /* @__PURE__ */ jsx5(Text5, { bold: true, children: check.name.padEnd(24) }),
+      /* @__PURE__ */ jsx5(Text5, { color: palette.dim, children: check.detail })
+    ] }, i);
+  }) });
+}
+function KeyValue({ rows, keyWidth = 14 }) {
+  return /* @__PURE__ */ jsx5(Box5, { flexDirection: "column", children: rows.map(([k, v, colour], i) => /* @__PURE__ */ jsxs5(Box5, { children: [
+    /* @__PURE__ */ jsx5(Text5, { color: palette.dim, children: ` ${String(k).padEnd(keyWidth)}` }),
+    /* @__PURE__ */ jsx5(Text5, { color: colour, children: String(v) })
+  ] }, i)) });
+}
+
+// src/ui/components/FieldTable.jsx
+import React6 from "react";
+import { Box as Box6, Text as Text6 } from "ink";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function FieldTable({ coverage: coverage2, limit }) {
+  const rows = limit ? coverage2.slice(0, limit) : coverage2;
+  const fieldWidth = Math.min(46, Math.max(...rows.map((r) => r.field.length)) + 1);
+  const mapWidth = Math.min(30, Math.max(...rows.map((r) => String(r.maps_to).length)) + 1);
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs6(Box6, { children: [
+      /* @__PURE__ */ jsx6(Text6, { bold: true, color: palette.dim, children: " " + "payload field".padEnd(fieldWidth) }),
+      /* @__PURE__ */ jsx6(Text6, { bold: true, color: palette.dim, children: "maps to".padEnd(mapWidth) }),
+      /* @__PURE__ */ jsx6(Text6, { bold: true, color: palette.dim, children: "value" })
+    ] }),
+    rows.map((row, i) => {
+      const colour = row.status === "MISSING" ? palette.bad : row.status === "empty" ? palette.dim : void 0;
+      return /* @__PURE__ */ jsxs6(Box6, { children: [
+        /* @__PURE__ */ jsx6(Text6, { color: colour, children: " " + truncate(row.field, fieldWidth - 1).padEnd(fieldWidth) }),
+        /* @__PURE__ */ jsx6(Text6, { color: palette.dim, children: truncate(String(row.maps_to), mapWidth - 1).padEnd(mapWidth) }),
+        /* @__PURE__ */ jsx6(Text6, { color: colour, children: truncate(row.value, 34) })
+      ] }, i);
+    }),
+    limit && coverage2.length > limit ? /* @__PURE__ */ jsx6(Text6, { color: palette.dim, children: ` \u2026 ${coverage2.length - limit} more fields` }) : null
+  ] });
+}
+
+// src/errors.mjs
+var ForgeError = class extends Error {
+  constructor(message, { hint, cause } = {}) {
+    super(message);
+    this.name = "ForgeError";
+    this.hint = hint;
+    if (cause) this.cause = cause;
+  }
+};
+var ConfigError = class extends ForgeError {
+  constructor(message, hint) {
+    super(message, { hint });
+    this.name = "ConfigError";
+  }
+};
+var ShopifyError = class extends ForgeError {
+  constructor(message, { status, body, hint } = {}) {
+    super(message, { hint });
+    this.name = "ShopifyError";
+    this.status = status;
+    this.body = body;
+  }
+};
+
+// src/logger.mjs
+import fs2 from "node:fs";
+import path2 from "node:path";
+var LOG_PATH = path2.join(STATE_DIR, "forge.log");
+var verbose = false;
+function setVerbose(v) {
+  verbose = Boolean(v);
+}
+function isVerbose() {
+  return verbose;
+}
+function audit(event, detail = {}) {
+  try {
+    fs2.mkdirSync(STATE_DIR, { recursive: true });
+    const line = JSON.stringify({ at: (/* @__PURE__ */ new Date()).toISOString(), event, ...redact(detail) });
+    fs2.appendFileSync(LOG_PATH, line + "\n");
+  } catch {
+  }
+}
+function redact(obj) {
+  const SECRET_KEYS = /token|secret|password|signature|authorization/i;
+  const walk = (v) => {
+    if (Array.isArray(v)) return v.map(walk);
+    if (v && typeof v === "object") {
+      return Object.fromEntries(Object.entries(v).map(([k, val]) => [k, SECRET_KEYS.test(k) ? "\xABredacted\xBB" : walk(val)]));
+    }
+    return v;
+  };
+  return walk(obj);
+}
+var logPath = LOG_PATH;
+
+// src/shopify/client.mjs
+var DEFAULT_API_VERSION = "2024-10";
+var ShopifyClient = class {
+  constructor({ domain, accessToken, apiVersion = DEFAULT_API_VERSION }) {
+    if (!domain) throw new ShopifyError("Shopify domain missing", { hint: "run `hookwright configure`" });
+    if (!accessToken) throw new ShopifyError("Shopify access token missing", { hint: "run `hookwright configure`" });
+    this.domain = normalizeDomain(domain);
+    this.protocol = /^http:\/\//i.test(String(domain).trim()) || /^(127\.0\.0\.1|localhost)(:\d+)?$/i.test(this.domain) ? "http" : "https";
+    this.accessToken = accessToken;
+    this.apiVersion = apiVersion || DEFAULT_API_VERSION;
+  }
+  get base() {
+    return `${this.protocol}://${this.domain}/admin/api/${this.apiVersion}`;
+  }
+  async request(pathOrUrl, { method = "GET", query, body, timeoutMs = 2e4 } = {}) {
+    const url = pathOrUrl.startsWith("http") ? new URL(pathOrUrl) : new URL(this.base + pathOrUrl);
+    for (const [k, v] of Object.entries(query ?? {})) {
+      if (v !== void 0 && v !== null && v !== "") url.searchParams.set(k, String(v));
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    let res;
+    try {
+      res = await fetch(url, {
+        method,
+        signal: controller.signal,
+        headers: {
+          "X-Shopify-Access-Token": this.accessToken,
+          "Content-Type": "application/json",
+          Accept: "application/json"
+        },
+        body: body ? JSON.stringify(body) : void 0
+      });
+    } catch (err) {
+      clearTimeout(timer);
+      if (err.name === "AbortError") throw new ShopifyError(`Shopify request timed out after ${timeoutMs}ms`, { hint: "check the store domain and your network" });
+      throw new ShopifyError(`Shopify request failed: ${err.message}`, { hint: "check the store domain" });
+    }
+    clearTimeout(timer);
+    const text = await res.text();
+    let json = null;
+    try {
+      json = text ? JSON.parse(text) : null;
+    } catch {
+    }
+    if (isVerbose()) audit("shopify.request", { url: url.pathname, status: res.status });
+    if (res.status === 401 || res.status === 403) {
+      throw new ShopifyError(`Shopify rejected the credentials (${res.status})`, {
+        status: res.status,
+        body: json ?? text,
+        hint: "the Admin API access token needs read_products scope, and must belong to this store"
+      });
+    }
+    if (res.status === 404) {
+      throw new ShopifyError("Shopify returned 404 \u2014 wrong store domain or API version", {
+        status: 404,
+        hint: `tried ${url.host}${url.pathname}`
+      });
+    }
+    if (res.status === 429) {
+      const retry = Number(res.headers.get("retry-after") ?? 2);
+      await sleep(retry * 1e3);
+      return this.request(pathOrUrl, { method, query, body, timeoutMs });
+    }
+    if (!res.ok) {
+      throw new ShopifyError(`Shopify error ${res.status}`, { status: res.status, body: json ?? text });
+    }
+    return { json, headers: res.headers };
+  }
+  /** Verifies the credentials and returns the real shop record. */
+  async shop() {
+    const { json } = await this.request("/shop.json");
+    return json?.shop ?? null;
+  }
+  /**
+   * Products, following Link-header pagination.
+   * @param {{limit?: number, title?: string, pages?: number, status?: string}} opts
+   */
+  async products({ limit = 50, title, pages = 1, status = "active" } = {}) {
+    const out = [];
+    let next = null;
+    for (let page = 0; page < pages; page += 1) {
+      const { json, headers } = next ? await this.request(next) : await this.request("/products.json", { query: { limit, title, status } });
+      out.push(...json?.products ?? []);
+      next = parseNextLink(headers.get("link"));
+      if (!next) break;
+    }
+    return out;
+  }
+  async productCount() {
+    const { json } = await this.request("/products/count.json");
+    return json?.count ?? 0;
+  }
+};
+function normalizeDomain(domain) {
+  return String(domain).trim().replace(/^https?:\/\//, "").replace(/\/.*$/, "").toLowerCase();
+}
+function parseNextLink(linkHeader) {
+  if (!linkHeader) return null;
+  const match = linkHeader.split(",").find((part) => part.includes('rel="next"'));
+  if (!match) return null;
+  const url = match.match(/<([^>]+)>/);
+  return url ? url[1] : null;
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+// src/core/catalogue.mjs
+async function verifyStore(cfg) {
+  const client = new ShopifyClient(cfg.shopify);
+  const shop = await client.shop();
+  const count = await client.productCount().catch(() => null);
+  return { shop, count };
+}
+async function fetchCatalogue(cfg, { search, pages = 1, limit = 50 } = {}) {
+  const client = new ShopifyClient(cfg.shopify);
+  const raw = await client.products({ title: search, pages, limit });
+  return raw.map(normalizeProduct).filter((p) => p.variants.length);
+}
+function autoSelect(products, count = 1) {
+  return products.slice(0, count).map((product) => ({
+    product,
+    variant: product.variants[0],
+    quantity: 1
+  }));
+}
+
+// src/phone.mjs
+var CALLING_CODES = {
+  IN: "91",
+  US: "1",
+  CA: "1",
+  GB: "44",
+  AE: "971",
+  SG: "65",
+  AU: "61",
+  NZ: "64",
+  DE: "49",
+  FR: "33",
+  IT: "39",
+  ES: "34",
+  NL: "31",
+  SE: "46",
+  RO: "40",
+  PL: "48",
+  ZA: "27",
+  NG: "234",
+  KE: "254",
+  BD: "880",
+  PK: "92",
+  LK: "94",
+  NP: "977",
+  MY: "60",
+  ID: "62",
+  PH: "63",
+  TH: "66",
+  VN: "84",
+  JP: "81",
+  KR: "82",
+  CN: "86",
+  SA: "966",
+  QA: "974",
+  KW: "965",
+  OM: "968",
+  BH: "973",
+  BR: "55",
+  MX: "52"
+};
+function callingCode(regionCode) {
+  return CALLING_CODES[String(regionCode || "").toUpperCase()] || null;
+}
+function toE164(raw, regionCode) {
+  const cleaned = String(raw ?? "").replace(/\s+/g, "");
+  if (!cleaned) return { ok: false, reason: "phone is empty" };
+  if (cleaned.startsWith("+")) {
+    const digits2 = cleaned.slice(1).replace(/\D/g, "");
+    if (digits2.length < 8 || digits2.length > 15) return { ok: false, reason: `+${digits2} is not a plausible E.164 length` };
+    return { ok: true, value: `+${digits2}` };
+  }
+  const cc = callingCode(regionCode);
+  if (!cc) {
+    return {
+      ok: false,
+      reason: `no country calling code known for region "${regionCode}" \u2014 give the phone in +E.164 form instead`
+    };
+  }
+  let national = cleaned.replace(/\D/g, "").replace(/^0+/, "");
+  if (national.startsWith(cc) && national.length > 10) national = national.slice(cc.length);
+  const value = `+${cc}${national}`;
+  const digits = value.slice(1);
+  if (digits.length < 8 || digits.length > 15) return { ok: false, reason: `${value} is not a plausible E.164 length` };
+  return { ok: true, value };
+}
+var knownRegions = Object.keys(CALLING_CODES);
+
+// src/core/paths.mjs
+function getPath(obj, path6) {
+  return String(path6).replace(/\[(\d+)\]/g, ".$1").split(".").reduce((acc, key) => acc == null ? void 0 : acc[key], obj);
+}
+function setPath(obj, path6, value) {
+  const keys = String(path6).replace(/\[(\d+)\]/g, ".$1").split(".");
+  const last = keys.pop();
+  const target = keys.reduce((acc, key) => {
+    if (acc[key] == null || typeof acc[key] !== "object") acc[key] = {};
+    return acc[key];
+  }, obj);
+  target[last] = value;
+  return obj;
+}
+
+// src/core/validate.mjs
+function checkRoundTrip(body) {
+  let reparsed;
+  try {
+    reparsed = JSON.stringify(JSON.parse(body));
+  } catch (err) {
+    return { name: "JSON round-trip", ok: false, detail: `body is not valid JSON: ${err.message}` };
+  }
+  if (reparsed === body) {
+    return { name: "JSON round-trip", ok: true, detail: "signed bytes survive parse \u2192 stringify" };
+  }
+  const at = firstDifference(body, reparsed);
+  return {
+    name: "JSON round-trip",
+    ok: false,
+    detail: `re-serialized body differs at offset ${at.index}: sent ${JSON.stringify(at.a)} vs recomputed ${JSON.stringify(at.b)}`
+  };
+}
+function checkGate(payload, provider) {
+  const actual = getPath(payload, provider.gate.path);
+  const ok = actual === provider.gate.value;
+  return {
+    name: "Schema gate",
+    ok,
+    detail: ok ? `${provider.gate.path} = "${actual}"` : `${provider.gate.path} is ${JSON.stringify(actual)} but the schema filter requires "${provider.gate.value}" \u2014 the event would be silently ignored`
+  };
+}
+function checkPhone(payload) {
+  const phone = getPath(payload, "data.phone") ?? getPath(payload, "data.customer.shipping_address.phone");
+  const region = getPath(payload, "data.customer.shipping_address.country_code");
+  if (!phone) {
+    return { name: "Phone", ok: false, detail: "no phone in data.phone or shipping_address.phone \u2014 consumer throws BadPayloadError" };
+  }
+  const parsed = toE164(phone, region);
+  return {
+    name: "Phone",
+    ok: parsed.ok,
+    detail: parsed.ok ? `${phone} \u2192 ${parsed.value} (region ${region || "n/a"})` : parsed.reason
+  };
+}
+function checkAllowedPhone(payload, config) {
+  const allowed = config.allowedPhones ?? [];
+  if (!allowed.length) {
+    return { name: "Phone allow-list", ok: true, detail: "no allow-list configured (skipped)", warn: true };
+  }
+  const phone = getPath(payload, "data.phone");
+  const parsed = toE164(phone, getPath(payload, "data.customer.shipping_address.country_code"));
+  const normalized = parsed.ok ? parsed.value : phone;
+  const ok = allowed.some((p) => toE164(p, "IN").value === normalized || p === normalized);
+  return {
+    name: "Phone allow-list",
+    ok,
+    detail: ok ? `${normalized} is an approved test handset` : `${normalized} is NOT in allowedPhones \u2014 refusing to risk messaging a real shopper`
+  };
+}
+function coverage(payload, fieldMap2) {
+  return fieldMap2.map((f) => {
+    const value = getPath(payload, f.source);
+    const present = value !== void 0 && value !== null && value !== "";
+    return {
+      field: f.source,
+      maps_to: f.target,
+      value: present ? preview(value) : "\u2014",
+      status: present ? "ok" : f.required ? "MISSING" : "empty",
+      required: Boolean(f.required),
+      note: f.note ?? ""
+    };
+  });
+}
+async function checkImages(payload, { timeoutMs = 1e4 } = {}) {
+  const items = getPath(payload, "data.line_items") ?? [];
+  const urls = [...new Set(items.map((i) => i?.image_url).filter(Boolean))];
+  if (!urls.length) {
+    return [{ name: "Product images", ok: false, detail: "no line item carries an image_url \u2014 cart.image resolves to undefined" }];
+  }
+  const results = await Promise.all(
+    urls.map(async (url) => {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeoutMs);
+      try {
+        const res = await fetch(url, { method: "HEAD", signal: controller.signal });
+        clearTimeout(timer);
+        return { url, status: res.status, ok: res.ok };
+      } catch (err) {
+        clearTimeout(timer);
+        return { url, status: 0, ok: false, error: err.name === "AbortError" ? "timeout" : err.message };
+      }
+    })
+  );
+  return results.map((r) => ({
+    name: "Product image",
+    ok: r.ok,
+    detail: `${r.ok ? "HTTP " + r.status : "unreachable (" + (r.error ?? r.status) + ")"} \u2014 ${shorten(r.url)}`
+  }));
+}
+async function runAll({ payload, body, provider, config, checkImageUrls = true }) {
+  const checks = [checkGate(payload, provider), checkRoundTrip(body), checkPhone(payload), checkAllowedPhone(payload, config)];
+  if (checkImageUrls) checks.push(...await checkImages(payload));
+  const cov = coverage(payload, provider.fieldMap);
+  const missing = cov.filter((c2) => c2.status === "MISSING");
+  checks.push({
+    name: "Required field coverage",
+    ok: missing.length === 0,
+    detail: missing.length === 0 ? `all ${cov.length} mapped fields resolved` : `missing: ${missing.map((m) => m.field).join(", ")}`
+  });
+  return {
+    checks,
+    coverage: cov,
+    ok: checks.filter((c2) => !c2.warn).every((c2) => c2.ok),
+    blocking: checks.filter((c2) => !c2.ok && !c2.warn)
+  };
+}
+function preview(value) {
+  if (typeof value === "object") return JSON.stringify(value).slice(0, 48);
+  const s = String(value);
+  return s.length > 48 ? s.slice(0, 45) + "\u2026" : s;
+}
+function shorten(url) {
+  const s = String(url);
+  return s.length > 62 ? s.slice(0, 40) + "\u2026" + s.slice(-18) : s;
+}
+function firstDifference(a, b) {
+  const len = Math.min(a.length, b.length);
+  for (let i = 0; i < len; i += 1) {
+    if (a[i] !== b[i]) return { index: i, a: a.slice(Math.max(0, i - 12), i + 12), b: b.slice(Math.max(0, i - 12), i + 12) };
+  }
+  return { index: len, a: a.slice(len), b: b.slice(len) };
+}
+
+// src/store.mjs
+import fs3 from "node:fs";
+import path3 from "node:path";
+var stamp = () => (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+function savePayload({ provider, payload, body, meta }) {
+  fs3.mkdirSync(OUT_DIR, { recursive: true });
+  const name = `${stamp()}__${provider}.json`;
+  const file = path3.join(OUT_DIR, name);
+  const record = {
+    savedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    provider,
+    meta,
+    payload,
+    // the exact string that must be signed and sent — never re-serialize this
+    body
+  };
+  fs3.writeFileSync(file, JSON.stringify(record, null, 2) + "\n");
+  fs3.writeFileSync(path3.join(OUT_DIR, "last.json"), JSON.stringify(record, null, 2) + "\n");
+  return file;
+}
+function loadLast() {
+  const file = path3.join(OUT_DIR, "last.json");
+  if (!fs3.existsSync(file)) return null;
+  return JSON.parse(fs3.readFileSync(file, "utf8"));
+}
+function readRecord(dir, file) {
+  const full = path3.join(dir, file);
+  try {
+    const rec = JSON.parse(fs3.readFileSync(full, "utf8"));
+    if (!rec || typeof rec !== "object" || !rec.savedAt || !rec.provider || !rec.body) return null;
+    return {
+      file,
+      path: full,
+      provider: String(rec.provider),
+      savedAt: String(rec.savedAt),
+      meta: rec.meta ?? {}
+    };
+  } catch {
+    return null;
+  }
+}
+function listPayloads(limit = 20) {
+  if (!fs3.existsSync(OUT_DIR)) return [];
+  return fs3.readdirSync(OUT_DIR).filter((f) => f.endsWith(".json") && f !== "last.json").sort().reverse().map((f) => readRecord(OUT_DIR, f)).filter(Boolean).slice(0, limit);
+}
+function loadPayload(file) {
+  const full = path3.isAbsolute(file) ? file : path3.join(OUT_DIR, file);
+  return JSON.parse(fs3.readFileSync(full, "utf8"));
+}
+
+// src/core/build.mjs
+function draftPayload({ cfg, providerId = "cashfree-occ", items, discount = 0, phone }) {
+  const provider = getProvider(providerId);
+  const resolvedPhone = phone ?? cfg.customer.phone;
+  const parsed = toE164(resolvedPhone, cfg.customer.countryCode);
+  const payload = provider.buildPayload({
+    config: cfg,
+    items,
+    discount,
+    phone: parsed.ok ? parsed.value : String(resolvedPhone ?? "")
+  });
+  const fields = (provider.editableFields ?? []).map((f) => ({ ...f, value: getPath(payload, f.path) }));
+  return { provider, payload, fields };
+}
+function applyEdits(payload, fields, edits) {
+  for (const field of fields) {
+    if (!(field.path in edits)) continue;
+    const raw = edits[field.path];
+    const value = field.type === "number" ? Number.parseFloat(raw) || 0 : raw;
+    setPath(payload, field.path, value);
+  }
+  return payload;
+}
+async function buildPayload2({ cfg, providerId = "cashfree-occ", items, discount = 0, phone, checkImageUrls = true, payload: prebuilt }) {
+  if (!items?.length) throw new ConfigError("no products selected");
+  const provider = getProvider(providerId);
+  const resolvedPhone = phone ?? cfg.customer.phone;
+  const parsed = toE164(resolvedPhone, cfg.customer.countryCode);
+  if (!parsed.ok) throw new ConfigError(`phone is unusable: ${parsed.reason}`);
+  const payload = prebuilt ?? provider.buildPayload({ config: cfg, items, discount, phone: parsed.value });
+  const body = JSON.stringify(payload);
+  const report = await runAll({ payload, body, provider, config: cfg, checkImageUrls });
+  const endpoint = provider.webhookUrl(cfg);
+  let host = "";
+  try {
+    host = endpoint ? new URL(endpoint).host : "";
+  } catch {
+    host = "";
+  }
+  const meta = {
+    provider: provider.id,
+    endpoint,
+    environment: host,
+    store: cfg.shopify.domain,
+    items: items.map((i) => ({ title: i.product.title, variant: i.variant?.title, qty: i.quantity, price: i.variant?.price })),
+    totalPrice: payload.data.total_price,
+    currency: payload.data.line_items[0]?.currency,
+    valid: report.ok
+  };
+  const file = savePayload({ provider: provider.id, payload, body, meta });
+  audit("payload.built", { provider: provider.id, valid: report.ok, file });
+  return { provider, payload, body, report, file, meta };
+}
+
+// src/core/send.mjs
+import fs4 from "node:fs";
+import path4 from "node:path";
+var PROD_PATTERNS = [/\bprod(uction)?\b/i, /\blive\b/i];
+function looksLikeProduction(origin) {
+  return PROD_PATTERNS.some((re) => re.test(String(origin)));
+}
+function buildRequest({ provider, config, body, timestamp }) {
+  const url = provider.webhookUrl(config);
+  const secret = provider.webhookSecret ? provider.webhookSecret(config) : "";
+  const signed = provider.sign({ body, secret, timestamp });
+  return { url, headers: signed.headers, signature: signed.signature, timestamp: signed.timestamp, body };
+}
+function toCurl({ url, headers, bodyFile }) {
+  const lines = [`curl -X POST '${url}' \\`];
+  for (const [k, v] of Object.entries(headers)) {
+    lines.push(`  -H '${k}: ${v}' \\`);
+  }
+  lines.push(`  --data-binary @${bodyFile}`);
+  return lines.join("\n");
+}
+function writeBodyFile(body, name = "last-body.json") {
+  fs4.mkdirSync(STATE_DIR, { recursive: true });
+  const file = path4.join(STATE_DIR, name);
+  fs4.writeFileSync(file, body);
+  return file;
+}
+async function send({ url, headers, body, timeoutMs = 2e4 }) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  const startedAt = Date.now();
+  try {
+    const res = await fetch(url, { method: "POST", headers, body, signal: controller.signal });
+    clearTimeout(timer);
+    const text = await res.text();
+    const result = {
+      ok: res.ok,
+      status: res.status,
+      durationMs: Date.now() - startedAt,
+      body: text,
+      headers: Object.fromEntries(res.headers.entries())
+    };
+    audit("webhook.sent", { url, status: res.status, durationMs: result.durationMs });
+    return result;
+  } catch (err) {
+    clearTimeout(timer);
+    const failure = {
+      ok: false,
+      status: 0,
+      durationMs: Date.now() - startedAt,
+      error: err.name === "AbortError" ? `timed out after ${timeoutMs}ms` : err.message
+    };
+    audit("webhook.failed", { url, error: failure.error });
+    return failure;
+  }
+}
+
+// src/core/dispatch.mjs
+async function dispatch({ cfg, record, force = false, dryRun = false, revalidate = true }) {
+  const rec = record ?? loadLast();
+  if (!rec) throw new ForgeError("nothing to send", { hint: "build a payload first" });
+  const provider = getProvider(rec.provider);
+  let report = null;
+  if (revalidate) {
+    report = await runAll({ payload: rec.payload, body: rec.body, provider, config: cfg, checkImageUrls: false });
+    if (!report.ok && !force) {
+      throw new ForgeError("refusing to send a payload that fails pre-flight", {
+        hint: `blocking: ${report.blocking.map((b) => b.name).join(", ")} \u2014 pass --force to override`
+      });
+    }
+  }
+  const request = buildRequest({ provider, config: cfg, body: rec.body });
+  if (looksLikeProduction(request.url) && !force) {
+    throw new ForgeError(`target looks like production: ${request.url}`, { hint: "pass --force if you really mean it" });
+  }
+  const bodyFile = writeBodyFile(rec.body);
+  const curl = toCurl({ url: request.url, headers: request.headers, bodyFile });
+  if (dryRun) return { dryRun: true, request, bodyFile, curl, report, provider };
+  const result = await send({ url: request.url, headers: request.headers, body: rec.body });
+  return { ...result, dryRun: false, request, bodyFile, curl, report, provider };
+}
+function explainStatus(status) {
+  if (status >= 200 && status < 300) return "accepted \u2014 a 2xx only means it was received; check eventData to confirm the event landed";
+  if (status === 401 || status === 403) return "signature rejected \u2014 the stored webhook_secret does not match the one used to sign";
+  if (status === 404) return "not found \u2014 wrong company id or urlKey in the webhook URL";
+  if (status === 400) return "bad request \u2014 the consumer could not parse the payload";
+  if (status >= 500) return "receiver error \u2014 check the endpoint logs";
+  return "unexpected status";
+}
+
+// src/core/clipboard.mjs
+import { spawn } from "node:child_process";
+var CANDIDATES = [
+  { cmd: "wl-copy", args: [], platforms: ["linux"] },
+  { cmd: "xclip", args: ["-selection", "clipboard"], platforms: ["linux"] },
+  { cmd: "xsel", args: ["--clipboard", "--input"], platforms: ["linux"] },
+  { cmd: "pbcopy", args: [], platforms: ["darwin"] },
+  { cmd: "clip.exe", args: [], platforms: ["linux", "win32"] },
+  { cmd: "clip", args: [], platforms: ["win32"] }
+];
+function pipeTo(cmd, args, text) {
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn(cmd, args, { stdio: ["pipe", "ignore", "ignore"] });
+    } catch {
+      return resolve(false);
+    }
+    child.on("error", () => resolve(false));
+    child.on("close", (code) => resolve(code === 0));
+    try {
+      child.stdin.end(text);
+    } catch {
+      resolve(false);
+    }
+  });
+}
+function osc52(text, stream) {
+  const out = stream ?? (process.stderr.isTTY ? process.stderr : process.stdout);
+  try {
+    const encoded = Buffer.from(text, "utf8").toString("base64");
+    out.write(`\x1B]52;c;${encoded}\x07`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function copy(text, { allowOsc52 = true } = {}) {
+  const platform = process.platform;
+  for (const candidate of CANDIDATES) {
+    if (!candidate.platforms.includes(platform)) continue;
+    const ok = await pipeTo(candidate.cmd, candidate.args, text);
+    if (ok) return { ok: true, via: candidate.cmd };
+  }
+  if (allowOsc52 && (process.stderr.isTTY || process.stdout.isTTY) && osc52(text)) {
+    return { ok: true, via: "terminal (OSC 52)" };
+  }
+  return { ok: false, via: "none" };
+}
+
+// src/ui/screens/Build.jsx
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+var STEP = {
+  LOADING: "loading",
+  PICK: "pick",
+  VARIANT: "variant",
+  QUANTITY: "quantity",
+  DISCOUNT: "discount",
+  MODE: "mode",
+  FIELDS: "fields",
+  BUILDING: "building",
+  REPORT: "report",
+  CONFIRM: "confirm",
+  SENDING: "sending",
+  RESULT: "result",
+  ERROR: "error"
+};
+function Build({ config, providerId = "cashfree-occ", onDone }) {
+  const { exit } = useApp();
+  const [step, setStep] = useState(STEP.LOADING);
+  const [products, setProducts] = useState([]);
+  const [chosen, setChosen] = useState([]);
+  const [cursor, setCursor] = useState(0);
+  const [items, setItems] = useState([]);
+  const [pendingVariant, setPendingVariant] = useState(null);
+  const [draft, setDraft] = useState(null);
+  const [fieldIndex, setFieldIndex] = useState(0);
+  const [edits, setEdits] = useState({});
+  const [built, setBuilt] = useState(null);
+  const [copied, setCopied] = useState(null);
+  const [showPayload, setShowPayload] = useState(true);
+  const [sendResult, setSendResult] = useState(null);
+  const [error, setError] = useState(null);
+  useInput3((input, key) => {
+    if (key.escape) onDone();
+    if ((step === STEP.RESULT || step === STEP.ERROR) && (key.return || input === "q")) onDone();
+    if (step === STEP.REPORT && input === "p") setShowPayload((v) => !v);
+    if (step === STEP.REPORT && input === "c" && built) {
+      copy(built.body).then(setCopied);
+    }
+  });
+  useEffect(() => {
+    let alive = true;
+    fetchCatalogue(config).then((list) => {
+      if (!alive) return;
+      if (!list.length) {
+        setError({ message: "Shopify returned no products", hint: "check that the token has read_products and the store has active products" });
+        setStep(STEP.ERROR);
+        return;
+      }
+      setProducts(list);
+      setStep(STEP.PICK);
+    }).catch((err) => {
+      if (!alive) return;
+      setError({ message: err.message, hint: err.hint });
+      setStep(STEP.ERROR);
+    });
+    return () => {
+      alive = false;
+    };
+  }, []);
+  const advance = (nextItems, nextCursor) => {
+    if (nextCursor >= chosen.length) {
+      setItems(nextItems);
+      setStep(STEP.DISCOUNT);
+      return;
+    }
+    setItems(nextItems);
+    setCursor(nextCursor);
+    const product = chosen[nextCursor];
+    if (product.variants.length > 1) {
+      setStep(STEP.VARIANT);
+    } else {
+      setPendingVariant(product.variants[0]);
+      setStep(STEP.QUANTITY);
+    }
+  };
+  const onProductsPicked = (ids) => {
+    const picked = ids.map((id) => products.find((p) => p.id === id)).filter(Boolean);
+    if (!picked.length) return;
+    setChosen(picked);
+    const first = picked[0];
+    setCursor(0);
+    setItems([]);
+    if (first.variants.length > 1) setStep(STEP.VARIANT);
+    else {
+      setPendingVariant(first.variants[0]);
+      setStep(STEP.QUANTITY);
+    }
+  };
+  const onVariantPicked = (variantId) => {
+    const product = chosen[cursor];
+    setPendingVariant(product.variants.find((v) => v.id === variantId) ?? product.variants[0]);
+    setStep(STEP.QUANTITY);
+  };
+  const onQuantity = (raw) => {
+    const qty = Math.max(1, Number.parseInt(raw, 10) || 1);
+    const product = chosen[cursor];
+    const nextItems = [...items, { product, variant: pendingVariant, quantity: qty }];
+    advance(nextItems, cursor + 1);
+  };
+  const onDiscount = (raw) => {
+    const discount = Math.max(0, Number.parseFloat(raw) || 0);
+    try {
+      const next = draftPayload({ cfg: config, providerId, items, discount });
+      setDraft({ ...next, discount });
+      setStep(STEP.MODE);
+    } catch (err) {
+      setError({ message: err.message, hint: err.hint });
+      setStep(STEP.ERROR);
+    }
+  };
+  const finalise = (payload) => {
+    setStep(STEP.BUILDING);
+    buildPayload2({ cfg: config, providerId, items, discount: draft.discount, payload }).then(async (result) => {
+      setBuilt(result);
+      if (config.defaults.copyToClipboard !== false) {
+        setCopied(await copy(result.body));
+      }
+      setStep(STEP.REPORT);
+    }).catch((err) => {
+      setError({ message: err.message, hint: err.hint });
+      setStep(STEP.ERROR);
+    });
+  };
+  const onMode = (mode) => {
+    if (mode === "accept") return finalise(draft.payload);
+    setFieldIndex(0);
+    setEdits({});
+    setStep(STEP.FIELDS);
+  };
+  const onFieldSubmit = (raw) => {
+    const field = draft.fields[fieldIndex];
+    const nextEdits = { ...edits, [field.path]: raw };
+    setEdits(nextEdits);
+    if (fieldIndex + 1 < draft.fields.length) {
+      setFieldIndex(fieldIndex + 1);
+      return;
+    }
+    finalise(applyEdits(draft.payload, draft.fields, nextEdits));
+  };
+  const doSend = () => {
+    setStep(STEP.SENDING);
+    dispatch({ cfg: config, record: { provider: built.provider.id, payload: built.payload, body: built.body } }).then((result) => {
+      setSendResult(result);
+      setStep(STEP.RESULT);
+    }).catch((err) => {
+      setError({ message: err.message, hint: err.hint });
+      setStep(STEP.ERROR);
+    });
+  };
+  const store = config.shopify.domain;
+  const currency = config.defaults.currency;
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx7(
+      Header,
+      {
+        title: "Build payload",
+        subtitle: `${metaFor(providerId).label} \xB7 abandoned checkout`,
+        right: store
+      }
+    ),
+    step === STEP.LOADING && /* @__PURE__ */ jsx7(Spinner, { label: `fetching live products from ${store}\u2026` }),
+    step === STEP.PICK && /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs7(Text7, { children: [
+        `Select the products in the abandoned cart `,
+        /* @__PURE__ */ jsx7(Text7, { color: palette.dim, children: "(space toggles \xB7 enter confirms)" })
+      ] }),
+      /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx7(
+        MultiSelect,
+        {
+          visibleOptionCount: 10,
+          options: products.map((p) => ({
+            label: `${truncate(p.title, 44).padEnd(45)} ${money(p.variants[0]?.price, currency)}`,
+            value: p.id
+          })),
+          onSubmit: onProductsPicked
+        }
+      ) })
+    ] }),
+    step === STEP.VARIANT && /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs7(Text7, { children: [
+        `Variant for `,
+        /* @__PURE__ */ jsx7(Text7, { bold: true, color: palette.accent, children: chosen[cursor]?.title })
+      ] }),
+      /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx7(
+        Select4,
+        {
+          visibleOptionCount: 8,
+          options: chosen[cursor].variants.map((v) => ({
+            label: `${truncate(v.title, 34).padEnd(35)} ${money(v.price, currency)}${v.sku ? "  " + v.sku : ""}`,
+            value: v.id
+          })),
+          onChange: onVariantPicked
+        },
+        `variant-${cursor}`
+      ) })
+    ] }),
+    step === STEP.QUANTITY && /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs7(Text7, { children: [
+        `Quantity for `,
+        /* @__PURE__ */ jsx7(Text7, { bold: true, color: palette.accent, children: chosen[cursor]?.title }),
+        /* @__PURE__ */ jsx7(Text7, { color: palette.dim, children: pendingVariant?.title ? ` \xB7 ${pendingVariant.title}` : "" })
+      ] }),
+      /* @__PURE__ */ jsxs7(Box7, { marginTop: 1, children: [
+        /* @__PURE__ */ jsx7(Text7, { color: palette.accent, children: "\u276F " }),
+        /* @__PURE__ */ jsx7(TextInput, { defaultValue: "1", placeholder: "1", onSubmit: onQuantity }, `qty-${cursor}`)
+      ] })
+    ] }),
+    step === STEP.DISCOUNT && /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs7(Text7, { children: [
+        `Cart discount in ${currency} `,
+        /* @__PURE__ */ jsx7(Text7, { color: palette.dim, children: "(0 for none)" })
+      ] }),
+      /* @__PURE__ */ jsxs7(Box7, { marginTop: 1, children: [
+        /* @__PURE__ */ jsx7(Text7, { color: palette.accent, children: "\u276F " }),
+        /* @__PURE__ */ jsx7(TextInput, { defaultValue: "0", placeholder: "0", onSubmit: onDiscount })
+      ] })
+    ] }),
+    step === STEP.MODE && draft && /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", borderStyle: "round", borderColor: palette.accent, paddingX: 1, marginBottom: 1, children: [
+        /* @__PURE__ */ jsx7(Text7, { color: palette.dim, children: `${draft.fields.length} fields have been filled in from Shopify and your profile.` }),
+        /* @__PURE__ */ jsx7(Text7, { color: palette.dim, children: "Review them one by one, or accept the suggestions as they are." })
+      ] }),
+      /* @__PURE__ */ jsx7(
+        Select4,
+        {
+          options: [
+            { label: "Use the suggested values".padEnd(30) + "fastest", value: "accept" },
+            { label: "Review every field".padEnd(30) + "enter accepts \xB7 type to change", value: "review" }
+          ],
+          onChange: onMode
+        }
+      )
+    ] }),
+    step === STEP.FIELDS && draft && /* @__PURE__ */ jsx7(
+      FieldPrompt,
+      {
+        field: draft.fields[fieldIndex],
+        index: fieldIndex,
+        total: draft.fields.length,
+        value: edits[draft.fields[fieldIndex].path] ?? draft.fields[fieldIndex].value,
+        onSubmit: onFieldSubmit
+      }
+    ),
+    step === STEP.BUILDING && /* @__PURE__ */ jsx7(Spinner, { label: "assembling payload, verifying images and signature fidelity\u2026" }),
+    (step === STEP.REPORT || step === STEP.CONFIRM) && built && /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx7(Summary, { built, currency }),
+      /* @__PURE__ */ jsx7(Section, { title: "Pre-flight", children: /* @__PURE__ */ jsx7(CheckList, { checks: built.report.checks }) }),
+      /* @__PURE__ */ jsx7(Section, { title: "Field coverage", children: /* @__PURE__ */ jsx7(FieldTable, { coverage: built.report.coverage }) }),
+      /* @__PURE__ */ jsx7(Section, { title: "Request", children: /* @__PURE__ */ jsx7(RequestPreview, { config, built }) }),
+      showPayload ? /* @__PURE__ */ jsx7(Section, { title: "Payload", children: /* @__PURE__ */ jsx7(Box7, { borderStyle: "round", borderColor: palette.dim, paddingX: 1, flexDirection: "column", children: /* @__PURE__ */ jsx7(Text7, { color: palette.dim, children: JSON.stringify(built.payload, null, 2) }) }) }) : null,
+      /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: copied?.ok ? /* @__PURE__ */ jsx7(Text7, { color: palette.ok, children: `\u2714 payload copied to clipboard via ${copied.via}` }) : /* @__PURE__ */ jsx7(Text7, { color: palette.dim, children: `payload saved to ${built.file} \xB7 press c to copy` }) }),
+      /* @__PURE__ */ jsx7(Box7, { children: /* @__PURE__ */ jsx7(Text7, { color: palette.dim, children: "p toggles the full payload \xB7 c copies it" }) }),
+      /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: built.report.ok ? /* @__PURE__ */ jsx7(Alert, { variant: "success", children: "payload is valid \u2014 the event will pass the schema gate and signature check" }) : /* @__PURE__ */ jsx7(Alert, { variant: "error", children: `blocking: ${built.report.blocking.map((b) => b.name).join(", ")}` }) }),
+      /* @__PURE__ */ jsxs7(Box7, { marginTop: 1, children: [
+        /* @__PURE__ */ jsx7(Text7, { children: "Send it to the endpoint now? " }),
+        /* @__PURE__ */ jsx7(
+          ConfirmInput,
+          {
+            isDisabled: !built.report.ok,
+            onConfirm: doSend,
+            onCancel: () => onDone()
+          }
+        )
+      ] }),
+      !built.report.ok && /* @__PURE__ */ jsx7(Text7, { color: palette.dim, children: "  sending is disabled while pre-flight fails \u2014 fix the payload, or use the CLI with --force" })
+    ] }),
+    step === STEP.SENDING && /* @__PURE__ */ jsx7(Spinner, { label: "signing and POSTing the webhook\u2026" }),
+    step === STEP.RESULT && sendResult && /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs7(Box7, { marginBottom: 1, children: [
+        sendResult.ok ? /* @__PURE__ */ jsx7(Badge, { color: "green", children: `HTTP ${sendResult.status}` }) : /* @__PURE__ */ jsx7(Badge, { color: "red", children: sendResult.error ? "FAILED" : `HTTP ${sendResult.status}` }),
+        /* @__PURE__ */ jsx7(Text7, { children: " " }),
+        /* @__PURE__ */ jsx7(Text7, { color: palette.dim, children: sendResult.error ?? explainStatus(sendResult.status) })
+      ] }),
+      /* @__PURE__ */ jsx7(
+        KeyValue,
+        {
+          rows: [
+            ["url", sendResult.request.url],
+            ["timestamp", sendResult.request.timestamp],
+            ["signature", truncate(sendResult.request.signature, 44)],
+            ["took", `${sendResult.durationMs}ms`],
+            ["response", truncate(String(sendResult.body ?? "\u2014"), 60)],
+            ["payload", built.file]
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsxs7(Box7, { marginTop: 1, flexDirection: "column", children: [
+        /* @__PURE__ */ jsx7(Text7, { color: palette.dim, children: "reproduce:" }),
+        /* @__PURE__ */ jsx7(Text7, { color: palette.dim, children: sendResult.curl })
+      ] }),
+      /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx7(Text7, { color: palette.dim, children: "press enter to return to the menu" }) })
+    ] }),
+    step === STEP.ERROR && error && /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx7(Alert, { variant: "error", children: error.message }),
+      error.hint ? /* @__PURE__ */ jsx7(Text7, { color: palette.warn, children: `  ${error.hint}` }) : null,
+      /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx7(Text7, { color: palette.dim, children: "press enter to return to the menu" }) })
+    ] })
+  ] });
+}
+function RequestPreview({ config, built }) {
+  let request = null;
+  try {
+    request = buildRequest({ provider: built.provider, config, body: built.body });
+  } catch {
+    request = null;
+  }
+  if (!request) return /* @__PURE__ */ jsx7(Text7, { color: palette.dim, children: "  destination not configured" });
+  return /* @__PURE__ */ jsx7(
+    KeyValue,
+    {
+      keyWidth: 22,
+      rows: [
+        ["POST", truncate(request.url, 56)],
+        ["x-webhook-timestamp", request.timestamp],
+        ["x-webhook-signature", truncate(request.signature, 46)],
+        ["body", `${built.body.length} bytes`]
+      ]
+    }
+  );
+}
+function FieldPrompt({ field, index, total, value, onSubmit }) {
+  const filled = Math.round(index / total * 30);
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs7(Box7, { children: [
+      /* @__PURE__ */ jsx7(Text7, { color: palette.accent, children: "\u2588".repeat(filled) }),
+      /* @__PURE__ */ jsx7(Text7, { color: palette.dim, children: "\u2591".repeat(30 - filled) }),
+      /* @__PURE__ */ jsx7(Text7, { color: palette.dim, children: `  ${index + 1}/${total}  ${field.group}` })
+    ] }),
+    /* @__PURE__ */ jsxs7(Box7, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx7(Text7, { bold: true, color: palette.heading, children: field.label }),
+      field.hint ? /* @__PURE__ */ jsx7(Text7, { color: palette.dim, children: `  ${field.hint}` }) : null,
+      field.optional ? /* @__PURE__ */ jsx7(Text7, { color: palette.dim, children: "  optional" }) : null
+    ] }),
+    /* @__PURE__ */ jsxs7(Box7, { marginTop: 1, children: [
+      /* @__PURE__ */ jsx7(Text7, { color: palette.accent, children: "\u276F " }),
+      /* @__PURE__ */ jsx7(
+        TextInput,
+        {
+          defaultValue: value == null ? "" : String(value),
+          placeholder: field.optional ? "(leave blank)" : "",
+          onSubmit
+        },
+        field.path
+      )
+    ] }),
+    /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx7(Text7, { color: palette.dim, children: "enter accepts the suggestion \xB7 edit the text to change it" }) })
+  ] });
+}
+function Summary({ built, currency }) {
+  const d = built.payload.data;
+  return /* @__PURE__ */ jsx7(Box7, { flexDirection: "column", borderStyle: "round", borderColor: palette.ok, paddingX: 1, children: /* @__PURE__ */ jsx7(
+    KeyValue,
+    {
+      rows: [
+        ["type", built.payload.type],
+        ["store", d.store_url],
+        ["customer", `${d.customer.shipping_address.customer_name} \xB7 ${d.phone}`],
+        ["items", d.line_items.map((i) => `${truncate(i.name, 28)} \xD7${i.quantity}`).join(", ")],
+        ["total", `${money(d.total_price, d.line_items[0]?.currency ?? currency)}  (was ${money(d.original_total_price)} \xB7 discount ${money(d.total_discount)})`],
+        ["checkout", truncate(d.abandoned_checkout_url, 58)],
+        ["saved", built.file]
+      ]
+    }
+  ) });
+}
+
+// src/ui/screens/Configure.jsx
+import React8, { useState as useState2 } from "react";
+import { Box as Box8, Text as Text8, useInput as useInput4 } from "ink";
+import { Spinner as Spinner2, TextInput as TextInput2, PasswordInput, Select as Select5, Alert as Alert2 } from "@inkjs/ui";
+import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
+var FIELDS = [
+  { group: "Customer", key: "customer.firstName", label: "First name", placeholder: "Test" },
+  { group: "Customer", key: "customer.lastName", label: "Last name", placeholder: "Shopper" },
+  { group: "Customer", key: "customer.email", label: "Email" },
+  { group: "Customer", key: "customer.countryCode", label: "Country code", placeholder: "IN", transform: (v) => v.toUpperCase() },
+  { group: "Customer", key: "customer.phone", label: "Phone", hint: "the handset that will receive the message" },
+  { group: "Customer", key: "customer.address1", label: "Address line 1" },
+  { group: "Customer", key: "customer.address2", label: "Address line 2", optional: true },
+  { group: "Customer", key: "customer.city", label: "City" },
+  { group: "Customer", key: "customer.province", label: "Province / state" },
+  { group: "Customer", key: "customer.provinceCode", label: "Province code", optional: true },
+  { group: "Customer", key: "customer.country", label: "Country name", placeholder: "India" },
+  { group: "Customer", key: "customer.zip", label: "Zip / postcode" },
+  { group: "Defaults", key: "defaults.currency", label: "Currency", placeholder: "INR", transform: (v) => v.toUpperCase() },
+  { group: "Defaults", key: "defaults.platform", label: "Platform", placeholder: "shopify" }
+];
+var SECTION_HINTS = {
+  Customer: "the shopper the abandoned cart belongs to",
+  Defaults: "currency, platform"
+};
+var get = (obj, path6) => path6.split(".").reduce((a, k) => a == null ? void 0 : a[k], obj);
+var set = (obj, path6, value) => {
+  const keys = path6.split(".");
+  const last = keys.pop();
+  const target = keys.reduce((a, k) => a[k] ??= {}, obj);
+  target[last] = value;
+  return obj;
+};
+function Configure({ config, section: initialSection, onDone }) {
+  const [draft] = useState2(() => structuredClone(config));
+  const [section, setSection] = useState2(initialSection ?? null);
+  const [index, setIndex] = useState2(0);
+  const [phase, setPhase] = useState2("form");
+  const [verifyMsg, setVerifyMsg] = useState2(null);
+  const fields = section ? FIELDS.filter((f) => f.group.toLowerCase() === section.toLowerCase()) : [];
+  useInput4((input, key) => {
+    if (key.escape) onDone();
+    if (phase === "done" && (key.return || input === "q")) onDone(draft);
+  });
+  const field = fields[index];
+  const commit = (raw) => {
+    const value = field.transform ? field.transform(String(raw ?? "").trim()) : String(raw ?? "").trim();
+    set(draft, field.key, value);
+    if (field.key === "customer.phone") {
+      const parsed = toE164(value, get(draft, "customer.countryCode"));
+      if (parsed.ok) {
+        set(draft, "customer.phone", parsed.value);
+        if (!draft.allowedPhones.includes(parsed.value)) draft.allowedPhones.push(parsed.value);
+      }
+    }
+    if (index + 1 < fields.length) {
+      setIndex(index + 1);
+      return;
+    }
+    finish();
+  };
+  const finish = () => {
+    {
+      const file = saveConfig(draft);
+      setVerifyMsg({ ok: true, text: `${section} settings saved`, file });
+      setPhase("done");
+      return;
+    }
+    setPhase("verifying");
+    verifyStore(draft).then(({ shop, count }) => {
+      if (shop?.currency) draft.defaults.currency = shop.currency;
+      setVerifyMsg({ ok: true, text: `connected to ${shop?.name} \xB7 ${shop?.currency} \xB7 ${count ?? "?"} products` });
+    }).catch((err) => setVerifyMsg({ ok: false, text: err.message, hint: err.hint })).finally(() => {
+      const file = saveConfig(draft);
+      setVerifyMsg((m) => ({ ...m, file }));
+      setPhase("done");
+    });
+  };
+  if (!section) {
+    return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx8(Header, { title: "Configure", subtitle: "pick what you want to change", right: "esc to go back" }),
+      /* @__PURE__ */ jsx8(
+        Select5,
+        {
+          visibleOptionCount: 8,
+          options: Object.entries(SECTION_HINTS).map(([key, hint]) => ({
+            label: `${key.padEnd(10)} ${hint}`,
+            value: key
+          })),
+          onChange: (value) => {
+            setSection(value);
+            setIndex(0);
+          }
+        }
+      )
+    ] });
+  }
+  if (phase === "verifying") {
+    return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx8(Header, { title: "Configure", subtitle: "verifying credentials" }),
+      /* @__PURE__ */ jsx8(Spinner2, { label: "contacting Shopify\u2026" })
+    ] });
+  }
+  if (phase === "done") {
+    return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx8(Header, { title: "Configure", subtitle: "saved" }),
+      /* @__PURE__ */ jsx8(Alert2, { variant: verifyMsg?.ok ? "success" : "warning", children: verifyMsg?.text ?? "saved" }),
+      verifyMsg?.hint ? /* @__PURE__ */ jsx8(Text8, { color: palette.warn, children: `  ${verifyMsg.hint}` }) : null,
+      /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: /* @__PURE__ */ jsx8(Text8, { color: palette.dim, children: `config written to ${verifyMsg?.file} (chmod 600)` }) }),
+      /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: /* @__PURE__ */ jsx8(Text8, { color: palette.dim, children: "press enter to return to the menu" }) })
+    ] });
+  }
+  const current = get(draft, field.key) ?? "";
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx8(Header, { title: "Configure", subtitle: `${field.group} \xB7 step ${index + 1} of ${fields.length}`, right: "esc to cancel" }),
+    /* @__PURE__ */ jsx8(Progress, { index, total: fields.length }),
+    /* @__PURE__ */ jsxs8(Section, { title: field.label, children: [
+      field.hint ? /* @__PURE__ */ jsx8(Text8, { color: palette.dim, children: `  ${field.hint}` }) : null,
+      /* @__PURE__ */ jsxs8(Box8, { marginTop: 1, children: [
+        /* @__PURE__ */ jsx8(Text8, { color: palette.accent, children: `${glyph.pointer} ` }),
+        field.type === "select" ? /* @__PURE__ */ jsx8(
+          Select5,
+          {
+            options: field.options,
+            defaultValue: current || void 0,
+            onChange: commit
+          },
+          field.key
+        ) : field.secret ? /* @__PURE__ */ jsx8(PasswordInput, { placeholder: current ? mask(current) : "\u2022\u2022\u2022\u2022\u2022\u2022", onSubmit: (v) => commit(v || current) }, field.key) : /* @__PURE__ */ jsx8(
+          TextInput2,
+          {
+            defaultValue: current,
+            placeholder: field.placeholder ?? (field.optional ? "(optional)" : ""),
+            onSubmit: (v) => commit(v || current)
+          },
+          field.key
+        )
+      ] })
+    ] })
+  ] });
+}
+function Progress({ index, total }) {
+  const filled = Math.round(index / total * 30);
+  return /* @__PURE__ */ jsxs8(Box8, { children: [
+    /* @__PURE__ */ jsx8(Text8, { color: palette.accent, children: "\u2588".repeat(filled) }),
+    /* @__PURE__ */ jsx8(Text8, { color: palette.dim, children: "\u2591".repeat(30 - filled) }),
+    /* @__PURE__ */ jsx8(Text8, { color: palette.dim, children: `  ${index}/${total}` })
+  ] });
+}
+
+// src/ui/screens/ConnectShopify.jsx
+import React9, { useState as useState3 } from "react";
+import { Box as Box9, Text as Text9, useInput as useInput5 } from "ink";
+import { Spinner as Spinner3, TextInput as TextInput3, PasswordInput as PasswordInput2, Alert as Alert3, Badge as Badge2 } from "@inkjs/ui";
+import { jsx as jsx9, jsxs as jsxs9 } from "react/jsx-runtime";
+var STEP2 = { DOMAIN: "domain", TOKEN: "token", VERIFY: "verify", DONE: "done", FAILED: "failed" };
+function ConnectShopify({ config, onDone }) {
+  const [draft] = useState3(() => structuredClone(config));
+  const [step, setStep] = useState3(STEP2.DOMAIN);
+  const [result, setResult] = useState3(null);
+  const [error, setError] = useState3(null);
+  useInput5((input, key) => {
+    if (key.escape) onDone();
+    if (step === STEP2.DONE && (key.return || input === "q")) onDone(draft);
+    if (step === STEP2.FAILED && (key.return || input === "q")) setStep(STEP2.DOMAIN);
+  });
+  const onDomain = (value) => {
+    draft.shopify.domain = normalizeDomain(value || draft.shopify.domain);
+    if (!draft.shopify.domain) return;
+    setStep(STEP2.TOKEN);
+  };
+  const onToken = (value) => {
+    draft.shopify.accessToken = value || draft.shopify.accessToken;
+    if (!draft.shopify.accessToken) return;
+    setStep(STEP2.VERIFY);
+    verifyStore(draft).then(({ shop, count }) => {
+      const applied = applyShopDefaults(draft, shop, count);
+      setResult({ shop, count, applied });
+      saveConfig(draft);
+      setStep(STEP2.DONE);
+    }).catch((err) => {
+      setError({ message: err.message, hint: err.hint });
+      setStep(STEP2.FAILED);
+    });
+  };
+  return /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx9(Header, { title: "Connect Shopify", subtitle: "the catalogue every payload is built from", right: "esc to cancel" }),
+    step === STEP2.DOMAIN && /* @__PURE__ */ jsxs9(Section, { title: "Store domain", children: [
+      /* @__PURE__ */ jsx9(Text9, { color: palette.dim, children: "  the myshopify.com domain, not your custom domain" }),
+      /* @__PURE__ */ jsxs9(Box9, { marginTop: 1, children: [
+        /* @__PURE__ */ jsx9(Text9, { color: palette.accent, children: `${glyph.pointer} ` }),
+        /* @__PURE__ */ jsx9(
+          TextInput3,
+          {
+            defaultValue: draft.shopify.domain,
+            placeholder: "your-store.myshopify.com",
+            onSubmit: onDomain
+          }
+        )
+      ] })
+    ] }),
+    step === STEP2.TOKEN && /* @__PURE__ */ jsxs9(Section, { title: "Admin API access token", children: [
+      /* @__PURE__ */ jsx9(Text9, { color: palette.dim, children: "  Shopify admin \u2192 Settings \u2192 Apps and sales channels \u2192 Develop apps" }),
+      /* @__PURE__ */ jsx9(Text9, { color: palette.dim, children: "  the token needs the read_products scope" }),
+      /* @__PURE__ */ jsxs9(Box9, { marginTop: 1, children: [
+        /* @__PURE__ */ jsx9(Text9, { color: palette.accent, children: `${glyph.pointer} ` }),
+        /* @__PURE__ */ jsx9(
+          PasswordInput2,
+          {
+            placeholder: draft.shopify.accessToken ? mask(draft.shopify.accessToken) : "shpat_\u2026",
+            onSubmit: onToken
+          }
+        )
+      ] })
+    ] }),
+    step === STEP2.VERIFY && /* @__PURE__ */ jsx9(Spinner3, { label: `connecting to ${draft.shopify.domain}\u2026` }),
+    step === STEP2.DONE && result && /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs9(Box9, { marginBottom: 1, children: [
+        /* @__PURE__ */ jsx9(Badge2, { color: "green", children: "CONNECTED" }),
+        /* @__PURE__ */ jsx9(Text9, { children: "  " }),
+        /* @__PURE__ */ jsx9(Text9, { bold: true, children: result.shop?.name })
+      ] }),
+      /* @__PURE__ */ jsx9(Box9, { flexDirection: "column", borderStyle: "round", borderColor: palette.ok, paddingX: 1, children: /* @__PURE__ */ jsx9(
+        KeyValue,
+        {
+          keyWidth: 16,
+          rows: [
+            ["domain", result.shop?.myshopify_domain ?? draft.shopify.domain],
+            ["storefront", result.shop?.domain ?? "\u2014"],
+            ["products", String(result.count ?? "?")],
+            ["currency", result.shop?.currency ?? "\u2014"],
+            ["country", `${result.shop?.country_name ?? "\u2014"} (${result.shop?.country_code ?? "\u2014"})`],
+            ["timezone", result.shop?.iana_timezone ?? "\u2014"],
+            ["plan", result.shop?.plan_display_name ?? "\u2014"],
+            ["contact", result.shop?.email ?? "\u2014"]
+          ]
+        }
+      ) }),
+      result.applied.length ? /* @__PURE__ */ jsx9(Section, { title: "Picked up from the store", children: result.applied.map((line, i) => /* @__PURE__ */ jsx9(Text9, { color: palette.dim, children: `  ${glyph.tick} ${line}` }, i)) }) : null,
+      /* @__PURE__ */ jsx9(Box9, { marginTop: 1, children: /* @__PURE__ */ jsx9(Alert3, { variant: "success", children: "Shopify connected \u2014 you can browse the real catalogue now" }) }),
+      /* @__PURE__ */ jsx9(Box9, { marginTop: 1, children: /* @__PURE__ */ jsx9(Text9, { color: palette.dim, children: "press enter to continue" }) })
+    ] }),
+    step === STEP2.FAILED && error && /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx9(Alert3, { variant: "error", children: error.message }),
+      error.hint ? /* @__PURE__ */ jsx9(Text9, { color: palette.warn, children: `  ${error.hint}` }) : null,
+      /* @__PURE__ */ jsxs9(Box9, { marginTop: 1, flexDirection: "column", children: [
+        /* @__PURE__ */ jsx9(Text9, { color: palette.dim, children: "  common causes:" }),
+        /* @__PURE__ */ jsx9(Text9, { color: palette.dim, children: "  \xB7 the token is missing the read_products scope" }),
+        /* @__PURE__ */ jsx9(Text9, { color: palette.dim, children: "  \xB7 the token belongs to a different store" }),
+        /* @__PURE__ */ jsx9(Text9, { color: palette.dim, children: "  \xB7 the domain is the custom domain, not the .myshopify.com one" })
+      ] }),
+      /* @__PURE__ */ jsx9(Box9, { marginTop: 1, children: /* @__PURE__ */ jsx9(Text9, { color: palette.dim, children: "press enter to try again" }) })
+    ] })
+  ] });
+}
+
+// src/ui/screens/Webhook.jsx
+import React10, { useState as useState4 } from "react";
+import { Box as Box10, Text as Text10, useInput as useInput6 } from "ink";
+import { Select as Select6, TextInput as TextInput4, PasswordInput as PasswordInput3, Alert as Alert4, Badge as Badge3, Spinner as Spinner4 } from "@inkjs/ui";
+import { jsx as jsx10, jsxs as jsxs10 } from "react/jsx-runtime";
+var STEP3 = { PICK: "pick", URL: "url", SECRET: "secret", PROBE: "probe", DONE: "done" };
+function Webhook({ config, onDone }) {
+  const [draft] = useState4(() => structuredClone(config));
+  const [providerId, setProviderId] = useState4(null);
+  const [step, setStep] = useState4(STEP3.PICK);
+  const [probe, setProbe] = useState4(null);
+  const [urlError, setUrlError] = useState4(null);
+  useInput6((input, key) => {
+    if (key.escape) {
+      if (step === STEP3.PICK) onDone(draft);
+      else {
+        setStep(STEP3.PICK);
+        setProviderId(null);
+      }
+    }
+    if (step === STEP3.DONE && (key.return || input === "q")) {
+      setStep(STEP3.PICK);
+      setProviderId(null);
+    }
+  });
+  const meta = providerId ? metaFor(providerId) : null;
+  const target = providerId ? targetFor(draft, providerId) : null;
+  const onUrl = (value) => {
+    const url = (value || target.webhookUrl || "").trim();
+    if (!/^https?:\/\/.+/i.test(url)) {
+      setUrlError("must be a full URL starting with http:// or https://");
+      return;
+    }
+    setUrlError(null);
+    setTarget(draft, providerId, { webhookUrl: url });
+    setStep(STEP3.SECRET);
+  };
+  const onSecret = (value) => {
+    setTarget(draft, providerId, { webhookSecret: value || target.webhookSecret });
+    saveConfig(draft);
+    setStep(STEP3.PROBE);
+    probeEndpoint(targetFor(draft, providerId).webhookUrl).then(setProbe).finally(() => setStep(STEP3.DONE));
+  };
+  if (step === STEP3.PICK) {
+    const options = [
+      ...listProviderMeta().map((p) => {
+        const t = targetFor(draft, p.id);
+        return {
+          label: p.label.padEnd(30) + (t.webhookUrl ? truncate(t.webhookUrl, 34) : "not set"),
+          value: p.id
+        };
+      }),
+      { label: "Back".padEnd(30), value: "__back" }
+    ];
+    return /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx10(Header, { title: "Webhook destinations", subtitle: "one endpoint and secret per integration", right: "esc to go back" }),
+      /* @__PURE__ */ jsx10(
+        Select6,
+        {
+          visibleOptionCount: options.length,
+          options,
+          onChange: (v) => {
+            if (v === "__back") return onDone(draft);
+            setProviderId(v);
+            setUrlError(null);
+            setStep(STEP3.URL);
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx10(Box10, { marginTop: 1, children: /* @__PURE__ */ jsx10(Text10, { color: palette.dim, children: `${glyph.dot} set globally \u2014 every build for that provider uses it` }) })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx10(Header, { title: meta.label, subtitle: `signature: ${meta.signature}`, right: "esc to cancel" }),
+    step === STEP3.URL && /* @__PURE__ */ jsxs10(Section, { title: "Webhook URL", children: [
+      /* @__PURE__ */ jsx10(Text10, { color: palette.dim, children: "  the full endpoint the provider would call \u2014 paste it as-is" }),
+      urlError ? /* @__PURE__ */ jsx10(Text10, { color: palette.bad, children: `  ${glyph.cross} ${urlError}` }) : null,
+      /* @__PURE__ */ jsxs10(Box10, { marginTop: 1, children: [
+        /* @__PURE__ */ jsx10(Text10, { color: palette.accent, children: `${glyph.pointer} ` }),
+        /* @__PURE__ */ jsx10(
+          TextInput4,
+          {
+            defaultValue: target.webhookUrl,
+            placeholder: "https://your-endpoint.example.com/webhook/\u2026",
+            onSubmit: onUrl
+          }
+        )
+      ] })
+    ] }),
+    step === STEP3.SECRET && /* @__PURE__ */ jsxs10(Section, { title: meta.id === "nitro" ? "Bearer token" : "Signing secret", children: [
+      /* @__PURE__ */ jsx10(Text10, { color: palette.dim, children: `  sent as ${meta.header}` }),
+      /* @__PURE__ */ jsx10(Text10, { color: palette.dim, children: "  must match what the receiver has stored" }),
+      /* @__PURE__ */ jsxs10(Box10, { marginTop: 1, children: [
+        /* @__PURE__ */ jsx10(Text10, { color: palette.accent, children: `${glyph.pointer} ` }),
+        /* @__PURE__ */ jsx10(
+          PasswordInput3,
+          {
+            placeholder: target.webhookSecret ? mask(target.webhookSecret) : "the signing secret\u2026",
+            onSubmit: onSecret
+          }
+        )
+      ] })
+    ] }),
+    step === STEP3.PROBE && /* @__PURE__ */ jsx10(Spinner4, { label: "checking the endpoint is reachable\u2026" }),
+    step === STEP3.DONE && /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs10(Box10, { marginBottom: 1, children: [
+        /* @__PURE__ */ jsx10(Badge3, { color: probe?.reachable ? "green" : "yellow", children: probe?.reachable ? "REACHABLE" : "UNVERIFIED" }),
+        /* @__PURE__ */ jsx10(Text10, { children: "  " }),
+        /* @__PURE__ */ jsx10(Text10, { color: palette.dim, children: probe?.reachable ? `responded HTTP ${probe.status} to an unsigned probe` : probe?.error ?? "could not reach it \u2014 saved anyway" })
+      ] }),
+      /* @__PURE__ */ jsx10(Box10, { flexDirection: "column", borderStyle: "round", borderColor: palette.ok, paddingX: 1, children: /* @__PURE__ */ jsx10(
+        KeyValue,
+        {
+          keyWidth: 10,
+          rows: [
+            ["provider", meta.label],
+            ["url", truncate(targetFor(draft, providerId).webhookUrl, 58)],
+            ["secret", targetFor(draft, providerId).webhookSecret ? mask(targetFor(draft, providerId).webhookSecret) : "none \u2014 signature will be skipped"]
+          ]
+        }
+      ) }),
+      !meta.available ? /* @__PURE__ */ jsx10(Box10, { marginTop: 1, children: /* @__PURE__ */ jsx10(Alert4, { variant: "info", children: `saved \u2014 ${meta.label} payload generation is not implemented yet` }) }) : null,
+      /* @__PURE__ */ jsx10(Box10, { marginTop: 1, children: /* @__PURE__ */ jsx10(Text10, { color: palette.dim, children: "press enter to configure another" }) })
+    ] })
+  ] });
+}
+async function probeEndpoint(url) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 1e4);
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ type: "FORGE_PROBE" }),
+      signal: controller.signal
+    });
+    clearTimeout(timer);
+    return { reachable: true, status: res.status };
+  } catch (err) {
+    clearTimeout(timer);
+    return { reachable: false, error: err.name === "AbortError" ? "timed out" : err.message };
+  }
+}
+
+// src/ui/screens/Doctor.jsx
+import React11, { useEffect as useEffect2, useState as useState5 } from "react";
+import { Box as Box11, Text as Text11, useInput as useInput7 } from "ink";
+import { Spinner as Spinner5 } from "@inkjs/ui";
+import { jsx as jsx11, jsxs as jsxs11 } from "react/jsx-runtime";
+function Doctor({ config, onDone }) {
+  const [checks, setChecks] = useState5(null);
+  useInput7((input, key) => {
+    if (key.escape || key.return || input === "q") onDone();
+  });
+  useEffect2(() => {
+    let alive = true;
+    run(config).then((result) => alive && setChecks(result));
+    return () => {
+      alive = false;
+    };
+  }, []);
+  return /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx11(Header, { title: "Doctor", subtitle: "everything the generator depends on" }),
+    !checks ? /* @__PURE__ */ jsx11(Spinner5, { label: "running checks\u2026" }) : /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx11(Section, { title: "Configuration", children: /* @__PURE__ */ jsx11(CheckList, { checks: checks.config }) }),
+      /* @__PURE__ */ jsx11(Section, { title: "Connectivity", children: /* @__PURE__ */ jsx11(CheckList, { checks: checks.connectivity }) }),
+      /* @__PURE__ */ jsx11(Section, { title: "Runtime", children: /* @__PURE__ */ jsx11(CheckList, { checks: checks.runtime }) }),
+      /* @__PURE__ */ jsx11(Box11, { marginTop: 1, children: /* @__PURE__ */ jsx11(Text11, { color: palette.dim, children: "press enter to return to the menu" }) })
+    ] })
+  ] });
+}
+async function run(config) {
+  const cfgChecks = configStatus(config).map((row) => ({
+    name: row.key,
+    ok: row.ok,
+    detail: row.value ? row.secret ? mask(row.value) : row.value : "not set"
+  }));
+  const connectivity = [];
+  if (config.shopify.domain && config.shopify.accessToken) {
+    try {
+      const { shop, count } = await verifyStore(config);
+      connectivity.push({ name: "Shopify", ok: true, detail: `${shop?.name} \xB7 ${shop?.currency} \xB7 ${count ?? "?"} products` });
+    } catch (err) {
+      connectivity.push({ name: "Shopify", ok: false, detail: err.message });
+    }
+  } else {
+    connectivity.push({ name: "Shopify", ok: false, detail: "not configured" });
+  }
+  const url = getProvider("cashfree-occ").webhookUrl(config);
+  if (url) {
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), 12e3);
+      const res = await fetch(url, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ type: "FORGE_PROBE" }),
+        signal: controller.signal
+      });
+      clearTimeout(timer);
+      connectivity.push({ name: "Webhook endpoint", ok: true, detail: `reachable \u2014 HTTP ${res.status} (unsigned probe, rejection is expected)` });
+    } catch (err) {
+      connectivity.push({ name: "Webhook endpoint", ok: false, detail: err.name === "AbortError" ? "timeout" : err.message });
+    }
+  } else {
+    connectivity.push({ name: "Webhook endpoint", ok: false, detail: "not configured" });
+  }
+  const runtime = [
+    { name: "node", ok: Number(process.versions.node.split(".")[0]) >= 20, detail: process.version },
+    { name: "global fetch", ok: typeof fetch === "function", detail: typeof fetch === "function" ? "available" : "missing \u2014 needs node 18+" }
+  ];
+  return { config: cfgChecks, connectivity, runtime };
+}
+
+// src/ui/screens/History.jsx
+import React12, { useState as useState6 } from "react";
+import { Box as Box12, Text as Text12, useInput as useInput8 } from "ink";
+import { Select as Select7, Spinner as Spinner6, Badge as Badge4, Alert as Alert5, ConfirmInput as ConfirmInput2 } from "@inkjs/ui";
+import { jsx as jsx12, jsxs as jsxs12 } from "react/jsx-runtime";
+function History({ config, onDone }) {
+  const [items] = useState6(() => listPayloads(20));
+  const [selected, setSelected] = useState6(null);
+  const [phase, setPhase] = useState6("list");
+  const [result, setResult] = useState6(null);
+  const [error, setError] = useState6(null);
+  useInput8((input, key) => {
+    if (key.escape) onDone();
+    if ((phase === "result" || phase === "error") && (key.return || input === "q")) onDone();
+  });
+  const onPick = (file) => {
+    setSelected(loadPayload(file));
+    setPhase("detail");
+  };
+  const resend = () => {
+    setPhase("sending");
+    dispatch({ cfg: config, record: selected }).then((r) => {
+      setResult(r);
+      setPhase("result");
+    }).catch((err) => {
+      setError(err);
+      setPhase("error");
+    });
+  };
+  if (!items.length) {
+    return /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx12(Header, { title: "History", subtitle: "saved payloads" }),
+      /* @__PURE__ */ jsx12(Text12, { color: palette.dim, children: "nothing built yet \u2014 press esc to go back" })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx12(Header, { title: "History", subtitle: `${items.length} saved payload${items.length === 1 ? "" : "s"}`, right: "esc to go back" }),
+    phase === "list" && /* @__PURE__ */ jsx12(
+      Select7,
+      {
+        visibleOptionCount: 10,
+        options: items.map((i) => ({
+          label: `${i.savedAt.replace("T", " ").slice(0, 19)}  ${i.provider}  ${money(i.meta.totalPrice, i.meta.currency)}  ${i.meta.valid ? "\u2714" : "\u2716"}`,
+          value: i.path
+        })),
+        onChange: onPick
+      }
+    ),
+    phase === "detail" && selected && /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx12(Section, { title: "Payload", children: /* @__PURE__ */ jsx12(
+        KeyValue,
+        {
+          rows: [
+            ["saved", selected.savedAt],
+            ["provider", selected.provider],
+            ["environment", selected.meta?.environment ?? "\u2014"],
+            ["store", selected.meta?.store ?? "\u2014"],
+            ["items", (selected.meta?.items ?? []).map((i) => `${truncate(i.title, 24)} \xD7${i.qty}`).join(", ")],
+            ["total", money(selected.meta?.totalPrice, selected.meta?.currency)],
+            ["bytes", String(selected.body.length)]
+          ]
+        }
+      ) }),
+      /* @__PURE__ */ jsxs12(Box12, { marginTop: 1, children: [
+        /* @__PURE__ */ jsx12(Text12, { children: "Re-send this payload (it will be re-signed with a fresh timestamp)? " }),
+        /* @__PURE__ */ jsx12(ConfirmInput2, { onConfirm: resend, onCancel: () => setPhase("list") })
+      ] })
+    ] }),
+    phase === "sending" && /* @__PURE__ */ jsx12(Spinner6, { label: "re-signing and sending\u2026" }),
+    phase === "result" && result && /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs12(Box12, { marginBottom: 1, children: [
+        /* @__PURE__ */ jsx12(Badge4, { color: result.ok ? "green" : "red", children: result.error ? "FAILED" : `HTTP ${result.status}` }),
+        /* @__PURE__ */ jsx12(Text12, { children: " " }),
+        /* @__PURE__ */ jsx12(Text12, { color: palette.dim, children: result.error ?? explainStatus(result.status) })
+      ] }),
+      /* @__PURE__ */ jsx12(Text12, { color: palette.dim, children: "press enter to return" })
+    ] }),
+    phase === "error" && error && /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx12(Alert5, { variant: "error", children: error.message }),
+      error.hint ? /* @__PURE__ */ jsx12(Text12, { color: palette.warn, children: `  ${error.hint}` }) : null,
+      /* @__PURE__ */ jsx12(Text12, { color: palette.dim, children: "press enter to return" })
+    ] })
+  ] });
+}
+
+// src/ui/screens/Clear.jsx
+import React13, { useState as useState7 } from "react";
+import { Box as Box13, Text as Text13, useInput as useInput9 } from "ink";
+import { Select as Select8, ConfirmInput as ConfirmInput3, Alert as Alert6, Badge as Badge5 } from "@inkjs/ui";
+
+// src/core/cleanup.mjs
+import fs5 from "node:fs";
+import path5 from "node:path";
+var bytes = (n) => n < 1024 ? `${n} B` : n < 1024 * 1024 ? `${(n / 1024).toFixed(1)} kB` : `${(n / 1024 / 1024).toFixed(1)} MB`;
+function sizeOf(file) {
+  try {
+    return fs5.statSync(file).size;
+  } catch {
+    return 0;
+  }
+}
+function inspect() {
+  const payloadFiles = fs5.existsSync(OUT_DIR) ? fs5.readdirSync(OUT_DIR).filter((f) => f.endsWith(".json")) : [];
+  const payloadBytes = payloadFiles.reduce((sum, f) => sum + sizeOf(path5.join(OUT_DIR, f)), 0);
+  const logBytes = sizeOf(logPath);
+  const configBytes = sizeOf(CONFIG_PATH);
+  return {
+    payloads: { count: payloadFiles.length, bytes: payloadBytes, label: `${payloadFiles.length} saved payload${payloadFiles.length === 1 ? "" : "s"} (${bytes(payloadBytes)})`, path: OUT_DIR },
+    logs: { count: logBytes ? 1 : 0, bytes: logBytes, label: logBytes ? `activity log (${bytes(logBytes)})` : "no log file", path: logPath },
+    config: { count: configBytes ? 1 : 0, bytes: configBytes, label: configBytes ? `config incl. Shopify token + webhook secret (${bytes(configBytes)})` : "no config file", path: CONFIG_PATH }
+  };
+}
+function clearPayloads() {
+  if (!fs5.existsSync(OUT_DIR)) return { removed: 0 };
+  const files = fs5.readdirSync(OUT_DIR).filter((f) => f.endsWith(".json"));
+  for (const f of files) fs5.rmSync(path5.join(OUT_DIR, f), { force: true });
+  fs5.rmSync(path5.join(OUT_DIR, "last-body.json"), { force: true });
+  fs5.rmSync(path5.join(STATE_DIR, "last-body.json"), { force: true });
+  return { removed: files.length };
+}
+function clearLogs() {
+  const existed = fs5.existsSync(logPath);
+  fs5.rmSync(logPath, { force: true });
+  return { removed: existed ? 1 : 0 };
+}
+function clearShopCache(cfg) {
+  const had = Boolean(cfg.shopify.shop);
+  cfg.shopify.shop = null;
+  saveConfig(cfg);
+  return { removed: had ? 1 : 0 };
+}
+function disconnectShopify(cfg) {
+  cfg.shopify.domain = "";
+  cfg.shopify.accessToken = "";
+  cfg.shopify.shop = null;
+  saveConfig(cfg);
+  return { removed: 1 };
+}
+function clearConfig() {
+  const existed = fs5.existsSync(CONFIG_PATH);
+  fs5.rmSync(CONFIG_PATH, { force: true });
+  return { removed: existed ? 1 : 0 };
+}
+function clearAll() {
+  const payloads = clearPayloads();
+  const logs = clearLogs();
+  const config = clearConfig();
+  return {
+    payloads: payloads.removed,
+    logs: logs.removed,
+    config: config.removed,
+    freshConfig: structuredClone(DEFAULT_CONFIG)
+  };
+}
+var TARGETS = {
+  payloads: { label: "Saved payloads", description: "the build history in the payloads directory", run: (cfg) => clearPayloads() },
+  logs: { label: "Activity log", description: "the local run log", run: (cfg) => clearLogs() },
+  shopCache: { label: "Cached store record", description: "the store name/currency snapshot \u2014 credentials kept", run: (cfg) => clearShopCache(cfg) },
+  disconnect: { label: "Disconnect Shopify", description: "forget the store domain and access token", run: (cfg) => disconnectShopify(cfg) },
+  all: { label: "Everything", description: "payloads, log and config \u2014 back to first run", run: () => clearAll() }
+};
+
+// src/ui/screens/Clear.jsx
+import { jsx as jsx13, jsxs as jsxs13 } from "react/jsx-runtime";
+function Clear({ config, onDone }) {
+  const [state] = useState7(() => inspect());
+  const [choice, setChoice] = useState7(null);
+  const [result, setResult] = useState7(null);
+  useInput9((input, key) => {
+    if (key.escape) onDone();
+    if (result && (key.return || input === "q")) onDone(result.freshConfig ?? config);
+  });
+  const run2 = () => {
+    const outcome = TARGETS[choice].run(config);
+    setResult(outcome);
+  };
+  if (result) {
+    return /* @__PURE__ */ jsxs13(Box13, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx13(Header, { title: "Clear", subtitle: "done" }),
+      /* @__PURE__ */ jsxs13(Box13, { marginBottom: 1, children: [
+        /* @__PURE__ */ jsx13(Badge5, { color: "green", children: "CLEARED" }),
+        /* @__PURE__ */ jsx13(Text13, { children: "  " }),
+        /* @__PURE__ */ jsx13(Text13, { color: palette.dim, children: choice === "all" ? `${result.payloads} payload(s), ${result.logs} log, ${result.config} config file removed` : `${result.removed} item(s) removed` })
+      ] }),
+      choice === "all" ? /* @__PURE__ */ jsx13(Alert6, { variant: "info", children: "back to first-run state \u2014 reconnect Shopify to continue" }) : null,
+      /* @__PURE__ */ jsx13(Box13, { marginTop: 1, children: /* @__PURE__ */ jsx13(Text13, { color: palette.dim, children: "press enter to return" }) })
+    ] });
+  }
+  if (choice) {
+    const target = TARGETS[choice];
+    return /* @__PURE__ */ jsxs13(Box13, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx13(Header, { title: "Clear", subtitle: target.label, right: "esc to cancel" }),
+      /* @__PURE__ */ jsx13(Alert6, { variant: "warning", children: `This permanently deletes ${target.description}.` }),
+      /* @__PURE__ */ jsx13(Section, { title: "Will be removed", children: choice === "all" ? /* @__PURE__ */ jsx13(
+        KeyValue,
+        {
+          keyWidth: 10,
+          rows: [
+            ["payloads", state.payloads.label],
+            ["log", state.logs.label],
+            ["config", state.config.label]
+          ]
+        }
+      ) : /* @__PURE__ */ jsx13(Text13, { color: palette.dim, children: `  ${glyph.dot} ${choice === "payloads" ? state.payloads.label : choice === "logs" ? state.logs.label : target.description}` }) }),
+      choice === "all" || choice === "disconnect" ? /* @__PURE__ */ jsx13(Box13, { marginTop: 1, children: /* @__PURE__ */ jsx13(Text13, { color: palette.warn, children: "  your Shopify access token will have to be entered again" }) }) : null,
+      /* @__PURE__ */ jsxs13(Box13, { marginTop: 1, children: [
+        /* @__PURE__ */ jsx13(Text13, { children: "Are you sure? " }),
+        /* @__PURE__ */ jsx13(ConfirmInput3, { defaultChoice: "cancel", onConfirm: run2, onCancel: () => setChoice(null) })
+      ] })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs13(Box13, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx13(Header, { title: "Clear", subtitle: "remove locally cached data", right: "esc to go back" }),
+    /* @__PURE__ */ jsxs13(Box13, { flexDirection: "column", marginBottom: 1, paddingX: 1, children: [
+      /* @__PURE__ */ jsx13(Text13, { color: palette.dim, children: `${glyph.dot} ${state.payloads.label}` }),
+      /* @__PURE__ */ jsx13(Text13, { color: palette.dim, children: `${glyph.dot} ${state.logs.label}` }),
+      /* @__PURE__ */ jsx13(Text13, { color: palette.dim, children: `${glyph.dot} ${state.config.label}` })
+    ] }),
+    /* @__PURE__ */ jsx13(
+      Select8,
+      {
+        visibleOptionCount: 8,
+        options: Object.entries(TARGETS).map(([key, t]) => ({
+          label: `${t.label.padEnd(24)} ${t.description}`,
+          value: key
+        })),
+        onChange: setChoice
+      }
+    )
+  ] });
+}
+
+// src/ui/App.jsx
+import { jsx as jsx14 } from "react/jsx-runtime";
+function App({ config: initialConfig, initialScreen = "home" }) {
+  const { exit } = useApp2();
+  const [config, setConfig] = useState8(initialConfig);
+  const [screen, setScreen] = useState8(initialScreen);
+  const [provider, setProvider] = useState8("cashfree-occ");
+  const [section, setSection] = useState8(null);
+  const go = (next) => (updated) => {
+    if (updated) setConfig(updated);
+    setSection(null);
+    setScreen(next);
+  };
+  const toHome = go("home");
+  const toSetup = go("setup");
+  const toIntegrations = go("integrations");
+  switch (screen) {
+    case "setup":
+      return /* @__PURE__ */ jsx14(
+        Setup,
+        {
+          config,
+          onBack: toHome,
+          onPick: (what) => {
+            if (what === "customer") {
+              setSection("Customer");
+              setScreen("configure");
+            } else if (what === "defaults") {
+              setSection("Defaults");
+              setScreen("configure");
+            } else setScreen(what);
+          }
+        }
+      );
+    case "integrations":
+      return /* @__PURE__ */ jsx14(
+        Integrations,
+        {
+          config,
+          onBack: toHome,
+          onSetup: () => setScreen("setup"),
+          onPick: (id) => {
+            setProvider(id);
+            setScreen("build");
+          }
+        }
+      );
+    case "connect":
+      return /* @__PURE__ */ jsx14(ConnectShopify, { config, onDone: toSetup });
+    case "webhook":
+      return /* @__PURE__ */ jsx14(Webhook, { config, onDone: toSetup });
+    case "configure":
+      return /* @__PURE__ */ jsx14(Configure, { config, section, onDone: toSetup });
+    case "build":
+      return /* @__PURE__ */ jsx14(Build, { config, providerId: provider, onDone: toIntegrations });
+    case "history":
+      return /* @__PURE__ */ jsx14(History, { config, onDone: toHome });
+    case "doctor":
+      return /* @__PURE__ */ jsx14(Doctor, { config, onDone: toHome });
+    case "clear":
+      return /* @__PURE__ */ jsx14(Clear, { config, onDone: toHome });
+    default:
+      return /* @__PURE__ */ jsx14(Home, { config, onPick: setScreen, onQuit: exit });
+  }
+}
+
+// src/pretty.mjs
+var ESC = "\x1B";
+var isTTY = process.stdout.isTTY;
+var wrap = (open, close) => (s) => process.stdout.isTTY ? `${ESC}[${open}m${s}${ESC}[${close}m` : String(s);
+var c = {
+  reset: (s) => s,
+  bold: wrap(1, 22),
+  dim: wrap(2, 22),
+  italic: wrap(3, 23),
+  underline: wrap(4, 24),
+  red: wrap(31, 39),
+  green: wrap(32, 39),
+  yellow: wrap(33, 39),
+  blue: wrap(34, 39),
+  magenta: wrap(35, 39),
+  cyan: wrap(36, 39),
+  grey: wrap(90, 39),
+  bgCyan: wrap(46, 49),
+  bgRed: wrap(41, 49)
+};
+var sym = {
+  tick: "\u2714",
+  cross: "\u2716",
+  warn: "\u25B2",
+  info: "\u2139",
+  arrow: "\u203A",
+  bullet: "\u2022",
+  pointer: "\u276F",
+  radioOn: "\u25C9",
+  radioOff: "\u25EF",
+  boxOn: "\u25FC",
+  boxOff: "\u25FB"
+};
+var plain = (s) => String(s).replace(/\x1b\[[0-9;]*m/g, "");
+var width = (s) => plain(s).length;
+function box(title, lines, colour = c.grey) {
+  const body = Array.isArray(lines) ? lines : [lines];
+  const w = Math.max(width(title) + 4, ...body.map((l) => width(l) + 2), 40);
+  const pad = (s) => s + " ".repeat(Math.max(0, w - width(s)));
+  console.log(colour("\u250C\u2500 ") + c.bold(title) + colour(" " + "\u2500".repeat(Math.max(0, w - width(title) - 3)) + "\u2510"));
+  for (const l of body) console.log(colour("\u2502") + pad(" " + l) + colour("\u2502"));
+  console.log(colour("\u2514" + "\u2500".repeat(w) + "\u2518"));
+}
+var log = {
+  ok: (m) => console.log(`${c.green(sym.tick)} ${m}`),
+  fail: (m) => console.log(`${c.red(sym.cross)} ${m}`),
+  warn: (m) => console.log(`${c.yellow(sym.warn)} ${m}`),
+  info: (m) => console.log(`${c.blue(sym.info)} ${m}`),
+  step: (m) => console.log(`${c.cyan(sym.arrow)} ${m}`),
+  dim: (m) => console.log(c.grey(`  ${m}`)),
+  blank: () => console.log()
+};
+function table(rows, headers) {
+  if (!rows.length) return;
+  const cols = headers || Object.keys(rows[0]);
+  const widths = cols.map((col) => Math.max(width(col), ...rows.map((r) => width(String(r[col] ?? "")))));
+  const line = (cells, colour = (s) => s) => "  " + cells.map((cell, i) => colour(String(cell) + " ".repeat(Math.max(0, widths[i] - width(String(cell)))))).join("  ");
+  console.log(line(cols, c.bold));
+  console.log("  " + c.grey(widths.map((w) => "\u2500".repeat(w)).join("  ")));
+  for (const r of rows) console.log(line(cols.map((col) => r[col] ?? "")));
+}
+
+// src/headless/run.mjs
+async function headless(command, args, config) {
+  switch (command) {
+    case "build":
+      return cmdBuild(args, config);
+    case "send":
+      return cmdSend(args, config);
+    case "doctor":
+      return cmdDoctor(args, config);
+    case "history":
+      return cmdHistory(args);
+    case "clear":
+      return cmdClear(args, config);
+    case "configure":
+      log.fail("configure needs an interactive terminal");
+      log.dim(`edit ${config._path} directly, or run hookwright configure from a TTY`);
+      return 1;
+    default:
+      log.fail(`unknown command "${command}"`);
+      log.dim("try: build \xB7 send \xB7 doctor \xB7 history \xB7 configure \xB7 help");
+      return 1;
+  }
+}
+function requireConfig(config) {
+  if (isConfigured(config)) return null;
+  const missing = configStatus(config).filter((r) => !r.ok).map((r) => r.key);
+  log.fail(`configuration incomplete: ${missing.join(", ")}`);
+  log.dim(`run \`hookwright configure\` or edit ${config._path}`);
+  return 1;
+}
+async function cmdBuild(args, config) {
+  const bad = requireConfig(config);
+  if (bad) return bad;
+  const count = Number.parseInt(args.flags.items ?? "1", 10) || 1;
+  const discount = Number.parseFloat(args.flags.discount ?? "0") || 0;
+  const search = typeof args.flags.search === "string" ? args.flags.search : void 0;
+  const checkImageUrls = args.flags.image !== false && args.flags["image-check"] !== false;
+  log.step(`fetching products from ${config.shopify.domain}\u2026`);
+  const products = await fetchCatalogue(config, { search });
+  if (!products.length) {
+    log.fail("Shopify returned no products");
+    return 1;
+  }
+  const items = autoSelect(products, count);
+  log.ok(`${items.length} product(s): ${items.map((i) => i.product.title).join(", ")}`);
+  const built = await buildPayload2({
+    cfg: config,
+    items,
+    discount,
+    phone: typeof args.flags.phone === "string" ? args.flags.phone : void 0,
+    checkImageUrls
+  });
+  if (args.flags.json) {
+    console.log(JSON.stringify({ file: built.file, valid: built.report.ok, checks: built.report.checks, payload: built.payload }, null, 2));
+  } else {
+    printReport(built);
+    if (args.flags.payload) {
+      log.blank();
+      log.step(c.bold("Payload"));
+      console.log(JSON.stringify(built.payload, null, 2));
+    }
+  }
+  if (args.flags.copy !== false && !args.flags.json) {
+    const result = await copy(built.body);
+    if (result.ok) log.ok(`payload copied to clipboard via ${result.via}`);
+    else log.dim(`clipboard unavailable \u2014 install xclip, xsel or wl-copy to enable copying`);
+  }
+  if (!built.report.ok && !args.flags.force) {
+    log.fail("pre-flight failed \u2014 not sending");
+    return 2;
+  }
+  if (args.flags.send || args.flags["dry-run"]) {
+    return cmdSend({ ...args, flags: { ...args.flags, _record: built } }, config, built);
+  }
+  log.blank();
+  log.dim(`send it with: hookwright send${args.flags["dry-run"] ? " --dry-run" : ""}`);
+  return 0;
+}
+async function cmdSend(args, config, built) {
+  const bad = requireConfig(config);
+  if (bad) return bad;
+  let record = built ? { provider: built.provider.id, payload: built.payload, body: built.body } : null;
+  if (!record && typeof args.flags.file === "string") record = loadPayload(args.flags.file);
+  if (!record) record = loadLast();
+  if (!record) {
+    log.fail("nothing to send \u2014 build a payload first");
+    return 1;
+  }
+  const result = await dispatch({
+    cfg: config,
+    record,
+    force: Boolean(args.flags.force),
+    dryRun: Boolean(args.flags["dry-run"])
+  });
+  if (result.dryRun) {
+    log.blank();
+    log.info("dry run \u2014 not sent");
+    box("Request", [
+      `POST ${result.request.url}`,
+      `x-webhook-timestamp  ${result.request.timestamp}`,
+      `x-webhook-signature  ${result.request.signature}`,
+      `body                 ${record.body.length} bytes`
+    ], c.cyan);
+    log.blank();
+    console.log(c.grey(result.curl));
+    return 0;
+  }
+  log.blank();
+  if (result.ok) log.ok(`HTTP ${result.status} in ${result.durationMs}ms \u2014 ${explainStatus(result.status)}`);
+  else log.fail(result.error ? `request failed: ${result.error}` : `HTTP ${result.status} \u2014 ${explainStatus(result.status)}`);
+  if (result.body) log.dim(`response: ${String(result.body).slice(0, 300)}`);
+  log.blank();
+  console.log(c.grey(result.curl));
+  return result.ok ? 0 : 3;
+}
+async function cmdDoctor(args, config) {
+  const result = await run(config);
+  const groups = [
+    ["Configuration", result.config],
+    ["Connectivity", result.connectivity],
+    ["Runtime", result.runtime]
+  ];
+  for (const [title, checks] of groups) {
+    log.blank();
+    log.step(c.bold(title));
+    for (const check of checks) {
+      const mark = check.ok ? c.green(sym.tick) : c.red(sym.cross);
+      console.log(`  ${mark} ${c.bold(String(check.name).padEnd(20))} ${c.grey(check.detail)}`);
+    }
+  }
+  log.blank();
+  const failed = [...result.config, ...result.connectivity, ...result.runtime].filter((c2) => !c2.ok);
+  if (args.flags.json) console.log(JSON.stringify(result, null, 2));
+  return failed.length ? 1 : 0;
+}
+function cmdHistory(args) {
+  const items = listPayloads(Number.parseInt(args.flags.limit ?? "20", 10) || 20);
+  if (args.flags.json) {
+    console.log(JSON.stringify(items, null, 2));
+    return 0;
+  }
+  if (!items.length) {
+    log.dim("no payloads built yet");
+    return 0;
+  }
+  table(
+    items.map((i) => ({
+      when: i.savedAt.replace("T", " ").slice(0, 19),
+      provider: i.provider,
+      env: i.meta.environment ?? "\u2014",
+      total: i.meta.totalPrice != null ? `${i.meta.totalPrice} ${i.meta.currency ?? ""}` : "\u2014",
+      valid: i.meta.valid ? c.green(sym.tick) : c.red(sym.cross),
+      file: i.file
+    })),
+    ["when", "provider", "env", "total", "valid", "file"]
+  );
+  return 0;
+}
+function cmdClear(args, config) {
+  const state = inspect();
+  const target = args.flags.all ? "all" : args.flags.payloads ? "payloads" : args.flags.logs ? "logs" : args.flags.disconnect ? "disconnect" : args.flags["shop-cache"] ? "shopCache" : null;
+  if (!target) {
+    log.step("locally cached data");
+    log.dim(state.payloads.label);
+    log.dim(state.logs.label);
+    log.dim(state.config.label);
+    log.blank();
+    log.info("choose what to remove:");
+    log.dim("--payloads     saved build history");
+    log.dim("--logs         activity log");
+    log.dim("--shop-cache   cached store record (credentials kept)");
+    log.dim("--disconnect   forget the Shopify domain and token");
+    log.dim("--all          payloads, log and config \u2014 back to first run");
+    log.dim("add --yes to skip the confirmation");
+    return 0;
+  }
+  if (!args.flags.yes) {
+    log.warn(`this permanently deletes ${TARGETS[target].description}`);
+    log.dim("re-run with --yes to confirm");
+    return 1;
+  }
+  const result = TARGETS[target].run(config);
+  if (target === "all") {
+    log.ok(`removed ${result.payloads} payload(s), ${result.logs} log, ${result.config} config file \u2014 back to first-run state`);
+  } else {
+    log.ok(`${TARGETS[target].label}: ${result.removed} item(s) removed`);
+  }
+  return 0;
+}
+function printReport(built) {
+  const d = built.payload.data;
+  log.blank();
+  box("Payload", [
+    `type      ${built.payload.type}`,
+    `store     ${d.store_url}`,
+    `customer  ${d.customer.shipping_address.customer_name} \xB7 ${d.phone}`,
+    `items     ${d.line_items.map((i) => `${i.name} x${i.quantity}`).join(", ")}`,
+    `total     ${d.total_price} ${d.line_items[0]?.currency}  (was ${d.original_total_price}, discount ${d.total_discount})`,
+    `saved     ${built.file}`
+  ], c.green);
+  log.blank();
+  log.step(c.bold("Pre-flight"));
+  for (const check of built.report.checks) {
+    const mark = check.ok ? c.green(sym.tick) : check.warn ? c.yellow(sym.warn) : c.red(sym.cross);
+    console.log(`  ${mark} ${c.bold(check.name.padEnd(24))} ${c.grey(check.detail)}`);
+  }
+  log.blank();
+  log.step(c.bold("Field coverage"));
+  table(
+    built.report.coverage.map((c2) => ({
+      field: c2.field,
+      "maps to": c2.maps_to,
+      value: c2.status === "MISSING" ? c.red(c2.value) : c2.value
+    })),
+    ["field", "maps to", "value"]
+  );
+}
+
+// src/cli.jsx
+import { jsx as jsx15 } from "react/jsx-runtime";
+var HELP = `
+${c.bold("hookwright")} \u2014 generate real, signed provider webhooks from a live Shopify catalogue
+
+${c.bold("USAGE")}
+  hookwright                        launch the interactive UI
+  hookwright <command> [options]    run headless (CI / scripting)
+
+${c.bold("COMMANDS")}
+  build        build a payload from real Shopify products
+  send         sign and POST the last built payload
+  doctor       verify credentials and connectivity
+  history      list saved payloads
+  clear        remove locally cached data (payloads, log, config)
+  configure    launch the setup wizard
+  help         show this message
+
+${c.bold("BUILD OPTIONS")}
+  --items <n>        how many products to put in the cart      (default 1)
+  --search <text>    only consider products matching a title
+  --discount <n>     cart discount in major currency units     (default 0)
+  --phone <e164>     override the configured test phone
+  --send             transmit immediately after building
+  --dry-run          print the request and curl, do not send
+  --no-image-check   skip HEAD-checking product image URLs
+  --payload          print the full generated payload
+  --no-copy          do not copy the payload to the clipboard
+  --json             machine-readable output
+
+${c.bold("SEND OPTIONS")}
+  --file <path>      send a specific saved payload
+  --dry-run          print the request without sending
+  --force            send even if pre-flight fails or target looks like prod
+
+${c.bold("CLEAR OPTIONS")}
+  --payloads         delete saved payloads
+  --logs             delete the activity log
+  --shop-cache       drop the cached store record, keep credentials
+  --disconnect       forget the Shopify domain and token
+  --all              payloads + log + config, back to first run
+  --yes              skip the confirmation
+
+${c.bold("GLOBAL")}
+  --config <path>    use a different config file
+  --verbose          verbose logging
+  --version          print version
+
+${c.grey(`config: ${CONFIG_PATH}`)}
+`;
+function parseArgs(argv) {
+  const args = { _: [], flags: {} };
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (token.startsWith("--")) {
+      const key = token.slice(2);
+      const next = argv[i + 1];
+      if (key.startsWith("no-")) {
+        args.flags[key.slice(3)] = false;
+      } else if (next && !next.startsWith("--")) {
+        args.flags[key] = next;
+        i += 1;
+      } else {
+        args.flags[key] = true;
+      }
+    } else {
+      args._.push(token);
+    }
+  }
+  return args;
+}
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const command = args._[0];
+  if (args.flags.verbose) setVerbose(true);
+  if (args.flags.version) {
+    const { version } = await Promise.resolve().then(() => (init_package(), package_exports)).then((m) => m.default).catch(() => ({ version: "dev" }));
+    console.log(version);
+    return;
+  }
+  if (command === "help" || args.flags.help) {
+    console.log(HELP);
+    return;
+  }
+  const config = loadConfig(args.flags.config);
+  if (command && command !== "ui") {
+    if (command === "configure" && process.stdin.isTTY) {
+      render(/* @__PURE__ */ jsx15(App, { config, initialScreen: "connect" }));
+      return;
+    }
+    const code = await headless(command, args, config);
+    process.exitCode = code;
+    return;
+  }
+  if (!process.stdin.isTTY) {
+    console.log(HELP);
+    console.error(c.yellow("\nno TTY detected \u2014 use a headless command (build / send / doctor / history)"));
+    process.exitCode = 1;
+    return;
+  }
+  render(/* @__PURE__ */ jsx15(App, { config, initialScreen: "home" }));
+}
+main().catch((err) => {
+  console.error(c.red(`
+${err.message}`));
+  if (err.hint) console.error(c.yellow(`  ${err.hint}`));
+  process.exitCode = 1;
+});
+export {
+  parseArgs
+};