@nordsym/apiclaw 1.5.13 → 1.5.14

package/dist/src/cli/index.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+/**
+ * APIClaw MCP Auto-Setup CLI
+ * Enterprise-grade, platform-agnostic configuration tool
+ */
+import { Command } from 'commander';
+import { writeFileSync } from 'fs';
+import { setupCommand } from './commands/setup.js';
+import { mcpInstallCommand } from './commands/mcp-install.js';
+import { doctorCommand } from './commands/doctor.js';
+import { restoreCommand } from './commands/restore.js';
+import { uninstallCommand } from './commands/uninstall.js';
+import { generateScript } from '../enterprise/script-generator.js';
+const VERSION = '1.0.0';
+const program = new Command();
+program
+    .name('apiclaw')
+    .description('APIClaw MCP Auto-Setup - Configure APIClaw across all your AI coding assistants')
+    .version(VERSION);
+// Setup command - main entry point
+program
+    .command('setup')
+    .description('Configure APIClaw for MCP clients')
+    .option('-c, --client <client>', 'Target specific client (claude-desktop, cursor, windsurf, cline, continue)')
+    .option('--config <path>', 'Custom config file path')
+    .option('-w, --workspace <id>', 'Pre-link APIClaw workspace ID')
+    .option('--dry-run', 'Show what would happen without making changes')
+    .option('-f, --force', 'Overwrite existing APIClaw configuration')
+    .option('--wizard', 'Interactive setup wizard')
+    .option('--all', 'Configure all detected clients')
+    .option('-v, --verbose', 'Verbose output')
+    .option('--enterprise', 'Generate enterprise deployment script')
+    .option('--output <file>', 'Output file for enterprise script')
+    .option('--script-type <type>', 'Script type: bash or powershell (default: auto)')
+    .action(async (options) => {
+    // Enterprise script generation mode
+    if (options.enterprise) {
+        const scriptType = options.scriptType || 'auto';
+        const result = generateScript(scriptType, {
+            workspace: options.workspace,
+            verbose: options.verbose,
+        });
+        if (options.output) {
+            writeFileSync(options.output, result.script);
+            console.log(`\n✓ Enterprise script written to: ${options.output}`);
+            console.log(`  Type: ${result.platform}`);
+            console.log(`\nUsage:`);
+            if (result.platform === 'bash') {
+                console.log(`  chmod +x ${options.output}`);
+                console.log(`  ./${options.output}`);
+            }
+            else {
+                console.log(`  powershell -ExecutionPolicy Bypass -File ${options.output}`);
+            }
+            console.log('');
+        }
+        else {
+            console.log(result.script);
+        }
+        return;
+    }
+    // Normal setup
+    await setupCommand(options);
+});
+// MCP Install command - simple focused installation
+program
+    .command('mcp-install')
+    .description('Install APIClaw into Claude Desktop or Claude Code MCP config')
+    .option('-c, --client <client>', 'Target specific client (claude-desktop, claude-code)')
+    .option('--dry-run', 'Show what would happen without making changes')
+    .action(mcpInstallCommand);
+// Doctor command - health check
+program
+    .command('doctor')
+    .description('Diagnose APIClaw setup and connectivity')
+    .option('--server-name <name>', 'Server name to check (default: apiclaw)')
+    .option('--json', 'Output as JSON')
+    .action(doctorCommand);
+// Restore command - rollback from backup
+program
+    .command('restore')
+    .description('Restore config from backup')
+    .option('-c, --client <client>', 'Target specific client')
+    .option('-l, --list', 'List available backups')
+    .option('-b, --backup <file>', 'Specific backup file to restore')
+    .option('--dry-run', 'Show what would be done without making changes')
+    .action(restoreCommand);
+// Uninstall command - remove APIClaw
+program
+    .command('uninstall')
+    .description('Remove APIClaw from all configured clients')
+    .option('-c, --client <client>', 'Target specific client')
+    .option('--all', 'Remove from all clients')
+    .option('--server-name <name>', 'Server name to remove (default: apiclaw)')
+    .option('--no-backup', 'Skip backup creation')
+    .option('--dry-run', 'Show what would be done without making changes')
+    .option('-f, --force', 'Remove even if not configured')
+    .action(uninstallCommand);
+// MCP Uninstall alias - same as uninstall but for consistency with mcp-install
+program
+    .command('mcp-uninstall')
+    .description('Remove APIClaw from Claude Desktop or Claude Code MCP config')
+    .option('-c, --client <client>', 'Target specific client (claude-desktop, claude-code)')
+    .option('--dry-run', 'Show what would be done without making changes')
+    .action(uninstallCommand);
+// Parse and execute
+program.parse();
+// Show help if no command provided
+if (!process.argv.slice(2).length) {
+    program.outputHelp();
+}

