kaching-cli 0.1.0

package/dist/mcp-LTF62ASB.js

@@ -0,0 +1,313 @@
+#!/usr/bin/env node
+import {
+  CliError,
+  KachingError,
+  formatMoney,
+  storeClient,
+  toMinor
+} from "./chunk-TWKERERX.js";
+
+// src/mcp.ts
+import { readFileSync, statSync } from "fs";
+import { basename, extname, resolve } from "path";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+var ok = (data) => ({ content: [{ type: "text", text: JSON.stringify(data, null, 2) }] });
+function fail(err) {
+  const message = err instanceof KachingError ? `${err.message} (${err.code}${err.details ? `: ${JSON.stringify(err.details)}` : ""})` : err instanceof Error ? err.message : String(err);
+  return { content: [{ type: "text", text: `Error: ${message}` }], isError: true };
+}
+var run = (fn) => async (args) => {
+  try {
+    return ok(await fn(args));
+  } catch (err) {
+    return fail(err);
+  }
+};
+async function currency() {
+  return (await storeClient().store.get()).currency;
+}
+function describeProduct(p, cur) {
+  return {
+    id: p.id,
+    slug: p.slug,
+    title: p.title,
+    type: p.type,
+    status: p.status,
+    description: p.description,
+    images: p.images,
+    variants: p.variants.map((v) => ({
+      id: v.id,
+      title: v.title,
+      price: formatMoney(v.price, cur),
+      price_minor: v.price,
+      compare_at_price: v.compare_at_price != null ? formatMoney(v.compare_at_price, cur) : null,
+      options: v.options,
+      stock: v.track_inventory ? v.inventory_quantity : "untracked",
+      available: v.available,
+      files: v.files?.map((f) => f.filename) ?? []
+    }))
+  };
+}
+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 readLocal(path) {
+  const abs = resolve(path);
+  try {
+    statSync(abs);
+  } catch {
+    throw new CliError(`File not found: ${abs}`);
+  }
+  return { blob: new Blob([readFileSync(abs)], { type: MIME[extname(abs).toLowerCase()] ?? "application/octet-stream" }), name: basename(abs) };
+}
+var price = z.number().nonnegative().describe("Price in normal currency units, e.g. 24.9 for $24.90");
+var variantSchema = z.object({
+  title: z.string().describe('Variant name shown to shoppers, e.g. "Large"'),
+  price,
+  options: z.record(z.string(), z.string()).optional().describe('Option values, e.g. {"size": "L", "color": "Black"}'),
+  stock: z.number().int().min(0).optional().describe("Track inventory with this quantity. Omit for unlimited."),
+  sku: z.string().optional()
+});
+async function startMcpServer() {
+  const dir = [process.env.KACHING_PROJECT_DIR, process.env.CLAUDE_PROJECT_DIR].find((v) => v && !v.includes("${"));
+  if (dir) process.chdir(dir);
+  const server = new McpServer({ name: "kaching", version: "0.1.0" });
+  server.registerTool(
+    "store_info",
+    {
+      description: "Get the store linked to the current project: name, currency, and whether Stripe payments are ready. Call this first. If it errors with 'No store linked', run `npx kaching-cli create .` in the project folder.",
+      annotations: { readOnlyHint: true }
+    },
+    run(async () => storeClient().store.get())
+  );
+  server.registerTool(
+    "list_products",
+    { description: "List all products with variants, prices and stock.", annotations: { readOnlyHint: true } },
+    run(async () => {
+      const client = storeClient();
+      const [{ data }, cur] = await Promise.all([client.products.list({ limit: 100 }), currency()]);
+      return data.map((p) => describeProduct(p, cur));
+    })
+  );
+  server.registerTool(
+    "create_product",
+    {
+      description: "Create a product. For one price use `price`; for sizes/colors pass `variants`. Digital products (downloads) use type 'digital' and then attach_file. Images can be URLs or local file paths.",
+      inputSchema: {
+        title: z.string(),
+        description: z.string().optional(),
+        type: z.enum(["physical", "digital"]).default("physical"),
+        price: price.optional(),
+        stock: z.number().int().min(0).optional().describe("Inventory for single-price products. Omit for unlimited."),
+        variants: z.array(variantSchema).optional(),
+        images: z.array(z.string()).optional().describe("Image URLs or absolute/relative local paths"),
+        draft: z.boolean().optional().describe("Hide from the storefront until published")
+      }
+    },
+    run(async (args) => {
+      const client = storeClient();
+      const cur = await currency();
+      if (args.price === void 0 && !args.variants?.length) throw new CliError("Provide `price` or `variants`");
+      let product = await client.products.create({
+        title: args.title,
+        description: args.description,
+        type: args.type,
+        status: args.draft ? "draft" : "active",
+        images: (args.images ?? []).filter((i) => /^https?:\/\//.test(i)),
+        variants: args.variants?.length ? args.variants.map((v, i) => ({
+          title: v.title,
+          price: toMinor(String(v.price), cur),
+          position: i,
+          options: v.options,
+          sku: v.sku,
+          ...v.stock !== void 0 && { track_inventory: true, inventory_quantity: v.stock }
+        })) : [
+          {
+            price: toMinor(String(args.price), cur),
+            ...args.stock !== void 0 && { track_inventory: true, inventory_quantity: args.stock }
+          }
+        ]
+      });
+      for (const path of (args.images ?? []).filter((i) => !/^https?:\/\//.test(i))) {
+        const { blob, name } = readLocal(path);
+        product = await client.products.uploadImage(product.id, blob, name);
+      }
+      return describeProduct(product, cur);
+    })
+  );
+  server.registerTool(
+    "update_product",
+    {
+      description: "Update a product's title, description, status or images (by slug or id). Use update_variant for price/stock.",
+      inputSchema: {
+        product: z.string().describe("Product slug or id"),
+        title: z.string().optional(),
+        description: z.string().optional(),
+        status: z.enum(["active", "draft", "archived"]).optional(),
+        add_images: z.array(z.string()).optional().describe("Image URLs or local paths to append")
+      }
+    },
+    run(async (args) => {
+      const client = storeClient();
+      const cur = await currency();
+      let product = await client.products.get(args.product);
+      const urls = (args.add_images ?? []).filter((i) => /^https?:\/\//.test(i));
+      if (args.title !== void 0 || args.description !== void 0 || args.status !== void 0 || urls.length) {
+        product = await client.products.update(product.id, {
+          title: args.title,
+          description: args.description,
+          status: args.status,
+          ...urls.length && { images: [...product.images, ...urls] }
+        });
+      }
+      for (const path of (args.add_images ?? []).filter((i) => !/^https?:\/\//.test(i))) {
+        const { blob, name } = readLocal(path);
+        product = await client.products.uploadImage(product.id, blob, name);
+      }
+      return describeProduct(product, cur);
+    })
+  );
+  server.registerTool(
+    "update_variant",
+    {
+      description: "Change a variant's price, sale price, stock or title. Get variant ids from list_products.",
+      inputSchema: {
+        variant_id: z.string(),
+        price: price.optional(),
+        compare_at_price: price.optional().describe("Original price to show as a sale (must be higher than price)"),
+        stock: z.number().int().min(0).optional(),
+        title: z.string().optional()
+      }
+    },
+    run(async (args) => {
+      const cur = await currency();
+      const product = await storeClient().variants.update(args.variant_id, {
+        ...args.title && { title: args.title },
+        ...args.price !== void 0 && { price: toMinor(String(args.price), cur) },
+        ...args.compare_at_price !== void 0 && { compare_at_price: toMinor(String(args.compare_at_price), cur) },
+        ...args.stock !== void 0 && { track_inventory: true, inventory_quantity: args.stock }
+      });
+      return describeProduct(product, cur);
+    })
+  );
+  server.registerTool(
+    "delete_product",
+    {
+      description: "Permanently delete a product. Prefer update_product with status 'archived' to hide it.",
+      inputSchema: { product: z.string().describe("Product slug or id") },
+      annotations: { destructiveHint: true }
+    },
+    run(async (args) => storeClient().products.delete(args.product))
+  );
+  server.registerTool(
+    "attach_file",
+    {
+      description: "Attach a downloadable file (PDF, zip, audio...) to a digital product. Buyers get expiring download links.",
+      inputSchema: {
+        product: z.string().describe("Digital product slug or id"),
+        path: z.string().describe("Local file path"),
+        variant_id: z.string().optional().describe("Defaults to the product's first variant")
+      }
+    },
+    run(async (args) => {
+      const client = storeClient();
+      const product = await client.products.get(args.product);
+      const { blob, name } = readLocal(args.path);
+      return client.variants.files.upload(args.variant_id ?? product.variants[0].id, blob, name);
+    })
+  );
+  server.registerTool(
+    "list_shipping_rates",
+    { description: "List shipping rates. With none, physical orders ship free worldwide.", annotations: { readOnlyHint: true } },
+    run(async () => storeClient().shippingRates.list())
+  );
+  server.registerTool(
+    "create_shipping_rate",
+    {
+      description: "Add a flat shipping rate for physical products. Checkout offers up to 5 rates.",
+      inputSchema: {
+        name: z.string().describe('e.g. "Standard" or "Express"'),
+        price: price.describe("Shipping price in normal units; 0 for free"),
+        countries: z.array(z.string().length(2)).optional().describe("ISO country codes, e.g. ['US','CA']. Omit for worldwide."),
+        min_days: z.number().int().min(0).optional(),
+        max_days: z.number().int().min(0).optional()
+      }
+    },
+    run(async (args) => {
+      const cur = await currency();
+      return storeClient().shippingRates.create({
+        name: args.name,
+        amount: toMinor(String(args.price), cur),
+        countries: args.countries,
+        ...args.min_days !== void 0 && { min_delivery_days: args.min_days, max_delivery_days: args.max_days ?? args.min_days }
+      });
+    })
+  );
+  server.registerTool(
+    "payments_status",
+    { description: "Check whether the store can accept payments (Stripe onboarding finished).", annotations: { readOnlyHint: true } },
+    run(async () => storeClient().payments.status())
+  );
+  server.registerTool(
+    "connect_payments",
+    {
+      description: "Get the Stripe onboarding link the store owner must open to receive payouts. This is the one step a human must do \u2014 give them `onboarding_url`. Pass `country` (ISO code) for EUR and other multi-country currencies.",
+      inputSchema: {
+        country: z.string().length(2).optional(),
+        email: z.string().optional()
+      }
+    },
+    run(async (args) => {
+      const client = storeClient();
+      const status = await client.payments.status().catch(() => null);
+      if (status?.ready) return { ready: true };
+      const link = await client.payments.onboard({ country: args.country, email: args.email });
+      return { ready: false, onboarding_url: link.start_url, note: "Valid for 7 days. Owner completes it in the browser." };
+    })
+  );
+  server.registerTool(
+    "list_orders",
+    {
+      description: "List recent orders (newest first).",
+      inputSchema: { unfulfilled_only: z.boolean().optional(), limit: z.number().int().min(1).max(100).optional() },
+      annotations: { readOnlyHint: true }
+    },
+    run(async (args) => {
+      const { data } = await storeClient().orders.list({
+        limit: args.limit ?? 20,
+        ...args.unfulfilled_only && { fulfillment_status: "unfulfilled" }
+      });
+      return data.map((o) => ({
+        id: o.id,
+        number: o.number,
+        date: o.created_at,
+        email: o.email,
+        total: formatMoney(o.total, o.currency),
+        fulfillment_status: o.fulfillment_status,
+        items: o.items.map((i) => `${i.quantity}\xD7 ${i.title}${i.variant_title ? ` (${i.variant_title})` : ""}`),
+        ship_to: o.shipping_address
+      }));
+    })
+  );
+  server.registerTool(
+    "fulfill_order",
+    { description: "Mark a physical order as shipped.", inputSchema: { order_id: z.string() } },
+    run(async (args) => storeClient().orders.fulfill(args.order_id))
+  );
+  await server.connect(new StdioServerTransport());
+}
+export {
+  startMcpServer
+};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "kaching-cli",
+  "version": "0.1.0",
+  "description": "Build a real online store from your terminal (or your coding agent) in minutes",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "kaching": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "assets",
+    "LICENSE",
+    "README.md"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "commander": "^14",
+    "zod": "^4.6.5"
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "tsup": "^8",
+    "typescript": "^5",
+    "@kaching.sh/sdk": "0.1.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sventhaman/Kaching.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://kaching.sh",
+  "bugs": "https://github.com/sventhaman/Kaching/issues",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "kaching",
+    "ecommerce",
+    "cli",
+    "mcp",
+    "stripe",
+    "storefront",
+    "claude-code"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "node scripts/bundle-assets.mjs && tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit"
+  }
+}