kaching-cli 0.1.0

package/assets/template/src/components/order-confirmation.tsx

@@ -0,0 +1,116 @@
+"use client";
+
+import { formatMoney, useOrder } from "@kaching.sh/react";
+import Link from "next/link";
+
+export function OrderConfirmation({ sessionId }: { sessionId: string | null }) {
+  const { order, status } = useOrder(sessionId);
+
+  if (status === "loading") {
+    return (
+      <Centered>
+        <p className="animate-pulse text-muted">Confirming your payment…</p>
+      </Centered>
+    );
+  }
+
+  if (!order) {
+    return (
+      <Centered>
+        <h1 className="font-display text-4xl">We couldn&apos;t find that order</h1>
+        <p className="mt-4 text-muted">
+          If you were charged, your receipt is on its way by email. Otherwise,{" "}
+          <Link href="/" className="underline underline-offset-4">
+            return to the shop
+          </Link>
+          .
+        </p>
+      </Centered>
+    );
+  }
+
+  const downloads = order.items.flatMap((i) => i.downloads.map((d) => ({ ...d, title: i.title })));
+  const address = order.shipping_address;
+
+  return (
+    <div className="mx-auto max-w-2xl px-4 pt-16 sm:px-6">
+      <p className="text-sm uppercase tracking-[0.2em] text-muted">Order #{order.number}</p>
+      <h1 className="mt-4 font-display text-5xl leading-tight">Thank you{order.customer_name ? `, ${order.customer_name.split(" ")[0]}` : ""}.</h1>
+      <p className="mt-4 text-muted">
+        {order.email ? <>A receipt is on its way to {order.email}.</> : "Your order is confirmed."}
+      </p>
+
+      {downloads.length > 0 && (
+        <section className="mt-10 rounded-card border border-border bg-surface p-6">
+          <h2 className="font-medium">Your downloads</h2>
+          <ul className="mt-4 space-y-3">
+            {downloads.map((d) => (
+              <li key={d.url} className="flex items-center justify-between gap-4">
+                <span className="min-w-0 truncate text-sm">{d.filename}</span>
+                <a href={d.url} className="shrink-0 rounded-full bg-accent px-4 py-2 text-sm text-accent-foreground hover:opacity-90">
+                  Download
+                </a>
+              </li>
+            ))}
+          </ul>
+        </section>
+      )}
+
+      <section className="mt-10 border-t border-border pt-8">
+        <ul className="space-y-3">
+          {order.items.map((i) => (
+            <li key={i.id} className="flex justify-between gap-4">
+              <span>
+                {i.title}
+                {i.variant_title && <span className="text-muted"> · {i.variant_title}</span>}
+                <span className="text-muted"> × {i.quantity}</span>
+              </span>
+              <span className="tabular-nums">{formatMoney(i.line_total, order.currency)}</span>
+            </li>
+          ))}
+        </ul>
+        <dl className="mt-6 space-y-2 border-t border-border pt-6 text-sm">
+          <Row label="Subtotal" value={formatMoney(order.subtotal, order.currency)} />
+          {order.shipping_total > 0 && <Row label={order.shipping_rate_name ?? "Shipping"} value={formatMoney(order.shipping_total, order.currency)} />}
+          {order.tax_total > 0 && <Row label="Tax" value={formatMoney(order.tax_total, order.currency)} />}
+          <div className="flex justify-between pt-2 text-base font-medium">
+            <dt>Total</dt>
+            <dd className="tabular-nums">{formatMoney(order.total, order.currency)}</dd>
+          </div>
+        </dl>
+      </section>
+
+      {address && (
+        <section className="mt-10 border-t border-border pt-8 text-sm">
+          <h2 className="font-medium">Shipping to</h2>
+          <address className="mt-2 not-italic leading-relaxed text-muted">
+            {[address.name, address.line1, address.line2, [address.postal_code, address.city].filter(Boolean).join(" "), address.country]
+              .filter(Boolean)
+              .map((line) => (
+                <span key={line} className="block">
+                  {line}
+                </span>
+              ))}
+          </address>
+        </section>
+      )}
+
+      <Link href="/" className="mt-12 inline-block text-sm underline underline-offset-4">
+        Continue shopping
+      </Link>
+    </div>
+  );
+}
+
+function Row({ label, value }: { label: string; value: string }) {
+  return (
+    <div className="flex justify-between text-muted">
+      <dt>{label}</dt>
+      <dd className="tabular-nums">{value}</dd>
+    </div>
+  );
+}
+
+function Centered({ children }: { children: React.ReactNode }) {
+  return <div className="mx-auto max-w-xl px-4 py-32 text-center">{children}</div>;
+}

