@nordsym/apiclaw 1.5.13 → 1.5.14

package/dist/src/metered.js

@@ -0,0 +1,80 @@
+/**
+ * APIClaw Metered Billing - Pay-per-call execution wrapper
+ *
+ * Usage:
+ * 1. Customer signs up with metered subscription
+ * 2. Each API call via executeMetered() reports usage to Stripe
+ * 3. Customer is billed at end of billing period based on usage
+ */
+import { executeAPICall } from './execute.js';
+import { reportUsage, hasActiveMeteredSubscription, METERED_BILLING } from './stripe.js';
+/**
+ * Execute an API call with metered billing tracking
+ *
+ * If customerId is provided and has active metered subscription,
+ * usage is reported to Stripe after successful execution.
+ */
+export async function executeMetered(providerId, action, params, options = {}) {
+    const { customerId, skipBilling, customerKey, userId } = options;
+    // Execute the API call
+    const result = await executeAPICall(providerId, action, params, userId, customerKey);
+    // Build response
+    const response = {
+        ...result,
+        billing: {
+            tracked: false,
+            pricePerCall: METERED_BILLING.pricePerCall,
+        },
+    };
+    // Skip billing if requested or no customer
+    if (skipBilling || !customerId) {
+        return response;
+    }
+    // Skip billing for failed calls
+    if (!result.success) {
+        return response;
+    }
+    // Check for active metered subscription
+    const subscription = await hasActiveMeteredSubscription(customerId);
+    if (!subscription.active) {
+        console.log(`Customer ${customerId} has no active metered subscription`);
+        return response;
+    }
+    // Report usage to Stripe meter
+    const usageReport = await reportUsage(customerId, 1, `${customerId}_${providerId}_${action}_${Date.now()}`);
+    if (usageReport.success) {
+        response.billing = {
+            tracked: true,
+            customerId,
+            pricePerCall: METERED_BILLING.pricePerCall,
+        };
+    }
+    else {
+        console.error(`Failed to report usage for ${customerId}:`, usageReport.error);
+    }
+    return response;
+}
+/**
+ * Execute multiple API calls in batch with usage tracking
+ */
+export async function executeMeteredBatch(calls, options = {}) {
+    const results = await Promise.all(calls.map((call) => executeMetered(call.provider, call.action, call.params, options)));
+    return results;
+}
+/**
+ * Calculate estimated cost for a number of API calls
+ */
+export function estimateCost(callCount) {
+    return {
+        calls: callCount,
+        pricePerCall: METERED_BILLING.pricePerCall,
+        totalCost: callCount * METERED_BILLING.pricePerCall,
+        currency: 'USD',
+    };
+}
+/**
+ * Get metered billing configuration
+ */
+export function getMeteredConfig() {
+    return METERED_BILLING;
+}

package/dist/src/open-apis.js

