@agent-cards/checkout 0.1.0

package/README.md

@@ -0,0 +1,126 @@
+# @agent-cards/checkout
+
+Let your browser agents pay with **the user's own card**, without your
+infrastructure ever touching card data.
+
+Your agent drives checkout normally. When the page tries to tokenize a card, we
+pause that one request, ask the cardholder to approve on their device, and their
+device supplies the card and calls the merchant. You get back the response to
+replay. A real card never enters your process, your logs, or your network.
+
+```
+your agent ──drives──> merchant checkout
+                            │ tokenization request
+                            ▼
+                    [ paused by this SDK ]
+                            │  template only, dummy card
+                            ▼
+                  Agentcard ──notify──> cardholder's device
+                                             │ decrypts card locally
+                                             ▼
+                                     merchant's card vault
+                            ┌────────token────────┘
+                            ▼
+                    [ request resumed ]  ──> order completes
+```
+
+## Install
+
+```bash
+npm i @agent-cards/checkout
+```
+
+## Use it
+
+Two lines against a CDP session you already have:
+
+```ts
+import { VaultClient, attachToCdp } from '@agent-cards/checkout';
+
+const vault = new VaultClient({
+  clientId: process.env.AGENTCARD_CLIENT_ID!,
+  clientSecret: process.env.AGENTCARD_CLIENT_SECRET!,
+});
+
+await attachToCdp(cdp, pageSessionId, {
+  vault,
+  user: 'usr_123',                 // whose card should pay
+  merchant: 'vanman.shop',
+  amount: '$5.83',
+  onApprovalUrl: (url) => sendToUser(url),   // iMessage, SMS, push, your call
+});
+```
+
+Then let your agent click "Pay" like it always does. `attachToCdp` holds the
+request open until the cardholder approves, so the checkout simply continues.
+
+Playwright:
+
+```ts
+import { attachToPlaywright } from '@agent-cards/checkout/playwright';
+await attachToPlaywright(page, { vault, user, merchant, amount });
+```
+
+## Credentials
+
+Use your **OAuth client credentials**, not an `sk_` API key — those are retired,
+and the checkout endpoints reject them (`client_credentials_required`) because an
+authorization is bound to the confidential client that created it. The SDK does
+the `client_credentials` exchange for you, caches the token, and refreshes it
+once on a 401. Create a client from the dashboard Credentials page or with
+`agent-cards-admin oauth-clients create`.
+
+## Why you need the SDK and not just `Fetch.enable`
+
+Card fields render in **cross-origin iframes**, which are separate CDP targets.
+Enabling `Fetch` on the page session never sees the tokenization request. You
+need recursive `Target.setAutoAttach({ flatten: true })` on every nested target,
+then `Fetch.enable` on each, then `Runtime.runIfWaitingForDebugger` to unpause
+them. That, plus which headers a merchant requires you to replay verbatim, is
+what this package encapsulates.
+
+## What runs where
+
+| | Sees the real card |
+|---|---|
+| Your agent / browser | **no** — only a dummy PAN and a token |
+| Agentcard servers | **no** — a request template and a token |
+| Cardholder's device | yes — decrypts locally, calls the merchant directly |
+
+Because your process only ever handles a dummy card and an opaque token, this
+integration is designed to keep you out of PCI scope. Get your own QSA's read
+before you put that in writing.
+
+## Supported processors
+
+Merchants inherit their processor, so one entry covers every store on it.
+
+| Processor | Status |
+|---|---|
+| Shopify | supported, verified end to end |
+| Stripe | supported, verified end to end |
+| Braintree / PayPal | supported, verified end to end |
+| Checkout.com | supported |
+| Adyen | not yet — the card is encrypted in-page, so a paused request carries a blob. Throws `CardEncryptedError` |
+
+The recognizer list is fetched from the API at runtime (`vault.syncRegistry()`),
+so new processors work without you shipping a release.
+
+## Errors worth handling
+
+- `ApprovalTimeoutError` — the user never approved. Default window is 15 minutes;
+  we have completed checkouts after a 5.5 minute approval delay.
+- `ApprovalDeclinedError` — the user said no.
+- `CardEncryptedError` — this processor needs vault-side crypto; route the
+  purchase to an Agentcard-issued card instead.
+
+## Building this package
+
+It declares **no dependencies**, matching `packages/vault`, so the workspace
+lockfile needs no importer entry for it (a new package with its own deps cannot
+be installed here without regenerating the lockfile, and a full regen drifts
+unrelated transitive versions). Build it with the workspace TypeScript:
+
+```bash
+pnpm --filter backend exec tsc -p packages/checkout/tsconfig.json
+```

