@nordsym/apiclaw 1.0.0 → 1.1.1

package/scripts/sync-and-deploy.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+# Sync API registry stats and deploy to Vercel
+
+cd "$(dirname "$0")/.."
+
+echo "📊 Updating registry count..."
+python3 << 'EOF'
+import json
+from datetime import datetime
+
+with open('src/registry/apis.json', 'r') as f:
+    registry = json.load(f)
+
+registry['count'] = len(registry['apis'])
+registry['lastUpdated'] = datetime.now().strftime('%Y-%m-%d')
+
+with open('src/registry/apis.json', 'w') as f:
+    json.dump(registry, f, indent=2)
+
+print(f"✓ Registry: {registry['count']} APIs")
+EOF
+
+echo "📦 Copying apis.json to landing..."
+cp src/registry/apis.json landing/src/lib/apis.json
+
+echo "📈 Generating stats for frontend..."
+cd landing
+node scripts/generate-stats.js
+
+echo "🗑️ Clearing build cache..."
+rm -rf .next
+
+echo "🚀 Deploying to Vercel..."
+npx vercel --prod --force --yes
+
+echo "✅ Done! Check https://apiclaw.nordsym.com"

package/src/credentials.ts

@@ -0,0 +1,177 @@
+// Real credential providers for APIClaw Connected tier
+// Reads from environment variables or ~/.secrets/
+
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { APICredentials } from './types.js';
+
+interface ProviderCredential {
+  type: 'basic' | 'api_key' | 'bearer';
+  get(): APICredentials | null;
+}
+
+// Load env file helper
+function loadEnvFile(filename: string): Record<string, string> {
+  const paths = [
+    join(homedir(), '.secrets', filename),
+    join(process.cwd(), filename),
+    join(process.cwd(), '.env.local'),
+  ];
+
+  for (const path of paths) {
+    if (existsSync(path)) {
+      const content = readFileSync(path, 'utf-8');
+      const vars: Record<string, string> = {};
+      for (const line of content.split('\n')) {
+        const match = line.match(/^([^=]+)=(.*)$/);
+        if (match) {
+          vars[match[1].trim()] = match[2].trim().replace(/^["']|["']$/g, '');
+        }
+      }
+      return vars;
+    }
+  }
+  return {};
+}
+
+// Provider credential getters
+const providers: Record<string, ProviderCredential> = {
+  '46elks': {
+    type: 'basic',
+    get(): APICredentials | null {
+      const env = loadEnvFile('46elks.env');
+      const user = env.ELKS_API_USER || process.env.ELKS_API_USER;
+      const pass = env.ELKS_API_PASSWORD || process.env.ELKS_API_PASSWORD;
+      
+      if (!user || !pass) return null;
+      
+      return {
+        type: 'basic',
+        username: user,
+        password: pass,
+      };
+    },
+  },
+
+  twilio: {
+    type: 'basic',
+    get(): APICredentials | null {
+      const env = loadEnvFile('twilio.env');
+      const sid = env.TWILIO_ACCOUNT_SID || process.env.TWILIO_ACCOUNT_SID;
+      const token = env.TWILIO_AUTH_TOKEN || process.env.TWILIO_AUTH_TOKEN;
+      
+      if (!sid || !token) return null;
+      
+      return {
+        type: 'basic',
+        username: sid,
+        password: token,
+      };
+    },
+  },
+
+  // Real credential providers
+  resend: {
+    type: 'api_key',
+    get(): APICredentials | null {
+      const env = loadEnvFile('resend.env');
+      const key = env.RESEND_API_KEY || process.env.RESEND_API_KEY;
+      if (key) {
+        return { type: 'api_key', api_key: key };
+      }
+      return null;
+    },
+  },
+
+  brave_search: {
+    type: 'api_key',
+    get(): APICredentials | null {
+      const env = loadEnvFile('brave.env');
+      const key = env.BRAVE_API_KEY || process.env.BRAVE_API_KEY;
+      if (key) {
+        return { type: 'api_key', api_key: key };
+      }
+      return null;
+    },
+  },
+
+  openrouter: {
+    type: 'bearer',
+    get(): APICredentials | null {
+      const env = loadEnvFile('openrouter.env');
+      const key = env.OPENROUTER_API_KEY || process.env.OPENROUTER_API_KEY;
+      if (key) {
+        return { type: 'bearer', api_key: key };
+      }
+      return null;
+    },
+  },
+
+  elevenlabs: {
+    type: 'api_key',
+    get(): APICredentials | null {
+      const env = loadEnvFile('elevenlabs.env');
+      const key = env.ELEVENLABS_API_KEY || process.env.ELEVENLABS_API_KEY;
+      if (key) {
+        return { type: 'api_key', api_key: key };
+      }
+      return null;
+    },
+  },
+};
+
+/**
+ * Get real credentials for a provider
+ * Returns null if provider not supported
+ */
+export function getCredentials(providerId: string): APICredentials | null {
+  const provider = providers[providerId];
+  if (!provider) return null;
+  return provider.get();
+}
+
+/**
+ * Check if a provider has real (non-demo) credentials available
+ */
+export function hasRealCredentials(providerId: string): boolean {
+  if (providerId === '46elks') {
+    const env = loadEnvFile('46elks.env');
+    return !!(env.ELKS_API_USER || process.env.ELKS_API_USER);
+  }
+  if (providerId === 'twilio') {
+    const env = loadEnvFile('twilio.env');
+    return !!(env.TWILIO_ACCOUNT_SID || process.env.TWILIO_ACCOUNT_SID);
+  }
+  if (providerId === 'resend') {
+    const env = loadEnvFile('resend.env');
+    return !!(env.RESEND_API_KEY || process.env.RESEND_API_KEY);
+  }
+  if (providerId === 'brave_search') {
+    const env = loadEnvFile('brave.env');
+    return !!(env.BRAVE_API_KEY || process.env.BRAVE_API_KEY);
+  }
+  if (providerId === 'openrouter') {
+    const env = loadEnvFile('openrouter.env');
+    return !!(env.OPENROUTER_API_KEY || process.env.OPENROUTER_API_KEY);
+  }
+  if (providerId === 'elevenlabs') {
+    const env = loadEnvFile('elevenlabs.env');
+    return !!(env.ELEVENLABS_API_KEY || process.env.ELEVENLABS_API_KEY);
+  }
+  return false;
+}
+
+/**
+ * List all supported providers
+ */
+export function listProviders(): string[] {
+  return Object.keys(providers);
+}
+
+/**
+ * Get credential type for a provider
+ */
+export function getCredentialType(providerId: string): string | null {
+  return providers[providerId]?.type || null;
+}

package/src/credits.ts

@@ -1,46 +1,73 @@
-// Credit system for APIvault
-// MVP: In-memory store. Production: Supabase
+// Credit system for APIClaw
+// Supports both in-memory (dev) and Convex (production) backends
 
-import { AgentCredits, Purchase, APICredentials, UsageRecord, TransactionFee } from './types.js';
+import { AgentCredits, Purchase, APICredentials, UsageRecord } from './types.js';
+import { getCredentials, hasRealCredentials } from './credentials.js';
 import { randomUUID } from 'crypto';
-import { getFeePercentage, hasProSubscription } from './revenuecat.js';
-
-// In-memory stores (replace with Supabase in production)
-const agentCredits: Map<string, AgentCredits> = new Map();
-const purchases: Map<string, Purchase> = new Map();
-const usage: Map<string, UsageRecord> = new Map();
-
-// Mock API keys for demo (in production, these would be provisioned from providers)
-const mockCredentials: Record<string, () => APICredentials> = {
-  '46elks': () => ({
-    type: 'basic',
-    username: `u_${randomUUID().slice(0, 8)}`,
-    password: `p_${randomUUID().slice(0, 16)}`
-  }),
-  'resend': () => ({
-    type: 'api_key',
-    api_key: `re_${randomUUID().replace(/-/g, '')}`
-  }),
-  'brave_search': () => ({
-    type: 'api_key',
-    api_key: `BSA${randomUUID().replace(/-/g, '').toUpperCase().slice(0, 20)}`
-  }),
-  'openrouter': () => ({
-    type: 'bearer',
-    api_key: `sk-or-v1-${randomUUID().replace(/-/g, '')}`
-  }),
-  'elevenlabs': () => ({
-    type: 'api_key',
-    api_key: `${randomUUID().replace(/-/g, '')}`
-  })
+
+// Storage backend type
+type StorageBackend = 'memory' | 'convex';
+
+// Configuration
+const BACKEND: StorageBackend = process.env.APICLAW_BACKEND === 'convex' ? 'convex' : 'memory';
+const CONVEX_URL = process.env.CONVEX_URL || '';
+const CONVEX_DEPLOY_KEY = process.env.CONVEX_DEPLOY_KEY || '';
+
+// In-memory stores (for local development)
+const agentCreditsStore: Map<string, AgentCredits> = new Map();
+const purchasesStore: Map<string, Purchase> = new Map();
+const usageStore: Map<string, UsageRecord> = new Map();
+
+// Provider that have real credentials available
+const REAL_CREDENTIAL_PROVIDERS = ['46elks', 'twilio'];
+
+// Credits per dollar by provider
+const CREDITS_PER_DOLLAR: Record<string, number> = {
+  '46elks': 30,      // ~30 SMS per dollar
+  'twilio': 25,      // ~25 SMS per dollar
+  'resend': 1000,    // ~1000 emails per dollar
+  'brave_search': 200, // ~200 searches per dollar
+  'openrouter': 100,   // ~100k tokens per dollar (varies by model)
+  'elevenlabs': 3333   // ~3333 characters per dollar
 };
 
+/**
+ * Calculate credits based on provider pricing
+ */
+function calculateCredits(providerId: string, amountUsd: number): number {
+  return Math.floor(amountUsd * (CREDITS_PER_DOLLAR[providerId] || 100));
+}
+
+/**
+ * Generate credentials for a provider
+ * Returns real credentials for supported providers, mock for others
+ */
+function generateCredentials(providerId: string): APICredentials {
+  // Try to get real credentials first
+  const realCreds = getCredentials(providerId);
+  if (realCreds && hasRealCredentials(providerId)) {
+    console.log(`[APIClaw] Using REAL credentials for ${providerId}`);
+    return realCreds;
+  }
+  
+  // Fall back to mock credentials
+  console.log(`[APIClaw] Using MOCK credentials for ${providerId}`);
+  return realCreds || {
+    type: 'api_key',
+    api_key: `mock_${providerId}_${randomUUID().slice(0, 8)}`
+  };
+}
+
+// =============================================================================
+// In-Memory Backend (for development)
+// =============================================================================
+
 /**
  * Get or create agent credits account
  */
 export function getAgentCredits(agentId: string): AgentCredits {
-  if (!agentCredits.has(agentId)) {
-    agentCredits.set(agentId, {
+  if (!agentCreditsStore.has(agentId)) {
+    agentCreditsStore.set(agentId, {
       agent_id: agentId,
       balance_usd: 0,
       currency: 'USD',
@@ -48,7 +75,7 @@ export function getAgentCredits(agentId: string): AgentCredits {
       updated_at: new Date().toISOString()
     });
   }
-  return agentCredits.get(agentId)!;
+  return agentCreditsStore.get(agentId)!;
 }
 
 /**
@@ -63,7 +90,7 @@ export function addCredits(agentId: string, amountUsd: number): AgentCredits {
 
 /**
  * Purchase API access
- * Returns credentials if successful
+ * Returns real credentials for 46elks and Twilio
  */
 export function purchaseAPIAccess(
   agentId: string,
@@ -80,11 +107,12 @@ export function purchaseAPIAccess(
     };
   }
   
-  // Check if provider exists
-  if (!mockCredentials[providerId]) {
+  // Check if provider is supported
+  const providerCredentials = getCredentials(providerId);
+  if (!providerCredentials) {
     return {
       success: false,
-      error: `Unknown provider: ${providerId}`
+      error: `Unknown provider: ${providerId}. Supported: ${Object.keys(CREDITS_PER_DOLLAR).join(', ')}`
     };
   }
   
@@ -92,6 +120,9 @@ export function purchaseAPIAccess(
   credits.balance_usd -= amountUsd;
   credits.updated_at = new Date().toISOString();
   
+  // Generate credentials (real for 46elks/twilio, mock for others)
+  const credentials = generateCredentials(providerId);
+  
   // Create purchase record
   const purchaseId = `pur_${randomUUID().slice(0, 12)}`;
   const purchase: Purchase = {
@@ -101,14 +132,14 @@ export function purchaseAPIAccess(
     amount_usd: amountUsd,
     credits_purchased: calculateCredits(providerId, amountUsd),
     status: 'active',
-    credentials: mockCredentials[providerId](),
+    credentials,
     created_at: new Date().toISOString()
   };
   
-  purchases.set(purchaseId, purchase);
+  purchasesStore.set(purchaseId, purchase);
   
   // Initialize usage tracking
-  usage.set(purchaseId, {
+  usageStore.set(purchaseId, {
     purchase_id: purchaseId,
     provider_id: providerId,
     units_used: 0,
@@ -117,44 +148,32 @@ export function purchaseAPIAccess(
     last_used_at: new Date().toISOString()
   });
   
-  return { success: true, purchase };
-}
-
-/**
- * Calculate credits based on provider pricing
- */
-function calculateCredits(providerId: string, amountUsd: number): number {
-  // Simplified credit calculation per provider
-  const creditsPerDollar: Record<string, number> = {
-    '46elks': 30,      // ~30 SMS per dollar
-    'resend': 1000,    // ~1000 emails per dollar
-    'brave_search': 200, // ~200 searches per dollar
-    'openrouter': 100,   // ~100k tokens per dollar (varies by model)
-    'elevenlabs': 3333   // ~3333 characters per dollar
-  };
+  // Flag if using real credentials
+  const isRealCredentials = hasRealCredentials(providerId);
+  console.log(`[APIClaw] Purchase complete: ${providerId} ($${amountUsd}) - Real credentials: ${isRealCredentials}`);
   
-  return Math.floor(amountUsd * (creditsPerDollar[providerId] || 100));
+  return { success: true, purchase };
 }
 
 /**
  * Get all purchases for an agent
  */
 export function getAgentPurchases(agentId: string): Purchase[] {
-  return Array.from(purchases.values()).filter(p => p.agent_id === agentId);
+  return Array.from(purchasesStore.values()).filter(p => p.agent_id === agentId);
 }
 
 /**
  * Get usage for a purchase
  */
 export function getUsage(purchaseId: string): UsageRecord | null {
-  return usage.get(purchaseId) || null;
+  return usageStore.get(purchaseId) || null;
 }
 
 /**
  * Record usage (call this when API is used)
  */
 export function recordUsage(purchaseId: string, unitsUsed: number, costUsd: number): UsageRecord | null {
-  const record = usage.get(purchaseId);
+  const record = usageStore.get(purchaseId);
   if (!record) return null;
   
   record.units_used += unitsUsed;
@@ -164,7 +183,7 @@ export function recordUsage(purchaseId: string, unitsUsed: number, costUsd: numb
   
   // Update purchase status if depleted
   if (record.units_remaining === 0) {
-    const purchase = purchases.get(purchaseId);
+    const purchase = purchasesStore.get(purchaseId);
     if (purchase) purchase.status = 'exhausted';
   }
   
@@ -178,84 +197,133 @@ export function getBalanceSummary(agentId: string): {
   credits: AgentCredits;
   active_purchases: Purchase[];
   total_spent_usd: number;
+  real_credentials_available: string[];
 } {
   const credits = getAgentCredits(agentId);
   const agentPurchases = getAgentPurchases(agentId);
   const activePurchases = agentPurchases.filter(p => p.status === 'active');
   const totalSpent = agentPurchases.reduce((sum, p) => sum + p.amount_usd, 0);
   
+  // List providers with real credentials
+  const realCredentialProviders = REAL_CREDENTIAL_PROVIDERS.filter(p => hasRealCredentials(p));
+  
   return {
     credits,
     active_purchases: activePurchases,
-    total_spent_usd: totalSpent
+    total_spent_usd: totalSpent,
+    real_credentials_available: realCredentialProviders
   };
 }
 
 /**
- * Calculate transaction fee based on user's subscription
- * Pro users: 2% fee
- * Free users: 5% fee
+ * Check which providers have real credentials
  */
-export async function calculateTransactionFee(
-  userId: string,
-  amountUsd: number
-): Promise<TransactionFee> {
-  const isPro = await hasProSubscription(userId);
-  const feePercentage = isPro ? 0.02 : 0.05;
-  const feeAmount = Math.round(amountUsd * feePercentage * 100) / 100;
-  
-  return {
-    amount_usd: amountUsd,
-    fee_percentage: feePercentage,
-    fee_amount_usd: feeAmount,
-    net_amount_usd: Math.round((amountUsd - feeAmount) * 100) / 100,
-    tier: isPro ? 'pro' : 'free',
-  };
+export function getProvidersWithRealCredentials(): string[] {
+  return REAL_CREDENTIAL_PROVIDERS.filter(p => hasRealCredentials(p));
 }
 
-/**
- * Purchase API access with subscription-aware fees
- */
-export async function purchaseAPIAccessWithFees(
+// =============================================================================
+// Convex Backend (for production) - HTTP API calls
+// =============================================================================
+
+interface ConvexResponse<T> {
+  data?: T;
+  error?: string;
+}
+
+async function convexQuery<T>(path: string, args: Record<string, unknown>): Promise<ConvexResponse<T>> {
+  if (!CONVEX_URL) {
+    return { error: 'Convex URL not configured' };
+  }
+
+  try {
+    const response = await fetch(`${CONVEX_URL}/api/query`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        ...(CONVEX_DEPLOY_KEY ? { 'Authorization': `Convex ${CONVEX_DEPLOY_KEY}` } : {}),
+      },
+      body: JSON.stringify({ path, args }),
+    });
+
+    const result = await response.json() as T;
+    return { data: result };
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : 'Convex query failed' };
+  }
+}
+
+async function convexMutation<T>(path: string, args: Record<string, unknown>): Promise<ConvexResponse<T>> {
+  if (!CONVEX_URL) {
+    return { error: 'Convex URL not configured' };
+  }
+
+  try {
+    const response = await fetch(`${CONVEX_URL}/api/mutation`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        ...(CONVEX_DEPLOY_KEY ? { 'Authorization': `Convex ${CONVEX_DEPLOY_KEY}` } : {}),
+      },
+      body: JSON.stringify({ path, args }),
+    });
+
+    const result = await response.json() as T;
+    return { data: result };
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : 'Convex mutation failed' };
+  }
+}
+
+// Convex-backed versions (async)
+export async function getAgentCreditsAsync(agentId: string): Promise<AgentCredits | null> {
+  if (BACKEND === 'memory') {
+    return getAgentCredits(agentId);
+  }
+
+  const result = await convexQuery<AgentCredits>('credits:getAgentCredits', { agentId });
+  return result.data || null;
+}
+
+export async function addCreditsAsync(agentId: string, amountUsd: number): Promise<AgentCredits | null> {
+  if (BACKEND === 'memory') {
+    return addCredits(agentId, amountUsd);
+  }
+
+  const result = await convexMutation<AgentCredits>('credits:addCredits', { agentId, amountUsd });
+  return result.data || null;
+}
+
+export async function purchaseAPIAccessAsync(
   agentId: string,
-  userId: string,
   providerId: string,
   amountUsd: number
-): Promise<{ 
-  success: boolean; 
-  purchase?: Purchase; 
-  fee?: TransactionFee;
-  error?: string 
-}> {
-  // Calculate fees first
-  const fee = await calculateTransactionFee(userId, amountUsd);
-  
-  // Total amount user pays = API cost + platform fee
-  const totalCost = amountUsd + fee.fee_amount_usd;
-  
-  const credits = getAgentCredits(agentId);
-  
-  if (credits.balance_usd < totalCost) {
-    return {
-      success: false,
-      error: `Insufficient balance. Have $${credits.balance_usd.toFixed(2)}, need $${totalCost.toFixed(2)} (includes ${fee.tier === 'pro' ? '2%' : '5%'} platform fee)`
-    };
+): Promise<{ success: boolean; purchase?: Purchase; error?: string }> {
+  if (BACKEND === 'memory') {
+    return purchaseAPIAccess(agentId, providerId, amountUsd);
   }
-  
-  // Make the purchase (deducts API cost)
-  const result = purchaseAPIAccess(agentId, providerId, amountUsd);
-  
-  if (result.success && result.purchase) {
-    // Deduct platform fee separately
-    credits.balance_usd -= fee.fee_amount_usd;
-    credits.updated_at = new Date().toISOString();
-    
-    return {
-      success: true,
-      purchase: result.purchase,
-      fee,
-    };
+
+  // Generate credentials server-side
+  const credentials = generateCredentials(providerId);
+
+  const result = await convexMutation<Purchase>('purchases:purchaseAccess', {
+    agentId,
+    providerId,
+    amountUsd,
+    credentials,
+  });
+
+  if (result.error) {
+    return { success: false, error: result.error };
   }
-  
-  return result;
+
+  return { success: true, purchase: result.data };
+}
+
+// Export backend info
+export function getBackendInfo(): { type: StorageBackend; convexUrl: string | null } {
+  return {
+    type: BACKEND,
+    convexUrl: BACKEND === 'convex' ? CONVEX_URL : null,
+  };
 }