@@ -0,0 +1,276 @@
+/**
+ * APIClaw Open APIs - Free APIs that don't require authentication
+ * These are called directly but still logged for analytics
+ */
+/**
+ * Registry of open APIs
+ */
+export const openAPIs = {
+    // Frankfurter - Free currency exchange rates (ECB data)
+    frankfurter: {
+        name: 'Frankfurter',
+        description: 'Free currency exchange rates from European Central Bank',
+        baseUrl: 'https://api.frankfurter.app',
+        actions: {
+            convert: {
+                method: 'GET',
+                path: (p) => `/latest?from=${p.from || 'SEK'}&to=${p.to || 'USD'}&amount=${p.amount || 1}`,
+                transform: (data, params) => ({
+                    from: params.from || 'SEK',
+                    to: params.to || 'USD',
+                    amount: data.amount,
+                    result: data.rates?.[params.to || 'USD'],
+                    rate: data.rates?.[params.to || 'USD'] / data.amount,
+                    date: data.date,
+                }),
+            },
+            latest: {
+                method: 'GET',
+                path: (p) => `/latest?from=${p.base || 'SEK'}${p.symbols ? `&to=${p.symbols}` : ''}`,
+                transform: (data) => ({
+                    base: data.base,
+                    date: data.date,
+                    rates: data.rates,
+                }),
+            },
+            historical: {
+                method: 'GET',
+                path: (p) => `/${p.date}?from=${p.base || 'SEK'}${p.symbols ? `&to=${p.symbols}` : ''}`,
+                transform: (data) => ({
+                    base: data.base,
+                    date: data.date,
+                    rates: data.rates,
+                }),
+            },
+            currencies: {
+                method: 'GET',
+                path: () => '/currencies',
+                transform: (data) => ({ currencies: data }),
+            },
+        },
+    },
+    // CoinGecko - Free crypto data
+    coingecko: {
+        name: 'CoinGecko',
+        description: 'Free cryptocurrency data - prices, market cap, volume',
+        baseUrl: 'https://api.coingecko.com/api/v3',
+        actions: {
+            price: {
+                method: 'GET',
+                path: (p) => `/simple/price?ids=${p.ids || 'bitcoin'}&vs_currencies=${p.vs_currencies || 'usd'}`,
+            },
+            coins_list: {
+                method: 'GET',
+                path: () => '/coins/list',
+            },
+            coin: {
+                method: 'GET',
+                path: (p) => `/coins/${p.id}?localization=false&tickers=false&community_data=false&developer_data=false`,
+                transform: (data) => ({
+                    id: data.id,
+                    symbol: data.symbol,
+                    name: data.name,
+                    price_usd: data.market_data?.current_price?.usd,
+                    market_cap_usd: data.market_data?.market_cap?.usd,
+                    price_change_24h: data.market_data?.price_change_percentage_24h,
+                }),
+            },
+            trending: {
+                method: 'GET',
+                path: () => '/search/trending',
+                transform: (data) => ({
+                    coins: data.coins?.map((c) => ({
+                        id: c.item.id,
+                        name: c.item.name,
+                        symbol: c.item.symbol,
+                        market_cap_rank: c.item.market_cap_rank,
+                    })),
+                }),
+            },
+        },
+    },
+    // IP-API - Free IP geolocation
+    ipapi: {
+        name: 'IP-API',
+        description: 'Free IP geolocation - get location from IP address',
+        baseUrl: 'http://ip-api.com',
+        actions: {
+            lookup: {
+                method: 'GET',
+                path: (p) => `/json/${p.ip || ''}`,
+                transform: (data) => ({
+                    ip: data.query,
+                    country: data.country,
+                    countryCode: data.countryCode,
+                    region: data.regionName,
+                    city: data.city,
+                    lat: data.lat,
+                    lon: data.lon,
+                    isp: data.isp,
+                    timezone: data.timezone,
+                }),
+            },
+        },
+    },
+    // Kroki - Diagrams as code
+    kroki: {
+        name: 'Kroki',
+        description: 'Generate diagrams from text. Supports: mermaid, d2, plantuml, graphviz, c4plantuml, blockdiag, bpmn. D2 is SVG-only.',
+        baseUrl: 'https://kroki.io',
+        actions: {
+            render: {
+                method: 'POST',
+                path: () => '', // Custom handling below
+            },
+        },
+    },
+};
+/**
+ * Check if a provider is an open API
+ */
+export function isOpenAPI(providerId) {
+    return providerId in openAPIs;
+}
+/**
+ * Get available actions for an open API
+ */
+export function getOpenAPIActions(providerId) {
+    return Object.keys(openAPIs[providerId]?.actions || {});
+}
+/**
+ * Execute an open API call
+ */
+export async function executeOpenAPI(providerId, action, params) {
+    const config = openAPIs[providerId];
+    if (!config) {
+        return {
+            success: false,
+            provider: providerId,
+            action,
+            error: `Unknown open API: ${providerId}`,
+        };
+    }
+    const actionConfig = config.actions[action];
+    if (!actionConfig) {
+        return {
+            success: false,
+            provider: providerId,
+            action,
+            error: `Unknown action '${action}' for ${providerId}. Available: ${Object.keys(config.actions).join(', ')}`,
+        };
+    }
+    try {
+        // Special handling for Kroki - use POST to get actual image data
+        if (providerId === 'kroki') {
+            const type = params.type || 'mermaid';
+            let format = params.format || 'svg';
+            const diagram = params.diagram || '';
+            if (!diagram) {
+                return {
+                    success: false,
+                    provider: providerId,
+                    action,
+                    error: 'Missing required param: diagram',
+                };
+            }
+            // D2 only supports SVG
+            if (type === 'd2' && format !== 'svg') {
+                format = 'svg';
+            }
+            try {
+                const response = await fetch(`https://kroki.io/${type}/${format}`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'text/plain' },
+                    body: diagram,
+                });
+                if (!response.ok) {
+                    const err = await response.text();
+                    return {
+                        success: false,
+                        provider: providerId,
+                        action,
+                        error: `Kroki error: ${err}`,
+                    };
+                }
+                // For SVG, return the content directly; for binary, return base64
+                if (format === 'svg') {
+                    const svg = await response.text();
+                    return {
+                        success: true,
+                        provider: providerId,
+                        action,
+                        data: {
+                            type,
+                            format: 'svg',
+                            content: svg,
+                            content_type: 'image/svg+xml',
+                            supported_types: ['mermaid', 'd2', 'plantuml', 'graphviz', 'c4plantuml', 'blockdiag', 'bpmn'],
+                        },
+                    };
+                }
+                else {
+                    const buffer = await response.arrayBuffer();
+                    const base64 = Buffer.from(buffer).toString('base64');
+                    return {
+                        success: true,
+                        provider: providerId,
+                        action,
+                        data: {
+                            type,
+                            format,
+                            content_base64: base64,
+                            content_type: format === 'png' ? 'image/png' : 'application/pdf',
+                        },
+                    };
+                }
+            }
+            catch (e) {
+                return {
+                    success: false,
+                    provider: providerId,
+                    action,
+                    error: e.message || 'Kroki request failed',
+                };
+            }
+        }
+        const url = config.baseUrl + actionConfig.path(params);
+        const response = await fetch(url, { method: actionConfig.method });
+        if (!response.ok) {
+            return {
+                success: false,
+                provider: providerId,
+                action,
+                error: `HTTP ${response.status}: ${response.statusText}`,
+            };
+        }
+        let data = await response.json();
+        if (actionConfig.transform) {
+            data = actionConfig.transform(data, params);
+        }
+        return {
+            success: true,
+            provider: providerId,
+            action,
+            data,
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            provider: providerId,
+            action,
+            error: e.message || 'Request failed',
+        };
+    }
+}
+/**
+ * List all open APIs with their actions
+ */
+export function listOpenAPIs() {
+    return Object.entries(openAPIs).map(([id, config]) => ({
+        provider: id,
+        name: config.name,
+        description: config.description,
+        actions: Object.keys(config.actions),
+    }));
+}

