@nordsym/apiclaw 1.7.3 → 1.7.5

package/dist/src/stripe.js

@@ -1,407 +0,0 @@
-// Stripe integration for APIClaw credit purchases
-import Stripe from 'stripe';
-import { config } from 'dotenv';
-// Load environment quietly to avoid polluting MCP stdio output.
-config({ path: '.env.local', quiet: true });
-const stripeSecretKey = process.env.STRIPE_SECRET_KEY;
-if (!stripeSecretKey) {
-    console.warn('STRIPE_SECRET_KEY not set - Stripe features disabled');
-}
-const stripe = stripeSecretKey ? new Stripe(stripeSecretKey) : null;
-// Credit packages
-export const CREDIT_PACKAGES = {
-    starter: {
-        id: 'starter',
-        name: 'Starter Pack',
-        amountUsd: 10,
-        credits: 100,
-        bonus: 0,
-        description: '$10 → 100 credits',
-    },
-    growth: {
-        id: 'growth',
-        name: 'Growth Pack',
-        amountUsd: 50,
-        credits: 550,
-        bonus: 50,
-        description: '$50 → 550 credits (10% bonus)',
-    },
-    scale: {
-        id: 'scale',
-        name: 'Scale Pack',
-        amountUsd: 100,
-        credits: 1200,
-        bonus: 200,
-        description: '$100 → 1,200 credits (20% bonus)',
-    },
-};
-/**
- * Create a Stripe Checkout Session for credit purchase
- */
-export async function createCheckoutSession(agentId, packageType, successUrl, cancelUrl) {
-    if (!stripe) {
-        return { error: 'Stripe not configured' };
-    }
-    const pkg = CREDIT_PACKAGES[packageType];
-    if (!pkg) {
-        return { error: `Invalid package: ${packageType}` };
-    }
-    try {
-        const session = await stripe.checkout.sessions.create({
-            mode: 'payment',
-            payment_method_types: ['card'],
-            line_items: [
-                {
-                    price_data: {
-                        currency: 'usd',
-                        product_data: {
-                            name: `APIClaw ${pkg.name}`,
-                            description: pkg.description,
-                            metadata: {
-                                packageType,
-                                credits: pkg.credits.toString(),
-                            },
-                        },
-                        unit_amount: pkg.amountUsd * 100, // Stripe uses cents
-                    },
-                    quantity: 1,
-                },
-            ],
-            metadata: {
-                agentId,
-                packageType,
-                credits: pkg.credits.toString(),
-            },
-            success_url: successUrl,
-            cancel_url: cancelUrl,
-        });
-        return {
-            sessionId: session.id,
-            url: session.url,
-        };
-    }
-    catch (error) {
-        console.error('Stripe checkout error:', error);
-        return {
-            error: error instanceof Error ? error.message : 'Checkout failed',
-        };
-    }
-}
-/**
- * Create a Payment Intent for programmatic payment (agent-to-agent)
- */
-export async function createPaymentIntent(agentId, packageType) {
-    if (!stripe) {
-        return { error: 'Stripe not configured' };
-    }
-    const pkg = CREDIT_PACKAGES[packageType];
-    if (!pkg) {
-        return { error: `Invalid package: ${packageType}` };
-    }
-    try {
-        const paymentIntent = await stripe.paymentIntents.create({
-            amount: pkg.amountUsd * 100,
-            currency: 'usd',
-            metadata: {
-                agentId,
-                packageType,
-                credits: pkg.credits.toString(),
-            },
-            automatic_payment_methods: {
-                enabled: true,
-            },
-        });
-        return {
-            clientSecret: paymentIntent.client_secret,
-            paymentIntentId: paymentIntent.id,
-            amount: pkg.amountUsd,
-        };
-    }
-    catch (error) {
-        console.error('Stripe payment intent error:', error);
-        return {
-            error: error instanceof Error ? error.message : 'Payment intent failed',
-        };
-    }
-}
-/**
- * Verify Stripe webhook signature
- */
-export function verifyWebhookSignature(payload, signature) {
-    if (!stripe)
-        return null;
-    const webhookSecret = process.env.STRIPE_WEBHOOK_SECRET;
-    if (!webhookSecret) {
-        console.error('STRIPE_WEBHOOK_SECRET not set');
-        return null;
-    }
-    try {
-        return stripe.webhooks.constructEvent(payload, signature, webhookSecret);
-    }
-    catch (error) {
-        console.error('Webhook signature verification failed:', error);
-        return null;
-    }
-}
-export function processWebhookEvent(event) {
-    switch (event.type) {
-        case 'checkout.session.completed': {
-            const session = event.data.object;
-            if (session.payment_status !== 'paid')
-                return null;
-            const metadata = session.metadata || {};
-            const agentId = metadata.agentId;
-            const packageType = metadata.packageType;
-            const credits = parseInt(metadata.credits || '0', 10);
-            if (!agentId || !packageType || !credits) {
-                console.error('Missing metadata in checkout session:', metadata);
-                return null;
-            }
-            return {
-                agentId,
-                packageType,
-                credits,
-                amountUsd: (session.amount_total || 0) / 100,
-                stripeSessionId: session.id,
-            };
-        }
-        case 'payment_intent.succeeded': {
-            const paymentIntent = event.data.object;
-            const metadata = paymentIntent.metadata || {};
-            const agentId = metadata.agentId;
-            const packageType = metadata.packageType;
-            const credits = parseInt(metadata.credits || '0', 10);
-            if (!agentId || !packageType || !credits) {
-                console.error('Missing metadata in payment intent:', metadata);
-                return null;
-            }
-            return {
-                agentId,
-                packageType,
-                credits,
-                amountUsd: paymentIntent.amount / 100,
-                stripePaymentIntentId: paymentIntent.id,
-            };
-        }
-        default:
-            return null;
-    }
-}
-/**
- * Get Stripe instance (for advanced usage)
- */
-export function getStripe() {
-    return stripe;
-}
-// ============================================
-// METERED BILLING (Pay-per-call)
-// ============================================
-// Stripe Meter configuration
-export const METERED_BILLING = {
-    meterId: 'mtr_61UFEGojJ0b2awh1441RtJYK3aJTqS9g',
-    eventName: 'api_call',
-    priceId: 'price_1T5qNFRtJYK3aJTqzHLnUjKG', // $0.002/call, linked to meter
-    productId: 'prod_U3yHbnc4NcLofW',
-    pricePerCall: 0.002, // $0.002 per API call
-};
-/**
- * Report API usage to Stripe Meter
- * Call this after each successful API call
- */
-export async function reportUsage(customerId, calls = 1, idempotencyKey) {
-    if (!stripe) {
-        return { success: false, error: 'Stripe not configured' };
-    }
-    try {
-        // Use Stripe's meter event API
-        const event = await stripe.billing.meterEvents.create({
-            event_name: METERED_BILLING.eventName,
-            payload: {
-                stripe_customer_id: customerId,
-                value: calls.toString(),
-            },
-            timestamp: Math.floor(Date.now() / 1000),
-        }, {
-            idempotencyKey: idempotencyKey || `usage_${customerId}_${Date.now()}_${Math.random()}`,
-        });
-        return { success: true, eventId: event.identifier };
-    }
-    catch (error) {
-        console.error('Failed to report usage:', error);
-        return {
-            success: false,
-            error: error instanceof Error ? error.message : 'Usage reporting failed',
-        };
-    }
-}
-/**
- * Create or get a customer in Stripe
- */
-export async function getOrCreateCustomer(agentId, email) {
-    if (!stripe) {
-        return { error: 'Stripe not configured' };
-    }
-    try {
-        // Search for existing customer by agentId
-        const existing = await stripe.customers.search({
-            query: `metadata['agentId']:'${agentId}'`,
-        });
-        if (existing.data.length > 0) {
-            return { customerId: existing.data[0].id };
-        }
-        // Create new customer
-        const customer = await stripe.customers.create({
-            email: email || `${agentId}@apiclaw.local`,
-            metadata: {
-                agentId,
-                source: 'apiclaw',
-            },
-        });
-        return { customerId: customer.id };
-    }
-    catch (error) {
-        console.error('Failed to get/create customer:', error);
-        return {
-            error: error instanceof Error ? error.message : 'Customer creation failed',
-        };
-    }
-}
-/**
- * Create a metered subscription for pay-per-call billing
- */
-export async function createMeteredSubscription(customerId, paymentMethodId) {
-    if (!stripe) {
-        return { error: 'Stripe not configured' };
-    }
-    try {
-        // If payment method provided, attach it
-        if (paymentMethodId) {
-            await stripe.paymentMethods.attach(paymentMethodId, {
-                customer: customerId,
-            });
-            await stripe.customers.update(customerId, {
-                invoice_settings: {
-                    default_payment_method: paymentMethodId,
-                },
-            });
-        }
-        // Create subscription with metered price
-        const subscription = await stripe.subscriptions.create({
-            customer: customerId,
-            items: [
-                {
-                    price: METERED_BILLING.priceId,
-                },
-            ],
-            payment_behavior: 'default_incomplete',
-            payment_settings: {
-                save_default_payment_method: 'on_subscription',
-            },
-            expand: ['latest_invoice.payment_intent'],
-        });
-        return {
-            subscriptionId: subscription.id,
-            status: subscription.status,
-        };
-    }
-    catch (error) {
-        console.error('Failed to create metered subscription:', error);
-        return {
-            error: error instanceof Error ? error.message : 'Subscription creation failed',
-        };
-    }
-}
-/**
- * Create a checkout session for metered billing subscription
- */
-export async function createMeteredCheckoutSession(agentId, successUrl, cancelUrl) {
-    if (!stripe) {
-        return { error: 'Stripe not configured' };
-    }
-    try {
-        const session = await stripe.checkout.sessions.create({
-            mode: 'subscription',
-            payment_method_types: ['card'],
-            line_items: [
-                {
-                    price: METERED_BILLING.priceId,
-                },
-            ],
-            metadata: {
-                agentId,
-                billingType: 'metered',
-            },
-            subscription_data: {
-                metadata: {
-                    agentId,
-                    billingType: 'metered',
-                },
-            },
-            success_url: successUrl,
-            cancel_url: cancelUrl,
-        });
-        return {
-            sessionId: session.id,
-            url: session.url,
-        };
-    }
-    catch (error) {
-        console.error('Metered checkout error:', error);
-        return {
-            error: error instanceof Error ? error.message : 'Checkout failed',
-        };
-    }
-}
-/**
- * Get usage summary for a subscription
- */
-export async function getUsageSummary(subscriptionId) {
-    if (!stripe) {
-        return { error: 'Stripe not configured' };
-    }
-    try {
-        // Get subscription details - use raw API response
-        const subscription = await stripe.subscriptions.retrieve(subscriptionId);
-        const subData = subscription;
-        // For metered billing with meters, usage is tracked via meter events
-        // The actual usage amount will show up on the invoice at period end
-        // For now, return period info and note that detailed usage is on the Stripe dashboard
-        return {
-            totalCalls: 0, // Usage tracked via meter events, visible in Stripe dashboard
-            totalCost: 0,
-            period: {
-                start: subData.current_period_start || Math.floor(Date.now() / 1000),
-                end: subData.current_period_end || Math.floor(Date.now() / 1000) + 30 * 24 * 3600,
-            },
-        };
-    }
-    catch (error) {
-        console.error('Failed to get usage summary:', error);
-        return {
-            error: error instanceof Error ? error.message : 'Usage summary failed',
-        };
-    }
-}
-/**
- * Check if a customer has an active metered subscription
- */
-export async function hasActiveMeteredSubscription(customerId) {
-    if (!stripe) {
-        return { active: false };
-    }
-    try {
-        const subscriptions = await stripe.subscriptions.list({
-            customer: customerId,
-            status: 'active',
-            price: METERED_BILLING.priceId,
-        });
-        if (subscriptions.data.length > 0) {
-            return { active: true, subscriptionId: subscriptions.data[0].id };
-        }
-        return { active: false };
-    }
-    catch (error) {
-        console.error('Failed to check subscription:', error);
-        return { active: false };
-    }
-}

