@nordsym/apiclaw 1.5.12 → 1.5.14

package/dist/src/analytics.js

@@ -0,0 +1,129 @@
+/**
+ * APIClaw Analytics - Track all API usage
+ * Both Direct Call and Open API calls are logged here
+ */
+import { appendFileSync, existsSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { ConvexHttpClient } from 'convex/browser';
+import { api } from '../convex/_generated/api.js';
+// Log directory
+const LOG_DIR = join(homedir(), '.apiclaw', 'logs');
+const LOG_FILE = join(LOG_DIR, 'api-calls.jsonl');
+// Convex client (lazy init)
+let convexClient = null;
+function getConvexClient() {
+    if (convexClient)
+        return convexClient;
+    const convexUrl = process.env.APICLAW_CONVEX_URL || process.env.NEXT_PUBLIC_CONVEX_URL;
+    if (!convexUrl)
+        return null;
+    try {
+        convexClient = new ConvexHttpClient(convexUrl);
+        return convexClient;
+    }
+    catch (e) {
+        console.error('[APIClaw Analytics] Failed to init Convex client:', e);
+        return null;
+    }
+}
+// Ensure log directory exists
+function ensureLogDir() {
+    if (!existsSync(LOG_DIR)) {
+        mkdirSync(LOG_DIR, { recursive: true });
+    }
+}
+/**
+ * Log an API call to local file AND Convex
+ */
+export function logAPICall(log) {
+    // 1. Local file (existing behavior)
+    try {
+        ensureLogDir();
+        const line = JSON.stringify(log) + '\n';
+        appendFileSync(LOG_FILE, line);
+    }
+    catch (e) {
+        console.error('[APIClaw Analytics] Failed to log to file:', e);
+    }
+    // 2. Send to Convex (new - includes anonymous usage)
+    sendToConvex(log).catch(() => { }); // Fire and forget
+}
+/**
+ * Send analytics event to Convex
+ * Works for both authenticated and anonymous users
+ */
+async function sendToConvex(log) {
+    const client = getConvexClient();
+    if (!client)
+        return;
+    try {
+        await client.mutation(api.analytics.log, {
+            event: 'api_call',
+            provider: log.provider,
+            query: log.action, // Store action as query field
+            identifier: log.userId || 'anonymous',
+            metadata: {
+                type: log.type,
+                success: log.success,
+                latencyMs: log.latencyMs,
+                error: log.error,
+                timestamp: log.timestamp,
+                ...log.metadata, // Include product and any other metadata
+            },
+        });
+    }
+    catch (e) {
+        // Silent fail - don't break API calls for logging errors
+        console.error('[APIClaw Analytics] Failed to send to Convex:', e);
+    }
+}
+/**
+ * Webhook for real-time analytics (optional)
+ * Set APICLAW_ANALYTICS_WEBHOOK env var to enable
+ */
+export async function sendToWebhook(log) {
+    const webhookUrl = process.env.APICLAW_ANALYTICS_WEBHOOK;
+    if (!webhookUrl)
+        return;
+    try {
+        await fetch(webhookUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(log),
+        });
+    }
+    catch (e) {
+        // Silent fail
+    }
+}
+/**
+ * Track API call with timing
+ */
+export async function trackAPICall(provider, action, type, userId, fn) {
+    const start = Date.now();
+    let success = true;
+    let error;
+    try {
+        return await fn();
+    }
+    catch (e) {
+        success = false;
+        error = e.message;
+        throw e;
+    }
+    finally {
+        const log = {
+            timestamp: new Date().toISOString(),
+            provider,
+            action,
+            type,
+            userId,
+            success,
+            latencyMs: Date.now() - start,
+            error,
+        };
+        logAPICall(log);
+        sendToWebhook(log).catch(() => { }); // Fire and forget
+    }
+}

package/dist/src/bin.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+/**
+ * APIClaw Entry Point
+ *
+ * - No args or MCP-related args → Run MCP server
+ * - setup/doctor/restore/uninstall → Run CLI
+ */
+const cliCommands = ['setup', 'mcp-install', 'mcp-uninstall', 'doctor', 'restore', 'uninstall', 'help', '--help', '-h', '--version', '-V'];
+const firstArg = process.argv[2];
+if (!firstArg || !cliCommands.includes(firstArg)) {
+    // Run MCP server
+    import('./index.js');
+}
+else {
+    // Run CLI
+    import('./cli/index.js');
+}

package/dist/src/capability-router.js