package/assets/template/src/components/price.tsx

@@ -0,0 +1,21 @@
+import { formatMoney } from "@kaching.sh/sdk";
+
+export function Price({
+  amount,
+  currency,
+  compareAt,
+  className = "",
+}: {
+  amount: number;
+  currency: string;
+  compareAt?: number | null;
+  className?: string;
+}) {
+  const onSale = compareAt != null && compareAt > amount;
+  return (
+    <span className={`tabular-nums ${className}`}>
+      <span className={onSale ? "text-sale" : undefined}>{formatMoney(amount, currency)}</span>
+      {onSale && <s className="ml-2 text-muted">{formatMoney(compareAt, currency)}</s>}
+    </span>
+  );
+}

package/assets/template/src/components/product-card.tsx

@@ -0,0 +1,44 @@
+import type { Product } from "@kaching.sh/sdk";
+import Image from "next/image";
+import Link from "next/link";
+import { Price } from "./price";
+
+export function ProductCard({ product, currency }: { product: Product; currency: string }) {
+  const image = product.images[0];
+  const soldOut = product.variants.every((v) => !v.available);
+  const range = product.price_range;
+  const first = product.variants[0];
+
+  return (
+    <Link href={`/products/${product.slug}`} className="group block">
+      <div className="relative aspect-[4/5] overflow-hidden rounded-card bg-surface">
+        {image ? (
+          <Image
+            src={image}
+            alt={product.title}
+            fill
+            sizes="(min-width: 1024px) 33vw, (min-width: 640px) 50vw, 100vw"
+            className="object-cover transition-transform duration-500 group-hover:scale-[1.03]"
+          />
+        ) : (
+          <div className="grid h-full place-items-center font-display text-6xl text-muted/60">{product.title[0]}</div>
+        )}
+        {soldOut && (
+          <span className="absolute left-3 top-3 rounded-full bg-background px-3 py-1 text-xs">Sold out</span>
+        )}
+        {product.type === "digital" && !soldOut && (
+          <span className="absolute left-3 top-3 rounded-full bg-background px-3 py-1 text-xs">Digital download</span>
+        )}
+      </div>
+      <div className="mt-4 flex items-baseline justify-between gap-4">
+        <h3 className="font-medium">{product.title}</h3>
+        {range && (
+          <p className="shrink-0 text-sm text-muted">
+            {range.min !== range.max && "From "}
+            <Price amount={range.min} currency={currency} compareAt={range.min === range.max ? first?.compare_at_price : null} />
+          </p>
+        )}
+      </div>
+    </Link>
+  );
+}

package/assets/template/src/components/product-form.tsx