package/dist/src/telemetry.js

@@ -1,49 +0,0 @@
-/**
- * APIClaw Telemetry - Anonymous usage tracking
- *
- * Tracks:
- * - Server starts
- * - Search queries (query text only, no PII)
- * - API executions (which APIs are popular)
- *
- * All data is anonymous. No personal information is collected.
- * Disable with APICLAW_TELEMETRY=false
- */
-const TELEMETRY_ENDPOINT = 'https://agile-crane-840.convex.cloud/api/mutation';
-const isEnabled = () => {
-    return process.env.APICLAW_TELEMETRY !== 'false';
-};
-const getContext = () => ({
-    version: process.env.npm_package_version || 'unknown',
-    platform: process.platform,
-    nodeVersion: process.version,
-    timestamp: Date.now(),
-});
-export const track = async (event) => {
-    if (!isEnabled())
-        return;
-    try {
-        const payload = {
-            ...event,
-            ...getContext(),
-        };
-        // Fire and forget - don't block the main flow
-        fetch(TELEMETRY_ENDPOINT, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                path: 'telemetry:track',
-                args: { event: payload },
-            }),
-        }).catch(() => {
-            // Silently fail - telemetry should never break the app
-        });
-    }
-    catch {
-        // Silently fail
-    }
-};
-export const trackStartup = () => track({ type: 'startup' });
-export const trackSearch = (query, resultCount, responseTimeMs) => track({ type: 'search', query, resultCount, responseTimeMs });
-export const trackExecute = (apiId, responseTimeMs) => track({ type: 'execute', apiId, responseTimeMs });
-export const trackDiscovery = (resultCount) => track({ type: 'discovery', resultCount });

