@opencard-dev/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1272 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * OpenCard CLI: Command-line interface for setup and management
+ *
+ * Commands:
+ *   opencard serve              Start webhook server with public tunnel
+ *   opencard setup              Interactive setup wizard
+ *   opencard status             Show connection & system status
+ *   opencard cards list         List all active cards
+ *   opencard rules list         List all spend rules
+ *   opencard rules add          Interactive rule creation
+ *   opencard test               Test rules with mock transactions
+ *   opencard approvals list     View pending approval requests
+ *   opencard version            Show version
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const stripe_1 = __importDefault(require("stripe"));
+const core_1 = require("@opencard-dev/core");
+const webhook_server_1 = require("@opencard-dev/webhook-server");
+const table_1 = require("table");
+const readline = __importStar(require("readline"));
+const localtunnel_1 = __importDefault(require("localtunnel"));
+// ─── Dashboard Rendering Helpers ──────────────────────────────────────────
+const BOX_WIDTH = 55; // inner width of the box (between │ characters)
+function useColor() {
+    return process.stdout.isTTY === true && !outputJson;
+}
+function colorize(text, color) {
+    if (!useColor())
+        return text;
+    return `${color}${text}\x1b[0m`;
+}
+function progressBar(filled, total) {
+    const BAR_WIDTH = 28;
+    const pct = total > 0 ? Math.min(filled / total, 1) : 0;
+    const filledChars = Math.round(pct * BAR_WIDTH);
+    const emptyChars = BAR_WIDTH - filledChars;
+    const bar = '█'.repeat(filledChars) + '░'.repeat(emptyChars);
+    if (!useColor())
+        return bar;
+    let colorCode;
+    if (pct > 0.85) {
+        colorCode = '\x1b[31m'; // red
+    }
+    else if (pct >= 0.60) {
+        colorCode = '\x1b[33m'; // yellow
+    }
+    else {
+        colorCode = '\x1b[32m'; // green
+    }
+    return `${colorCode}${bar}\x1b[0m`;
+}
+function formatMoney(cents) {
+    return `$${(cents / 100).toFixed(2)}`;
+}
+function formatTimeAgo(dateStr) {
+    const date = new Date(dateStr);
+    const now = new Date();
+    const diffMs = now.getTime() - date.getTime();
+    const diffMinutes = Math.floor(diffMs / 60000);
+    const diffHours = Math.floor(diffMs / 3600000);
+    if (diffMinutes < 60) {
+        return `${diffMinutes} minutes ago`;
+    }
+    else if (diffHours < 24) {
+        return `${diffHours} hours ago`;
+    }
+    else if (diffHours < 48) {
+        // Check if it was actually yesterday (calendar day)
+        const yesterday = new Date(now);
+        yesterday.setUTCDate(yesterday.getUTCDate() - 1);
+        if (date.toISOString().slice(0, 10) === yesterday.toISOString().slice(0, 10)) {
+            return 'yesterday';
+        }
+    }
+    // Older: "Mar 15"
+    return date.toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
+}
+/** Pad/truncate a string to exactly `width` chars */
+function pad(str, width) {
+    if (str.length > width)
+        return str.slice(0, width);
+    return str + ' '.repeat(width - str.length);
+}
+/** Build a single box line: "│  content  │" padded to BOX_WIDTH */
+function boxLine(content) {
+    // Strip ANSI codes for length calculation
+    const stripped = content.replace(/\x1b\[[0-9;]*m/g, '');
+    const padding = BOX_WIDTH - stripped.length - 2; // 2 for leading spaces
+    return `│  ${content}${' '.repeat(Math.max(0, padding))}  │`;
+}
+function boxEmpty() {
+    return `│${''.padEnd(BOX_WIDTH + 2)}│`;
+}
+function boxTop() {
+    return `┌${'─'.repeat(BOX_WIDTH + 2)}┐`;
+}
+function boxBottom() {
+    return `└${'─'.repeat(BOX_WIDTH + 2)}┘`;
+}
+function boxDivider() {
+    return `├${'─'.repeat(BOX_WIDTH + 2)}┤`;
+}
+function renderDashboard(result) {
+    const INDENT = '  ';
+    console.log();
+    // Header
+    const stripeStatus = result.stripeConnected ? '✓' : '✗';
+    console.log(`${INDENT}OpenCard v${result.version} — ${result.stripeConnected ? 'connected to Stripe' : 'not connected to Stripe'} ${stripeStatus}`);
+    if (result.webhookRunning) {
+        const uptimeStr = result.webhookUptime ? ` (uptime ${result.webhookUptime})` : '';
+        console.log(`${INDENT}Webhook server: running on :${result.webhookPort}${uptimeStr}`);
+    }
+    else {
+        console.log(`${INDENT}Webhook server: not running`);
+    }
+    if (!result.dbAvailable) {
+        console.log(`${INDENT}⚠  Run webhook server to enable spend tracking`);
+    }
+    console.log();
+    if (result.cards.length === 0) {
+        console.log(`${INDENT}No cards found. Run \`opencard setup\` to create your first card.`);
+        console.log();
+        return;
+    }
+    // Card boxes
+    console.log(`${INDENT}${boxTop()}`);
+    for (let i = 0; i < result.cards.length; i++) {
+        const card = result.cards[i];
+        if (i > 0) {
+            console.log(`${INDENT}${boxDivider()}`);
+        }
+        // Card header: 💳 Name ···last4 (status)
+        const cardHeader = `💳 ${card.cardholderName || 'Unknown'}  ···${card.last4}  (${card.status})`;
+        console.log(`${INDENT}${boxLine(cardHeader)}`);
+        // Description line (if set)
+        if (card.description) {
+            console.log(`${INDENT}${boxLine(`${card.description}`)}`);
+        }
+        // Rule line
+        const ruleDisplay = card.ruleName || (card.ruleId ? card.ruleId : 'No rule assigned');
+        console.log(`${INDENT}${boxLine(`Rule: ${ruleDisplay}`)}`);
+        // Spend section
+        console.log(`${INDENT}${boxEmpty()}`);
+        if (card.spend === null) {
+            // DB not available
+            console.log(`${INDENT}${boxLine('Spend data unavailable')}`);
+        }
+        else {
+            const rule = card.rule;
+            // Today
+            const todaySpend = card.spend.today;
+            const dailyLimit = rule?.dailyLimit ?? null;
+            if (dailyLimit !== null) {
+                const todayPct = Math.round((todaySpend / dailyLimit) * 100);
+                console.log(`${INDENT}${boxLine(`Today       ${formatMoney(todaySpend)} / ${formatMoney(dailyLimit)}`)}`);
+                console.log(`${INDENT}${boxLine(`${progressBar(todaySpend, dailyLimit)}  ${todayPct}%`)}`);
+            }
+            else {
+                console.log(`${INDENT}${boxLine(`Today       ${formatMoney(todaySpend)}`)}`);
+            }
+            console.log(`${INDENT}${boxEmpty()}`);
+            // This Month
+            const monthSpend = card.spend.thisMonth;
+            const monthlyLimit = rule?.monthlyLimit ?? null;
+            if (monthlyLimit !== null) {
+                const monthPct = Math.round((monthSpend / monthlyLimit) * 100);
+                console.log(`${INDENT}${boxLine(`This Month  ${formatMoney(monthSpend)} / ${formatMoney(monthlyLimit)}`)}`);
+                console.log(`${INDENT}${boxLine(`${progressBar(monthSpend, monthlyLimit)}  ${monthPct}%`)}`);
+            }
+            else {
+                console.log(`${INDENT}${boxLine(`This Month  ${formatMoney(monthSpend)}`)}`);
+            }
+        }
+        // Recent transactions
+        console.log(`${INDENT}${boxEmpty()}`);
+        console.log(`${INDENT}${boxLine('Last 3 transactions:')}`);
+        if (card.recentTransactions.length === 0) {
+            console.log(`${INDENT}${boxLine('  No transactions yet')}`);
+        }
+        else {
+            for (const txn of card.recentTransactions) {
+                const amt = pad(formatMoney(txn.amount), 8);
+                const merchant = pad(txn.merchantName || 'Unknown', 20);
+                const when = formatTimeAgo(txn.recordedAt);
+                console.log(`${INDENT}${boxLine(`  ${amt}  ${merchant}  ${when}`)}`);
+            }
+        }
+    }
+    console.log(`${INDENT}${boxBottom()}`);
+    console.log();
+    // Footer
+    const s = result.summary;
+    console.log(`${INDENT}${s.activeCards} active card${s.activeCards !== 1 ? 's' : ''} · ${s.declinedToday} declined today · ${s.transactionsThisWeek} transactions this week`);
+    console.log();
+}
+// ─── Configuration ────────────────────────────────────────────────────────
+const VERSION = '0.1.0';
+const RULES_STORE_PATH = process.env.RULES_STORE_PATH || './opencard-rules.json';
+// Global output flag
+let outputJson = false;
+// ─── CLI Setup ────────────────────────────────────────────────────────────
+commander_1.program
+    .name('opencard')
+    .description('OpenCard CLI for Stripe Issuing automation')
+    .version(VERSION)
+    .option('--json', 'Output JSON instead of formatted text')
+    .addHelpText('after', `
+
+Quick Start Examples:
+  
+  # Set up your first card (interactive wizard)
+  opencard setup
+  
+  # Check status of all cards and spend
+  opencard status
+  
+  # List all active cards
+  opencard cards list
+  opencard cards list --json
+  
+  # Manage spend rules
+  opencard rules list
+  opencard rules add
+  
+  # Test your rules with example transactions
+  opencard test
+  
+  # Human-in-the-loop approvals
+  opencard approvals list
+  opencard approvals approve <id>
+  opencard approvals deny <id> --note "reason"
+
+Documentation: https://github.com/JLongshot/opencard`);
+// ─── Commands ──────────────────────────────────────────────────────────────
+/**
+ * opencard setup
+ * Interactive setup wizard for initial configuration
+ */
+commander_1.program
+    .command('setup')
+    .description('Interactive setup wizard')
+    .action(async () => {
+    try {
+        await runSetup();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(message);
+        process.exit(1);
+    }
+});
+/**
+ * opencard status
+ * Show rich dashboard: cards, spend vs limits, recent transactions, webhook health
+ */
+commander_1.program
+    .command('status')
+    .description('Show rich dashboard with card spend, limits, and recent transactions')
+    .action(async (options, cmd) => {
+    outputJson = cmd.parent?.opts()?.json || false;
+    try {
+        const result = await getRichStatus();
+        if (outputJson) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            renderDashboard(result);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(message);
+        process.exit(1);
+    }
+});
+/**
+ * opencard cards list
+ * Show all active cards in table format
+ */
+const cardsCommand = commander_1.program
+    .command('cards')
+    .description('Manage cards')
+    .addHelpText('after', `
+
+Examples:
+  
+  opencard cards list          # Show all active cards in table format
+  opencard cards list --json   # Show all cards as JSON
+`);
+cardsCommand
+    .command('list')
+    .description('List active cards')
+    .option('--json', 'Output as JSON')
+    .action(async (options, cmd) => {
+    outputJson = cmd.parent?.parent?.opts()?.json || options.json || false;
+    try {
+        const cards = await getCards();
+        if (outputJson) {
+            console.log(JSON.stringify({ cards }, null, 2));
+        }
+        else {
+            if (cards.length === 0) {
+                console.log('No active cards found.');
+                return;
+            }
+            const tableData = [
+                ['Card ID', 'Last 4', 'Cardholder', 'Description', 'Status', 'Created'],
+                ...cards.map(card => [
+                    card.id.substring(0, 12) + '...',
+                    card.last4,
+                    card.cardholder_name || '—',
+                    card.description || '—',
+                    card.status,
+                    new Date(card.created * 1000).toLocaleDateString(),
+                ]),
+            ];
+            console.log('\n💳 Active Cards');
+            console.log((0, table_1.table)(tableData, { border: getBorderChars() }));
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(message);
+        process.exit(1);
+    }
+});
+/**
+ * opencard rules list
+ * Show all spend rules in table format
+ */
+const rulesCommand = commander_1.program
+    .command('rules')
+    .description('Manage spend rules')
+    .addHelpText('after', `
+
+Examples:
+  
+  opencard rules list          # Show all configured rules
+  opencard rules add           # Interactively create a new rule
+`);
+rulesCommand
+    .command('list')
+    .description('List all configured spend rules')
+    .option('--json', 'Output as JSON')
+    .action(async (options, cmd) => {
+    outputJson = cmd.parent?.parent?.opts()?.json || options.json || false;
+    try {
+        const rules = await getRules();
+        if (outputJson) {
+            console.log(JSON.stringify({ rules }, null, 2));
+        }
+        else {
+            if (rules.length === 0) {
+                console.log('No rules configured.');
+                return;
+            }
+            const tableData = [
+                ['Rule ID', 'Max Per Txn', 'Daily Limit', 'Monthly Limit', 'On Failure'],
+                ...rules.map(ruleItem => {
+                    const rule = ruleItem.rule;
+                    const maxPerTxn = rule.maxPerTransaction
+                        ? `$${(rule.maxPerTransaction / 100).toFixed(2)}`
+                        : '—';
+                    const daily = rule.dailyLimit
+                        ? `$${(rule.dailyLimit / 100).toFixed(2)}`
+                        : '—';
+                    const monthly = rule.monthlyLimit
+                        ? `$${(rule.monthlyLimit / 100).toFixed(2)}`
+                        : '—';
+                    return [
+                        ruleItem.id.substring(0, 12) + '...',
+                        maxPerTxn,
+                        daily,
+                        monthly,
+                        rule.onFailure || 'decline',
+                    ];
+                }),
+            ];
+            console.log('\n📋 Spend Rules');
+            console.log((0, table_1.table)(tableData, { border: getBorderChars() }));
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(message);
+        process.exit(1);
+    }
+});
+/**
+ * opencard rules add
+ * Interactive rule creation
+ */
+rulesCommand
+    .command('add')
+    .description('Create a new spend rule (interactive)')
+    .action(async (options, cmd) => {
+    try {
+        await createRule();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(message);
+        process.exit(1);
+    }
+});
+/**
+ * opencard test
+ * Simulate 3 authorization requests against the user's configured rules.
+ * No real Stripe calls, no real money — validates the decision engine end-to-end.
+ */
+commander_1.program
+    .command('test')
+    .description('Simulate authorization requests against your rules (no real charges)')
+    .action(async (options, cmd) => {
+    outputJson = cmd.parent?.opts()?.json || false;
+    try {
+        await runTest();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(message);
+        process.exit(1);
+    }
+});
+/**
+ * opencard serve
+ * Start webhook server with public tunnel and Stripe webhook registration
+ */
+commander_1.program
+    .command('serve')
+    .description('Start webhook server with public tunnel and Stripe webhook registration')
+    .option('--port <port>', 'Webhook server port (default: 3000)', '3000')
+    .option('--no-tunnel', 'Skip localtunnel and use --url instead')
+    .option('--url <url>', 'Public webhook URL (use with --no-tunnel)')
+    .action(async (options) => {
+    try {
+        await runServe(parseInt(options.port, 10), options.tunnel, options.url);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(message);
+        process.exit(1);
+    }
+});
+/**
+ * opencard version
+ * Show version
+ */
+commander_1.program
+    .command('version')
+    .description('Show version')
+    .action(() => {
+    console.log(`OpenCard CLI v${VERSION}`);
+});
+// ─── Implementation ───────────────────────────────────────────────────────
+/**
+ * Collect all data needed for the rich status dashboard.
+ */
+async function getRichStatus() {
+    const stripeKey = process.env.STRIPE_SECRET_KEY;
+    const webhookPort = parseInt(process.env.WEBHOOK_PORT || '3000', 10);
+    const version = VERSION;
+    const stripeConnected = !!stripeKey;
+    const webhookRunning = await checkWebhookHealth(webhookPort);
+    // Try to get webhook uptime from health endpoint
+    let webhookUptime = null;
+    if (webhookRunning) {
+        try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 2000);
+            const response = await fetch(`http://localhost:${webhookPort}/health`, { signal: controller.signal });
+            clearTimeout(timeout);
+            if (response.ok) {
+                const data = await response.json();
+                if (typeof data.uptime === 'number') {
+                    webhookUptime = formatUptime(data.uptime);
+                }
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    // Try to open DB
+    let db = null;
+    let dbAvailable = false;
+    try {
+        db = new core_1.OpenCardDatabase();
+        dbAvailable = true;
+    }
+    catch {
+        dbAvailable = false;
+    }
+    // Load rules store
+    const store = new core_1.RulesStore(RULES_STORE_PATH);
+    let rulesMap = new Map();
+    try {
+        const rulesList = await store.listRules();
+        for (const entry of rulesList) {
+            rulesMap.set(entry.id, entry);
+        }
+    }
+    catch {
+        // rules not available
+    }
+    // Load cards from Stripe
+    let stripeCards = [];
+    if (stripeKey) {
+        try {
+            const stripe = new stripe_1.default(stripeKey, { apiVersion: '2023-10-16' });
+            const response = await stripe.issuing.cards.list({ limit: 100 });
+            stripeCards = response.data.map(card => ({
+                id: card.id,
+                last4: card.last4,
+                cardholderName: typeof card.cardholder === 'object' && card.cardholder !== null
+                    ? card.cardholder.name || null
+                    : null,
+                description: card.metadata?.opencard_description ?? null,
+                status: card.status,
+                ruleId: card.metadata?.opencard_rule_id || null,
+            }));
+        }
+        catch {
+            // Stripe unavailable
+        }
+    }
+    // Build per-card data
+    const cards = [];
+    // Summary accumulators
+    let declinedToday = 0;
+    let transactionsThisWeek = 0;
+    // Get today midnight UTC and week start
+    const now = new Date();
+    const todayMidnight = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()));
+    const monthStart = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1));
+    const weekAgo = new Date(todayMidnight.getTime() - 7 * 24 * 60 * 60 * 1000);
+    // Compute global summary stats from DB if available
+    if (db) {
+        try {
+            const rawDb = db.getDb();
+            // Declined today
+            const declinedRow = rawDb.prepare(`SELECT COUNT(*) as cnt FROM authorizations WHERE status = 'declined' AND created_at >= ?`).get(todayMidnight.toISOString().replace('T', ' ').slice(0, 19));
+            declinedToday = declinedRow.cnt;
+            // Transactions this week
+            const txnRow = rawDb.prepare(`SELECT COUNT(*) as cnt FROM transactions WHERE recorded_at >= ?`).get(weekAgo.toISOString().replace('T', ' ').slice(0, 19));
+            transactionsThisWeek = txnRow.cnt;
+        }
+        catch {
+            // ignore
+        }
+    }
+    // Build each card's rich status
+    for (const stripeCard of stripeCards) {
+        const ruleEntry = stripeCard.ruleId ? rulesMap.get(stripeCard.ruleId) || null : null;
+        const rule = ruleEntry?.rule || null;
+        const ruleName = rule?.name || (stripeCard.ruleId ? stripeCard.ruleId : null);
+        let spend = null;
+        let recentTransactions = [];
+        if (db) {
+            try {
+                const rawDb = db.getDb();
+                // Spend from authorizations table with status='approved' for real-time budget enforcement.
+                // We use authorizations (not transactions) because:
+                //   - authorizations are real-time and status reflects rule enforcement decisions
+                //   - transactions are a subset of authorizations that were captured by Stripe
+                //   - using the same table ensures budget enforcement and reporting show the same spend totals
+                //   - this matches MCP get_balance and list_cards for consistency
+                // Today's spend (approved authorizations since midnight UTC)
+                const todayRow = rawDb.prepare(`SELECT COALESCE(SUM(amount), 0) as total FROM authorizations WHERE card_id = ? AND status = 'approved' AND created_at >= ?`).get(stripeCard.id, todayMidnight.toISOString().replace('T', ' ').slice(0, 19));
+                // This month's spend (approved authorizations since 1st of month UTC)
+                const monthRow = rawDb.prepare(`SELECT COALESCE(SUM(amount), 0) as total FROM authorizations WHERE card_id = ? AND status = 'approved' AND created_at >= ?`).get(stripeCard.id, monthStart.toISOString().replace('T', ' ').slice(0, 19));
+                spend = {
+                    today: todayRow.total,
+                    thisMonth: monthRow.total,
+                };
+                // Last 3 transactions
+                const txnRows = rawDb.prepare(`SELECT amount, merchant_name, recorded_at FROM transactions WHERE card_id = ? ORDER BY recorded_at DESC LIMIT 3`).all(stripeCard.id);
+                recentTransactions = txnRows.map(row => ({
+                    amount: row.amount,
+                    merchantName: row.merchant_name,
+                    recordedAt: row.recorded_at,
+                }));
+            }
+            catch {
+                // DB queries failed — leave spend as null
+            }
+        }
+        cards.push({
+            id: stripeCard.id,
+            last4: stripeCard.last4,
+            cardholderName: stripeCard.cardholderName,
+            description: stripeCard.description,
+            status: stripeCard.status,
+            ruleId: stripeCard.ruleId,
+            ruleName,
+            rule,
+            spend,
+            recentTransactions,
+        });
+    }
+    const activeCards = cards.filter(c => c.status === 'active').length;
+    if (db) {
+        db.close();
+    }
+    return {
+        version,
+        stripeConnected,
+        webhookRunning,
+        webhookPort,
+        webhookUptime,
+        dbAvailable,
+        cards,
+        summary: {
+            activeCards,
+            declinedToday,
+            transactionsThisWeek,
+        },
+    };
+}
+function formatUptime(seconds) {
+    const h = Math.floor(seconds / 3600);
+    const m = Math.floor((seconds % 3600) / 60);
+    if (h > 0)
+        return `${h}h ${m}m`;
+    return `${m}m`;
+}
+async function runSetup() {
+    console.log('\n🎯 OpenCard Setup Wizard');
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+    // Check Stripe key
+    const stripeKey = process.env.STRIPE_SECRET_KEY;
+    if (!stripeKey) {
+        console.log('❌ Error: STRIPE_SECRET_KEY not set');
+        console.log('\nSet your key with: export STRIPE_SECRET_KEY=sk_test_...');
+        process.exit(1);
+    }
+    console.log('✓ STRIPE_SECRET_KEY configured');
+    // Initialize client
+    let client;
+    try {
+        client = new core_1.StripeClient({ secretKey: stripeKey });
+        console.log('✓ Connected to Stripe');
+    }
+    catch (error) {
+        console.error('✗ Failed to initialize Stripe client:', error);
+        process.exit(1);
+    }
+    // Create a test cardholder
+    console.log('\n📋 Creating test cardholder...');
+    try {
+        const cardholder = await client.createCardholder('Test Agent', 'test@example.com');
+        console.log(`✓ Cardholder created: ${cardholder.id}`);
+        console.log(`  Name: ${cardholder.name}`);
+        console.log(`  Email: ${cardholder.email}`);
+        // Create a rule in the rules store (best practice — keeps rules out of Stripe metadata)
+        console.log('\n📋 Creating spend rule...');
+        const store = new core_1.RulesStore(RULES_STORE_PATH);
+        const rule = core_1.SpendRules.template('daily_limit').build();
+        const ruleId = await store.createRule(rule);
+        console.log(`✓ Rule created: ${ruleId}`);
+        console.log(`  Daily limit: $${((rule.dailyLimit || 0) / 100).toFixed(2)}`);
+        // Create a test card linked to the rule via ruleId
+        console.log('\n💳 Creating test card...');
+        const card = await client.createCard(cardholder.id, {
+            agentName: 'test-agent',
+            description: 'Test card created by opencard setup',
+            ruleId,
+        });
+        console.log(`✓ Card created: ${card.last4}`);
+        console.log(`  ID: ${card.id}`);
+        console.log(`  Expires: ${card.expiry}`);
+        console.log(`  Status: ${card.status}`);
+        // Get card details
+        console.log('\n🔍 Fetching card details...');
+        const cardDetails = await client.getCard(card.id);
+        console.log(`✓ Card retrieved successfully`);
+        console.log(`  Last 4: ${cardDetails.last4}`);
+        console.log(`  Agent: ${cardDetails.agentName}`);
+        console.log('\n✅ Setup complete!');
+        console.log('\nNext steps:');
+        console.log('  1. Review the documentation: https://github.com/JLongshot/opencard');
+        console.log('  2. Integrate with your agent using the @opencard/core SDK');
+        console.log('  3. Test with more cards and rules\n');
+    }
+    catch (error) {
+        console.error('✗ Setup failed:', error);
+        process.exit(1);
+    }
+}
+async function getCards() {
+    const stripeKey = process.env.STRIPE_SECRET_KEY;
+    if (!stripeKey) {
+        throw new Error('STRIPE_SECRET_KEY not set. Get your test key from https://dashboard.stripe.com/apikeys');
+    }
+    if (!stripeKey.startsWith('sk_test_') && !stripeKey.startsWith('sk_live_')) {
+        console.warn('STRIPE_SECRET_KEY looks invalid — test keys start with sk_test_, live keys with sk_live_');
+    }
+    const stripe = new stripe_1.default(stripeKey, { apiVersion: '2023-10-16' });
+    const response = await stripe.issuing.cards.list({ limit: 100 });
+    return response.data.map(card => ({
+        id: card.id,
+        last4: card.last4,
+        cardholder_name: card.cardholder?.name || null,
+        description: card.metadata?.opencard_description ?? null,
+        status: card.status,
+        created: card.created,
+    }));
+}
+async function getRules() {
+    const store = new core_1.RulesStore(RULES_STORE_PATH);
+    return await store.listRules();
+}
+async function createRule() {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const question = (prompt) => {
+        return new Promise(resolve => {
+            rl.question(prompt, resolve);
+        });
+    };
+    try {
+        console.log('\n📋 Create a New Spend Rule');
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+        const limitStr = await question('Limit amount (in cents, e.g. 10000 for $100): ');
+        const periodStr = await question('Period (daily/monthly): ');
+        const onFailureStr = await question('On failure (decline/alert [not yet implemented]/pause [not yet implemented]): ');
+        const nameStr = await question('Rule name (optional): ');
+        const limit = parseInt(limitStr, 10);
+        const period = periodStr.toLowerCase().startsWith('m') ? 'monthly' : 'daily';
+        const onFailure = onFailureStr.toLowerCase() || 'decline';
+        if (isNaN(limit) || limit <= 0) {
+            console.error('Invalid limit amount');
+            rl.close();
+            return;
+        }
+        if (onFailure === 'alert' || onFailure === 'pause') {
+            console.warn(`\n⚠️  Note: the "${onFailure}" mode is not yet implemented — charges will be declined. Use "decline" for now.\n`);
+        }
+        const store = new core_1.RulesStore(RULES_STORE_PATH);
+        const ruleData = {
+            name: nameStr || undefined,
+            onFailure: onFailure,
+            dailyLimit: period === 'daily' ? limit : undefined,
+            monthlyLimit: period === 'monthly' ? limit : undefined,
+        };
+        const ruleId = await store.createRule(ruleData);
+        console.log('\n✅ Rule created successfully!');
+        console.log(`  ID: ${ruleId}`);
+        console.log(`  Name: ${nameStr || '—'}`);
+        console.log(`  Limit: $${(limit / 100).toFixed(2)} (${period})`);
+        console.log(`  On failure: ${onFailure}\n`);
+        rl.close();
+    }
+    catch (error) {
+        rl.close();
+        throw error;
+    }
+}
+async function runTest() {
+    const store = new core_1.RulesStore(RULES_STORE_PATH);
+    let rules = await store.listRules();
+    let usingTempRule = false;
+    let ruleId;
+    let rule;
+    // If no rules exist, create a temporary test rule
+    if (rules.length === 0) {
+        usingTempRule = true;
+        const tempRule = {
+            name: 'Test Rule (temporary)',
+            maxPerTransaction: 10000, // $100/txn
+            dailyLimit: 50000, // $500/day
+            onFailure: 'decline',
+        };
+        ruleId = await store.createRule(tempRule);
+        rule = tempRule;
+        rules = [{ id: ruleId, rule }];
+    }
+    else {
+        // Use the first configured rule
+        ({ id: ruleId, rule } = rules[0]);
+    }
+    const ruleName = rule.name || ruleId;
+    // ── Build test scenarios ────────────────────────────────────────────────
+    //
+    // Scenario 1: Should APPROVE — small amount, neutral category
+    // Scenario 2: Should DECLINE — amount exceeds per-transaction or daily limit
+    // Scenario 3: Should DECLINE or APPROVE — category test with Blue Bottle Coffee
+    //
+    // We derive realistic thresholds from the actual rule so the scenarios
+    // produce the intended outcomes regardless of what the user configured.
+    const perTxLimit = rule.maxPerTransaction;
+    const dailyLimit = rule.dailyLimit;
+    const monthlyLimit = rule.monthlyLimit;
+    const hasAllowedCategories = (rule.allowedCategories?.length ?? 0) > 0;
+    const hasBlockedCategories = (rule.blockedCategories?.length ?? 0) > 0;
+    // Scenario 1: small, approved amount in a neutral/allowed category
+    const approveCategory = hasAllowedCategories
+        ? rule.allowedCategories[0]
+        : 'software';
+    const approveAmount = perTxLimit
+        ? Math.min(Math.floor(perTxLimit * 0.25), 2500) // 25% of per-tx limit, max $25
+        : dailyLimit
+            ? Math.min(Math.floor(dailyLimit * 0.05), 2500) // 5% of daily, max $25
+            : 2500; // fallback: $25
+    // Scenario 2: amount that exceeds per-transaction limit (or daily/monthly if no per-tx)
+    let declineAmount;
+    let declineReason2;
+    if (perTxLimit !== undefined) {
+        declineAmount = perTxLimit + 5000; // $50 over limit
+        declineReason2 = 'exceeds per-transaction limit';
+    }
+    else if (dailyLimit !== undefined) {
+        declineAmount = dailyLimit + 5000;
+        declineReason2 = 'exceeds daily limit';
+    }
+    else if (monthlyLimit !== undefined) {
+        declineAmount = monthlyLimit + 5000;
+        declineReason2 = 'exceeds monthly limit';
+    }
+    else {
+        // No limits? Approve it anyway (edge case — show it passes)
+        declineAmount = 100000; // $1000
+        declineReason2 = 'exceeds limit';
+    }
+    // Scenario 3: Blue Bottle Coffee (restaurants) — check category rules
+    const thirdCategory = 'restaurants';
+    const thirdMerchant = 'Blue Bottle Coffee';
+    const thirdAmount = 500; // $5
+    // Will scenario 3 be approved or declined?
+    let scenario3Expected;
+    let scenario3DeclineReason;
+    if (hasAllowedCategories && !rule.allowedCategories.includes(thirdCategory)) {
+        // restaurants not in allowed list → declined
+        scenario3Expected = false;
+        scenario3DeclineReason = 'category not in allowed list';
+    }
+    else if (hasBlockedCategories && rule.blockedCategories.includes(thirdCategory)) {
+        // restaurants is blocked → declined
+        scenario3Expected = false;
+        scenario3DeclineReason = 'blocked category';
+    }
+    else {
+        // No category restriction → approved (amount is tiny)
+        scenario3Expected = true;
+    }
+    const scenarios = [
+        {
+            label: 'scenario1',
+            amount: approveAmount,
+            merchantName: 'Vercel Inc',
+            category: approveCategory,
+            expectedApproved: true,
+        },
+        {
+            label: 'scenario2',
+            amount: declineAmount,
+            merchantName: 'Best Buy',
+            category: 'electronics',
+            expectedApproved: false,
+            declineReason: declineReason2,
+        },
+        {
+            label: 'scenario3',
+            amount: thirdAmount,
+            merchantName: thirdMerchant,
+            category: thirdCategory,
+            expectedApproved: scenario3Expected,
+            declineReason: scenario3DeclineReason,
+        },
+    ];
+    // ── Run evaluations ─────────────────────────────────────────────────────
+    const results = scenarios.map(scenario => {
+        const auth = (0, core_1.mockAuthorization)({
+            amount: scenario.amount,
+            category: scenario.category,
+            merchantName: scenario.merchantName,
+        });
+        // Zero spend context — we're testing rule logic, not cumulative spend
+        const decision = (0, core_1.evaluateAuthorization)(auth, rule, {
+            dailySpend: 0,
+            monthlySpend: 0,
+        });
+        return {
+            ...scenario,
+            actualApproved: decision.approved,
+            reason: decision.reason,
+            passed: decision.approved === scenario.expectedApproved,
+        };
+    });
+    // ── Compute summary ─────────────────────────────────────────────────────
+    const approvedCount = results.filter(r => r.actualApproved).length;
+    const declinedCount = results.filter(r => !r.actualApproved).length;
+    // "working" means the engine made the expected decision for each scenario
+    const allCorrect = results.every(r => r.passed);
+    const coffeeMessage = '\n  Your agent has a credit card now. Pretty wild.\n' +
+        '  Have it buy my agent a coffee → https://buymeacoffee.com/ovenbeardl ☕';
+    // ── Output ──────────────────────────────────────────────────────────────
+    if (outputJson) {
+        const jsonOutput = {
+            rule: { id: ruleId, name: ruleName },
+            usingTempRule,
+            results: results.map(r => ({
+                merchant: r.merchantName,
+                amount: r.amount,
+                amountDollars: `$${(r.amount / 100).toFixed(2)}`,
+                category: r.category,
+                approved: r.actualApproved,
+                expectedApproved: r.expectedApproved,
+                passed: r.passed,
+                reason: r.reason,
+            })),
+            summary: {
+                approved: approvedCount,
+                declined: declinedCount,
+                total: results.length,
+                allCorrect,
+            },
+        };
+        console.log(JSON.stringify(jsonOutput, null, 2));
+        // Coffee line always goes to stderr to avoid breaking JSON output
+        process.stderr.write(coffeeMessage + '\n');
+        return;
+    }
+    // Pretty-print output
+    console.log('\n🧪 Testing your rules...\n');
+    if (usingTempRule) {
+        console.log('  ⚠️  No rules configured — using temporary test rule ($100/txn, $500/day)\n');
+    }
+    console.log(`  Rule: ${ruleName}\n`);
+    // Determine column widths for alignment
+    const lines = results.map(r => {
+        const amountStr = `$${(r.amount / 100).toFixed(2)}`;
+        const label = `${amountStr} at "${r.merchantName}" (${r.category})`;
+        return label;
+    });
+    const maxLabelLen = Math.max(...lines.map(l => l.length));
+    for (let i = 0; i < results.length; i++) {
+        const r = results[i];
+        const label = lines[i];
+        const padding = '.'.repeat(Math.max(1, maxLabelLen - label.length + 4));
+        const statusIcon = r.actualApproved ? '✓ APPROVED' : '✗ DECLINED';
+        let line = `  ${label} ${padding} ${statusIcon}`;
+        // Append decline reason for declined transactions
+        if (!r.actualApproved && r.declineReason) {
+            line += ` — ${r.declineReason}`;
+        }
+        else if (!r.actualApproved && r.reason) {
+            // Extract a short reason from the evaluation output
+            const shortReason = r.reason
+                .replace(/^(Transaction|Daily limit exceeded|Monthly limit exceeded|Merchant category)/, match => match.toLowerCase())
+                .replace(/\s+/g, ' ')
+                .trim();
+            // Use the first clause only
+            line += ` — ${shortReason.split('\n')[0]}`;
+        }
+        console.log(line);
+    }
+    // Summary line
+    const summaryParts = [];
+    if (approvedCount > 0)
+        summaryParts.push(`${approvedCount} approved`);
+    if (declinedCount > 0)
+        summaryParts.push(`${declinedCount} declined`);
+    const summary = summaryParts.join(', ');
+    const statusMsg = allCorrect
+        ? 'your rules are working.'
+        : 'some results were unexpected — check your rules.';
+    console.log(`\n  ${summary} — ${statusMsg}`);
+    console.log(coffeeMessage);
+    console.log();
+}
+async function checkWebhookHealth(port) {
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 2000);
+        const response = await fetch(`http://localhost:${port}/health`, {
+            signal: controller.signal,
+        });
+        clearTimeout(timeout);
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+// ─── Serve Command Implementation ─────────────────────────────────────────────
+async function runServe(port, useTunnel, tunnelUrl) {
+    // ── Validate STRIPE_SECRET_KEY ────────────────────────────────────────────
+    const stripeKey = process.env.STRIPE_SECRET_KEY;
+    if (!stripeKey) {
+        console.error('[Serve] FATAL: STRIPE_SECRET_KEY environment variable is not set.');
+        console.error('[Serve] Set it with: export STRIPE_SECRET_KEY=sk_test_...');
+        process.exit(1);
+    }
+    const stripe = new stripe_1.default(stripeKey, { apiVersion: '2023-10-16' });
+    console.log('[Serve] ✓ STRIPE_SECRET_KEY configured');
+    // ── Start webhook server ──────────────────────────────────────────────────
+    console.log(`[Serve] Starting webhook server on port ${port}...`);
+    let serverStarted = false;
+    const serverPromise = (0, webhook_server_1.startWebhookServer)(port);
+    // Give server a moment to start
+    const serverTimeout = new Promise((resolve) => {
+        setTimeout(resolve, 1000);
+    });
+    await Promise.race([serverPromise, serverTimeout]);
+    serverStarted = true;
+    console.log('[Serve] ✓ Webhook server started');
+    // ── Determine public URL ──────────────────────────────────────────────────
+    let publicUrl;
+    if (!useTunnel && tunnelUrl) {
+        // Use provided URL directly
+        publicUrl = tunnelUrl;
+        console.log(`[Serve] Using provided URL: ${publicUrl}`);
+    }
+    else if (useTunnel) {
+        // Create localtunnel
+        console.log('[Serve] Creating public tunnel...');
+        try {
+            const tunnel = await (0, localtunnel_1.default)({ port, subdomain: 'opencard' });
+            publicUrl = tunnel.url;
+            console.log(`[Serve] ✓ Tunnel created: ${publicUrl}`);
+            // Clean up tunnel on exit
+            process.on('SIGINT', async () => {
+                console.log('[Serve] Closing tunnel...');
+                await tunnel.close();
+                process.exit(0);
+            });
+        }
+        catch (err) {
+            console.error('[Serve] Failed to create tunnel:', err instanceof Error ? err.message : err);
+            console.error('[Serve] Tip: localtunnel may be unavailable. Try running with --no-tunnel --url https://your-public-url');
+            process.exit(1);
+        }
+    }
+    else {
+        console.error('[Serve] No public URL provided. Use --tunnel (default) or --no-tunnel --url <url>');
+        process.exit(1);
+    }
+    // ── Register webhook with Stripe ──────────────────────────────────────────
+    const webhookUrl = `${publicUrl}/webhooks/stripe`;
+    console.log(`[Serve] Registering webhook endpoint with Stripe: ${webhookUrl}`);
+    let endpointId = null;
+    try {
+        const endpoint = await stripe.webhookEndpoints.create({
+            url: webhookUrl,
+            enabled_events: ['issuing_authorization.request'],
+        });
+        endpointId = endpoint.id;
+        console.log(`[Serve] ✓ Webhook endpoint registered: ${endpointId}`);
+        console.log(`[Serve] ✓ Webhook secret: ${endpoint.secret}`);
+        console.log(`[Serve] ⚠️  Save this secret and set: export STRIPE_WEBHOOK_SECRET=${endpoint.secret}`);
+    }
+    catch (err) {
+        console.error('[Serve] Failed to register webhook:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+    // ── Print status and listen ───────────────────────────────────────────────
+    console.log('\n┌─────────────────────────────────────────────────────┐');
+    console.log('│ OpenCard Webhook Server Ready                       │');
+    console.log('├─────────────────────────────────────────────────────┤');
+    console.log(`│ Public URL: ${webhookUrl.padEnd(43)}│`);
+    console.log(`│ Endpoint ID: ${endpointId?.padEnd(40)}│`);
+    console.log('│                                                     │');
+    console.log('│ Health check:  GET  http://localhost:' + port.toString().padEnd(10) + '/health     │');
+    console.log('│ Webhook:       POST http://localhost:' + port.toString().padEnd(10) + '/webhooks/stripe │');
+    console.log('│                                                     │');
+    console.log('│ Press Ctrl+C to stop and deregister webhook.        │');
+    console.log('└─────────────────────────────────────────────────────┘\n');
+    // ── Handle SIGINT for cleanup ─────────────────────────────────────────────
+    process.on('SIGINT', async () => {
+        console.log('\n[Serve] Shutting down...');
+        if (endpointId) {
+            try {
+                console.log('[Serve] Deregistering webhook endpoint...');
+                await stripe.webhookEndpoints.del(endpointId);
+                console.log('[Serve] ✓ Webhook endpoint deregistered');
+            }
+            catch (err) {
+                console.error('[Serve] Failed to deregister webhook:', err instanceof Error ? err.message : err);
+            }
+        }
+        console.log('[Serve] Bye!');
+        process.exit(0);
+    });
+    // Keep the process running
+    await new Promise(() => {
+        // Never resolve — process is kept alive by event listeners
+    });
+}
+function getBorderChars() {
+    return {
+        topBody: '─',
+        topJoin: '┬',
+        topLeft: '┌',
+        topRight: '┐',
+        bottomBody: '─',
+        bottomJoin: '┴',
+        bottomLeft: '└',
+        bottomRight: '┘',
+        bodyLeft: '│',
+        bodyRight: '│',
+        bodyJoin: '│',
+        joinBody: '─',
+        joinLeft: '├',
+        joinRight: '┤',
+        joinJoin: '┼',
+    };
+}
+// ─── Approvals commands ───────────────────────────────────────────────────────
+/**
+ * opencard approvals list
+ * Show pending approval requests from the SQLite database
+ */
+const approvalsCommand = commander_1.program
+    .command('approvals')
+    .description('Manage human-in-the-loop spending approval requests')
+    .addHelpText('after', `
+
+Workflow:
+  
+  # View pending approvals
+  opencard approvals list
+  
+  # Approve a request
+  opencard approvals approve <request-id>
+  opencard approvals approve <request-id> --by "alice" --note "approved for travel"
+  
+  # Deny a request
+  opencard approvals deny <request-id> --note "exceeded budget"
+`);
+approvalsCommand
+    .command('list')
+    .description('List pending approval requests')
+    .action(async (options, cmd) => {
+    outputJson = cmd.parent?.parent?.opts()?.json || false;
+    try {
+        const db = new core_1.OpenCardDatabase();
+        const pending = db.listPendingApprovalRequests();
+        db.close();
+        if (outputJson) {
+            console.log(JSON.stringify({ pending }, null, 2));
+            return;
+        }
+        if (pending.length === 0) {
+            console.log('\n  No pending approval requests.\n');
+            return;
+        }
+        console.log('\nPending Approval Requests:\n');
+        for (const req of pending) {
+            const amountDollars = `$${(req.amount / 100).toFixed(2)}`;
+            const createdAt = new Date(req.created_at.replace(' ', 'T') + 'Z');
+            const expiresAt = new Date(req.expires_at.replace(' ', 'T') + 'Z');
+            const now = new Date();
+            const requestedAgo = formatTimeAgo(createdAt.toISOString());
+            const expiresInMs = expiresAt.getTime() - now.getTime();
+            const expiresInSec = Math.max(0, Math.floor(expiresInMs / 1000));
+            const expiresInMin = Math.floor(expiresInSec / 60);
+            const expiresInSecRem = expiresInSec % 60;
+            const expiresStr = expiresInMs <= 0
+                ? 'expired'
+                : `${expiresInMin}m ${expiresInSecRem}s`;
+            console.log(`  ${req.id}  ${amountDollars} at "${req.merchant_name}"`);
+            console.log(`  Reason: ${req.reason}`);
+            console.log(`  Card: ${req.card_id}${req.merchant_category ? ` · Category: ${req.merchant_category}` : ''}`);
+            console.log(`  Requested: ${requestedAgo} · Expires in ${expiresStr}`);
+            console.log();
+            console.log(`  opencard approvals approve ${req.id}`);
+            console.log(`  opencard approvals deny ${req.id} --note "reason"`);
+            console.log();
+        }
+    }
+    catch (error) {
+        console.error('Error listing approvals:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+approvalsCommand
+    .command('approve <id>')
+    .description('Approve a pending approval request')
+    .option('--by <who>', 'Your name/identifier (default: "operator")')
+    .option('--note <note>', 'Optional note')
+    .action(async (id, options) => {
+    try {
+        const db = new core_1.OpenCardDatabase();
+        const request = db.approveRequest(id, options.by || 'operator', options.note);
+        db.close();
+        const amountDollars = `$${(request.amount / 100).toFixed(2)}`;
+        console.log(`\n✅ Approved: ${id}`);
+        console.log(`   ${amountDollars} at "${request.merchant_name}"`);
+        console.log(`   Approved by: ${request.decided_by}`);
+        if (request.decision_note) {
+            console.log(`   Note: ${request.decision_note}`);
+        }
+        console.log();
+    }
+    catch (error) {
+        console.error('Error approving request:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+approvalsCommand
+    .command('deny <id>')
+    .description('Deny a pending approval request')
+    .option('--by <who>', 'Your name/identifier (default: "operator")')
+    .option('--note <note>', 'Optional note explaining the denial')
+    .action(async (id, options) => {
+    try {
+        const db = new core_1.OpenCardDatabase();
+        const request = db.denyRequest(id, options.by || 'operator', options.note);
+        db.close();
+        const amountDollars = `$${(request.amount / 100).toFixed(2)}`;
+        console.log(`\n✗ Denied: ${id}`);
+        console.log(`   ${amountDollars} at "${request.merchant_name}"`);
+        console.log(`   Denied by: ${request.decided_by}`);
+        if (request.decision_note) {
+            console.log(`   Note: ${request.decision_note}`);
+        }
+        console.log();
+    }
+    catch (error) {
+        console.error('Error denying request:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+// ─── Parse and run ────────────────────────────────────────────────────────
+commander_1.program.parse(process.argv);
+// Show help if no command
+if (!process.argv.slice(2).length) {
+    commander_1.program.outputHelp();
+}
+//# sourceMappingURL=index.js.map