kaching-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,503 @@
+#!/usr/bin/env node
+import {
+  CliError,
+  DEFAULT_BASE_URL,
+  accountClient,
+  apiUrl,
+  c,
+  formatMoney,
+  handleError,
+  isJson,
+  log,
+  openBrowser,
+  out,
+  readConfig,
+  setJsonMode,
+  storeClient,
+  table,
+  toMinor,
+  upsertEnvFile,
+  writeConfig
+} from "./chunk-TWKERERX.js";
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/auth.ts
+import { hostname } from "os";
+async function post(base, path, body) {
+  const res = await fetch(base + path, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  return { status: res.status, data: await res.json() };
+}
+async function login(opts) {
+  const base = apiUrl(opts.apiUrl);
+  const start = await post(base, "/cli/device", { client_name: `kaching CLI on ${hostname()}` });
+  if (start.status !== 200) throw new CliError(`Could not start login against ${base}`, "login_failed");
+  const d = start.data;
+  log(`
+  Confirm this code in your browser: ${c.bold(c.cyan(d.user_code))}
+`);
+  const opened = opts.open !== false && openBrowser(d.verification_uri_complete);
+  log(`  ${opened ? "Opened" : "Open"} ${c.cyan(d.verification_uri_complete)}
+`);
+  log(c.dim("  Waiting for approval\u2026"));
+  const deadline = new Date(d.expires_at).getTime();
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, d.interval * 1e3));
+    const poll = await post(base, "/cli/token", { device_code: d.device_code });
+    if (poll.data.status === "approved" && poll.data.account_token) {
+      writeConfig({ account_token: poll.data.account_token, api_url: opts.apiUrl ? base : readConfig().api_url });
+      return;
+    }
+    if (poll.data.status === "denied") throw new CliError("Login was denied in the browser.", "login_denied");
+    if (poll.data.status === "expired") break;
+  }
+  throw new CliError("Login code expired. Run `kaching login` again.", "login_expired");
+}
+function registerAuth(program2) {
+  program2.command("login").description("Log in to kaching (opens your browser to approve this device)").option("--api-url <url>", "API base URL (for self-hosted or local development)").option("--no-open", "Print the URL instead of opening a browser").action(async (opts) => {
+    await login(opts);
+    const { data } = await accountClient().stores.list();
+    out(
+      { logged_in: true, stores: data.map((s) => s.slug) },
+      () => log(`${c.green("\u2714")} Logged in. ${data.length} store${data.length === 1 ? "" : "s"} on this account.`)
+    );
+  });
+  program2.command("logout").description("Forget the saved account token on this machine").action(() => {
+    writeConfig({ account_token: void 0 });
+    out({ logged_in: false }, () => log(`${c.green("\u2714")} Logged out.`));
+  });
+  program2.command("whoami").description("Show login status and this account's stores").action(async () => {
+    if (!readConfig().account_token && !process.env.KACHING_ACCOUNT_TOKEN) {
+      return out({ logged_in: false, api_url: apiUrl() }, () => log("Not logged in. Run `kaching login`."));
+    }
+    const { data } = await accountClient().stores.list();
+    out({ logged_in: true, api_url: apiUrl(), stores: data }, () => {
+      log(`Logged in to ${c.cyan(apiUrl())}`);
+      for (const s of data) {
+        console.log(`  ${c.bold(s.slug)}  ${s.name}  ${s.currency.toUpperCase()}  ${s.payments.ready ? c.green("payments ready") : c.yellow("payments not set up")}`);
+      }
+    });
+  });
+}
+
+// src/commands/create.ts
+import { spawnSync } from "child_process";
+import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+import { basename, dirname, join, relative, resolve } from "path";
+import { fileURLToPath } from "url";
+var assetsDir = () => join(dirname(fileURLToPath(import.meta.url)), "..", "assets");
+function detectPackageManager() {
+  const ua = process.env.npm_config_user_agent ?? "";
+  if (ua.startsWith("pnpm")) return "pnpm";
+  if (ua.startsWith("yarn")) return "yarn";
+  if (ua.startsWith("bun")) return "bun";
+  return "npm";
+}
+function scaffold(dir, slug, pm) {
+  const assets = assetsDir();
+  if (!existsSync(join(assets, "template"))) throw new CliError("Storefront template missing from this CLI build.", "no_template");
+  cpSync(join(assets, "template"), dir, { recursive: true });
+  if (existsSync(join(dir, "gitignore"))) renameSync(join(dir, "gitignore"), join(dir, ".gitignore"));
+  const vendorSrc = join(assets, "vendor");
+  const tarballs = existsSync(vendorSrc) ? readdirSync(vendorSrc).filter((f) => f.endsWith(".tgz")) : [];
+  const pkgPath = join(dir, "package.json");
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+  pkg.name = slug;
+  delete pkg.packageManager;
+  if (tarballs.length) {
+    mkdirSync(join(dir, "vendor"), { recursive: true });
+    const overrides = {};
+    for (const file of tarballs) {
+      cpSync(join(vendorSrc, file), join(dir, "vendor", file));
+      const name = file.includes("-react-") ? "@kaching.sh/react" : "@kaching.sh/sdk";
+      overrides[name] = `file:./vendor/${file}`;
+    }
+    for (const [name, spec] of Object.entries(overrides)) pkg.dependencies[name] = spec;
+    pkg.overrides = overrides;
+    pkg.resolutions = overrides;
+  } else {
+    const { version } = JSON.parse(readFileSync(join(assets, "sdk.json"), "utf8"));
+    for (const name of ["@kaching.sh/sdk", "@kaching.sh/react"]) pkg.dependencies[name] = `^${version}`;
+  }
+  writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+  if (pm === "pnpm") {
+    const overrides = pkg.overrides ? `overrides:
+${Object.entries(pkg.overrides).map(([k, v]) => `  "${k}": "${v}"`).join("\n")}
+` : "";
+    writeFileSync(join(dir, "pnpm-workspace.yaml"), `allowBuilds:
+  sharp: true
+  unrs-resolver: true
+${overrides}`);
+  }
+}
+function install(dir, pm) {
+  const res = spawnSync(pm, ["install"], { cwd: dir, stdio: isJson() ? "ignore" : "inherit", shell: process.platform === "win32" });
+  return res.status === 0;
+}
+function registerCreate(program2) {
+  program2.command("create").description("Create a new store and a ready-to-run Next.js storefront").argument("[directory]", "Folder to create", ".").option("-n, --name <name>", "Store name (defaults to the folder name)").option("-c, --currency <code>", "Three-letter currency code", "usd").option("--support-email <email>", "Customer support email shown in the store and receipts").option("--no-install", "Skip installing dependencies").action(async (directory, opts) => {
+    const dir = resolve(directory);
+    if (existsSync(dir) && readdirSync(dir).filter((f) => !f.startsWith(".")).length > 0) {
+      throw new CliError(`${relative(process.cwd(), dir) || "."} is not empty. Pick a new folder name.`, "dir_not_empty");
+    }
+    if (!readConfig().account_token && !process.env.KACHING_ACCOUNT_TOKEN) {
+      if (!process.stdin.isTTY || isJson()) throw new CliError("Not logged in. Run `kaching login` first.", "not_logged_in");
+      await login({});
+    }
+    const name = opts.name ?? titleCase(basename(dir));
+    log(`${c.dim("\u2022")} Creating store ${c.bold(name)}\u2026`);
+    const created = await accountClient().stores.create({
+      name,
+      currency: opts.currency,
+      ...opts.supportEmail && { support_email: opts.supportEmail }
+    });
+    const pm = detectPackageManager();
+    log(`${c.dim("\u2022")} Writing storefront to ${c.bold(relative(process.cwd(), dir) || ".")}`);
+    mkdirSync(dir, { recursive: true });
+    scaffold(dir, created.slug, pm);
+    const api = apiUrl();
+    upsertEnvFile(join(dir, ".env.local"), {
+      NEXT_PUBLIC_KACHING_PUBLISHABLE_KEY: created.keys.publishable,
+      NEXT_PUBLIC_KACHING_API_URL: api === DEFAULT_BASE_URL ? void 0 : api,
+      // Server-only. Used by the kaching CLI/agents in this folder. Never expose to the browser.
+      KACHING_SECRET_KEY: created.keys.secret
+    });
+    let installed = false;
+    if (opts.install) {
+      log(`${c.dim("\u2022")} Installing dependencies with ${pm}\u2026`);
+      installed = install(dir, pm);
+      if (!installed) log(c.yellow(`  Install failed \u2014 run \`${pm} install\` in the folder to retry.`));
+    }
+    const { keys: _, ...store } = created;
+    const cd = relative(process.cwd(), dir);
+    const run = pm === "npm" ? "npm run dev" : `${pm} dev`;
+    const nextSteps = [
+      ...cd ? [`cd ${cd}`] : [],
+      ...installed ? [] : [`${pm} install`],
+      run,
+      'kaching products create --title "..." --price 25',
+      "kaching payments connect"
+    ];
+    out({ store, directory: dir, installed, package_manager: pm, next_steps: nextSteps }, () => {
+      log(`
+${c.green("\u2714")} ${c.bold(name)} is ready.
+`);
+      log("  Next:");
+      for (const step of nextSteps) log(`    ${c.cyan(step)}`);
+      log(`
+  Keys are in ${c.bold(".env.local")} (gitignored). Storefront runs on http://localhost:3001
+`);
+    });
+  });
+  program2.command("link").description("Connect this folder to an existing store (writes keys to .env.local)").argument("[store]", "Store slug (see `kaching whoami`)").action(async (slug) => {
+    const client = accountClient();
+    const { data: stores } = await client.stores.list();
+    const store = slug ? stores.find((s) => s.slug === slug) : stores.length === 1 ? stores[0] : void 0;
+    if (!store) {
+      throw new CliError(
+        stores.length === 0 ? "This account has no stores yet. Run `kaching create`." : `Specify which store: ${stores.map((s) => s.slug).join(", ")}`,
+        "store_required"
+      );
+    }
+    const keys = await issueKeys(store.id);
+    const api = apiUrl();
+    upsertEnvFile(join(process.cwd(), ".env.local"), {
+      NEXT_PUBLIC_KACHING_PUBLISHABLE_KEY: keys.publishable,
+      NEXT_PUBLIC_KACHING_API_URL: api === DEFAULT_BASE_URL ? void 0 : api,
+      KACHING_SECRET_KEY: keys.secret
+    });
+    out({ store }, () => log(`${c.green("\u2714")} Linked to ${c.bold(store.name)}. Keys written to .env.local.`));
+  });
+}
+async function issueKeys(storeId) {
+  const token = process.env.KACHING_ACCOUNT_TOKEN ?? readConfig().account_token;
+  const res = await fetch(`${apiUrl()}/stores/${storeId}/keys`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+    body: JSON.stringify({ name: "cli-link" })
+  });
+  const data = await res.json();
+  if (!res.ok) throw new CliError(data?.error?.message ?? "Could not issue keys", data?.error?.code);
+  return data;
+}
+var titleCase = (s) => s.replace(/[-_]+/g, " ").replace(/\s+/g, " ").trim().replace(/\b\w/g, (ch) => ch.toUpperCase()) || "My Store";
+
+// src/commands/store.ts
+import { readFileSync as readFileSync2, statSync } from "fs";
+import { basename as basename2, dirname as dirname2, extname, resolve as resolve2 } from "path";
+var collect = (value, prev = []) => [...prev, value];
+var MIME = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+  ".avif": "image/avif",
+  ".pdf": "application/pdf",
+  ".zip": "application/zip",
+  ".epub": "application/epub+zip",
+  ".mp3": "audio/mpeg",
+  ".mp4": "video/mp4"
+};
+function readLocalFile(path) {
+  const abs = resolve2(path);
+  try {
+    statSync(abs);
+  } catch {
+    throw new CliError(`File not found: ${path}`, "file_not_found");
+  }
+  const type = MIME[extname(abs).toLowerCase()] ?? "application/octet-stream";
+  return { blob: new Blob([readFileSync2(abs)], { type }), name: basename2(abs) };
+}
+var isUrl = (s) => /^https?:\/\//.test(s);
+async function attachMedia(product, images, files) {
+  const client = storeClient();
+  let current = product;
+  const urls = images.filter(isUrl);
+  if (urls.length) current = await client.products.update(current.id, { images: [...current.images, ...urls] });
+  for (const path of images.filter((i) => !isUrl(i))) {
+    const { blob, name } = readLocalFile(path);
+    log(c.dim(`  uploading ${name}\u2026`));
+    current = await client.products.uploadImage(current.id, blob, name);
+  }
+  for (const path of files) {
+    const { blob, name } = readLocalFile(path);
+    log(c.dim(`  uploading ${name}\u2026`));
+    await client.variants.files.upload(current.variants[0].id, blob, name);
+  }
+  return files.length ? client.products.get(current.id) : current;
+}
+function printProduct(p, currency) {
+  console.log(`${c.bold(p.title)} ${c.dim(`/${p.slug}`)}  ${p.type}  ${p.status}`);
+  for (const v of p.variants) {
+    const stock = v.track_inventory ? `${v.inventory_quantity} in stock` : "untracked";
+    const files = v.files?.length ? `  ${v.files.length} file(s)` : "";
+    console.log(`  ${v.title.padEnd(16)} ${formatMoney(v.price, currency).padEnd(14)} ${c.dim(stock)}${files}  ${c.dim(v.id)}`);
+  }
+}
+function registerStoreCommands(program2) {
+  program2.command("store").description("Show the store linked to this folder").action(async () => {
+    const store = await storeClient().store.get();
+    out(store, (s) => {
+      console.log(`${c.bold(s.name)} ${c.dim(`(${s.slug})`)}  ${s.currency.toUpperCase()}`);
+      console.log(`  payments: ${s.payments.ready ? c.green("ready") : c.yellow(s.payments.connected ? `pending (${s.payments.card_payments_status})` : "not connected \u2014 run `kaching payments connect`")}`);
+      console.log(`  tax: ${s.tax_enabled ? "on" : "off"}`);
+    });
+  });
+  const products = program2.command("products").description("Manage products");
+  products.command("list").description("List products").action(async () => {
+    const client = storeClient();
+    const [{ data }, store] = await Promise.all([client.products.list({ limit: 100 }), client.store.get()]);
+    out(data, (list) => {
+      if (!list.length) return log("No products yet. Add one with `kaching products create`.");
+      table(
+        list.map((p) => ({
+          slug: p.slug,
+          title: p.title,
+          type: p.type,
+          status: p.status,
+          price: p.price_range ? formatMoney(p.price_range.min, store.currency) : "-",
+          variants: p.variants.length
+        }))
+      );
+    });
+  });
+  products.command("get").description("Show a product with its variants").argument("<slug>", "Product slug or id").action(async (slug) => {
+    const client = storeClient();
+    const [product, store] = await Promise.all([client.products.get(slug), client.store.get()]);
+    out(product, (p) => printProduct(p, store.currency));
+  });
+  products.command("create").description("Create a product. Prices are in normal units (e.g. 24.90)").requiredOption("-t, --title <title>", "Product title").option("-p, --price <amount>", "Price for a single-variant product, e.g. 24.90").option("-d, --description <text>", "Description").option("--type <type>", "physical or digital", "physical").option("--variant <spec>", 'Variant as "Title:price[:stock]", e.g. "Large:39.90:10" (repeatable)', collect).option("--option-name <name>", 'Option name for --variant titles, e.g. "size"').option("--stock <n>", "Track inventory with this quantity (single-variant products)").option("--sku <sku>", "SKU (single-variant products)").option("--image <pathOrUrl>", "Image file or URL (repeatable)", collect).option("--file <path>", "Downloadable file for digital products (repeatable)", collect).option("--draft", "Create as a draft (hidden from the storefront)").action(async (opts) => {
+    const client = storeClient();
+    const store = await client.store.get();
+    if (!opts.price && !opts.variant?.length) throw new CliError("Provide --price or at least one --variant", "price_required");
+    if (opts.file?.length && opts.type !== "digital") throw new CliError("--file requires --type digital", "not_digital");
+    const input = {
+      title: opts.title,
+      description: opts.description,
+      type: opts.type,
+      status: opts.draft ? "draft" : "active"
+    };
+    if (opts.variant?.length) {
+      input.variants = opts.variant.map((spec, i) => {
+        const [title, price, stock] = spec.split(":");
+        if (!title || !price) throw new CliError(`Invalid --variant "${spec}". Use "Title:price[:stock]"`, "invalid_variant");
+        return {
+          title,
+          price: toMinor(price, store.currency),
+          position: i,
+          ...opts.optionName && { options: { [opts.optionName]: title } },
+          ...stock !== void 0 && { track_inventory: true, inventory_quantity: Number(stock) }
+        };
+      });
+    } else {
+      input.variants = [
+        {
+          price: toMinor(opts.price, store.currency),
+          ...opts.sku && { sku: opts.sku },
+          ...opts.stock !== void 0 && { track_inventory: true, inventory_quantity: Number(opts.stock) }
+        }
+      ];
+    }
+    let product = await client.products.create(input);
+    product = await attachMedia(product, opts.image ?? [], opts.file ?? []);
+    out(product, (p) => {
+      log(`${c.green("\u2714")} Created`);
+      printProduct(p, store.currency);
+    });
+  });
+  products.command("update").description("Update a product (and its price/stock if it has a single variant)").argument("<slug>", "Product slug or id").option("-t, --title <title>").option("-d, --description <text>").option("-p, --price <amount>", "New price (single-variant products)").option("--compare-at <amount>", "Original price to show as a sale (single-variant products)").option("--stock <n>", "Set tracked inventory (single-variant products)").option("--status <status>", "active, draft or archived").option("--image <pathOrUrl>", "Add an image (repeatable)", collect).option("--file <path>", "Add a downloadable file (repeatable)", collect).action(async (slug, opts) => {
+    const client = storeClient();
+    const [store, existing] = await Promise.all([client.store.get(), client.products.get(slug)]);
+    let product = existing;
+    const fields = { title: opts.title, description: opts.description, status: opts.status };
+    if (Object.values(fields).some((v) => v !== void 0)) product = await client.products.update(existing.id, fields);
+    if (opts.price !== void 0 || opts.stock !== void 0 || opts.compareAt !== void 0) {
+      if (product.variants.length !== 1) {
+        throw new CliError("This product has several variants \u2014 update them with `kaching variants update <id>`.", "multiple_variants");
+      }
+      product = await client.variants.update(product.variants[0].id, {
+        ...opts.price !== void 0 && { price: toMinor(opts.price, store.currency) },
+        ...opts.compareAt !== void 0 && { compare_at_price: toMinor(opts.compareAt, store.currency) },
+        ...opts.stock !== void 0 && { track_inventory: true, inventory_quantity: Number(opts.stock) }
+      });
+    }
+    product = await attachMedia(product, opts.image ?? [], opts.file ?? []);
+    out(product, (p) => {
+      log(`${c.green("\u2714")} Updated`);
+      printProduct(p, store.currency);
+    });
+  });
+  products.command("delete").description("Delete a product (use `update --status archived` to just hide it)").argument("<slug>", "Product slug or id").action(async (slug) => {
+    const res = await storeClient().products.delete(slug);
+    out(res, () => log(`${c.green("\u2714")} Deleted ${slug}`));
+  });
+  products.command("import").description("Create products from a JSON file (array of product objects; prices in minor units, image/file paths relative to the JSON)").argument("<file>", "Path to JSON").action(async (file) => {
+    const client = storeClient();
+    const base = dirname2(resolve2(file));
+    const items = JSON.parse(readFileSync2(file, "utf8"));
+    if (!Array.isArray(items)) throw new CliError("The JSON file must contain an array of products", "invalid_import");
+    const created = [];
+    for (const { image_files = [], files = [], ...input } of items) {
+      log(`${c.dim("\u2022")} ${input.title}`);
+      const product = await client.products.create(input);
+      created.push(
+        await attachMedia(
+          product,
+          image_files.map((p) => isUrl(p) ? p : resolve2(base, p)),
+          files.map((p) => resolve2(base, p))
+        )
+      );
+    }
+    out(created, (list) => log(`${c.green("\u2714")} Imported ${list.length} product${list.length === 1 ? "" : "s"}`));
+  });
+  const variants = program2.command("variants").description("Manage product variants");
+  variants.command("update").description("Update a variant's price or stock").argument("<id>", "Variant id (see `kaching products get <slug>`)").option("-p, --price <amount>").option("--compare-at <amount>").option("--stock <n>").option("-t, --title <title>").action(async (id, opts) => {
+    const client = storeClient();
+    const store = await client.store.get();
+    const product = await client.variants.update(id, {
+      ...opts.title && { title: opts.title },
+      ...opts.price !== void 0 && { price: toMinor(opts.price, store.currency) },
+      ...opts.compareAt !== void 0 && { compare_at_price: toMinor(opts.compareAt, store.currency) },
+      ...opts.stock !== void 0 && { track_inventory: true, inventory_quantity: Number(opts.stock) }
+    });
+    out(product, (p) => printProduct(p, store.currency));
+  });
+  const shipping = program2.command("shipping").description("Manage shipping rates (physical products)");
+  shipping.command("list").action(async () => {
+    const client = storeClient();
+    const [{ data }, store] = await Promise.all([client.shippingRates.list(), client.store.get()]);
+    out(data, (list) => {
+      if (!list.length) return log("No shipping rates \u2014 physical orders ship free worldwide. Add one with `kaching shipping create`.");
+      table(
+        list.map((r) => ({
+          name: r.name,
+          price: formatMoney(r.amount, store.currency),
+          countries: r.countries.length ? r.countries.join(",") : "worldwide",
+          days: r.min_delivery_days != null ? `${r.min_delivery_days}-${r.max_delivery_days}` : "-",
+          active: r.active ? "yes" : "no",
+          id: r.id
+        }))
+      );
+    });
+  });
+  shipping.command("create").requiredOption("-n, --name <name>", 'e.g. "Standard"').requiredOption("-p, --price <amount>", "e.g. 4.90 (0 for free)").option("--countries <codes>", "Comma-separated ISO codes, e.g. US,CA (default: worldwide)").option("--days <min-max>", 'Delivery estimate in business days, e.g. "2-5"').action(async (opts) => {
+    const client = storeClient();
+    const store = await client.store.get();
+    const [min, max] = opts.days ? String(opts.days).split("-").map(Number) : [];
+    const rate = await client.shippingRates.create({
+      name: opts.name,
+      amount: toMinor(opts.price, store.currency),
+      countries: opts.countries ? String(opts.countries).split(",").map((s) => s.trim()) : [],
+      ...min !== void 0 && { min_delivery_days: min, max_delivery_days: max ?? min }
+    });
+    out(rate, (r) => log(`${c.green("\u2714")} Added ${r.name} (${formatMoney(r.amount, store.currency)})`));
+  });
+  shipping.command("delete").argument("<id>").action(async (id) => {
+    out(await storeClient().shippingRates.delete(id), () => log(`${c.green("\u2714")} Deleted`));
+  });
+  const payments = program2.command("payments").description("Stripe payouts setup");
+  payments.command("connect").description("Get the link where the store owner connects Stripe (the one step a human must do)").option("--country <code>", "Business country, e.g. US (asked during onboarding if omitted)").option("--email <email>", "Owner's email").option("--no-open", "Print the link without opening a browser").action(async (opts) => {
+    const client = storeClient();
+    const status = await client.payments.status().catch(() => null);
+    if (status?.ready) return out({ ready: true }, () => log(`${c.green("\u2714")} Payments are already set up.`));
+    const link = await client.payments.onboard({ country: opts.country, email: opts.email });
+    const opened = opts.open !== false && openBrowser(link.start_url);
+    out({ ready: false, onboarding_url: link.start_url }, () => {
+      log(`
+  The store owner needs to finish Stripe onboarding (about 5 minutes):
+`);
+      log(`  ${c.cyan(link.start_url)}
+`);
+      log(c.dim(`  ${opened ? "Opened in your browser. " : ""}The link stays valid for 7 days. Check progress with \`kaching payments status\`.`));
+    });
+  });
+  payments.command("status").action(async () => {
+    const status = await storeClient().payments.status();
+    out(
+      status,
+      (s) => log(s.ready ? `${c.green("\u2714")} Ready to accept payments` : `${c.yellow("\u2026")} Not ready (${s.connected ? s.card_payments_status : "not connected"})`)
+    );
+  });
+  const orders = program2.command("orders").description("View and fulfil orders");
+  orders.command("list").option("--unfulfilled", "Only orders waiting to ship").option("-l, --limit <n>", "How many", "20").action(async (opts) => {
+    const { data } = await storeClient().orders.list({
+      limit: Number(opts.limit),
+      ...opts.unfulfilled && { fulfillment_status: "unfulfilled" }
+    });
+    out(data, (list) => {
+      if (!list.length) return log("No orders yet.");
+      table(
+        list.map((o) => ({
+          number: `#${o.number}`,
+          date: o.created_at.slice(0, 10),
+          customer: o.email ?? "-",
+          items: o.items.reduce((n, i) => n + i.quantity, 0),
+          total: formatMoney(o.total, o.currency),
+          fulfillment: o.fulfillment_status,
+          id: o.id
+        }))
+      );
+    });
+  });
+  orders.command("fulfill").description("Mark an order as shipped").argument("<id>", "Order id").action(async (id) => {
+    const order = await storeClient().orders.fulfill(id);
+    out(order, (o) => log(`${c.green("\u2714")} Order #${o.number} marked fulfilled`));
+  });
+}
+
+// src/index.ts
+var program = new Command().name("kaching").description("Commerce for AI agents: products, cart, Stripe checkout and orders for your storefront.").version("0.1.0").option("--json", "Machine-readable output (for agents and scripts)").showHelpAfterError().hook("preAction", (cmd) => setJsonMode(Boolean(cmd.opts().json)));
+registerAuth(program);
+registerCreate(program);
+registerStoreCommands(program);
+program.command("mcp").description("Run the kaching MCP server over stdio (for Claude Code and other agents)").action(async () => {
+  const { startMcpServer } = await import("./mcp-LTF62ASB.js");
+  await startMcpServer();
+});
+program.parseAsync().catch(handleError);