package/dist/cdp.d.ts

@@ -0,0 +1,41 @@
+import type { VaultClient } from './client.js';
+/**
+ * Minimal shape of a CDP connection. Works with a raw websocket client, a
+ * Puppeteer CDPSession, or Playwright's CDPSession.
+ */
+export interface CdpLike {
+    send(method: string, params?: any, sessionId?: string): Promise<any>;
+    on(handler: (method: string, params: any, sessionId?: string) => void): void;
+}
+export interface AttachOptions {
+    vault: VaultClient;
+    user: string;
+    merchant: string;
+    amount: string;
+    onApprovalUrl?: (url: string) => void;
+    onEvent?: (e: {
+        type: string;
+        detail?: unknown;
+    }) => void;
+}
+/**
+ * Take over card tokenization for a page.
+ *
+ * IMPORTANT: card fields render in cross-origin iframes, which are separate CDP
+ * targets. Enabling Fetch on the page session alone will never see the
+ * tokenization request. This attaches recursively so every nested target is
+ * armed, which is the whole reason this adapter exists.
+ */
+export declare function attachToCdp(cdp: CdpLike, pageSessionId: string, opts: AttachOptions): Promise<void>;
+/**
+ * Playwright convenience wrapper — the path for cloud browsers that hand you a
+ * CDP websocket (Kernel's `cdp_ws_url`, Browserbase, etc.):
+ *
+ *   const browser = await chromium.connectOverCDP(kernelBrowser.cdp_ws_url);
+ *   const page = await browser.contexts()[0].newPage();
+ *   await attachToPlaywright(page, { vault, user, merchant, amount });
+ *
+ * Uses Playwright's own request routing, which already spans subframes — see
+ * the note in the body for why a hand-rolled CDPSession does not work here.
+ */
+export declare function attachToPlaywright(page: any, opts: AttachOptions): Promise<void>;

package/dist/cdp.js