package/dist/src/proxy.js

@@ -0,0 +1,28 @@
+/**
+ * APIClaw Proxy - Fallback to hosted API when no local credentials
+ */
+import { readSession, getMachineFingerprint } from './session.js';
+const PROXY_BASE = "https://brilliant-puffin-712.eu-west-1.convex.site/proxy";
+export async function callProxy(provider, params) {
+    const url = `${PROXY_BASE}/${provider}`;
+    // Get session and fingerprint for tracking
+    const session = readSession();
+    const fingerprint = getMachineFingerprint();
+    const identifier = session?.workspaceId || `anon:${fingerprint}`;
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "X-APIClaw-Identifier": identifier,
+            "X-APIClaw-Provider": provider,
+            "X-APIClaw-Action": params.action || "call",
+        },
+        body: JSON.stringify(params),
+    });
+    if (!response.ok) {
+        const errorData = await response.json().catch(() => ({ error: "Proxy request failed" }));
+        throw new Error(errorData.error || `Proxy error: ${response.status}`);
+    }
+    return response.json();
+}
+export const PROXY_PROVIDERS = ["openrouter", "brave_search", "resend", "elevenlabs", "46elks", "twilio", "replicate", "firecrawl", "e2b", "groq", "deepgram", "serper", "mistral", "cohere", "together", "stability", "assemblyai", "github", "apilayer"];

package/dist/src/session.js

@@ -0,0 +1,86 @@
+/**
+ * Session management for APIClaw MCP server
+ * Stores session token locally at ~/.apiclaw/session
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+const SESSION_DIR = path.join(os.homedir(), '.apiclaw');
+const SESSION_FILE = path.join(SESSION_DIR, 'session');
+/**
+ * Ensure the ~/.apiclaw directory exists
+ */
+function ensureSessionDir() {
+    if (!fs.existsSync(SESSION_DIR)) {
+        fs.mkdirSync(SESSION_DIR, { mode: 0o700 });
+    }
+}
+/**
+ * Read session from ~/.apiclaw/session
+ * Returns null if no session file exists or if it's invalid
+ */
+export function readSession() {
+    try {
+        if (!fs.existsSync(SESSION_FILE)) {
+            return null;
+        }
+        const content = fs.readFileSync(SESSION_FILE, 'utf8');
+        const data = JSON.parse(content);
+        // Validate required fields
+        if (!data.sessionToken || !data.workspaceId || !data.email) {
+            console.error('[APIClaw] Invalid session file, clearing...');
+            clearSession();
+            return null;
+        }
+        return data;
+    }
+    catch (error) {
+        console.error('[APIClaw] Error reading session:', error);
+        return null;
+    }
+}
+/**
+ * Write session to ~/.apiclaw/session
+ */
+export function writeSession(sessionToken, workspaceId, email) {
+    try {
+        ensureSessionDir();
+        const data = {
+            sessionToken,
+            workspaceId,
+            email,
+            createdAt: Date.now(),
+        };
+        fs.writeFileSync(SESSION_FILE, JSON.stringify(data, null, 2), {
+            mode: 0o600, // Read/write for owner only
+        });
+        console.error(`[APIClaw] Session saved for ${email}`);
+    }
+    catch (error) {
+        console.error('[APIClaw] Error writing session:', error);
+        throw error;
+    }
+}
+/**
+ * Clear session file
+ */
+export function clearSession() {
+    try {
+        if (fs.existsSync(SESSION_FILE)) {
+            fs.unlinkSync(SESSION_FILE);
+            console.error('[APIClaw] Session cleared');
+        }
+    }
+    catch (error) {
+        console.error('[APIClaw] Error clearing session:', error);
+    }
+}
+/**
+ * Get machine fingerprint (for session binding)
+ * Uses hostname + username as a simple fingerprint
+ */
+export function getMachineFingerprint() {
+    const hostname = os.hostname();
+    const username = os.userInfo().username;
+    return `${hostname}:${username}`;
+}