glyphpay 0.4.0 → 1.0.0

package/README.md

@@ -1,184 +1,190 @@
-# glyphpay
-
-Drop-in connector that lets a website take payments through [GlyphPay](https://glyphpay.net) by Design Glyph. Payments go to the site owner's own Stripe connected account.
-
-| Import | Runs on | What it gives you |
-| --- | --- | --- |
-| `glyphpay/server` | Site's server | `glyphPay()`: `checkout` and `webhook` route handlers, plus `createPayment`, `getPayment`, `refund`, `reconcile` |
-| `glyphpay/react` | Browser | `<GlyphPayCheckout />` |
-| `glyphpay/browser` | Browser, any site | `mountCheckout(el, options)` for sites without React |
-
-The CLI covers setup, diagnostics, and credential lifecycle:
-
-| Command | What it does |
-| --- | --- |
-| `glyphpay connect` | Pair a site through the browser and write the server credential. |
-| `glyphpay doctor` | Check env, token, Stripe readiness, webhook URL, and an optional signed test event. |
-| `glyphpay rotate` | Re-pair the site and replace the credential. |
-| `glyphpay disconnect` | Revoke the credential and remove the local keys. |
-| `glyphpay deliveries` | List recent webhook deliveries and retry one with `--retry <id>`. |
-| `glyphpay init` | Scaffold routes for Next.js, Remix, Astro, SvelteKit, Hono, or Express. |
-
-## Connect a site from the CLI
-
-```sh
-npx glyphpay connect --url https://client-site.com
-```
-
-The command opens Glyph Pay in your browser. Sign in as the client's billing email (or a Design Glyph admin), pick the client account, confirm the webhook URL and approve the pairing code. The terminal receives a test service credential and, when a webhook URL was registered, its signing secret. It writes both to `.env.local`:
-
-```sh
-GLYPHPAY_TOKEN=dgsvc_test_...
-GLYPHPAY_CALLBACK_SECRET=dgcb_...
-```
-
-- `--url <site>` registers `<site>/api/glyphpay/webhook`. Pass a full URL to use a different route.
-- `--env <path>` targets another env file; `--print` prints the values instead of writing.
-- `--no-open`, `--base-url` and `--timeout` help scripts and local testing.
-- Codes expire after ten minutes. Approving again rotates the token: the previous token stops working immediately.
-- Pairing is disabled while the platform is in live mode.
-
-The browser never receives the credential. Keep the token in server environment variables and never prefix it with `NEXT_PUBLIC_`, `VITE_` or `PUBLIC_`.
-
-## Check, rotate, and disconnect
-
-```sh
-npx glyphpay doctor
-npx glyphpay doctor --json
-npx glyphpay rotate
-npx glyphpay disconnect
-```
-
-`doctor` verifies the local env file, checks for credentials leaked into public-prefixed variables, validates the token with Glyph Pay, checks Stripe charge readiness and the registered webhook, and optionally sends a signed test event:
-
-```sh
-npx glyphpay doctor --send-test-event
-```
-
-The test event has type `webhook.test` and a zero-dollar `data` payload. Ignore event types you do not handle in `onEvent`; do not treat the test event as a real payment.
-
-`rotate` re-runs browser approval and reuses the registered callback URL when the current token is still valid. `disconnect` revokes the credential immediately and removes `GLYPHPAY_TOKEN` and `GLYPHPAY_CALLBACK_SECRET` from the env file; pass `--yes` in scripts or `--keep-env` to leave the local values in place.
-
-## Inspect and retry webhook deliveries
-
-```sh
-npx glyphpay deliveries
-npx glyphpay deliveries --retry evt_...
-```
-
-`deliveries` lists the most recent callback outbox records for the credential's client and environment: event type, delivery state, attempt count, timestamp, and the last error. A retry sends the exact stored signed event again and persists the result. Retry is one attempt; fix the endpoint first. The admin **Connections** tab exposes the same operations.
-
-## Scaffold a site
-
-```sh
-npx glyphpay init
-```
-
-The command detects the project framework from `package.json`. It creates a server connector plus the framework-native checkout and webhook entry points, and appends placeholders to `.env.example` without changing existing values. Supported targets:
-
-- **Next.js App Router** — `app/api/glyphpay/*` or `src/app/api/glyphpay/*` route handlers.
-- **SvelteKit** — `src/routes/api/glyphpay/*/+server.ts` with `src/lib/server/glyphpay.ts`.
-- **Astro** — `src/pages/api/glyphpay/*.ts`; use server/SSR output and an adapter.
-- **Remix** — `app/routes/api.glyphpay.*.ts` with `app/lib/glyphpay.server.ts`.
-- **Hono** — `src/glyphpay-routes.ts`; mount it with `app.route("/api/glyphpay", glyphpayRoutes)`.
-- **Express** — `src/glyphpay-routes.ts`; mount it with `app.use("/api/glyphpay", glyphpayRoutes)`. The webhook route uses `express.raw` so signatures verify against the original bytes.
-
-It refuses to overwrite existing files unless you pass `--force`; use `--dry-run` to preview. Then run `glyphpay connect` and wire `priceOrder()` and `onEvent()` to your order database.
-
-## Manual setup: connect the client in Design Glyph admin
-
-1. **Admin → Clients → (client)**: make sure Stripe onboarding is complete (charges enabled).
-2. **Issue a service credential** (test first). Copy the `dgsvc_test_…` token. It is shown only once.
-3. **Set the callback URL** to `https://<client-site>/api/glyphpay/webhook`. Copy the signing secret. It is also shown only once.
-
-## Add to the client site
-
-```sh
-pnpm add glyphpay
-```
-
-`.env` (server only, never `NEXT_PUBLIC_`):
-
-```sh
-GLYPHPAY_TOKEN=dgsvc_test_...
-GLYPHPAY_CALLBACK_SECRET=...
-```
-
-`lib/glyphpay.ts`
-
-```ts
-import { glyphPay, CheckoutError } from "glyphpay/server";
-
-export const glyphpay = glyphPay({
-  token: process.env.GLYPHPAY_TOKEN,
-  callbackSecret: process.env.GLYPHPAY_CALLBACK_SECRET,
-
-  // Price the order from YOUR data. Never trust an amount sent by the browser.
-  async priceOrder(body) {
-    const cart = await db.carts.get((body as { cartId: string }).cartId);
-    if (!cart?.items.length) throw new CheckoutError("Your cart is empty.");
-    // orderId must change whenever the total changes, or GlyphPay returns 409.
-    return { orderId: `${cart.id}-v${cart.version}`, amountCents: cart.totalCents, description: `Order ${cart.id}` };
-  },
-
-  // Signed and verified. At-least-once delivery: dedupe on event.id. Throw to have it retried.
-  async onEvent(event) {
-    if (event.type === "payment.succeeded") await db.orders.markPaid(event.data.orderId, event.id);
-  },
-});
-```
-
-`app/api/glyphpay/checkout/route.ts`
-
-```ts
-import { glyphpay } from "@/lib/glyphpay";
-export const POST = glyphpay.checkout;
-```
-
-`app/api/glyphpay/webhook/route.ts`
-
-```ts
-import { glyphpay } from "@/lib/glyphpay";
-export const POST = glyphpay.webhook;
-```
-
-Checkout page:
-
-```tsx
-import { GlyphPayCheckout } from "glyphpay/react";
-
-<GlyphPayCheckout order={{ cartId }} returnUrl={`/thank-you?cart=${cartId}`} appearance={{ theme: "stripe" }} />
-```
-
-Style the button with `.glyphpay button { … }`. Errors appear in `.glyphpay [role=alert]`.
-
-Without React:
-
-```html
-<div id="pay"></div>
-<script type="module">
-  import { mountCheckout } from "glyphpay/browser";
-  mountCheckout(document.getElementById("pay"), { order: { cartId: "42" }, returnUrl: "/thank-you" });
-</script>
-```
-
-The route handlers take a standard `Request` and return a `Response`, so the same two lines work in Remix, Astro, Hono, SvelteKit, and Cloudflare Workers. In Express, `glyphpay init` generates a small adapter that preserves the raw webhook body.
-
-## How a payment flows
-
-1. The component POSTs `order` to `/api/glyphpay/checkout`. `priceOrder` sets the amount, and the site's server calls GlyphPay with the token.
-2. The browser gets back only `clientSecret`, `publishableKey`, and `stripeAccount`, then mounts Stripe's Payment Element.
-3. The shopper pays, and Stripe redirects to `returnUrl`. **The redirect doesn't prove payment.**
-4. GlyphPay POSTs `payment.succeeded` to `/api/glyphpay/webhook`, and `onEvent` marks the order paid. The thank-you page reads the order status from your database, or calls `glyphpay.getPayment(paymentId)`.
-
-Refunds run server-side:
-
-```ts
-await glyphpay.refund(paymentId, { idempotencyKey: `${orderId}-refund-1` });
-```
-
-## Develop
-
-```sh
-cd packages/glyphpay && npm install && npm test
-```
+# glyphpay
+
+Drop-in connector that lets a website take payments through [GlyphPay](https://glyphpay.net) by Design Glyph. Payments go to the site owner's own Stripe connected account.
+
+| Import | Runs on | What it gives you |
+| --- | --- | --- |
+| `glyphpay/server` | Site's server | `glyphPay()`: `checkout` and `webhook` route handlers, plus `createPayment`, `getPayment`, `refund`, `reconcile` |
+| `glyphpay/react` | Browser | `<GlyphPayCheckout />` |
+| `glyphpay/browser` | Browser, any site | `mountCheckout(el, options)` for sites without React |
+
+The CLI covers setup, diagnostics, and credential lifecycle:
+
+| Command | What it does |
+| --- | --- |
+| `glyphpay connect` | Pair a site through the browser and write the server credential. |
+| `glyphpay doctor` | Check env, token, Stripe readiness, webhook URL, and an optional signed test event. |
+| `glyphpay rotate` | Re-pair the site and replace the credential. |
+| `glyphpay disconnect` | Revoke the credential and remove the local keys. |
+| `glyphpay deliveries` | Page/filter webhook deliveries and retry one with `--retry <id>`. |
+| `glyphpay init` | Scaffold routes for Next.js, Remix, Astro, SvelteKit, Hono, or Express. |
+
+## 1.0 compatibility
+
+`glyphpay` 1.x follows Semantic Versioning. The documented package exports and the `/api/client/v1` and `/api/cli/v1` HTTP contracts accept additive changes only; ignore unknown response fields and event types. Breaking changes ship under a new API version with an overlap period. The full rules are in `docs/versioning-policy.md`.
+
+The CLI supports **Node 18+**. The server connector (`glyphpay/server`) uses `fetch` and Web Crypto and targets **Node 20+**, Next.js, edge runtimes, and Cloudflare Workers. A 1.0 release is a code and contract milestone: live payments remain gated by sandbox acceptance, deployment verification, and written approval.
+
+## Connect a site from the CLI
+
+```sh
+npx glyphpay connect --url https://client-site.com
+```
+
+The command opens Glyph Pay in your browser. Sign in as the client's billing email (or a Design Glyph admin), pick the client account, confirm the webhook URL and approve the pairing code. The terminal receives a test service credential and, when a webhook URL was registered, its signing secret. It writes both to `.env.local`:
+
+```sh
+GLYPHPAY_TOKEN=dgsvc_test_...
+GLYPHPAY_CALLBACK_SECRET=dgcb_...
+```
+
+- `--url <site>` registers `<site>/api/glyphpay/webhook`. Pass a full URL to use a different route.
+- `--env <path>` targets another env file; `--print` prints the values instead of writing.
+- `--no-open`, `--base-url` and `--timeout` help scripts and local testing.
+- Codes expire after ten minutes. Approving again rotates the token: the previous token stops working immediately.
+- Pairing is disabled while the platform is in live mode.
+
+The browser never receives the credential. Keep the token in server environment variables and never prefix it with `NEXT_PUBLIC_`, `VITE_` or `PUBLIC_`.
+
+## Check, rotate, and disconnect
+
+```sh
+npx glyphpay doctor
+npx glyphpay doctor --json
+npx glyphpay rotate
+npx glyphpay disconnect
+```
+
+`doctor` verifies the local env file, checks for credentials leaked into public-prefixed variables, validates the token with Glyph Pay, checks Stripe charge readiness and the registered webhook, and optionally sends a signed test event:
+
+```sh
+npx glyphpay doctor --send-test-event
+```
+
+The test event has type `webhook.test` and a zero-dollar `data` payload. Ignore event types you do not handle in `onEvent`; do not treat the test event as a real payment.
+
+`rotate` re-runs browser approval and reuses the registered callback URL when the current token is still valid. `disconnect` revokes the credential immediately and removes `GLYPHPAY_TOKEN` and `GLYPHPAY_CALLBACK_SECRET` from the env file; pass `--yes` in scripts or `--keep-env` to leave the local values in place.
+
+## Inspect and retry webhook deliveries
+
+```sh
+npx glyphpay deliveries
+npx glyphpay deliveries --retry evt_...
+```
+
+`deliveries` pages through callback outbox records for the credential's client and environment: event type, delivery state, attempt count, timestamp, and the last error. Filter with `--state pending|delivered|failed`, control the page with `--limit 1..100`, and pass the returned `--cursor` for the next page. A retry sends the exact stored signed event again and persists the result. Retry is one attempt; fix the endpoint first. The admin **Connections** tab exposes the same filtering, pagination, and retry operations.
+
+## Scaffold a site
+
+```sh
+npx glyphpay init
+```
+
+The command detects the project framework from `package.json`. It creates a server connector plus the framework-native checkout and webhook entry points, and appends placeholders to `.env.example` without changing existing values. Supported targets:
+
+- **Next.js App Router** — `app/api/glyphpay/*` or `src/app/api/glyphpay/*` route handlers.
+- **SvelteKit** — `src/routes/api/glyphpay/*/+server.ts` with `src/lib/server/glyphpay.ts`.
+- **Astro** — `src/pages/api/glyphpay/*.ts`; use server/SSR output and an adapter.
+- **Remix** — `app/routes/api.glyphpay.*.ts` with `app/lib/glyphpay.server.ts`.
+- **Hono** — `src/glyphpay-routes.ts`; mount it with `app.route("/api/glyphpay", glyphpayRoutes)`.
+- **Express** — `src/glyphpay-routes.ts`; mount it with `app.use("/api/glyphpay", glyphpayRoutes)`. The webhook route uses `express.raw` so signatures verify against the original bytes.
+
+It refuses to overwrite existing files unless you pass `--force`; use `--dry-run` to preview. Then run `glyphpay connect` and wire `priceOrder()` and `onEvent()` to your order database.
+
+## Manual setup: connect the client in Design Glyph admin
+
+1. **Admin → Clients → (client)**: make sure Stripe onboarding is complete (charges enabled).
+2. **Issue a service credential** (test first). Copy the `dgsvc_test_…` token. It is shown only once.
+3. **Set the callback URL** to `https://<client-site>/api/glyphpay/webhook`. Copy the signing secret. It is also shown only once.
+
+## Add to the client site
+
+```sh
+pnpm add glyphpay
+```
+
+`.env` (server only, never `NEXT_PUBLIC_`):
+
+```sh
+GLYPHPAY_TOKEN=dgsvc_test_...
+GLYPHPAY_CALLBACK_SECRET=...
+```
+
+`lib/glyphpay.ts`
+
+```ts
+import { glyphPay, CheckoutError } from "glyphpay/server";
+
+export const glyphpay = glyphPay({
+  token: process.env.GLYPHPAY_TOKEN,
+  callbackSecret: process.env.GLYPHPAY_CALLBACK_SECRET,
+
+  // Price the order from YOUR data. Never trust an amount sent by the browser.
+  async priceOrder(body) {
+    const cart = await db.carts.get((body as { cartId: string }).cartId);
+    if (!cart?.items.length) throw new CheckoutError("Your cart is empty.");
+    // orderId must change whenever the total changes, or GlyphPay returns 409.
+    return { orderId: `${cart.id}-v${cart.version}`, amountCents: cart.totalCents, description: `Order ${cart.id}` };
+  },
+
+  // Signed and verified. At-least-once delivery: dedupe on event.id. Throw to have it retried.
+  async onEvent(event) {
+    if (event.type === "payment.succeeded") await db.orders.markPaid(event.data.orderId, event.id);
+  },
+});
+```
+
+`app/api/glyphpay/checkout/route.ts`
+
+```ts
+import { glyphpay } from "@/lib/glyphpay";
+export const POST = glyphpay.checkout;
+```
+
+`app/api/glyphpay/webhook/route.ts`
+
+```ts
+import { glyphpay } from "@/lib/glyphpay";
+export const POST = glyphpay.webhook;
+```
+
+Checkout page:
+
+```tsx
+import { GlyphPayCheckout } from "glyphpay/react";
+
+<GlyphPayCheckout order={{ cartId }} returnUrl={`/thank-you?cart=${cartId}`} appearance={{ theme: "stripe" }} />
+```
+
+Style the button with `.glyphpay button { … }`. Errors appear in `.glyphpay [role=alert]`.
+
+Without React:
+
+```html
+<div id="pay"></div>
+<script type="module">
+  import { mountCheckout } from "glyphpay/browser";
+  mountCheckout(document.getElementById("pay"), { order: { cartId: "42" }, returnUrl: "/thank-you" });
+</script>
+```
+
+The route handlers take a standard `Request` and return a `Response`, so the same two lines work in Remix, Astro, Hono, SvelteKit, and Cloudflare Workers. In Express, `glyphpay init` generates a small adapter that preserves the raw webhook body.
+
+## How a payment flows
+
+1. The component POSTs `order` to `/api/glyphpay/checkout`. `priceOrder` sets the amount, and the site's server calls GlyphPay with the token.
+2. The browser gets back only `clientSecret`, `publishableKey`, and `stripeAccount`, then mounts Stripe's Payment Element.
+3. The shopper pays, and Stripe redirects to `returnUrl`. **The redirect doesn't prove payment.**
+4. GlyphPay POSTs `payment.succeeded` to `/api/glyphpay/webhook`, and `onEvent` marks the order paid. The thank-you page reads the order status from your database, or calls `glyphpay.getPayment(paymentId)`.
+
+Refunds run server-side:
+
+```ts
+await glyphpay.refund(paymentId, { idempotencyKey: `${orderId}-refund-1` });
+```
+
+## Develop
+
+```sh
+cd packages/glyphpay && npm install && npm test
+```

package/dist/cli.d.ts

@@ -51,6 +51,12 @@ export interface CliOptions {
     dir?: string;
     /** Deliveries: replay one failed or delivered callback by id. */
     retry?: string;
+    /** Deliveries: filter by delivery state. */
+    state?: "pending" | "delivered" | "failed";
+    /** Deliveries: opaque next-page cursor returned by the API. */
+    cursor?: string;
+    /** Deliveries: page size, 1-100. */
+    limit?: number;
 }
 export interface ConnectResult {
     businessName: string;
@@ -79,6 +85,7 @@ export interface CallbackDeliveriesResponse {
     businessName: string;
     environment: "test" | "live";
     deliveries: CallbackDeliveryView[];
+    nextCursor: string | null;
 }
 export interface CallbackReplayResponse {
     outcome: "delivered" | "retry" | "failed";

package/dist/cli.js

@@ -20,7 +20,7 @@ import { access, chmod, mkdir, readFile, stat, writeFile } from "node:fs/promise
 import { dirname, join, relative, resolve } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { pathToFileURL } from "node:url";
-const VERSION = "0.4.0";
+const VERSION = "1.0.0";
 const DEFAULT_BASE_URL = "https://designglyph.web.app";
 const DEFAULT_ENV_FILE = ".env.local";
 const DEFAULT_TIMEOUT_SECONDS = 600;
@@ -180,6 +180,40 @@ export function parseArgs(argv) {
             }
             continue;
         }
+        if (flag === "--state") {
+            const raw = inlineValue ?? takeValue(argv, index, flag)[0];
+            if (inlineValue === undefined)
+                index += 1;
+            if (raw !== "pending" && raw !== "delivered" && raw !== "failed") {
+                throw new CliUsageError("--state must be pending, delivered, or failed.");
+            }
+            options.state = raw;
+            continue;
+        }
+        if (flag === "--cursor") {
+            if (inlineValue !== undefined) {
+                if (!inlineValue)
+                    throw new CliUsageError("--cursor needs a value.");
+                options.cursor = inlineValue;
+            }
+            else {
+                const [value, next] = takeValue(argv, index, flag);
+                options.cursor = value;
+                index = next;
+            }
+            continue;
+        }
+        if (flag === "--limit") {
+            const raw = inlineValue ?? takeValue(argv, index, flag)[0];
+            if (inlineValue === undefined)
+                index += 1;
+            const parsed = Number(raw);
+            if (!Number.isInteger(parsed) || parsed < 1 || parsed > 100) {
+                throw new CliUsageError("--limit must be an integer between 1 and 100.");
+            }
+            options.limit = parsed;
+            continue;
+        }
         if (flag === "--dir") {
             if (inlineValue !== undefined) {
                 if (!inlineValue)
@@ -211,44 +245,47 @@ export function parseArgs(argv) {
     return { command, options };
 }
 export function helpText() {
-    return `glyphpay - take payments on your site through Glyph Pay
-
-Usage
-  glyphpay connect [options]       Connect a site (alias: login)
-  glyphpay rotate [options]        Re-pair and rotate the current credential
-  glyphpay disconnect [options]    Revoke the credential and remove local keys
-  glyphpay doctor [options]        Check env, token, Stripe and webhook setup
-  glyphpay deliveries [options]    List recent webhook deliveries
-  glyphpay init [options]          Scaffold an integration for your framework
-  glyphpay --version
-
-Connect / rotate
-  --url <site-url>         Site to connect. Adds ${WEBHOOK_PATH} when the URL
-                           has no path. Or pass the exact callback URL.
-  --env <path>             Env file to update (default: ${DEFAULT_ENV_FILE})
-  --print                  Print the credentials instead of writing a file
-  --no-open                Do not open a browser automatically
-  --base-url <url>         Glyph Pay API origin (default: ${DEFAULT_BASE_URL})
-  --timeout <seconds>      Wait for approval (default: ${DEFAULT_TIMEOUT_SECONDS})
-
-Doctor
-  --json                   Print a machine-readable report
-  --send-test-event        POST a signed webhook.test event to the callback URL
-
-Disconnect
-  --yes, -y                Do not ask for confirmation
-  --keep-env               Keep the local env values after revocation
-
-Deliveries
-  --retry <id>             Send one stored webhook again (alias: webhooks)
-  --json                   Print a machine-readable response
-
-Init
-  --dir <path>             Project directory (default: current directory)
-  --dry-run                Show planned files without writing them
-  --force                  Overwrite generated files
-
-The browser step signs in to Glyph Pay, lets you pick the client account, and
+    return `glyphpay - take payments on your site through Glyph Pay
+
+Usage
+  glyphpay connect [options]       Connect a site (alias: login)
+  glyphpay rotate [options]        Re-pair and rotate the current credential
+  glyphpay disconnect [options]    Revoke the credential and remove local keys
+  glyphpay doctor [options]        Check env, token, Stripe and webhook setup
+  glyphpay deliveries [options]    List recent webhook deliveries
+  glyphpay init [options]          Scaffold an integration for your framework
+  glyphpay --version
+
+Connect / rotate
+  --url <site-url>         Site to connect. Adds ${WEBHOOK_PATH} when the URL
+                           has no path. Or pass the exact callback URL.
+  --env <path>             Env file to update (default: ${DEFAULT_ENV_FILE})
+  --print                  Print the credentials instead of writing a file
+  --no-open                Do not open a browser automatically
+  --base-url <url>         Glyph Pay API origin (default: ${DEFAULT_BASE_URL})
+  --timeout <seconds>      Wait for approval (default: ${DEFAULT_TIMEOUT_SECONDS})
+
+Doctor
+  --json                   Print a machine-readable report
+  --send-test-event        POST a signed webhook.test event to the callback URL
+
+Disconnect
+  --yes, -y                Do not ask for confirmation
+  --keep-env               Keep the local env values after revocation
+
+Deliveries
+  --state <state>          pending, delivered, or failed
+  --limit <n>              Page size, 1-100 (default: 50)
+  --cursor <cursor>        Next-page cursor from the previous response
+  --retry <id>             Send one stored webhook again (alias: webhooks)
+  --json                   Print a machine-readable response
+
+Init
+  --dir <path>             Project directory (default: current directory)
+  --dry-run                Show planned files without writing them
+  --force                  Overwrite generated files
+
+The browser step signs in to Glyph Pay, lets you pick the client account, and
 approves this machine. The service credential goes only to this terminal.`;
 }
 /* ------------------------------------------------------------------ */
@@ -890,7 +927,15 @@ export async function runDeliveries(options = {}) {
         }
         return result;
     }
-    const result = await api(baseUrl, "/credential/deliveries", undefined, token);
+    const params = new URLSearchParams();
+    if (options.state)
+        params.set("state", options.state);
+    if (options.limit)
+        params.set("limit", String(options.limit));
+    if (options.cursor)
+        params.set("cursor", options.cursor);
+    const query = params.toString();
+    const result = await api(baseUrl, `/credential/deliveries${query ? `?${query}` : ""}`, undefined, token);
     if (options.json) {
         say(JSON.stringify(result, null, 2));
         return result;
@@ -899,13 +944,22 @@ export async function runDeliveries(options = {}) {
     say(style(1, `Webhook deliveries - ${result.businessName} (${result.environment} mode)`));
     say();
     if (result.deliveries.length === 0) {
-        say("No deliveries recorded yet.");
+        say(options.state ? `No ${options.state} deliveries recorded.` : "No deliveries recorded yet.");
     }
     else {
         for (const delivery of result.deliveries)
             printDelivery(delivery);
         say();
         say("Retry one with `glyphpay deliveries --retry <id>`.");
+        if (result.nextCursor) {
+            const next = ["glyphpay deliveries"];
+            if (options.state)
+                next.push("--state", options.state);
+            if (options.limit)
+                next.push("--limit", String(options.limit));
+            next.push("--cursor", result.nextCursor);
+            say(`Next page: ${next.join(" ")}`);
+        }
     }
     return result;
 }
@@ -913,28 +967,28 @@ function libTemplate(ts) {
     const cartId = ts
         ? `const cartId = (body as { cartId?: string } | null)?.cartId;`
         : `const cartId = body?.cartId;`;
-    return `import { glyphPay, CheckoutError } from "glyphpay/server";
-
-export const glyphpay = glyphPay({
-  token: process.env.GLYPHPAY_TOKEN,
-  callbackSecret: process.env.GLYPHPAY_CALLBACK_SECRET,
-
-  async priceOrder(body) {
-    // Load the cart/order from YOUR database and return its server-side price.
-    // Never trust an amount sent by the browser.
-    ${cartId}
-    if (!cartId) throw new CheckoutError("Your cart is empty.");
-    throw new CheckoutError("Connect priceOrder() to your order database before accepting payments.");
-  },
-
-  async onEvent(event) {
-    // At-least-once delivery: dedupe on event.id before changing an order.
-    if (event.type === "payment.succeeded") {
-      // TODO: mark the order paid and store event.id.
-      console.log(\`GlyphPay payment succeeded for \${event.data.orderId}\`);
-    }
-  },
-});
+    return `import { glyphPay, CheckoutError } from "glyphpay/server";
+
+export const glyphpay = glyphPay({
+  token: process.env.GLYPHPAY_TOKEN,
+  callbackSecret: process.env.GLYPHPAY_CALLBACK_SECRET,
+
+  async priceOrder(body) {
+    // Load the cart/order from YOUR database and return its server-side price.
+    // Never trust an amount sent by the browser.
+    ${cartId}
+    if (!cartId) throw new CheckoutError("Your cart is empty.");
+    throw new CheckoutError("Connect priceOrder() to your order database before accepting payments.");
+  },
+
+  async onEvent(event) {
+    // At-least-once delivery: dedupe on event.id before changing an order.
+    if (event.type === "payment.succeeded") {
+      // TODO: mark the order paid and store event.id.
+      console.log(\`GlyphPay payment succeeded for \${event.data.orderId}\`);
+    }
+  },
+});
 `;
 }
 function routeTemplate(libImport) {

package/package.json

@@ -1,60 +1,60 @@
-{
-  "name": "glyphpay",
-  "version": "0.4.0",
-  "description": "Drop-in GlyphPay checkout for websites, with a CLI for setup, diagnostics, and credential lifecycle.",
-  "homepage": "https://glyphpay.net",
-  "keywords": [
-    "glyphpay",
-    "payments",
-    "checkout",
-    "stripe",
-    "react",
-    "nextjs"
-  ],
-  "license": "UNLICENSED",
-  "type": "module",
-  "bin": {
-    "glyphpay": "dist/cli.js"
-  },
-  "files": [
-    "dist"
-  ],
-  "engines": {
-    "node": ">=18"
-  },
-  "exports": {
-    "./server": {
-      "types": "./dist/server.d.ts",
-      "default": "./dist/server.js"
-    },
-    "./browser": {
-      "types": "./dist/browser.d.ts",
-      "default": "./dist/browser.js"
-    },
-    "./react": {
-      "types": "./dist/react.d.ts",
-      "default": "./dist/react.js"
-    }
-  },
-  "scripts": {
-    "build": "tsc",
-    "prepare": "tsc",
-    "test": "tsc && node --test test/*.test.mjs"
-  },
-  "dependencies": {
-    "@stripe/stripe-js": "^10.2.1"
-  },
-  "peerDependencies": {
-    "react": ">=18"
-  },
-  "peerDependenciesMeta": {
-    "react": {
-      "optional": true
-    }
-  },
-  "devDependencies": {
-    "@types/node": "^22.20.5",
-    "@types/react": "^19",
-    "typescript": "^5"
-  }
-}
+{
+  "name": "glyphpay",
+  "version": "1.0.0",
+  "description": "Drop-in GlyphPay checkout for websites, with a CLI for setup, diagnostics, and credential lifecycle.",
+  "homepage": "https://glyphpay.net",
+  "keywords": [
+    "glyphpay",
+    "payments",
+    "checkout",
+    "stripe",
+    "react",
+    "nextjs"
+  ],
+  "license": "UNLICENSED",
+  "type": "module",
+  "bin": {
+    "glyphpay": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "exports": {
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "default": "./dist/server.js"
+    },
+    "./browser": {
+      "types": "./dist/browser.d.ts",
+      "default": "./dist/browser.js"
+    },
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "default": "./dist/react.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepare": "tsc",
+    "test": "tsc && node --test test/*.test.mjs"
+  },
+  "dependencies": {
+    "@stripe/stripe-js": "^10.2.1"
+  },
+  "peerDependencies": {
+    "react": ">=18"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^22.20.5",
+    "@types/react": "^19",
+    "typescript": "^5"
+  }
+}