@@ -0,0 +1,123 @@
+const CARD_PATTERNS = [
+    '*pci.shopifyinc.com/sessions*',
+    '*shopifycs.com/sessions*',
+    '*api.stripe.com/v1/payment_methods*',
+    '*api.stripe.com/v1/tokens*',
+    '*braintree-api.com/graphql*',
+    '*checkout.com/tokens*',
+];
+/**
+ * Take over card tokenization for a page.
+ *
+ * IMPORTANT: card fields render in cross-origin iframes, which are separate CDP
+ * targets. Enabling Fetch on the page session alone will never see the
+ * tokenization request. This attaches recursively so every nested target is
+ * armed, which is the whole reason this adapter exists.
+ */
+export async function attachToCdp(cdp, pageSessionId, opts) {
+    const armed = new Set();
+    const arm = async (sessionId) => {
+        const key = sessionId ?? '__root__';
+        if (armed.has(key))
+            return;
+        armed.add(key);
+        await cdp.send('Fetch.enable', {
+            patterns: CARD_PATTERNS.map((urlPattern) => ({ urlPattern, requestStage: 'Request' })),
+        }, sessionId).catch(() => { });
+        // Descend into this target's own children (iframes inside iframes).
+        await cdp.send('Target.setAutoAttach', {
+            autoAttach: true, waitForDebuggerOnStart: true, flatten: true,
+        }, sessionId).catch(() => { });
+    };
+    cdp.on(async (method, params, sessionId) => {
+        if (method === 'Target.attachedToTarget') {
+            const child = params.sessionId;
+            await arm(child);
+            // Child targets start paused when waitForDebuggerOnStart is set.
+            await cdp.send('Runtime.runIfWaitingForDebugger', {}, child).catch(() => { });
+            return;
+        }
+        if (method !== 'Fetch.requestPaused')
+            return;
+        const { requestId, request } = params;
+        if (!opts.vault.isCardRequest(request.url, request.method)) {
+            await cdp.send('Fetch.continueRequest', { requestId }, sessionId).catch(() => { });
+            return;
+        }
+        let body = request.postData ?? '';
+        if (!body && request.hasPostData) {
+            body = (await cdp.send('Fetch.getRequestPostData', { requestId }, sessionId).catch(() => ({ postData: '' }))).postData ?? '';
+        }
+        opts.onEvent?.({ type: 'card_request_paused', detail: { url: request.url } });
+        try {
+            const replay = await opts.vault.authorize({
+                user: opts.user,
+                merchant: opts.merchant,
+                amount: opts.amount,
+                onApprovalUrl: opts.onApprovalUrl,
+                request: { url: request.url, method: request.method, headers: request.headers, body },
+            });
+            await cdp.send('Fetch.fulfillRequest', {
+                requestId,
+                responseCode: replay.status,
+                responseHeaders: Object.entries(replay.headers).map(([name, value]) => ({ name, value: String(value) })),
+                body: Buffer.from(replay.body).toString('base64'),
+            }, sessionId);
+            opts.onEvent?.({ type: 'authorized' });
+        }
+        catch (err) {
+            opts.onEvent?.({ type: 'failed', detail: String(err) });
+            await cdp.send('Fetch.failRequest', { requestId, errorReason: 'Aborted' }, sessionId).catch(() => { });
+        }
+    });
+    await arm(pageSessionId);
+}
+/**
+ * Playwright convenience wrapper — the path for cloud browsers that hand you a
+ * CDP websocket (Kernel's `cdp_ws_url`, Browserbase, etc.):
+ *
+ *   const browser = await chromium.connectOverCDP(kernelBrowser.cdp_ws_url);
+ *   const page = await browser.contexts()[0].newPage();
+ *   await attachToPlaywright(page, { vault, user, merchant, amount });
+ *
+ * Uses Playwright's own request routing, which already spans subframes — see
+ * the note in the body for why a hand-rolled CDPSession does not work here.
+ */
+export async function attachToPlaywright(page, opts) {
+    // Playwright's own routing, NOT a hand-rolled CDP session.
+    //
+    // A CDPSession from `newCDPSession(page)` is bound to the PAGE target and its
+    // send() takes no session id, so every command meant for an attached child
+    // target lands on the page instead — the nested card iframes are never armed
+    // and the tokenization request sails past. Card fields are cross-origin
+    // iframes essentially always, so that adapter was broken for the only case
+    // that matters.
+    //
+    // page.route already spans subframes, so Playwright does the target
+    // bookkeeping that attachToCdp has to do by hand for a raw connection.
+    await page.route((url) => opts.vault.isCardRequest(url.toString()), async (route) => {
+        const request = route.request();
+        // The matcher only sees the URL; a preflight or a GET must pass through
+        // untouched or the browser's CORS check fails on our synthetic answer.
+        if (!opts.vault.isCardRequest(request.url(), request.method())) {
+            return route.fallback();
+        }
+        const body = request.postData() ?? '';
+        opts.onEvent?.({ type: 'card_request_paused', detail: { url: request.url() } });
+        try {
+            const replay = await opts.vault.authorize({
+                user: opts.user,
+                merchant: opts.merchant,
+                amount: opts.amount,
+                onApprovalUrl: opts.onApprovalUrl,
+                request: { url: request.url(), method: request.method(), headers: request.headers(), body },
+            });
+            await route.fulfill({ status: replay.status, headers: replay.headers, body: replay.body });
+            opts.onEvent?.({ type: 'authorized' });
+        }
+        catch (err) {
+            opts.onEvent?.({ type: 'failed', detail: String(err) });
+            await route.abort();
+        }
+    });
+}

package/dist/client.d.ts