package/dist/src/cli.js

@@ -0,0 +1,302 @@
+#!/usr/bin/env node
+/**
+ * APIClaw Interactive CLI
+ * Run with: npx @nordsym/apiclaw --cli
+ */
+import * as readline from 'readline';
+import { ConvexHttpClient } from 'convex/browser';
+import { discoverAPIs } from './discovery.js';
+import { executeAPICall, getConnectedProviders } from './execute.js';
+import { readSession, writeSession, clearSession, getMachineFingerprint } from './session.js';
+const CONVEX_URL = process.env.CONVEX_URL || 'https://adventurous-avocet-799.convex.cloud';
+const convex = new ConvexHttpClient(CONVEX_URL);
+// Colors for terminal
+const colors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+};
+function log(msg) {
+    console.log(msg);
+}
+function success(msg) {
+    console.log(`${colors.green}✓${colors.reset} ${msg}`);
+}
+function error(msg) {
+    console.log(`${colors.red}✗${colors.reset} ${msg}`);
+}
+function info(msg) {
+    console.log(`${colors.cyan}ℹ${colors.reset} ${msg}`);
+}
+let workspaceContext = null;
+async function validateSession() {
+    const session = readSession();
+    if (!session)
+        return false;
+    try {
+        const result = await convex.query("workspaces:getWorkspaceStatus", {
+            sessionToken: session.sessionToken,
+        });
+        if (!result?.authenticated || result?.status !== 'active') {
+            clearSession();
+            return false;
+        }
+        workspaceContext = {
+            sessionToken: session.sessionToken,
+            workspaceId: session.workspaceId,
+            email: result.email ?? '',
+            tier: result.tier ?? 'free',
+            usageRemaining: result.usageRemaining ?? 0,
+        };
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function registerOwner(email) {
+    info(`Sending magic link to ${email}...`);
+    try {
+        const fingerprint = getMachineFingerprint();
+        // Use HTTP endpoint for magic link
+        const response = await fetch(`${CONVEX_URL.replace('.cloud', '.site')}/workspace/magic-link`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ email, fingerprint }),
+        });
+        const result = await response.json();
+        if (result?.success && result?.token) {
+            success(`Magic link sent to ${email}`);
+            log(`\n📧 Check your email and click the link to authenticate.`);
+            // Start polling for verification
+            log(`\n⏳ Waiting for you to click the link...`);
+            log(`   (Press Ctrl+C to cancel)\n`);
+            await pollForVerification(result.token, fingerprint);
+        }
+        else {
+            error(`Failed: ${result?.error || 'Unknown error'}`);
+        }
+    }
+    catch (err) {
+        error(`Failed: ${err instanceof Error ? err.message : 'Unknown error'}`);
+    }
+}
+async function pollForVerification(token, fingerprint) {
+    const maxAttempts = 60; // 5 minutes
+    for (let i = 0; i < maxAttempts; i++) {
+        await new Promise(r => setTimeout(r, 5000)); // Poll every 5 seconds
+        try {
+            const response = await fetch(`${CONVEX_URL.replace('.cloud', '.site')}/workspace/poll?token=${token}`);
+            const result = await response.json();
+            if (result?.verified && result?.sessionToken) {
+                // Save the real session
+                writeSession(result.sessionToken, result.workspaceId || '', result.email || '');
+                success(`Authenticated as ${result.email}!`);
+                // Reload workspace context
+                await validateSession();
+                return;
+            }
+        }
+        catch {
+            // Continue polling
+        }
+        // Show progress dot
+        process.stdout.write('.');
+    }
+    log('\n');
+    error('Verification timed out. Please try again.');
+}
+async function showStatus() {
+    const valid = await validateSession();
+    log(`\n${colors.bright}APIClaw Status${colors.reset}`);
+    log(`${'─'.repeat(40)}`);
+    if (valid && workspaceContext) {
+        success(`Authenticated as ${workspaceContext.email}`);
+        log(`   Tier: ${workspaceContext.tier}`);
+        log(`   Remaining calls: ${workspaceContext.usageRemaining}`);
+    }
+    else {
+        error(`Not authenticated`);
+        log(`   Run: ${colors.cyan}register <email>${colors.reset}`);
+    }
+    log('');
+}
+async function discover(query) {
+    info(`Searching for: "${query}"`);
+    try {
+        const results = discoverAPIs(query, { maxResults: 5 });
+        if (!results || results.length === 0) {
+            log(`No APIs found for "${query}"`);
+            return;
+        }
+        log(`\n${colors.bright}Found ${results.length} APIs:${colors.reset}\n`);
+        // Get connected providers for Direct Call detection
+        const connected = getConnectedProviders().map(p => p.provider.toLowerCase());
+        for (const result of results) {
+            const api = result.provider;
+            const isDirectCall = connected.includes(api.id?.toLowerCase() || api.name.toLowerCase().replace(/\s+/g, '_'));
+            const directCallBadge = isDirectCall ? `${colors.green}[Direct Call]${colors.reset}` : '';
+            log(`${colors.cyan}${api.name}${colors.reset} ${directCallBadge}`);
+            log(`   ${api.description}`);
+            log(`   Category: ${api.category}`);
+            log(`   Pricing: ${api.pricing?.model || 'See docs'}`);
+            log('');
+        }
+    }
+    catch (err) {
+        error(`Search failed: ${err instanceof Error ? err.message : 'Unknown error'}`);
+    }
+}
+async function listConnected() {
+    try {
+        const providers = getConnectedProviders();
+        log(`\n${colors.bright}Direct Call Providers (no API key needed):${colors.reset}\n`);
+        for (const p of providers) {
+            log(`${colors.cyan}${p.provider}${colors.reset}`);
+            log(`   Actions: ${p.actions?.join(', ') || 'See docs'}`);
+            log('');
+        }
+    }
+    catch (err) {
+        error(`Failed: ${err instanceof Error ? err.message : 'Unknown error'}`);
+    }
+}
+async function callApi(provider, action, params) {
+    if (!workspaceContext) {
+        error('Not authenticated. Run: register <email>');
+        return;
+    }
+    info(`Calling ${provider}.${action}...`);
+    try {
+        const result = await executeAPICall(provider, action, params, workspaceContext.workspaceId);
+        log(`\n${colors.bright}Result:${colors.reset}\n`);
+        log(JSON.stringify(result, null, 2));
+        log('');
+    }
+    catch (err) {
+        error(`Call failed: ${err instanceof Error ? err.message : 'Unknown error'}`);
+    }
+}
+function showHelp() {
+    log(`
+${colors.bright}🦞 APIClaw CLI${colors.reset}
+
+${colors.cyan}Commands:${colors.reset}
+  register <email>      Send magic link to authenticate
+  status                Check authentication status
+  discover <query>      Search for APIs by capability
+  list                  Show Direct Call providers
+  call <provider> <action> <json-params>
+                        Call an API (e.g., call brave_search search {"q":"test"})
+  help                  Show this help
+  exit                  Quit
+
+${colors.cyan}Examples:${colors.reset}
+  discover send SMS
+  discover image generation
+  list
+  call brave_search search {"q":"hello world"}
+`);
+}
+function parseCallCommand(args) {
+    // Format: provider action {json}
+    const match = args.match(/^(\S+)\s+(\S+)\s+(.+)$/);
+    if (!match)
+        return null;
+    try {
+        const params = JSON.parse(match[3]);
+        return { provider: match[1], action: match[2], params };
+    }
+    catch {
+        return null;
+    }
+}
+export async function startCLI() {
+    log(`
+${colors.bright}🦞 APIClaw CLI v1.1.5${colors.reset}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Type ${colors.cyan}help${colors.reset} for commands, ${colors.cyan}exit${colors.reset} to quit.
+`);
+    // Check session on startup
+    const valid = await validateSession();
+    if (valid && workspaceContext) {
+        success(`Authenticated as ${workspaceContext.email}`);
+    }
+    else {
+        info(`Not authenticated. Run: ${colors.cyan}register <email>${colors.reset}`);
+    }
+    log('');
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: `${colors.red}apiclaw${colors.reset}> `,
+    });
+    rl.prompt();
+    rl.on('line', async (line) => {
+        const input = line.trim();
+        const [cmd, ...args] = input.split(/\s+/);
+        const argsStr = args.join(' ');
+        switch (cmd.toLowerCase()) {
+            case '':
+                break;
+            case 'help':
+            case '?':
+                showHelp();
+                break;
+            case 'exit':
+            case 'quit':
+            case 'q':
+                log('Bye! 🦞');
+                process.exit(0);
+                break;
+            case 'register':
+                if (!argsStr) {
+                    error('Usage: register <email>');
+                }
+                else {
+                    await registerOwner(argsStr);
+                }
+                break;
+            case 'status':
+                await showStatus();
+                break;
+            case 'discover':
+            case 'search':
+                if (!argsStr) {
+                    error('Usage: discover <query>');
+                }
+                else {
+                    await discover(argsStr);
+                }
+                break;
+            case 'list':
+            case 'connected':
+                await listConnected();
+                break;
+            case 'call':
+                const parsed = parseCallCommand(argsStr);
+                if (!parsed) {
+                    error('Usage: call <provider> <action> {"param":"value"}');
+                    log('Example: call brave_search search {"q":"hello"}');
+                }
+                else {
+                    await callApi(parsed.provider, parsed.action, parsed.params);
+                }
+                break;
+            default:
+                error(`Unknown command: ${cmd}`);
+                log(`Type ${colors.cyan}help${colors.reset} for available commands.`);
+        }
+        rl.prompt();
+    });
+    rl.on('close', () => {
+        log('\nBye! 🦞');
+        process.exit(0);
+    });
+}