@@ -0,0 +1,240 @@
+/**
+ * APIClaw Capability Router
+ * Routes capability requests to the best available provider
+ */
+import { executeAPICall } from './execute.js';
+import { logAPICall } from './analytics.js';
+// Convex HTTP API for capability queries
+const CONVEX_URL = process.env.NEXT_PUBLIC_CONVEX_URL || 'https://adventurous-avocet-799.convex.cloud';
+/**
+ * Query Convex for providers that support a capability
+ */
+async function getProvidersForCapability(capabilityId, region) {
+    try {
+        const res = await fetch(`${CONVEX_URL}/api/query`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                path: 'capabilities:getProviders',
+                args: { capabilityId, region },
+            }),
+        });
+        if (!res.ok)
+            return [];
+        const data = await res.json();
+        if (Array.isArray(data))
+            return data;
+        return (data.value || []);
+    }
+    catch (e) {
+        console.error('Failed to fetch capability providers:', e);
+        return [];
+    }
+}
+/**
+ * Map capability params to provider-specific params
+ */
+function mapParams(params, mapping) {
+    const result = {};
+    for (const [capParam, value] of Object.entries(params)) {
+        const providerParam = mapping[capParam] || capParam;
+        result[providerParam] = value;
+    }
+    return result;
+}
+/**
+ * Log capability usage to Convex
+ */
+async function logCapabilityUsage(params) {
+    try {
+        await fetch(`${CONVEX_URL}/api/mutation`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                path: 'capabilities:logUsage',
+                args: params,
+            }),
+        });
+    }
+    catch (e) {
+        console.error('Failed to log capability usage:', e);
+    }
+}
+/**
+ * Execute a capability request with automatic provider selection and fallback
+ */
+export async function executeCapability(capabilityId, action, params, userId, preferences = {}) {
+    const startTime = Date.now();
+    const enableFallback = preferences.fallback !== false; // Default true
+    // Get providers for this capability
+    const providers = await getProvidersForCapability(capabilityId, preferences.region);
+    if (providers.length === 0) {
+        return {
+            success: false,
+            capability: capabilityId,
+            action,
+            fallbackAttempted: false,
+            error: `No providers available for capability: ${capabilityId}`,
+        };
+    }
+    // Filter by max price if specified
+    let filteredProviders = providers;
+    if (preferences.maxPrice !== undefined) {
+        filteredProviders = providers.filter(p => p.pricePerUnit <= preferences.maxPrice);
+    }
+    // Prefer specific provider if requested
+    if (preferences.preferredProvider) {
+        const preferred = filteredProviders.find(p => p.providerId === preferences.preferredProvider);
+        if (preferred) {
+            filteredProviders = [preferred, ...filteredProviders.filter(p => p.providerId !== preferences.preferredProvider)];
+        }
+    }
+    if (filteredProviders.length === 0) {
+        return {
+            success: false,
+            capability: capabilityId,
+            action,
+            fallbackAttempted: false,
+            error: 'No providers match your preferences (region/price)',
+        };
+    }
+    // Try providers in order
+    let fallbackAttempted = false;
+    let lastError = '';
+    for (let i = 0; i < filteredProviders.length; i++) {
+        const provider = filteredProviders[i];
+        const isFirstAttempt = i === 0;
+        if (!isFirstAttempt) {
+            fallbackAttempted = true;
+        }
+        try {
+            // Map params to provider-specific format
+            const mappedParams = mapParams(params, provider.paramMapping || {});
+            // Execute via existing executeAPICall
+            const result = await executeAPICall(provider.providerId, action, mappedParams, userId);
+            const latencyMs = Date.now() - startTime;
+            if (result.success) {
+                // Log successful usage
+                logCapabilityUsage({
+                    capabilityId,
+                    providerId: provider.providerId,
+                    userId,
+                    action,
+                    success: true,
+                    fallbackUsed: fallbackAttempted,
+                    fallbackReason: fallbackAttempted ? lastError : undefined,
+                    latencyMs,
+                    cost: provider.pricePerUnit,
+                    currency: provider.currency,
+                });
+                // Also log to file-based analytics
+                logAPICall({
+                    timestamp: new Date().toISOString(),
+                    provider: provider.providerId,
+                    action,
+                    type: 'direct',
+                    userId,
+                    success: true,
+                    latencyMs,
+                });
+                return {
+                    success: true,
+                    capability: capabilityId,
+                    action,
+                    providerUsed: provider.providerId,
+                    fallbackAttempted,
+                    fallbackReason: fallbackAttempted ? lastError : undefined,
+                    data: result.data,
+                    cost: provider.pricePerUnit,
+                    currency: provider.currency,
+                    latencyMs,
+                };
+            }
+            // Provider returned error, try next
+            lastError = result.error || 'Unknown error';
+            if (!enableFallback) {
+                break;
+            }
+        }
+        catch (e) {
+            lastError = e.message || 'Provider execution failed';
+            if (!enableFallback) {
+                break;
+            }
+        }
+    }
+    // All providers failed
+    const latencyMs = Date.now() - startTime;
+    logCapabilityUsage({
+        capabilityId,
+        providerId: filteredProviders[0].providerId,
+        userId,
+        action,
+        success: false,
+        fallbackUsed: fallbackAttempted,
+        fallbackReason: lastError,
+        latencyMs,
+        cost: 0,
+        currency: 'SEK',
+    });
+    return {
+        success: false,
+        capability: capabilityId,
+        action,
+        fallbackAttempted,
+        error: `All providers failed. Last error: ${lastError}`,
+        latencyMs,
+    };
+}
+/**
+ * List available capabilities
+ */
+export async function listCapabilities() {
+    try {
+        const res = await fetch(`${CONVEX_URL}/api/query`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                path: 'capabilities:list',
+                args: {},
+            }),
+        });
+        if (!res.ok)
+            return [];
+        const data = await res.json();
+        const capabilities = Array.isArray(data) ? data : (data.value || []);
+        return capabilities.map(c => ({
+            id: c.id,
+            name: c.name,
+            category: c.category,
+        }));
+    }
+    catch (e) {
+        return [];
+    }
+}
+/**
+ * Check if a capability exists
+ */
+export async function hasCapability(capabilityId) {
+    try {
+        const res = await fetch(`${CONVEX_URL}/api/query`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                path: 'capabilities:getById',
+                args: { id: capabilityId },
+            }),
+        });
+        if (!res.ok)
+            return false;
+        const data = await res.json();
+        if (data && typeof data === 'object' && 'value' in data) {
+            return !!data.value;
+        }
+        return !!data;
+    }
+    catch (e) {
+        return false;
+    }
+}