@@ -0,0 +1,82 @@
+import { type Recognizer } from './registry.js';
+export interface PausedRequest {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    body: string;
+}
+export interface ReplayResponse {
+    status: number;
+    headers: Record<string, string>;
+    /** Body to hand back to the browser, verbatim. */
+    body: string;
+}
+export interface AuthorizeInput {
+    /** Your identifier for the person whose card should pay. */
+    user: string;
+    /** Shown to the user on the approval screen. */
+    merchant: string;
+    amount: string;
+    request: PausedRequest;
+    /** Abort if the user has not approved within this many ms. Default 15 min. */
+    timeoutMs?: number;
+    /** Called once with the URL to surface to the user, if you deliver it yourself. */
+    onApprovalUrl?: (url: string) => void;
+}
+export declare class CardEncryptedError extends Error {
+    psp: string;
+    constructor(psp: string);
+}
+export declare class ApprovalTimeoutError extends Error {
+    constructor(ms: number);
+}
+export declare class ApprovalDeclinedError extends Error {
+    constructor(reason: string);
+}
+export interface VaultClientOptions {
+    /**
+     * Your Agentcard OAuth client credentials. The SDK exchanges them for a
+     * short-lived access token and refreshes it when it expires.
+     *
+     * NOT an `sk_` API key: those are retired, and the checkout endpoints reject
+     * them with `client_credentials_required` because an authorization has to be
+     * bound to the confidential client that created it.
+     */
+    clientId: string;
+    clientSecret: string;
+    baseUrl?: string;
+    /** Override the PSP registry (tests, or pinning). Defaults to the hosted list. */
+    registry?: Recognizer[];
+    fetchImpl?: typeof fetch;
+    pollIntervalMs?: number;
+}
+export declare class VaultClient {
+    private readonly opts;
+    private readonly baseUrl;
+    private readonly fetch;
+    private readonly pollIntervalMs;
+    private registry;
+    constructor(opts: VaultClientOptions);
+    /** Refresh recognizers from the API so new PSPs work without a redeploy. */
+    syncRegistry(): Promise<void>;
+    /** True when this request is a card tokenization we can take over. */
+    isCardRequest(url: string, method?: string): boolean;
+    /**
+     * Hand us a paused tokenization request. We ask the cardholder to approve,
+     * their device supplies the card and calls the merchant, and you get back the
+     * response to replay into the browser. Your process never sees a card.
+     */
+    authorize(input: AuthorizeInput): Promise<ReplayResponse>;
+    private token;
+    private inflight;
+    /**
+     * Exchange client credentials for an access token, reusing the cached one
+     * until it is nearly expired. Concurrent callers share a single in-flight
+     * exchange rather than each minting their own token.
+     */
+    private accessToken;
+    /** Authenticated request that retries ONCE on a 401 with a fresh token. */
+    private call;
+    private post;
+    private get;
+}

package/dist/client.js