@@ -0,0 +1,123 @@
+"use client";
+
+import type { Product, Variant } from "@kaching.sh/sdk";
+import { useCart } from "@kaching.sh/react";
+import { useMemo, useState } from "react";
+import { Price } from "./price";
+
+// Variant picker + add to cart. Variants with `options` (e.g. {size: "M", color: "Black"}) get one
+// selector per option; otherwise variants are chosen by title.
+export function ProductForm({ product, currency }: { product: Product; currency: string }) {
+  const { addItem, pending, error } = useCart();
+  const variants = product.variants;
+
+  const optionNames = useMemo(() => [...new Set(variants.flatMap((v) => Object.keys(v.options)))], [variants]);
+  const initial = variants.find((v) => v.available) ?? variants[0];
+  const [selected, setSelected] = useState<Variant>(initial);
+
+  const pickOption = (name: string, value: string) => {
+    const wanted = { ...selected.options, [name]: value };
+    const match =
+      variants.find((v) => optionNames.every((n) => v.options[n] === wanted[n])) ??
+      variants.find((v) => v.options[name] === value);
+    if (match) setSelected(match);
+  };
+
+  const [quantity, setQuantity] = useState(1);
+
+  return (
+    <div className="space-y-8">
+      <Price amount={selected.price} currency={currency} compareAt={selected.compare_at_price} className="text-2xl" />
+
+      {variants.length > 1 &&
+        (optionNames.length > 0 ? (
+          optionNames.map((name) => {
+            const values = [...new Set(variants.map((v) => v.options[name]).filter(Boolean))];
+            return (
+              <Fieldset key={name} legend={name}>
+                {values.map((value) => {
+                  const candidate = variants.find((v) => v.options[name] === value && optionNames.every((n) => n === name || v.options[n] === selected.options[n]));
+                  return (
+                    <Choice
+                      key={value}
+                      active={selected.options[name] === value}
+                      unavailable={candidate ? !candidate.available : false}
+                      onClick={() => pickOption(name, value)}
+                    >
+                      {value}
+                    </Choice>
+                  );
+                })}
+              </Fieldset>
+            );
+          })
+        ) : (
+          <Fieldset legend="Option">
+            {variants.map((v) => (
+              <Choice key={v.id} active={v.id === selected.id} unavailable={!v.available} onClick={() => setSelected(v)}>
+                {v.title}
+              </Choice>
+            ))}
+          </Fieldset>
+        ))}
+
+      <div className="flex gap-3">
+        {product.type === "physical" && (
+          <div className="flex items-center rounded-full border border-border">
+            <button type="button" onClick={() => setQuantity((q) => Math.max(1, q - 1))} className="h-14 w-12 text-muted hover:text-foreground" aria-label="Decrease quantity">
+              −
+            </button>
+            <span className="w-6 text-center tabular-nums">{quantity}</span>
+            <button type="button" onClick={() => setQuantity((q) => Math.min(99, q + 1))} className="h-14 w-12 text-muted hover:text-foreground" aria-label="Increase quantity">
+              +
+            </button>
+          </div>
+        )}
+        <button
+          type="button"
+          disabled={!selected.available || pending}
+          onClick={() => addItem(selected.id, quantity)}
+          className="h-14 flex-1 rounded-full bg-accent text-accent-foreground transition-opacity hover:opacity-90 disabled:cursor-not-allowed disabled:opacity-50"
+        >
+          {!selected.available ? "Sold out" : pending ? "Adding…" : "Add to cart"}
+        </button>
+      </div>
+      {error && <p className="text-sm text-sale">{error.message}</p>}
+      {product.type === "digital" && <p className="text-sm text-muted">Instant download after purchase. Links are also emailed to you.</p>}
+    </div>
+  );
+}
+
+function Fieldset({ legend, children }: { legend: string; children: React.ReactNode }) {
+  return (
+    <fieldset>
+      <legend className="mb-3 text-sm capitalize text-muted">{legend}</legend>
+      <div className="flex flex-wrap gap-2">{children}</div>
+    </fieldset>
+  );
+}
+
+function Choice({
+  active,
+  unavailable,
+  onClick,
+  children,
+}: {
+  active: boolean;
+  unavailable: boolean;
+  onClick: () => void;
+  children: React.ReactNode;
+}) {
+  return (
+    <button
+      type="button"
+      onClick={onClick}
+      aria-pressed={active}
+      className={`min-w-14 rounded-full border px-5 py-2.5 text-sm transition-colors ${
+        active ? "border-foreground bg-foreground text-background" : "border-border hover:border-foreground"
+      } ${unavailable ? "text-muted line-through" : ""}`}
+    >
+      {children}
+    </button>
+  );
+}

package/assets/template/src/components/providers.tsx

@@ -0,0 +1,14 @@
+"use client";
+
+import { KachingProvider } from "@kaching.sh/react";
+
+export function Providers({ children }: { children: React.ReactNode }) {
+  return (
+    <KachingProvider
+      publishableKey={process.env.NEXT_PUBLIC_KACHING_PUBLISHABLE_KEY!}
+      baseUrl={process.env.NEXT_PUBLIC_KACHING_API_URL}
+    >
+      {children}
+    </KachingProvider>
+  );
+}

package/assets/template/src/lib/kaching.ts

@@ -0,0 +1,24 @@
+import { createKaching, KachingError } from "@kaching.sh/sdk";
+import { notFound } from "next/navigation";
+import { cache } from "react";
+
+// Server-side client. The publishable key is safe here and in the browser; it can read the
+// catalog and create carts/checkouts, nothing else.
+export const kaching = createKaching({
+  apiKey: process.env.NEXT_PUBLIC_KACHING_PUBLISHABLE_KEY,
+  baseUrl: process.env.NEXT_PUBLIC_KACHING_API_URL,
+});
+
+// Deduped per request, so layout + pages can both ask for the store.
+export const getStore = cache(() => kaching.store.get());
+
+export const getProducts = cache(async () => (await kaching.products.list({ limit: 100 })).data);
+
+export const getProduct = cache(async (slug: string) => {
+  try {
+    return await kaching.products.get(slug);
+  } catch (err) {
+    if (err instanceof KachingError && err.status === 404) notFound();
+    throw err;
+  }
+});