package/dist/src/confirmation.js

@@ -0,0 +1,240 @@
+/**
+ * APIClaw Confirmation System
+ * For actions that cost money or have side effects
+ *
+ * Flow:
+ * 1. Agent calls action → gets preview + token
+ * 2. Agent shows preview to user
+ * 3. User confirms → agent calls confirm with token
+ * 4. APIClaw executes the actual action
+ */
+import { randomBytes } from 'crypto';
+// In-memory store for pending confirmations (in production, use Redis)
+const pendingActions = new Map();
+// Actions that require confirmation before execution
+export const CONFIRMATION_REQUIRED = {
+    // Invoicing - costs money per send
+    coaccept: ['send_invoice', 'send_reminder'],
+    // SMS - costs money per message
+    '46elks': ['send_sms'],
+    twilio: ['send_sms'],
+    // Email sends (less critical but still good to confirm)
+    resend: ['send_email'],
+};
+// Token expiry time (5 minutes)
+const TOKEN_EXPIRY_MS = 5 * 60 * 1000;
+/**
+ * Check if an action requires confirmation (hardcoded list only)
+ * For dynamic providers, use requiresConfirmationAsync
+ */
+export function requiresConfirmation(provider, action) {
+    const actions = CONFIRMATION_REQUIRED[provider];
+    return actions?.includes(action) ?? false;
+}
+/**
+ * Check if a dynamic provider action requires confirmation
+ * This is imported dynamically to avoid circular deps
+ */
+export async function requiresConfirmationAsync(provider, action) {
+    // First check hardcoded list
+    if (requiresConfirmation(provider, action)) {
+        return { required: true, isDynamic: false };
+    }
+    // Then check dynamic provider config
+    try {
+        const { getDynamicConfirmationConfig } = await import('./execute-dynamic.js');
+        const config = await getDynamicConfirmationConfig(provider, action);
+        if (config.required) {
+            return {
+                required: true,
+                estimatedCost: config.estimatedCost,
+                isDynamic: true
+            };
+        }
+    }
+    catch (e) {
+        // Dynamic config not available, that's ok
+    }
+    return { required: false };
+}
+/**
+ * Generate a confirmation token and store the pending action
+ */
+export function createPendingAction(provider, action, params, preview, userId) {
+    // Clean up expired tokens
+    cleanupExpired();
+    const token = randomBytes(16).toString('hex');
+    const now = Date.now();
+    const pending = {
+        token,
+        provider,
+        action,
+        params,
+        preview,
+        createdAt: now,
+        expiresAt: now + TOKEN_EXPIRY_MS,
+        userId,
+    };
+    pendingActions.set(token, pending);
+    return pending;
+}
+/**
+ * Get a pending action by token (and validate it)
+ */
+export function getPendingAction(token) {
+    const pending = pendingActions.get(token);
+    if (!pending) {
+        return null;
+    }
+    if (Date.now() > pending.expiresAt) {
+        pendingActions.delete(token);
+        return null;
+    }
+    return pending;
+}
+/**
+ * Consume a pending action (use it and remove from store)
+ */
+export function consumePendingAction(token) {
+    const pending = getPendingAction(token);
+    if (pending) {
+        pendingActions.delete(token);
+    }
+    return pending;
+}
+/**
+ * Clean up expired tokens
+ */
+function cleanupExpired() {
+    const now = Date.now();
+    for (const [token, pending] of pendingActions.entries()) {
+        if (now > pending.expiresAt) {
+            pendingActions.delete(token);
+        }
+    }
+}
+/**
+ * Generate a human-readable preview for an action
+ */
+export function generatePreview(provider, action, params) {
+    // Provider-specific preview generators
+    switch (provider) {
+        case 'coaccept':
+            return generateCoAcceptPreview(action, params);
+        case '46elks':
+        case 'twilio':
+            return generateSMSPreview(params);
+        case 'resend':
+            return generateEmailPreview(params);
+        default:
+            return { action, params };
+    }
+}
+function generateCoAcceptPreview(action, params) {
+    if (action === 'send_invoice') {
+        const items = params.items || [];
+        const totalAmount = items.reduce((sum, item) => sum + (item.amount || 0), 0);
+        return {
+            type: 'invoice',
+            recipient: {
+                name: params.recipient_name,
+                email: params.recipient_email,
+                org_number: params.recipient_org_nr,
+            },
+            amount: {
+                subtotal: totalAmount,
+                vat_rate: params.vat_rate || 25,
+                vat_amount: totalAmount * ((params.vat_rate || 25) / 100),
+                total: totalAmount * (1 + (params.vat_rate || 25) / 100),
+                currency: params.currency || 'SEK',
+            },
+            due_date: params.due_date,
+            items: items.map((item) => ({
+                description: item.description,
+                quantity: item.quantity || 1,
+                unit_price: item.unit_price || item.amount,
+                amount: item.amount,
+            })),
+            payment_method: 'SMS + Swish/Card (CoAccept)',
+            estimated_cost: '~2-5 SEK per invoice',
+        };
+    }
+    return { action, params };
+}
+function generateSMSPreview(params) {
+    const messageLength = (params.message || '').length;
+    const segments = Math.ceil(messageLength / 160);
+    return {
+        type: 'sms',
+        to: params.to,
+        from: params.from || 'NordSym',
+        message: params.message,
+        message_length: messageLength,
+        segments,
+        estimated_cost: `~${(segments * 0.35).toFixed(2)} SEK`,
+    };
+}
+function generateEmailPreview(params) {
+    return {
+        type: 'email',
+        to: params.to,
+        from: params.from || 'noreply@nordsym.com',
+        subject: params.subject,
+        preview: (params.message || params.html || '').substring(0, 200) + '...',
+    };
+}
+/**
+ * Validate params before creating preview
+ * Returns { valid: true } or { valid: false, errors: [...] }
+ */
+export function validateParams(provider, action, params) {
+    const errors = [];
+    switch (provider) {
+        case 'coaccept':
+            if (action === 'send_invoice') {
+                if (!params.recipient_name)
+                    errors.push('Missing: recipient_name');
+                if (!params.recipient_email)
+                    errors.push('Missing: recipient_email');
+                if (!params.items || !Array.isArray(params.items) || params.items.length === 0) {
+                    errors.push('Missing: items (at least one invoice item required)');
+                }
+                if (!params.due_date)
+                    errors.push('Missing: due_date (YYYY-MM-DD)');
+                // Validate email format
+                if (params.recipient_email && !params.recipient_email.includes('@')) {
+                    errors.push('Invalid: recipient_email format');
+                }
+                // Validate due date is not in past
+                if (params.due_date) {
+                    const dueDate = new Date(params.due_date);
+                    const today = new Date();
+                    today.setHours(0, 0, 0, 0);
+                    if (dueDate < today) {
+                        errors.push('Invalid: due_date cannot be in the past');
+                    }
+                }
+            }
+            break;
+        case '46elks':
+        case 'twilio':
+            if (!params.to)
+                errors.push('Missing: to (phone number)');
+            if (!params.message)
+                errors.push('Missing: message');
+            // Validate phone format (basic check)
+            if (params.to && !params.to.startsWith('+')) {
+                errors.push('Invalid: phone number must start with + (e.g., +46701234567)');
+            }
+            break;
+        case 'resend':
+            if (!params.to)
+                errors.push('Missing: to (email address)');
+            if (!params.subject)
+                errors.push('Missing: subject');
+            if (!params.message && !params.html)
+                errors.push('Missing: message or html content');
+            break;
+    }
+    return errors.length > 0 ? { valid: false, errors } : { valid: true };
+}