package/dist/src/types.js

@@ -1,2 +0,0 @@
-// Core types for APIvault
-export {};

package/dist/src/utils/backup.js

@@ -1,181 +0,0 @@
-/**
- * Backup System
- * Handles timestamped backups of config files with automatic cleanup
- */
-import { existsSync, mkdirSync, readdirSync, unlinkSync, copyFileSync } from 'fs';
-import { dirname, basename, join } from 'path';
-const MAX_BACKUPS = 5;
-const BACKUP_PATTERN = /\.backup\.(\d+)\.json$/;
-/**
- * Generate backup filename with timestamp
- */
-function generateBackupFilename(originalPath) {
-    const dir = dirname(originalPath);
-    const base = basename(originalPath, '.json');
-    const timestamp = Date.now();
-    return join(dir, `${base}.backup.${timestamp}.json`);
-}
-/**
- * Create a backup of a config file
- */
-export function createBackup(configPath) {
-    try {
-        // Check if original file exists
-        if (!existsSync(configPath)) {
-            return {
-                success: true,
-                backupPath: null,
-                // No backup needed if file doesn't exist
-            };
-        }
-        // Ensure backup directory exists
-        const dir = dirname(configPath);
-        if (!existsSync(dir)) {
-            mkdirSync(dir, { recursive: true });
-        }
-        // Generate backup path
-        const backupPath = generateBackupFilename(configPath);
-        // Copy file
-        copyFileSync(configPath, backupPath);
-        // Cleanup old backups
-        cleanupOldBackups(configPath);
-        return {
-            success: true,
-            backupPath,
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            backupPath: null,
-            error: error instanceof Error ? error.message : 'Unknown error creating backup',
-        };
-    }
-}
-/**
- * List all backups for a config file
- */
-export function listBackups(configPath) {
-    const dir = dirname(configPath);
-    const baseName = basename(configPath, '.json');
-    if (!existsSync(dir)) {
-        return [];
-    }
-    const files = readdirSync(dir);
-    const backups = [];
-    for (const file of files) {
-        // Match backup pattern: {basename}.backup.{timestamp}.json
-        const match = file.match(new RegExp(`^${escapeRegex(baseName)}\\.backup\\.(\\d+)\\.json$`));
-        if (match) {
-            const timestamp = parseInt(match[1], 10);
-            const fullPath = join(dir, file);
-            backups.push({
-                path: fullPath,
-                timestamp,
-                date: new Date(timestamp),
-                filename: file,
-            });
-        }
-    }
-    // Sort by timestamp, newest first
-    return backups.sort((a, b) => b.timestamp - a.timestamp);
-}
-/**
- * Get the most recent backup
- */
-export function getLatestBackup(configPath) {
-    const backups = listBackups(configPath);
-    return backups[0] || null;
-}
-/**
- * Cleanup old backups, keeping only MAX_BACKUPS most recent
- */
-export function cleanupOldBackups(configPath) {
-    const backups = listBackups(configPath);
-    let deleted = 0;
-    // Keep only the first MAX_BACKUPS
-    const toDelete = backups.slice(MAX_BACKUPS);
-    for (const backup of toDelete) {
-        try {
-            unlinkSync(backup.path);
-            deleted++;
-        }
-        catch {
-            // Ignore deletion errors
-        }
-    }
-    return deleted;
-}
-/**
- * Restore from a backup
- */
-export function restoreBackup(backupPath, targetPath) {
-    try {
-        if (!existsSync(backupPath)) {
-            return {
-                success: false,
-                backupPath: null,
-                error: `Backup file not found: ${backupPath}`,
-            };
-        }
-        // Backup current file before restoring
-        const preRestoreBackup = createBackup(targetPath);
-        // Copy backup to target
-        copyFileSync(backupPath, targetPath);
-        return {
-            success: true,
-            backupPath: preRestoreBackup.backupPath,
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            backupPath: null,
-            error: error instanceof Error ? error.message : 'Unknown error restoring backup',
-        };
-    }
-}
-/**
- * Restore from the most recent backup
- */
-export function restoreLatestBackup(configPath) {
-    const latest = getLatestBackup(configPath);
-    if (!latest) {
-        return {
-            success: false,
-            backupPath: null,
-            error: 'No backups found',
-        };
-    }
-    return restoreBackup(latest.path, configPath);
-}
-/**
- * Format backup info for display
- */
-export function formatBackupInfo(backup) {
-    const date = backup.date.toLocaleString();
-    return `${backup.filename} (${date})`;
-}
-/**
- * Escape regex special characters
- */
-function escapeRegex(str) {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-/**
- * Delete all backups for a config file
- */
-export function deleteAllBackups(configPath) {
-    const backups = listBackups(configPath);
-    let deleted = 0;
-    for (const backup of backups) {
-        try {
-            unlinkSync(backup.path);
-            deleted++;
-        }
-        catch {
-            // Ignore deletion errors
-        }
-    }
-    return deleted;
-}