@agent-cards/sdk 0.23.28 → 0.24.1

package/dist/cardlink-vpos.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Cardlink's VPOS (the redirect payment page Greek banks give their merchants: Eurobank's paycenter on
+ * vpos.eurocommerce.gr, Cardlink's own on ecommerce.cardlink.gr, Nexi Greece's on www.alphaecommerce.gr), as this SDK
+ * reads it.
+ *
+ * The merchant's order page posts a signed entry form, top-level, to https://<host>/vpos/shophandlermpi, and the VPOS
+ * answers with its card page, whose form posts the card back to that same URL. The entry carries no card, and it is the
+ * one request this SDK pauses: the cardholder's device repeats it over the end-to-end TLS relay and fills the card into
+ * the page the VPOS returns to it (payment-core processors/cardlink_vpos.js). Every other POST the agent's browser makes
+ * to these hosts carries a card the agent typed or leads to a page that asks for one: the card page's own post and its
+ * card check, which share the entry's URL and carry the page's own fields, and anything posted to Cardlink's test
+ * hosts. This SDK aborts every one of them, so a placeholder card never reaches the VPOS.
+ *
+ * CARDLINK_VPOS_ENTRY_HOSTS is payment-core's CARDLINK_VPOS_HOSTS, and isCardlinkVposEntryUrl is payment-core's
+ * isCardlinkVposEntryUrl; cardlink-vpos.test.mjs pins both to payment-core.
+ */
+export declare const CARDLINK_VPOS_PSP = "cardlink_vpos";
+export declare const CARDLINK_VPOS_ENTRY_HOSTS: readonly string[];
+export declare const CARDLINK_VPOS_TEST_HOSTS: readonly string[];
+/**
+ * Whether a URL is an entry exactly as a merchant's form action writes it: https, one of the three live hosts in lower
+ * case, the default port, no credentials, the path /vpos/shophandlermpi, and no query or fragment, not even an empty one.
+ */
+export declare function isCardlinkVposEntryUrl(raw: unknown): boolean;
+/** Whether a URL is on one of the VPOS's hosts, live or test: https, no credentials, any port, any case, a trailing dot or not. */
+export declare function isCardlinkVposHost(raw: string): boolean;
+/**
+ * Whether a body reads as a merchant's entry and never as the card page's post: a form whose every pair decodes, that
+ * names a mid and a digest, and that carries none of the card page's fields or a card field. payment-core's entry rules
+ * judge the rest at create.
+ */
+export declare function isCardlinkVposEntryBody(body: string | null | undefined): boolean;
+/** The one request on the VPOS's hosts this SDK pauses: a POST of an entry body to an entry URL. */
+export declare function isCardlinkVposEntry(url: string, method: string, body: string | null | undefined): boolean;
+/**
+ * Whether an adapter must hand this request to the pre-claim gates: it is on one of the VPOS's hosts and this build's
+ * registry serves the entry. The card page's posts share the entry's URL, so the CDP adapter pauses them through the
+ * recognizer's host patterns, and attachToPlaywright's route predicate asks this, so both adapters show the gates every
+ * request to a VPOS host once the lane is armed.
+ */
+export declare function isArmedCardlinkVposUrl(vault: {
+    isCardRequest(url: string, method?: string): boolean;
+} | undefined, url: string): boolean;

package/dist/cardlink-vpos.js