package/assets/template/src/store.config.ts

@@ -0,0 +1,16 @@
+// Storefront copy and layout knobs. Colors and fonts live in src/app/globals.css.
+// The store name, currency and products come from kaching.
+export const storeConfig = {
+  hero: {
+    eyebrow: "New collection",
+    title: "Made slowly, made well.",
+    subtitle: "Small-batch goods, shipped from our studio to your door.",
+  },
+  /** Thin bar above the header. Set to null to hide. */
+  announcement: "Free returns within 30 days" as string | null,
+  footer: {
+    blurb: "Independent studio. Every order packed by hand.",
+  },
+  /** Product grid columns on large screens: 3 or 4. */
+  gridColumns: 3 as 3 | 4,
+};

package/assets/template/tsconfig.json

@@ -0,0 +1,34 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts",
+    "**/*.mts"
+  ],
+  "exclude": ["node_modules"]
+}

package/dist/chunk-TWKERERX.js

@@ -0,0 +1,283 @@
+#!/usr/bin/env node
+
+// ../js/dist/index.js
+var DEFAULT_BASE_URL = "https://kaching.sh/api/v1";
+var KachingError = class extends Error {
+  constructor(status, code, message, details) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.details = details;
+    this.name = "KachingError";
+  }
+  status;
+  code;
+  details;
+};
+function createKaching(options = {}) {
+  const baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+  const doFetch = options.fetch ?? globalThis.fetch.bind(globalThis);
+  const token = options.apiKey ?? options.sessionToken;
+  async function request(method, path, body, query) {
+    const url = new URL(baseUrl + path);
+    for (const [k, v] of Object.entries(query ?? {})) if (v !== void 0) url.searchParams.set(k, String(v));
+    const isForm = typeof FormData !== "undefined" && body instanceof FormData;
+    const res = await doFetch(url, {
+      method,
+      headers: {
+        ...token && { Authorization: `Bearer ${token}` },
+        ...body !== void 0 && !isForm && { "Content-Type": "application/json" }
+      },
+      body: body === void 0 ? void 0 : isForm ? body : JSON.stringify(body),
+      cache: "no-store"
+    });
+    const data = await res.json().catch(() => null);
+    if (!res.ok) {
+      const err = data?.error;
+      throw new KachingError(res.status, err?.code ?? "http_error", err?.message ?? `Request failed (${res.status})`, err?.details);
+    }
+    return data;
+  }
+  const get = (path, query) => request("GET", path, void 0, query);
+  const post = (path, body) => request("POST", path, body ?? {});
+  const patch = (path, body) => request("PATCH", path, body);
+  const del = (path) => request("DELETE", path);
+  const enc = encodeURIComponent;
+  return {
+    stores: {
+      /** Requires a Clerk session token. */
+      list: () => get("/stores"),
+      /** Requires a Clerk session token. Returns API keys once. */
+      create: (input) => post("/stores", input)
+    },
+    store: {
+      get: () => get("/store"),
+      update: (input) => patch("/store", input)
+    },
+    payments: {
+      status: () => get("/store/payments"),
+      /** Creates the Stripe account if needed and returns onboarding links. */
+      onboard: (input = {}) => post("/store/payments", input)
+    },
+    products: {
+      list: (query = {}) => get("/products", query),
+      /** By id or slug. */
+      get: (idOrSlug) => get(`/products/${enc(idOrSlug)}`),
+      create: (input) => post("/products", input),
+      update: (idOrSlug, input) => patch(`/products/${enc(idOrSlug)}`, input),
+      delete: (idOrSlug) => del(`/products/${enc(idOrSlug)}`),
+      addVariant: (idOrSlug, input) => post(`/products/${enc(idOrSlug)}/variants`, input),
+      /** Uploads an image (≤4 MB) and appends it to the product. */
+      uploadImage: (idOrSlug, file, filename = "image") => {
+        const form = new FormData();
+        form.append("file", file, filename);
+        return request("POST", `/products/${enc(idOrSlug)}/images`, form);
+      }
+    },
+    variants: {
+      update: (id, input) => patch(`/variants/${enc(id)}`, input),
+      delete: (id) => del(`/variants/${enc(id)}`),
+      files: {
+        list: (variantId) => get(`/variants/${enc(variantId)}/files`),
+        /** Registers a file and uploads its bytes via the signed URL. */
+        upload: async (variantId, file, filename) => {
+          const created = await post(`/variants/${enc(variantId)}/files`, {
+            filename,
+            content_type: file.type || void 0,
+            size_bytes: file.size
+          });
+          const res = await doFetch(created.upload_url, {
+            method: "PUT",
+            headers: file.type ? { "Content-Type": file.type } : {},
+            body: file
+          });
+          if (!res.ok) throw new KachingError(res.status, "upload_failed", `File upload failed (${res.status})`);
+          const { upload_url: _, ...rest } = created;
+          return rest;
+        }
+      }
+    },
+    shippingRates: {
+      list: () => get("/shipping-rates"),
+      create: (input) => post("/shipping-rates", input),
+      update: (id, input) => patch(`/shipping-rates/${enc(id)}`, input),
+      delete: (id) => del(`/shipping-rates/${enc(id)}`)
+    },
+    carts: {
+      create: (input = {}) => post("/carts", input),
+      get: (id) => get(`/carts/${enc(id)}`),
+      /** Adds to the existing quantity. */
+      addItem: (id, item) => post(`/carts/${enc(id)}/items`, item),
+      /** Sets the quantity; 0 removes the line. */
+      updateItem: (id, variantId, quantity) => patch(`/carts/${enc(id)}/items/${enc(variantId)}`, { quantity }),
+      removeItem: (id, variantId) => del(`/carts/${enc(id)}/items/${enc(variantId)}`),
+      checkout: (id, input) => post(`/carts/${enc(id)}/checkout`, input)
+    },
+    checkout: {
+      /** "Buy now": creates a cart and a checkout in one call. */
+      create: (input) => post("/checkout", input),
+      /** The order for a completed Checkout Session. 404 until the payment webhook lands — poll briefly. */
+      getOrder: (sessionId) => get(`/checkout/sessions/${enc(sessionId)}`)
+    },
+    orders: {
+      list: (query = {}) => get("/orders", query),
+      get: (id) => get(`/orders/${enc(id)}`),
+      fulfill: (id) => post(`/orders/${enc(id)}/fulfill`)
+    }
+  };
+}
+function formatMoney(amount, currency, locale) {
+  const code = currency.toUpperCase();
+  const digits = new Intl.NumberFormat("en", { style: "currency", currency: code }).resolvedOptions().maximumFractionDigits ?? 2;
+  return new Intl.NumberFormat(locale, { style: "currency", currency: code }).format(amount / 10 ** digits);
+}
+
+// src/output.ts
+import { spawn } from "child_process";
+var CliError = class extends Error {
+  constructor(message, code = "error") {
+    super(message);
+    this.code = code;
+  }
+  code;
+};
+var jsonMode = false;
+var setJsonMode = (on) => {
+  jsonMode = on;
+};
+var isJson = () => jsonMode;
+var tty = process.stdout.isTTY && !process.env.NO_COLOR;
+var wrap = (code) => (s) => tty ? `\x1B[${code}m${s}\x1B[0m` : s;
+var c = { bold: wrap(1), dim: wrap(2), green: wrap(32), yellow: wrap(33), red: wrap(31), cyan: wrap(36) };
+function out(data, human) {
+  if (jsonMode) console.log(JSON.stringify(data, null, 2));
+  else human(data);
+}
+function log(message) {
+  if (!jsonMode) console.error(message);
+}
+function table(rows) {
+  if (rows.length === 0) return;
+  const cols = Object.keys(rows[0]);
+  const width = (col) => Math.max(col.length, ...rows.map((r) => String(r[col]).length));
+  const widths = Object.fromEntries(cols.map((col) => [col, width(col)]));
+  console.log(c.dim(cols.map((col) => col.toUpperCase().padEnd(widths[col])).join("  ")));
+  for (const r of rows) console.log(cols.map((col) => String(r[col]).padEnd(widths[col])).join("  "));
+}
+function handleError(err) {
+  const e = err instanceof KachingError ? { code: err.code, message: err.message, status: err.status, details: err.details } : err instanceof CliError ? { code: err.code, message: err.message } : { code: "error", message: err instanceof Error ? err.message : String(err) };
+  if (jsonMode) console.log(JSON.stringify({ error: e }, null, 2));
+  else {
+    console.error(`${c.red("\u2716")} ${e.message}`);
+    if ("details" in e && e.details) console.error(c.dim(JSON.stringify(e.details)));
+  }
+  process.exit(1);
+}
+function openBrowser(url) {
+  if (!process.stdout.isTTY || process.env.CI) return false;
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+  const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+  try {
+    spawn(cmd, args, { stdio: "ignore", detached: true }).unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function toMinor(value, currency) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n < 0) throw new CliError(`Invalid price: ${value}`, "invalid_price");
+  const digits = new Intl.NumberFormat("en", { style: "currency", currency: currency.toUpperCase() }).resolvedOptions().maximumFractionDigits ?? 2;
+  return Math.round(n * 10 ** digits);
+}
+
+// src/config.ts
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var configPath = () => join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "kaching", "config.json");
+function readConfig() {
+  try {
+    return JSON.parse(readFileSync(configPath(), "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeConfig(update) {
+  const path = configPath();
+  mkdirSync(dirname(path), { recursive: true });
+  const next = { ...readConfig(), ...update };
+  for (const k of Object.keys(next)) if (next[k] === void 0) delete next[k];
+  writeFileSync(path, JSON.stringify(next, null, 2) + "\n", { mode: 384 });
+  chmodSync(path, 384);
+}
+function parseEnvFile(path) {
+  if (!existsSync(path)) return {};
+  const out2 = {};
+  for (const line of readFileSync(path, "utf8").split("\n")) {
+    const m = line.match(/^\s*([A-Z0-9_]+)\s*=\s*(.*)\s*$/);
+    if (m) out2[m[1]] = m[2].replace(/^["']|["']$/g, "");
+  }
+  return out2;
+}
+function upsertEnvFile(path, values) {
+  let text = existsSync(path) ? readFileSync(path, "utf8") : "";
+  for (const [key, value] of Object.entries(values)) {
+    if (value === void 0) continue;
+    const line = `${key}=${value}`;
+    const re = new RegExp(`^${key}=.*$`, "m");
+    text = re.test(text) ? text.replace(re, line) : `${text}${text && !text.endsWith("\n") ? "\n" : ""}${line}
+`;
+  }
+  writeFileSync(path, text, { mode: 384 });
+}
+function projectEnv() {
+  let dir = process.cwd();
+  for (; ; ) {
+    const env = { ...parseEnvFile(join(dir, ".env")), ...parseEnvFile(join(dir, ".env.local")) };
+    if (env.KACHING_SECRET_KEY || env.NEXT_PUBLIC_KACHING_PUBLISHABLE_KEY) return env;
+    const parent = dirname(dir);
+    if (parent === dir) return {};
+    dir = parent;
+  }
+}
+function apiUrl(override) {
+  return (override ?? process.env.KACHING_API_URL ?? projectEnv().NEXT_PUBLIC_KACHING_API_URL ?? readConfig().api_url ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+}
+function accountClient() {
+  const token = process.env.KACHING_ACCOUNT_TOKEN ?? readConfig().account_token;
+  if (!token) throw new CliError("Not logged in. Run `kaching login` first.", "not_logged_in");
+  return createKaching({ apiKey: token, baseUrl: apiUrl() });
+}
+function storeClient() {
+  const key = process.env.KACHING_SECRET_KEY ?? projectEnv().KACHING_SECRET_KEY;
+  if (!key) {
+    throw new CliError(
+      "No store linked to this folder. Run `kaching create` to make one, or `kaching link` to connect an existing store.",
+      "no_store"
+    );
+  }
+  return createKaching({ apiKey: key, baseUrl: apiUrl() });
+}
+
+export {
+  DEFAULT_BASE_URL,
+  KachingError,
+  formatMoney,
+  CliError,
+  setJsonMode,
+  isJson,
+  c,
+  out,
+  log,
+  table,
+  handleError,
+  openBrowser,
+  toMinor,
+  readConfig,
+  writeConfig,
+  upsertEnvFile,
+  apiUrl,
+  accountClient,
+  storeClient
+};