@visa/cli 4.1.0-rc.8 → 4.1.0-rc.81

package/dist/checkout-engine/adapters/generic.js

@@ -0,0 +1,216 @@
+// Generic adapter. Drives the detect.ts field map: fills text inputs and
+// <select> dropdowns, handles split vs combined expiry, two- vs four-digit
+// years, and split first/last name. It is the fallback that should beat any
+// well-behaved guest checkout on its own.
+import { maskCvc, maskExpiry, maskPan, redactContact } from '../evidence.js';
+function pad2(n) {
+    return String(n).padStart(2, '0');
+}
+export function resolveLocator(page, entry) {
+    if (entry.frame)
+        return page.frameLocator(entry.frame).locator(entry.locator);
+    return page.locator(entry.locator);
+}
+function matchOption(options, wanted) {
+    for (const w of wanted) {
+        const lc = w.toLowerCase();
+        for (const o of options) {
+            if (o.value === w)
+                return o.value;
+            if (o.value.toLowerCase() === lc)
+                return o.value;
+            if (o.text.toLowerCase() === lc)
+                return o.value;
+        }
+    }
+    // looser: contains
+    for (const w of wanted) {
+        const lc = w.toLowerCase();
+        for (const o of options)
+            if (o.text.toLowerCase().includes(lc))
+                return o.value;
+    }
+    return null;
+}
+const MONTH_NAMES = [
+    'january',
+    'february',
+    'march',
+    'april',
+    'may',
+    'june',
+    'july',
+    'august',
+    'september',
+    'october',
+    'november',
+    'december',
+];
+function monthOptionValue(options, month) {
+    return matchOption(options, [pad2(month), String(month), MONTH_NAMES[month - 1] ?? '']);
+}
+function yearOptionValue(options, year) {
+    return matchOption(options, [String(year), pad2(year % 100), String(year % 100)]);
+}
+// value chosen for a select-style role, or the typed string for inputs.
+function expCombinedValue(entry, month, year) {
+    const mm = pad2(month);
+    const yy = pad2(year % 100);
+    const max = entry.maxlength ?? 0;
+    // A maxlength of exactly 4 means MMYY with no separator.
+    if (max === 4)
+        return `${mm}${yy}`;
+    return `${mm}/${yy}`;
+}
+// Playwright failure messages embed the attempted value in their call log
+// (`- fill("4242…")`, `- selectOption("123")`), so an unscrubbed error from a
+// FAILED fill would write the exact secret it was typing (cvc/DAVV, expiry,
+// contact PII) into evidence — and from there into the persisted receipt.
+// Scrub the call-log payloads and every literal occurrence of the value.
+export function scrubFillErrorMessage(message, value) {
+    let scrubbed = message.replace(/\b(fill|selectOption)\("(?:[^"\\]|\\.)*"\)/g, '$1("<redacted>")');
+    if (value)
+        scrubbed = scrubbed.split(value).join('<redacted>');
+    return scrubbed;
+}
+const DEFAULT_FILL_TIMEOUT_MS = 5000;
+async function fillOne(page, role, entry, value, displayValue, fillTimeoutMs) {
+    const base = {
+        role,
+        locator: entry.locator,
+        confidence: entry.confidence,
+        source: entry.source,
+        frame: entry.frame,
+        value: displayValue,
+    };
+    try {
+        const loc = resolveLocator(page, entry);
+        if (entry.tag === 'select') {
+            await loc.selectOption(value, { timeout: fillTimeoutMs });
+        }
+        else {
+            await loc.fill(value, { timeout: fillTimeoutMs });
+        }
+        return { ...base, ok: true };
+    }
+    catch (err) {
+        return { ...base, ok: false, error: scrubFillErrorMessage(err.message, value) };
+    }
+}
+async function fillFields(page, fields, credential, contact, opts = {}) {
+    const fillTimeoutMs = opts.fillTimeoutMs ?? DEFAULT_FILL_TIMEOUT_MS;
+    const filled = [];
+    const fullName = contact.fullName ?? credential?.cardholderName;
+    const first = contact.firstName ?? fullName?.split(/\s+/)[0];
+    const last = contact.lastName ?? fullName?.split(/\s+/).slice(1).join(' ');
+    // Order matters a little: contact/name before card is harmless, but we fill
+    // card fields explicitly per role so order is not load-bearing.
+    const jobs = [];
+    const add = (role, entry, value, display) => {
+        if (!entry)
+            return;
+        // Skip fields that are not currently visible (e.g. a collapsed accordion
+        // panel or a not-yet-reached step). The executor reveals them and re-fills.
+        if (entry.visible === false)
+            return;
+        jobs.push({
+            role,
+            entry,
+            run: async () => fillOne(page, role, entry, value(), display(), fillTimeoutMs),
+        });
+    };
+    if (credential) {
+        add('number', fields.number, () => credential.pan, () => maskPan(credential.pan));
+        add('cvc', fields.cvc, () => credential.cvc, () => maskCvc(credential.cvc));
+    }
+    if (fullName)
+        add('name', fields.name, () => fullName, () => redactContact('name', fullName));
+    if (first)
+        add('nameFirst', fields.nameFirst, () => first, () => redactContact('nameFirst', first));
+    if (last)
+        add('nameLast', fields.nameLast, () => last, () => redactContact('nameLast', last));
+    // Expiry display values are always redacted: the expiry is part of the
+    // keyable credential (DPAN + expiry + DAVV) and never enters the log.
+    if (credential && fields.expCombined) {
+        const e = fields.expCombined;
+        const v = expCombinedValue(e, credential.expMonth, credential.expYear);
+        add('expCombined', e, () => v, () => maskExpiry());
+    }
+    if (credential && fields.expMonth) {
+        const e = fields.expMonth;
+        const value = e.tag === 'select'
+            ? (monthOptionValue(e.options ?? [], credential.expMonth) ?? pad2(credential.expMonth))
+            : pad2(credential.expMonth);
+        add('expMonth', e, () => value, () => maskExpiry());
+    }
+    if (credential && fields.expYear) {
+        const e = fields.expYear;
+        let value;
+        if (e.tag === 'select') {
+            value = yearOptionValue(e.options ?? [], credential.expYear) ?? String(credential.expYear);
+        }
+        else if ((e.maxlength ?? 0) === 2) {
+            value = pad2(credential.expYear % 100);
+        }
+        else {
+            value = String(credential.expYear);
+        }
+        add('expYear', e, () => value, () => maskExpiry());
+    }
+    // Contact / shipping. Display values are always redacted: these are PII and
+    // the evidence log is built to be persistable.
+    if (contact.email)
+        add('email', fields.email, () => contact.email, () => redactContact('email', contact.email));
+    if (contact.phone)
+        add('phone', fields.phone, () => contact.phone, () => redactContact('phone', contact.phone));
+    if (contact.addressLine1)
+        add('addressLine1', fields.addressLine1, () => contact.addressLine1, () => redactContact('addressLine1', contact.addressLine1));
+    if (contact.addressLine2)
+        add('addressLine2', fields.addressLine2, () => contact.addressLine2, () => redactContact('addressLine2', contact.addressLine2));
+    if (contact.city)
+        add('city', fields.city, () => contact.city, () => redactContact('city', contact.city));
+    if (contact.postalCode)
+        add('postalCode', fields.postalCode, () => contact.postalCode, () => redactContact('postalCode', contact.postalCode));
+    if (fields.state && contact.state) {
+        const e = fields.state;
+        const wanted = contact.state;
+        const value = e.tag === 'select' ? (matchOption(e.options ?? [], [wanted]) ?? wanted) : wanted;
+        add('state', e, () => value, () => redactContact('state', value));
+    }
+    if (fields.country && contact.country) {
+        const e = fields.country;
+        const value = e.tag === 'select'
+            ? (matchOption(e.options ?? [], [contact.country]) ?? contact.country)
+            : contact.country;
+        add('country', e, () => value, () => redactContact('country', value));
+    }
+    for (const j of jobs) {
+        const r = await j.run();
+        if (r)
+            filled.push(r);
+    }
+    return filled;
+}
+// Credential-free contact prefill for merchants that must calculate shipping,
+// tax, and the final total before a human reviews the payment.
+export async function fillContactFieldMap(page, fields, contact, opts = {}) {
+    return fillFields(page, fields, null, contact, opts);
+}
+// The shared post-approval fill routine used by every adapter.
+export async function fillFieldMap(page, fields, credential, contact, opts = {}) {
+    return fillFields(page, fields, credential, contact, opts);
+}
+export class GenericAdapter {
+    name = 'generic';
+    matches(_detected) {
+        // The generic adapter is the universal fallback; it always matches.
+        return true;
+    }
+    async fill(page, fields, credential, contact) {
+        const filled = await fillFieldMap(page, fields, credential, contact);
+        return {
+            ok: filled.some((f) => f.role === 'number' && f.ok),
+            filled,
+        };
+    }
+}