@@ -0,0 +1,90 @@
+/**
+ * Cardlink's VPOS (the redirect payment page Greek banks give their merchants: Eurobank's paycenter on
+ * vpos.eurocommerce.gr, Cardlink's own on ecommerce.cardlink.gr, Nexi Greece's on www.alphaecommerce.gr), as this SDK
+ * reads it.
+ *
+ * The merchant's order page posts a signed entry form, top-level, to https://<host>/vpos/shophandlermpi, and the VPOS
+ * answers with its card page, whose form posts the card back to that same URL. The entry carries no card, and it is the
+ * one request this SDK pauses: the cardholder's device repeats it over the end-to-end TLS relay and fills the card into
+ * the page the VPOS returns to it (payment-core processors/cardlink_vpos.js). Every other POST the agent's browser makes
+ * to these hosts carries a card the agent typed or leads to a page that asks for one: the card page's own post and its
+ * card check, which share the entry's URL and carry the page's own fields, and anything posted to Cardlink's test
+ * hosts. This SDK aborts every one of them, so a placeholder card never reaches the VPOS.
+ *
+ * CARDLINK_VPOS_ENTRY_HOSTS is payment-core's CARDLINK_VPOS_HOSTS, and isCardlinkVposEntryUrl is payment-core's
+ * isCardlinkVposEntryUrl; cardlink-vpos.test.mjs pins both to payment-core.
+ */
+export const CARDLINK_VPOS_PSP = 'cardlink_vpos';
+export const CARDLINK_VPOS_ENTRY_HOSTS = Object.freeze(['vpos.eurocommerce.gr', 'ecommerce.cardlink.gr', 'www.alphaecommerce.gr']);
+export const CARDLINK_VPOS_TEST_HOSTS = Object.freeze(['eurocommerce-test.cardlink.gr', 'ecommerce-test.cardlink.gr',
+    'alphaecommerce-test.cardlink.gr']);
+const ENTRY_PATH = '/vpos/shophandlermpi';
+// An entry URL, for asking whether this build's registry serves the entry.
+const PROBE = 'https://vpos.eurocommerce.gr/vpos/shophandlermpi';
+// A field of the card page's form or of its card check, or any card field: an entry never carries one.
+const PAGE_FIELD = /^(?:card[._]|cvv|cmd$|trid$|st$|paystep$|paymentmethod$|startbonus$|bonusdata$|what$|tds2_)/i;
+/**
+ * Whether a URL is an entry exactly as a merchant's form action writes it: https, one of the three live hosts in lower
+ * case, the default port, no credentials, the path /vpos/shophandlermpi, and no query or fragment, not even an empty one.
+ */
+export function isCardlinkVposEntryUrl(raw) {
+    if (typeof raw !== 'string' || raw.length > 256 || raw.includes('?') || raw.includes('#'))
+        return false;
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        return false;
+    }
+    return url.href === raw && url.protocol === 'https:' && !url.port && !url.username && !url.password
+        && CARDLINK_VPOS_ENTRY_HOSTS.includes(url.hostname) && url.pathname === ENTRY_PATH;
+}
+/** Whether a URL is on one of the VPOS's hosts, live or test: https, no credentials, any port, any case, a trailing dot or not. */
+export function isCardlinkVposHost(raw) {
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        return false;
+    }
+    const host = url.hostname.toLowerCase().replace(/\.$/, '');
+    return url.protocol === 'https:' && !url.username && !url.password && (CARDLINK_VPOS_ENTRY_HOSTS.includes(host) || CARDLINK_VPOS_TEST_HOSTS.includes(host));
+}
+/**
+ * Whether a body reads as a merchant's entry and never as the card page's post: a form whose every pair decodes, that
+ * names a mid and a digest, and that carries none of the card page's fields or a card field. payment-core's entry rules
+ * judge the rest at create.
+ */
+export function isCardlinkVposEntryBody(body) {
+    if (typeof body !== 'string' || body === '')
+        return false;
+    const names = [];
+    for (const chunk of body.split('&')) {
+        const eq = chunk.indexOf('=');
+        if (eq < 1)
+            return false;
+        try {
+            names.push(decodeURIComponent(chunk.slice(0, eq).replace(/\+/g, ' ')));
+            decodeURIComponent(chunk.slice(eq + 1).replace(/\+/g, ' '));
+        }
+        catch {
+            return false;
+        }
+    }
+    return names.includes('mid') && names.includes('digest') && !names.some((name) => PAGE_FIELD.test(name));
+}
+/** The one request on the VPOS's hosts this SDK pauses: a POST of an entry body to an entry URL. */
+export function isCardlinkVposEntry(url, method, body) {
+    return String(method).toUpperCase() === 'POST' && isCardlinkVposEntryUrl(url) && isCardlinkVposEntryBody(body);
+}
+/**
+ * Whether an adapter must hand this request to the pre-claim gates: it is on one of the VPOS's hosts and this build's
+ * registry serves the entry. The card page's posts share the entry's URL, so the CDP adapter pauses them through the
+ * recognizer's host patterns, and attachToPlaywright's route predicate asks this, so both adapters show the gates every
+ * request to a VPOS host once the lane is armed.
+ */
+export function isArmedCardlinkVposUrl(vault, url) {
+    return isCardlinkVposHost(url) && typeof vault?.isCardRequest === 'function' && vault.isCardRequest(PROBE, 'POST');
+}

package/dist/cdp.d.ts

@@ -1,7 +1,7 @@
 import { type VaultClient, type ExecutionMetadata } from './client.js';
 import { type StripeCheckoutOptions } from './stripe-checkout.js';
 import { type HoldOptions } from './hold.js';
-import { type CheckoutController, type LifecycleOptions, type PaymentEndpointGuard, type PausedCheckout } from './lifecycle.js';
+import { type CheckoutController, type LifecycleOptions, type PaymentEndpointGuard } from './lifecycle.js';
 /**
  * The CORS headers a fulfilled CROSS-ORIGIN request needs, or null when the
  * request is same-origin (or carries no Origin, so no CORS check applies).
@@ -103,16 +103,6 @@ export interface CdpTargetInfo {
     browserContextId?: string;
 }
 export interface AttachOptions extends LifecycleOptions, ExecutionMetadata {
-    /**
-     * Pause only: the card request pauses and is handed to `onPaused` with the page's request,
-     * and this transport creates no authorization. The business creates it (`voice.authorizations.create`
-     * with its posture, user and return link, as on its other purchases), reads the result, and calls
-     * `controller.resume(result)`; the processor's answer then reaches the page exactly as on the default
-     * path. Default false: the transport creates and polls the authorization itself. Raw CDP only.
-     */
-    pauseOnly?: boolean;
-    /** With `pauseOnly`: the paused request and the controller to resume it on. Required when `pauseOnly` is set. */
-    onPaused?: (paused: PausedCheckout) => void | Promise<void>;
     /**
      * Hold mode (CARD-REQUEST-HOLD.md): the first card request pauses and is HELD with nothing created, and
      * `controller.hold` (CardRequestHold) answers it. `controller.release({ amount, currency, pageTotal })` creates the
@@ -121,8 +111,8 @@ export interface AttachOptions extends LifecycleOptions, ExecutionMetadata {
      * fails it. A request held past its processor's own wait is cancelled first. One request is held at a time; every
      * other card request, and every one after a decision, fails at once. Besides the registry's processors, a hold
      * catches Bolt's sealed tokenizer and, with `placeholderNumbers`, any request carrying the placeholder card (both
-     * cancel-only, except a sandbox placeholder post released with `continuePlaceholder`). Raw CDP only; not with
-     * `pauseOnly`. Service workers are bypassed in this mode unless `serviceWorkers: 'refuse'`.
+     * cancel-only, except a sandbox placeholder post released with `continuePlaceholder`). Raw CDP only.
+     * Service workers are bypassed in this mode unless `serviceWorkers: 'refuse'`.
      */
     hold?: boolean | HoldOptions;
     /**