@nordsym/apiclaw 1.7.2 → 1.7.4

package/dist/src/bin.js

@@ -1,17 +0,0 @@
-#!/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

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