@nordsym/apiclaw 1.5.17 → 1.5.19

package/dist/src/metered.js

@@ -1,80 +0,0 @@
-/**
- * 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

@@ -1,276 +0,0 @@
-/**
- * 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

@@ -1,28 +0,0 @@
-/**
- * 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

@@ -1,86 +0,0 @@
-/**
- * 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}`;
-}