package/dist/checkout-engine/adapters/index.d.ts

@@ -0,0 +1,8 @@
+import type { DetectResult } from '../detect.js';
+import type { CheckoutAdapter } from './generic.js';
+export type { CheckoutAdapter } from './generic.js';
+export { GenericAdapter } from './generic.js';
+export { ShopifyAdapter } from './shopify.js';
+export { StripeLikeAdapter } from './stripe-like.js';
+export { fillFieldMap, resolveLocator } from './generic.js';
+export declare function selectAdapter(detected: DetectResult): CheckoutAdapter;

package/dist/checkout-engine/adapters/index.js

@@ -0,0 +1,21 @@
+// Adapter registry. Specific adapters get first crack; the generic adapter is
+// the universal fallback and always matches last. Selection is a pure
+// function of an already-run detection — adapters never re-detect.
+import { GenericAdapter } from './generic.js';
+import { ShopifyAdapter } from './shopify.js';
+import { StripeLikeAdapter } from './stripe-like.js';
+export { GenericAdapter } from './generic.js';
+export { ShopifyAdapter } from './shopify.js';
+export { StripeLikeAdapter } from './stripe-like.js';
+export { fillFieldMap, resolveLocator } from './generic.js';
+const FALLBACK = new GenericAdapter();
+export function selectAdapter(detected) {
+    // Shopify owns the outer checkout form and can still delegate card fields to
+    // an iframe, so it gets first crack and reuses fillFieldMap for both.
+    const specific = [new ShopifyAdapter(detected), new StripeLikeAdapter()];
+    for (const a of specific) {
+        if (a.matches(detected))
+            return a;
+    }
+    return FALLBACK;
+}

