paybridge 0.5.0 → 0.7.0

package/README.md

@@ -197,6 +197,9 @@ app.post('/webhook', express.raw({ type: 'application/json' }), (req, res) => {
 | **Adyen** | ✅ | ⛔ | ✅ | ✅ | **Production** |
 | **Mercado Pago** | ✅ | ✅ | ✅ | ✅ | **Production** |
 | **Razorpay** | ✅ | ✅ | ✅ | ✅ | **Production** |
+| **Mollie** | ✅ | ⛔ | ✅ | ✅ | **Production** |
+| **Square** | ✅ | ⛔ | ✅ | ✅ | **Production** |
+| **Pesapal** | ✅ | ⛔ | ✅ | ✅ | **Production** |
 
 ### Crypto on/off-ramp providers
 
@@ -204,6 +207,8 @@ app.post('/webhook', express.raw({ type: 'application/json' }), (req, res) => {
 |----------|---------|----------|-------|----------|--------|
 | **MoonPay** | ✅ | ✅ | ✅ | ✅ | **Production** |
 | **Yellow Card** | ⚠️ | ⚠️ | ⚠️ | ⚠️ | **Experimental** |
+| **Transak** | ✅ | ✅ | ✅ | ✅ | **Production** |
+| **Ramp Network** | ✅ | ✅ | ✅ | ✅ | **Production** |
 
 **Legend:** ✅ Supported | ⛔ Not supported by upstream API | ⚠️ Experimental (spec unverified)
 
@@ -313,6 +318,62 @@ const pay = new PayBridge({
 
 **Note:** Razorpay webhooks do not include timestamp-based replay protection.
 
+### Mollie
+
+```typescript
+const pay = new PayBridge({
+  provider: 'mollie',
+  credentials: {
+    apiKey: 'test_...' // Or live_... for production
+  },
+  sandbox: true,
+  webhookSecret: 'optional_webhook_secret'
+});
+```
+
+**Docs:** [Mollie API Reference](https://docs.mollie.com/reference)
+
+**Note:** Mollie subscriptions require Customer + Mandate setup (not yet supported by paybridge). Mollie webhooks have no signature scheme — security relies on getPayment() round-trip + source IP validation.
+
+### Square
+
+```typescript
+const pay = new PayBridge({
+  provider: 'square',
+  credentials: {
+    apiKey: 'EAAAEOuL...', // Access token
+    locationId: 'LOCATION123',
+    notificationUrl: 'https://example.com/webhook' // Required for signature verification
+  },
+  sandbox: true,
+  webhookSecret: 'your_webhook_secret'
+});
+```
+
+**Docs:** [Square API Reference](https://developer.squareup.com/reference/square)
+
+**Note:** Square subscriptions require multi-step Catalog + Customer + Plan setup (not yet supported by paybridge). Webhook signature uses notificationUrl + raw body.
+
+### Pesapal
+
+```typescript
+const pay = new PayBridge({
+  provider: 'pesapal',
+  credentials: {
+    apiKey: 'qkio1BGG...', // consumer_key
+    secretKey: 'osGQ364R...', // consumer_secret
+    notificationId: 'IPN123', // Register IPN URL with Pesapal first
+    username: 'merchant@example.com' // Required for refunds
+  },
+  sandbox: true,
+  webhookSecret: 'optional_webhook_secret'
+});
+```
+
+**Docs:** [Pesapal API Reference](https://developer.pesapal.com/)
+
+**Note:** Pesapal subscriptions not yet supported. Pesapal IPN has no signature scheme — security relies on getPayment() round-trip + source IP validation. OAuth-style token caching (5min expiry).
+
 ## Switch Providers in 1 Line
 
 ```typescript

package/dist/cli/commands/providers.d.ts

@@ -0,0 +1 @@
+export declare function runProviders(args: string[]): Promise<void>;

package/dist/cli/commands/providers.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runProviders = runProviders;
+const index_1 = require("../../index");
+const crypto_1 = require("../../crypto");
+const utils_1 = require("../utils");
+const FIAT_PROVIDERS = [
+    'softycomp',
+    'yoco',
+    'ozow',
+    'payfast',
+    'paystack',
+    'stripe',
+    'peach',
+    'flutterwave',
+    'adyen',
+    'mercadopago',
+    'razorpay',
+    'mollie',
+    'square',
+    'pesapal',
+];
+const CRYPTO_PROVIDERS = ['moonpay', 'yellowcard', 'transak', 'ramp'];
+function createDummyProvider(name) {
+    const dummyCreds = {
+        softycomp: { apiKey: 'dummy', secretKey: 'dummy' },
+        yoco: { apiKey: 'dummy' },
+        ozow: { apiKey: 'dummy', siteCode: 'dummy', privateKey: 'dummy' },
+        payfast: { merchantId: 'dummy', merchantKey: 'dummy' },
+        paystack: { apiKey: 'dummy' },
+        stripe: { apiKey: 'dummy' },
+        peach: { apiKey: 'dummy', secretKey: 'dummy' },
+        flutterwave: { apiKey: 'dummy' },
+        adyen: { apiKey: 'dummy', merchantAccount: 'dummy' },
+        mercadopago: { apiKey: 'dummy' },
+        razorpay: { apiKey: 'dummy', secretKey: 'dummy' },
+        mollie: { apiKey: 'dummy' },
+        square: { apiKey: 'dummy', locationId: 'dummy' },
+        pesapal: { apiKey: 'dummy', secretKey: 'dummy' },
+    };
+    return new index_1.PayBridge({
+        provider: name,
+        credentials: dummyCreds[name],
+        sandbox: true,
+    });
+}
+function createDummyCryptoProvider(name) {
+    const dummyCreds = {
+        moonpay: { apiKey: 'dummy', secretKey: 'dummy' },
+        yellowcard: { apiKey: 'dummy', secretKey: 'dummy' },
+        transak: { apiKey: 'dummy', secretKey: 'dummy' },
+        ramp: { apiKey: 'dummy' },
+        mock: { apiKey: 'dummy' },
+    };
+    return new crypto_1.CryptoRamp({
+        provider: name,
+        credentials: dummyCreds[name],
+        sandbox: true,
+    });
+}
+async function runProviders(args) {
+    const isJson = args.includes('--json');
+    if (isJson) {
+        const fiat = FIAT_PROVIDERS.map((name) => {
+            const provider = createDummyProvider(name);
+            const caps = provider.provider.getCapabilities();
+            return {
+                provider: name,
+                type: 'fiat',
+                region: caps.country || 'N/A',
+                currencies: caps.currencies,
+                fee: `${caps.fees.percent ?? 0}% + ${caps.fees.fixed ?? 0}`,
+                minAmount: caps.minAmount,
+                maxAmount: caps.maxAmount,
+                avgLatencyMs: caps.avgLatencyMs,
+            };
+        });
+        const crypto = CRYPTO_PROVIDERS.map((name) => {
+            const ramp = createDummyCryptoProvider(name);
+            const caps = ramp.getCapabilities();
+            return {
+                provider: name,
+                type: 'crypto',
+                onRampSupported: !!caps.onRampLimits,
+                offRampSupported: !!caps.offRampLimits,
+                assets: caps.supportedAssets,
+                onRampFeePercent: caps.fees.onRampPercent,
+                offRampFeePercent: caps.fees.offRampPercent,
+                experimental: caps.experimental,
+                avgLatencyMs: caps.avgLatencyMs,
+            };
+        });
+        console.log(JSON.stringify({ fiat, crypto }, null, 2));
+        return;
+    }
+    console.log((0, utils_1.colorize)('\nFIAT PROVIDERS', 'bright'));
+    console.log('==============\n');
+    const fiatRows = [
+        ['PROVIDER', 'REGION', 'CURRENCIES', 'FEE'],
+    ];
+    for (const name of FIAT_PROVIDERS) {
+        const provider = createDummyProvider(name);
+        const caps = provider.provider.getCapabilities();
+        fiatRows.push([
+            name,
+            caps.country || 'N/A',
+            caps.currencies.join('/'),
+            `${caps.fees.percent ?? 0}% + ${caps.fees.fixed ?? 0}`,
+        ]);
+    }
+    console.log((0, utils_1.formatTable)(fiatRows));
+    console.log((0, utils_1.colorize)('\n\nCRYPTO PROVIDERS', 'bright'));
+    console.log('================\n');
+    const cryptoRows = [
+        ['PROVIDER', 'ON-RAMP', 'OFF-RAMP', 'ASSETS', 'FEE (ON/OFF)'],
+    ];
+    for (const name of CRYPTO_PROVIDERS) {
+        const ramp = createDummyCryptoProvider(name);
+        const caps = ramp.getCapabilities();
+        const onRampIcon = caps.experimental ? '⚠' : caps.onRampLimits ? '✓' : '✗';
+        const offRampIcon = caps.experimental ? '⚠' : caps.offRampLimits ? '✓' : '✗';
+        const feeText = caps.experimental
+            ? '⚠ experimental'
+            : `${caps.fees.onRampPercent ?? 0}% / ${caps.fees.offRampPercent ?? 0}%`;
+        cryptoRows.push([
+            name,
+            onRampIcon,
+            offRampIcon,
+            caps.supportedAssets.slice(0, 4).join('/'),
+            feeText,
+        ]);
+    }
+    console.log((0, utils_1.formatTable)(cryptoRows));
+    console.log('');
+}

package/dist/cli/commands/quote.d.ts

@@ -0,0 +1 @@
+export declare function runQuote(args: string[]): Promise<void>;

package/dist/cli/commands/quote.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runQuote = runQuote;
+const crypto_1 = require("../../crypto");
+const utils_1 = require("../utils");
+const CRYPTO_PROVIDERS = ['moonpay', 'yellowcard', 'transak', 'ramp'];
+function createCryptoProviderFromEnv(providerName) {
+    const envMap = {
+        moonpay: {
+            keys: ['MOONPAY_API_KEY', 'MOONPAY_SECRET_KEY'],
+            mapper: (env) => ({ apiKey: env.MOONPAY_API_KEY, secretKey: env.MOONPAY_SECRET_KEY }),
+        },
+        yellowcard: {
+            keys: ['YELLOWCARD_API_KEY', 'YELLOWCARD_SECRET_KEY'],
+            mapper: (env) => ({ apiKey: env.YELLOWCARD_API_KEY, secretKey: env.YELLOWCARD_SECRET_KEY }),
+        },
+        transak: {
+            keys: ['TRANSAK_API_KEY', 'TRANSAK_SECRET_KEY'],
+            mapper: (env) => ({ apiKey: env.TRANSAK_API_KEY, secretKey: env.TRANSAK_SECRET_KEY }),
+        },
+        ramp: {
+            keys: ['RAMP_API_KEY'],
+            mapper: (env) => ({ apiKey: env.RAMP_API_KEY }),
+        },
+        mock: {
+            keys: [],
+            mapper: () => ({ apiKey: 'mock' }),
+        },
+    };
+    const config = envMap[providerName];
+    if (!config) {
+        throw new Error(`Unknown crypto provider: ${providerName}`);
+    }
+    const missing = config.keys.filter((k) => !process.env[k]);
+    if (missing.length > 0) {
+        throw new Error(`Missing required env vars: ${missing.join(', ')}`);
+    }
+    const credentials = config.mapper(process.env);
+    return new crypto_1.CryptoRamp({
+        provider: providerName,
+        credentials,
+        sandbox: true,
+    });
+}
+async function runQuote(args) {
+    const providerName = args[0];
+    if (!providerName) {
+        console.error('Usage: paybridge quote <provider> --direction on|off --fiat-amount N --fiat-currency CUR --asset ASSET --network NET');
+        process.exit(1);
+    }
+    if (!CRYPTO_PROVIDERS.includes(providerName)) {
+        console.error(`Unknown crypto provider: ${providerName}`);
+        console.error(`Available: ${CRYPTO_PROVIDERS.join(', ')}`);
+        process.exit(1);
+    }
+    const getArg = (flag) => {
+        const idx = args.indexOf(flag);
+        return idx >= 0 && args[idx + 1] ? args[idx + 1] : undefined;
+    };
+    const direction = getArg('--direction');
+    const fiatAmountStr = getArg('--fiat-amount');
+    const fiatCurrency = getArg('--fiat-currency');
+    const asset = getArg('--asset');
+    const network = getArg('--network');
+    if (!direction || !fiatAmountStr || !fiatCurrency || !asset) {
+        console.error('Missing required flags: --direction, --fiat-amount, --fiat-currency, --asset');
+        process.exit(1);
+    }
+    const fiatAmount = parseFloat(fiatAmountStr);
+    if (!Number.isFinite(fiatAmount) || fiatAmount <= 0) {
+        console.error('Invalid fiat amount (must be positive number)');
+        process.exit(1);
+    }
+    let provider;
+    try {
+        provider = createCryptoProviderFromEnv(providerName);
+    }
+    catch (error) {
+        console.error((0, utils_1.colorize)(error.message, 'red'));
+        process.exit(1);
+    }
+    try {
+        const quote = await provider.getQuote(direction, fiatAmount, fiatCurrency, asset, network || asset);
+        console.log(JSON.stringify(quote, null, 2));
+        process.exit(0);
+    }
+    catch (error) {
+        console.error((0, utils_1.colorize)(`Quote error: ${error.message}`, 'red'));
+        process.exit(1);
+    }
+}

package/dist/cli/commands/test.d.ts

@@ -0,0 +1 @@
+export declare function runTest(args: string[]): Promise<void>;

package/dist/cli/commands/test.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runTest = runTest;
+const runners_1 = require("../runners");
+const utils_1 = require("../utils");
+async function runProviderTest(runner) {
+    const missing = runner.envRequired.filter((key) => !process.env[key]);
+    if (missing.length > 0) {
+        return {
+            provider: runner.name,
+            status: 'skipped',
+            message: `Missing: ${missing.join(', ')}`,
+        };
+    }
+    console.log(`${(0, utils_1.colorize)('[…]', 'cyan')} ${runner.name} - validating...`);
+    try {
+        const result = await runner.run();
+        if (!result.id) {
+            throw new Error('No payment ID returned');
+        }
+        console.log(`${(0, utils_1.colorize)('[✓]', 'green')} ${runner.name} → id=${result.id}${result.checkoutUrl ? `, url=${result.checkoutUrl.substring(0, 60)}...` : ''}, status=${result.status}`);
+        return {
+            provider: runner.name,
+            status: 'success',
+            data: {
+                id: result.id,
+                checkoutUrl: result.checkoutUrl,
+                status: result.status,
+            },
+        };
+    }
+    catch (error) {
+        console.log(`${(0, utils_1.colorize)('[✗]', 'red')} ${runner.name} ERROR: ${error.message || String(error)}`);
+        return {
+            provider: runner.name,
+            status: 'failed',
+            message: error.message || String(error),
+        };
+    }
+}
+async function runTest(args) {
+    const isAll = args.includes('--all');
+    const providerName = args.find((a) => !a.startsWith('--'));
+    if (!isAll && !providerName) {
+        console.error('Usage: paybridge test <provider> | paybridge test --all');
+        process.exit(1);
+    }
+    console.log('\n=== PayBridge Test ===\n');
+    const results = [];
+    if (isAll) {
+        for (const runner of runners_1.runners) {
+            const result = await runProviderTest(runner);
+            results.push(result);
+        }
+    }
+    else {
+        const runner = runners_1.runners.find((r) => r.name === providerName);
+        if (!runner) {
+            console.error(`Unknown provider: ${providerName}`);
+            console.error(`Available: ${runners_1.runners.map((r) => r.name).join(', ')}`);
+            process.exit(1);
+        }
+        const result = await runProviderTest(runner);
+        results.push(result);
+    }
+    console.log('\n=== Summary ===\n');
+    const succeeded = results.filter((r) => r.status === 'success').length;
+    const skipped = results.filter((r) => r.status === 'skipped').length;
+    const failed = results.filter((r) => r.status === 'failed').length;
+    results.forEach((r) => {
+        const icon = r.status === 'success'
+            ? (0, utils_1.colorize)('[✓]', 'green')
+            : r.status === 'skipped'
+                ? (0, utils_1.colorize)('[ ]', 'dim')
+                : (0, utils_1.colorize)('[✗]', 'red');
+        const msg = r.message ? ` (${r.message})` : '';
+        console.log(`${icon} ${r.provider}${msg}`);
+    });
+    console.log(`\nSucceeded: ${succeeded}, Skipped: ${skipped}, Failed: ${failed}`);
+    if (failed > 0) {
+        console.log('\nSome providers failed validation.');
+        process.exit(1);
+    }
+    else if (succeeded === 0) {
+        console.log('\nNo providers validated (all skipped). Set env vars to validate.');
+        process.exit(0);
+    }
+    else {
+        console.log('\nAll enabled providers validated successfully!');
+        process.exit(0);
+    }
+}

package/dist/cli/commands/webhook.d.ts

@@ -0,0 +1 @@
+export declare function runWebhook(args: string[]): Promise<void>;

package/dist/cli/commands/webhook.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runWebhook = runWebhook;
+const index_1 = require("../../index");
+const utils_1 = require("../utils");
+const PROVIDERS = [
+    'softycomp',
+    'yoco',
+    'ozow',
+    'payfast',
+    'paystack',
+    'stripe',
+    'peach',
+    'flutterwave',
+    'adyen',
+    'mercadopago',
+    'razorpay',
+    'mollie',
+    'square',
+    'pesapal',
+];
+function createProviderFromEnv(providerName) {
+    const envMap = {
+        softycomp: {
+            keys: ['SOFTYCOMP_API_KEY', 'SOFTYCOMP_SECRET_KEY', 'SOFTYCOMP_WEBHOOK_SECRET'],
+            mapper: (env) => ({
+                apiKey: env.SOFTYCOMP_API_KEY,
+                secretKey: env.SOFTYCOMP_SECRET_KEY,
+                webhookSecret: env.SOFTYCOMP_WEBHOOK_SECRET,
+            }),
+        },
+        yoco: {
+            keys: ['YOCO_API_KEY', 'YOCO_WEBHOOK_SECRET'],
+            mapper: (env) => ({ apiKey: env.YOCO_API_KEY, webhookSecret: env.YOCO_WEBHOOK_SECRET }),
+        },
+        ozow: {
+            keys: ['OZOW_API_KEY', 'OZOW_SITE_CODE', 'OZOW_PRIVATE_KEY'],
+            mapper: (env) => ({
+                apiKey: env.OZOW_API_KEY,
+                siteCode: env.OZOW_SITE_CODE,
+                privateKey: env.OZOW_PRIVATE_KEY,
+            }),
+        },
+        payfast: {
+            keys: ['PAYFAST_MERCHANT_ID', 'PAYFAST_MERCHANT_KEY', 'PAYFAST_PASSPHRASE'],
+            mapper: (env) => ({
+                merchantId: env.PAYFAST_MERCHANT_ID,
+                merchantKey: env.PAYFAST_MERCHANT_KEY,
+                passphrase: env.PAYFAST_PASSPHRASE,
+            }),
+        },
+        paystack: {
+            keys: ['PAYSTACK_API_KEY', 'PAYSTACK_WEBHOOK_SECRET'],
+            mapper: (env) => ({ apiKey: env.PAYSTACK_API_KEY, webhookSecret: env.PAYSTACK_WEBHOOK_SECRET }),
+        },
+        stripe: {
+            keys: ['STRIPE_API_KEY', 'STRIPE_WEBHOOK_SECRET'],
+            mapper: (env) => ({ apiKey: env.STRIPE_API_KEY, webhookSecret: env.STRIPE_WEBHOOK_SECRET }),
+        },
+        peach: {
+            keys: ['PEACH_ACCESS_TOKEN', 'PEACH_ENTITY_ID', 'PEACH_WEBHOOK_SECRET'],
+            mapper: (env) => ({
+                apiKey: env.PEACH_ACCESS_TOKEN,
+                secretKey: env.PEACH_ENTITY_ID,
+                webhookSecret: env.PEACH_WEBHOOK_SECRET,
+            }),
+        },
+        flutterwave: {
+            keys: ['FLUTTERWAVE_API_KEY', 'FLUTTERWAVE_WEBHOOK_SECRET'],
+            mapper: (env) => ({ apiKey: env.FLUTTERWAVE_API_KEY, webhookSecret: env.FLUTTERWAVE_WEBHOOK_SECRET }),
+        },
+        adyen: {
+            keys: ['ADYEN_API_KEY', 'ADYEN_MERCHANT_ACCOUNT', 'ADYEN_WEBHOOK_SECRET'],
+            mapper: (env) => ({
+                apiKey: env.ADYEN_API_KEY,
+                merchantAccount: env.ADYEN_MERCHANT_ACCOUNT,
+                webhookSecret: env.ADYEN_WEBHOOK_SECRET,
+            }),
+        },
+        mercadopago: {
+            keys: ['MERCADOPAGO_ACCESS_TOKEN', 'MERCADOPAGO_WEBHOOK_SECRET'],
+            mapper: (env) => ({ apiKey: env.MERCADOPAGO_ACCESS_TOKEN, webhookSecret: env.MERCADOPAGO_WEBHOOK_SECRET }),
+        },
+        razorpay: {
+            keys: ['RAZORPAY_KEY_ID', 'RAZORPAY_KEY_SECRET', 'RAZORPAY_WEBHOOK_SECRET'],
+            mapper: (env) => ({
+                apiKey: env.RAZORPAY_KEY_ID,
+                secretKey: env.RAZORPAY_KEY_SECRET,
+                webhookSecret: env.RAZORPAY_WEBHOOK_SECRET,
+            }),
+        },
+        mollie: {
+            keys: ['MOLLIE_API_KEY'],
+            mapper: (env) => ({ apiKey: env.MOLLIE_API_KEY }),
+        },
+        square: {
+            keys: ['SQUARE_ACCESS_TOKEN', 'SQUARE_LOCATION_ID', 'SQUARE_WEBHOOK_SECRET'],
+            mapper: (env) => ({
+                apiKey: env.SQUARE_ACCESS_TOKEN,
+                locationId: env.SQUARE_LOCATION_ID,
+                webhookSecret: env.SQUARE_WEBHOOK_SECRET,
+            }),
+        },
+        pesapal: {
+            keys: ['PESAPAL_CONSUMER_KEY', 'PESAPAL_CONSUMER_SECRET'],
+            mapper: (env) => ({ apiKey: env.PESAPAL_CONSUMER_KEY, secretKey: env.PESAPAL_CONSUMER_SECRET }),
+        },
+    };
+    const config = envMap[providerName];
+    if (!config) {
+        throw new Error(`Unknown provider: ${providerName}`);
+    }
+    const required = config.keys.filter((k) => !k.includes('WEBHOOK_SECRET'));
+    const missing = required.filter((k) => !process.env[k]);
+    if (missing.length > 0) {
+        throw new Error(`Missing required env vars: ${missing.join(', ')}`);
+    }
+    const credentials = config.mapper(process.env);
+    return new index_1.PayBridge({
+        provider: providerName,
+        credentials,
+        sandbox: true,
+        webhookSecret: credentials.webhookSecret,
+    });
+}
+async function runWebhook(args) {
+    const subcommand = args[0];
+    const providerName = args[1];
+    if (!subcommand || !providerName) {
+        console.error('Usage: paybridge webhook verify|parse <provider> [--header key=value]');
+        process.exit(1);
+    }
+    if (!PROVIDERS.includes(providerName)) {
+        console.error(`Unknown provider: ${providerName}`);
+        console.error(`Available: ${PROVIDERS.join(', ')}`);
+        process.exit(1);
+    }
+    const headerFlags = args.slice(2).filter((a) => a.startsWith('--header')).map((a) => a.replace('--header', '').trim());
+    const headersJsonFlag = args.find((a) => a.startsWith('--headers-json='));
+    let headers = {};
+    if (headersJsonFlag) {
+        const json = headersJsonFlag.replace('--headers-json=', '');
+        try {
+            headers = JSON.parse(json);
+        }
+        catch {
+            console.error('Invalid JSON in --headers-json');
+            process.exit(1);
+        }
+    }
+    else {
+        headers = (0, utils_1.parseHeaders)(headerFlags);
+    }
+    const rawBody = await (0, utils_1.readStdin)();
+    let body;
+    try {
+        body = JSON.parse(rawBody);
+    }
+    catch {
+        body = rawBody;
+    }
+    let provider;
+    try {
+        provider = createProviderFromEnv(providerName);
+    }
+    catch (error) {
+        console.error((0, utils_1.colorize)(error.message, 'red'));
+        process.exit(1);
+    }
+    if (subcommand === 'verify') {
+        const valid = provider.verifyWebhook(body, headers);
+        if (valid) {
+            console.log((0, utils_1.colorize)('OK', 'green'));
+            process.exit(0);
+        }
+        else {
+            console.log((0, utils_1.colorize)('INVALID', 'red'));
+            process.exit(1);
+        }
+    }
+    else if (subcommand === 'parse') {
+        try {
+            const event = provider.parseWebhook(body, headers);
+            console.log(JSON.stringify(event, null, 2));
+            process.exit(0);
+        }
+        catch (error) {
+            console.error((0, utils_1.colorize)(`Parse error: ${error.message}`, 'red'));
+            process.exit(1);
+        }
+    }
+    else {
+        console.error(`Unknown webhook subcommand: ${subcommand}`);
+        console.error('Use "verify" or "parse"');
+        process.exit(1);
+    }
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_1 = require("./commands/test");
+const providers_1 = require("./commands/providers");
+const webhook_1 = require("./commands/webhook");
+const quote_1 = require("./commands/quote");
+const utils_1 = require("./utils");
+async function main() {
+    const [, , command, ...args] = process.argv;
+    switch (command) {
+        case 'test':
+            await (0, test_1.runTest)(args);
+            break;
+        case 'providers':
+            await (0, providers_1.runProviders)(args);
+            break;
+        case 'webhook':
+            await (0, webhook_1.runWebhook)(args);
+            break;
+        case 'quote':
+            await (0, quote_1.runQuote)(args);
+            break;
+        case '-h':
+        case '--help':
+        case 'help':
+        case undefined:
+            (0, utils_1.printHelp)();
+            process.exit(0);
+            break;
+        case '-v':
+        case '--version':
+            (0, utils_1.printVersion)();
+            process.exit(0);
+            break;
+        default:
+            console.error(`Unknown command: ${command}`);
+            (0, utils_1.printHelp)(true);
+            process.exit(1);
+    }
+}
+main().catch((err) => {
+    console.error(err.message);
+    process.exit(1);
+});

package/dist/cli/runners.d.ts

@@ -0,0 +1,10 @@
+export interface ProviderRunner {
+    name: string;
+    envRequired: string[];
+    run: () => Promise<{
+        id: string;
+        checkoutUrl?: string;
+        status: string;
+    }>;
+}
+export declare const runners: ProviderRunner[];