@@ -0,0 +1,164 @@
+import { BUILTIN_REGISTRY, findRecognizer } from './registry.js';
+export class CardEncryptedError extends Error {
+    psp;
+    constructor(psp) {
+        super(`${psp} encrypts the card in-page; a paused request carries a blob, not a PAN. ` +
+            `Agentcard must run this PSP's client-side crypto in the vault.`);
+        this.psp = psp;
+        this.name = 'CardEncryptedError';
+    }
+}
+export class ApprovalTimeoutError extends Error {
+    constructor(ms) { super(`user did not approve within ${ms}ms`); this.name = 'ApprovalTimeoutError'; }
+}
+export class ApprovalDeclinedError extends Error {
+    constructor(reason) { super(`user declined: ${reason}`); this.name = 'ApprovalDeclinedError'; }
+}
+export class VaultClient {
+    opts;
+    baseUrl;
+    fetch;
+    pollIntervalMs;
+    registry;
+    constructor(opts) {
+        this.opts = opts;
+        this.baseUrl = (opts.baseUrl ?? 'https://api.agentcard.sh').replace(/\/$/, '');
+        this.fetch = opts.fetchImpl ?? globalThis.fetch;
+        this.registry = opts.registry ?? BUILTIN_REGISTRY;
+        this.pollIntervalMs = opts.pollIntervalMs ?? 2000;
+    }
+    /** Refresh recognizers from the API so new PSPs work without a redeploy. */
+    async syncRegistry() {
+        // Never break checkout over a registry fetch — an auth blip or a bad
+        // response leaves the built-in recognizers in place.
+        let raw;
+        try {
+            raw = await this.get('/v2/checkout/recognizers');
+        }
+        catch {
+            return;
+        }
+        if (!Array.isArray(raw))
+            return;
+        this.registry = raw.map((e) => ({
+            ...e,
+            match: new RegExp(e.match, 'i'),
+            passthroughHeaders: e.passthroughHeaders.map((h) => new RegExp(h, 'i')),
+        }));
+    }
+    /** True when this request is a card tokenization we can take over. */
+    isCardRequest(url, method = 'POST') {
+        return method.toUpperCase() === 'POST' && findRecognizer(url, this.registry) !== null;
+    }
+    /**
+     * Hand us a paused tokenization request. We ask the cardholder to approve,
+     * their device supplies the card and calls the merchant, and you get back the
+     * response to replay into the browser. Your process never sees a card.
+     */
+    async authorize(input) {
+        const rec = findRecognizer(input.request.url, this.registry);
+        if (!rec)
+            throw new Error(`not a known tokenization endpoint: ${input.request.url}`);
+        if (rec.clientSideEncrypted)
+            throw new CardEncryptedError(rec.psp);
+        const timeoutMs = input.timeoutMs ?? 15 * 60_000;
+        const created = await this.post('/v2/checkout/authorizations', {
+            user: input.user,
+            merchant: input.merchant,
+            amount: input.amount,
+            psp: rec.psp,
+            request: {
+                url: input.request.url,
+                method: input.request.method,
+                headers: pickHeaders(input.request.headers, rec.passthroughHeaders),
+                body: input.request.body,
+            },
+        });
+        input.onApprovalUrl?.(created.approvalUrl);
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            await sleep(this.pollIntervalMs);
+            const s = await this.get(`/v2/checkout/authorizations/${created.id}`);
+            if (s.status === 'approved')
+                return s.response;
+            if (s.status === 'declined')
+                throw new ApprovalDeclinedError(s.reason ?? 'no reason given');
+        }
+        throw new ApprovalTimeoutError(timeoutMs);
+    }
+    // --- auth: client_credentials, cached until just before it expires --------
+    token = null;
+    inflight = null;
+    /**
+     * Exchange client credentials for an access token, reusing the cached one
+     * until it is nearly expired. Concurrent callers share a single in-flight
+     * exchange rather than each minting their own token.
+     */
+    async accessToken(force = false) {
+        if (!force && this.token && Date.now() < this.token.expiresAt)
+            return this.token.value;
+        if (!force && this.inflight)
+            return this.inflight;
+        this.inflight = (async () => {
+            const body = new URLSearchParams({
+                grant_type: 'client_credentials',
+                client_id: this.opts.clientId,
+                client_secret: this.opts.clientSecret,
+            });
+            const r = await this.fetch(`${this.baseUrl}/api/v1/oauth/token`, {
+                method: 'POST',
+                headers: { 'content-type': 'application/x-www-form-urlencoded' },
+                body: body.toString(),
+            });
+            if (!r.ok) {
+                // RFC 6749 error shape, which real OAuth clients expect verbatim.
+                const d = await r.json().catch(() => ({}));
+                throw new Error(`agentcard auth failed: ${d.error ?? r.status} ${d.error_description ?? ''}`.trim());
+            }
+            const d = (await r.json());
+            // Renew a minute early so a token never expires mid-checkout.
+            const ttl = Math.max(60, (d.expires_in ?? 3600) - 60);
+            this.token = { value: d.access_token, expiresAt: Date.now() + ttl * 1000 };
+            return this.token.value;
+        })().finally(() => { this.inflight = null; });
+        return this.inflight;
+    }
+    /** Authenticated request that retries ONCE on a 401 with a fresh token. */
+    async call(path, init = {}, retried = false) {
+        const token = await this.accessToken();
+        const r = await this.fetch(`${this.baseUrl}${path}`, {
+            ...init,
+            headers: { ...(init.headers ?? {}), authorization: `Bearer ${token}`, 'content-type': 'application/json' },
+        });
+        // A token can be revoked or expire early; one forced refresh, then give up.
+        if (r.status === 401 && !retried) {
+            await this.accessToken(true);
+            return this.call(path, init, true);
+        }
+        if (!r.ok)
+            throw new Error(`agentcard ${path} -> ${r.status} ${await r.text()}`);
+        return r.json();
+    }
+    post(path, body) {
+        return this.call(path, { method: 'POST', body: JSON.stringify(body) });
+    }
+    get(path) {
+        return this.call(path);
+    }
+}
+/**
+ * Forward only the headers the merchant needs to accept the replay. Everything
+ * else (cookies, UA, tracing) is dropped so we transmit as little as possible.
+ */
+function pickHeaders(headers, allow) {
+    const out = {};
+    for (const [k, v] of Object.entries(headers)) {
+        const lk = k.toLowerCase();
+        if (lk === 'content-type' || allow.some((re) => re.test(lk)))
+            out[lk] = v;
+    }
+    if (!out['content-type'])
+        out['content-type'] = 'application/json';
+    return out;
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { VaultClient, CardEncryptedError, ApprovalTimeoutError, ApprovalDeclinedError } from './client.js';
+export type { PausedRequest, ReplayResponse, AuthorizeInput, VaultClientOptions } from './client.js';
+export { attachToCdp, attachToPlaywright } from './cdp.js';
+export type { CdpLike, AttachOptions } from './cdp.js';
+export { BUILTIN_REGISTRY, findRecognizer } from './registry.js';
+export type { Recognizer } from './registry.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+export { VaultClient, CardEncryptedError, ApprovalTimeoutError, ApprovalDeclinedError } from './client.js';
+export { attachToCdp, attachToPlaywright } from './cdp.js';
+export { BUILTIN_REGISTRY, findRecognizer } from './registry.js';

package/dist/registry.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Which outbound requests carry a raw card, and where the card sits inside them.
+ *
+ * This is the only merchant-specific knowledge in the system, and it is keyed by
+ * PSP rather than by merchant: every Shopify store shares one entry, every Stripe
+ * site shares another. The list is served from the Agentcard API at runtime so
+ * integrators pick up new processors without shipping a release.
+ */
+export type Encoding = 'json' | 'form';
+export interface Recognizer {
+    /** Stable id, e.g. "shopify" */
+    psp: string;
+    /** Matches the tokenization endpoint. */
+    match: RegExp;
+    encoding: Encoding;
+    /**
+     * Request headers that must be replayed verbatim for the merchant to accept
+     * the call (signatures, client tokens). Matched case-insensitively.
+     */
+    passthroughHeaders: RegExp[];
+    /**
+     * True when the card is encrypted inside the page before the request leaves.
+     * A digit swap is useless here; the vault must re-run the PSP's client-side
+     * crypto instead. Kept in the registry so callers can fail loudly.
+     */
+    clientSideEncrypted?: boolean;
+}
+export declare const BUILTIN_REGISTRY: Recognizer[];
+export declare function findRecognizer(url: string, registry?: Recognizer[]): Recognizer | null;

package/dist/registry.js

@@ -0,0 +1,45 @@
+/**
+ * Which outbound requests carry a raw card, and where the card sits inside them.
+ *
+ * This is the only merchant-specific knowledge in the system, and it is keyed by
+ * PSP rather than by merchant: every Shopify store shares one entry, every Stripe
+ * site shares another. The list is served from the Agentcard API at runtime so
+ * integrators pick up new processors without shipping a release.
+ */
+export const BUILTIN_REGISTRY = [
+    {
+        psp: 'shopify',
+        match: /(checkout\.pci\.shopifyinc\.com|deposit\.[a-z0-9-]+\.shopifycs\.com)\/sessions/i,
+        encoding: 'json',
+        passthroughHeaders: [/^shopify-identification-signature$/i],
+    },
+    {
+        psp: 'stripe',
+        match: /api\.stripe\.com\/v1\/(payment_methods|tokens)/i,
+        encoding: 'form',
+        // Elements' own surface markers; without these Stripe rejects the surface.
+        passthroughHeaders: [/^authorization$/i, /^stripe-version$/i, /^x-stripe-client-user-agent$/i],
+    },
+    {
+        psp: 'braintree',
+        match: /payments(\.sandbox)?\.braintree-api\.com\/graphql/i,
+        encoding: 'json',
+        passthroughHeaders: [/^authorization$/i, /^braintree-version$/i],
+    },
+    {
+        psp: 'checkout_com',
+        match: /api(\.sandbox)?\.checkout\.com\/tokens/i,
+        encoding: 'json',
+        passthroughHeaders: [/^authorization$/i],
+    },
+    {
+        psp: 'adyen',
+        match: /(checkoutshopper-[a-z]+\.adyen\.com|adyenpayments\.com)/i,
+        encoding: 'json',
+        passthroughHeaders: [],
+        clientSideEncrypted: true,
+    },
+];
+export function findRecognizer(url, registry = BUILTIN_REGISTRY) {
+    return registry.find((r) => r.match.test(url)) ?? null;
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@agent-cards/checkout",
+  "version": "0.1.0",
+  "description": "Let browser agents pay with the user's own card, without your infrastructure ever touching card data.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./cdp": "./dist/cdp.js",
+    "./playwright": "./dist/cdp.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "_comment_build": "TypeScript is fetched rather than declared as a devDependency ON PURPOSE. This package ships zero dependencies, which is why pnpm writes no importer for it in the workspace lockfile; adding any dep here creates one, and an importer the lockfile has not been regenerated for fails every Vercel build with ERR_PNPM_OUTDATED_LOCKFILE. Pinned so the published output is reproducible.",
+    "build": "npx -y -p typescript@5.9.3 tsc",
+    "prepublishOnly": "pnpm build",
+    "test": "node test.mjs"
+  },
+  "keywords": [
+    "payments",
+    "agents",
+    "browser-automation",
+    "pci",
+    "checkout"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "license": "UNLICENSED"
+}