package/dist/checkout-engine/adapters/shopify.d.ts

@@ -0,0 +1,31 @@
+import type { Page } from 'playwright-core';
+import { type PageAmountRead } from '../amount.js';
+import { type DetectResult, type FieldMap } from '../detect.js';
+import type { CardCredential } from '../instrument.js';
+import type { Contact, FillResult } from '../types.js';
+import { type CheckoutAdapter } from './generic.js';
+type ShopifySummary = {
+    subtotalMinor: number | null;
+    shippingMinor: number | null;
+    taxMinor: number | null;
+    discountMinor: number;
+    totalMinor: number | null;
+    currency: string | null;
+    verified: boolean;
+};
+export declare function parseShopifySummary(text: string): ShopifySummary;
+export declare function readShopifyAmount(page: Page, requireVerified: boolean): Promise<PageAmountRead>;
+export declare function readStableShopifyAmount(page: Page, timeoutMs?: number): Promise<PageAmountRead>;
+export declare function isShopifyCheckoutPage(page: Page): Promise<boolean>;
+export declare function detectShopifyChallenge(page: Page): Promise<{
+    signal: string;
+} | null>;
+export declare class ShopifyAdapter implements CheckoutAdapter {
+    private readonly detected;
+    name: string;
+    constructor(detected: DetectResult);
+    matches(detected: DetectResult): boolean;
+    prepareContact(page: Page, contact: Contact): Promise<FillResult>;
+    fill(page: Page, _fields: FieldMap, credential: CardCredential, _contact: Contact): Promise<FillResult>;
+}
+export {};