@nordsym/apiclaw 1.0.0

package/src/registry/parse_apis.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+"""
+Parse public-apis README and convert to APIClaw registry format
+"""
+import re
+import json
+import hashlib
+
+# Read the README content
+with open('/tmp/public-apis-readme.md', 'r') as f:
+    content = f.read()
+
+apis = []
+current_category = None
+
+# Split by lines
+lines = content.split('\n')
+
+for i, line in enumerate(lines):
+    # Check for category headers (### Animals, ### Anime, etc.)
+    if line.startswith('### ') and not line.startswith('### API'):
+        current_category = line[4:].strip()
+        continue
+    
+    # Skip non-table rows
+    if not line.startswith('|'):
+        continue
+    
+    # Skip header rows and separator rows
+    if '---' in line or 'API | Description' in line or 'API|Description' in line:
+        continue
+    
+    # Parse table row
+    # Format: | [Name](url) | Description | Auth | HTTPS | CORS |
+    parts = line.split('|')
+    if len(parts) < 5:
+        continue
+    
+    # Extract API info
+    api_cell = parts[1].strip() if len(parts) > 1 else ''
+    desc_cell = parts[2].strip() if len(parts) > 2 else ''
+    auth_cell = parts[3].strip() if len(parts) > 3 else ''
+    https_cell = parts[4].strip() if len(parts) > 4 else ''
+    cors_cell = parts[5].strip() if len(parts) > 5 else ''
+    
+    # Extract name and link from markdown link format [Name](url)
+    link_match = re.match(r'\[([^\]]+)\]\(([^)]+)\)', api_cell)
+    if not link_match:
+        continue
+    
+    name = link_match.group(1)
+    link = link_match.group(2)
+    
+    # Generate slug ID
+    slug = re.sub(r'[^a-z0-9]+', '-', name.lower()).strip('-')
+    
+    # Parse auth type
+    auth = 'None'
+    if '`apiKey`' in auth_cell or 'apiKey' in auth_cell:
+        auth = 'apiKey'
+    elif '`OAuth`' in auth_cell or 'OAuth' in auth_cell:
+        auth = 'OAuth'
+    elif '`X-Mashape-Key`' in auth_cell:
+        auth = 'apiKey'
+    elif '`User-Agent`' in auth_cell:
+        auth = 'User-Agent'
+    elif 'No' in auth_cell:
+        auth = 'None'
+    
+    # Parse HTTPS
+    https = 'Yes' in https_cell
+    
+    # Parse CORS
+    cors = 'unknown'
+    if 'Yes' in cors_cell:
+        cors = 'yes'
+    elif 'No' in cors_cell:
+        cors = 'no'
+    
+    # Generate keywords from category and description
+    keywords = []
+    if current_category:
+        keywords.append(current_category.lower().replace(' & ', '-').replace(' ', '-'))
+    
+    # Add some common keywords from description
+    desc_lower = desc_cell.lower()
+    for keyword in ['data', 'api', 'free', 'real-time', 'json', 'rest', 'graphql']:
+        if keyword in desc_lower:
+            keywords.append(keyword)
+    
+    api_entry = {
+        "id": slug,
+        "name": name,
+        "description": desc_cell,
+        "category": current_category or "Uncategorized",
+        "auth": auth,
+        "https": https,
+        "cors": cors,
+        "link": link,
+        "pricing": "unknown",  # public-apis doesn't have pricing info
+        "keywords": list(set(keywords))
+    }
+    
+    apis.append(api_entry)
+
+# Remove duplicates by ID (keep first occurrence)
+seen_ids = set()
+unique_apis = []
+for api in apis:
+    if api['id'] not in seen_ids:
+        seen_ids.add(api['id'])
+        unique_apis.append(api)
+    else:
+        # Make ID unique by appending category
+        cat_slug = re.sub(r'[^a-z0-9]+', '-', api['category'].lower()).strip('-')
+        new_id = f"{api['id']}-{cat_slug}"
+        if new_id not in seen_ids:
+            api['id'] = new_id
+            seen_ids.add(new_id)
+            unique_apis.append(api)
+
+print(f"Parsed {len(unique_apis)} unique APIs")
+
+# Write to JSON
+output = {
+    "version": "1.0.0",
+    "source": "https://github.com/public-apis/public-apis",
+    "lastUpdated": "2026-02-16",
+    "count": len(unique_apis),
+    "apis": unique_apis
+}
+
+with open('/Users/gustavhemmingsson/clawd/products/api-discovery/src/registry/apis.json', 'w') as f:
+    json.dump(output, f, indent=2)
+
+print(f"Wrote to apis.json")
+
+# Print some stats
+categories = {}
+for api in unique_apis:
+    cat = api['category']
+    categories[cat] = categories.get(cat, 0) + 1
+
+print("\nAPIs per category:")
+for cat, count in sorted(categories.items(), key=lambda x: -x[1]):
+    print(f"  {cat}: {count}")

package/src/revenuecat.ts

@@ -0,0 +1,239 @@
+// RevenueCat integration for APIClaw
+// Handles Pro subscription checking and fee calculation
+
+const REVENUECAT_API_URL = 'https://api.revenuecat.com/v1';
+const PROJECT_ID = '0d074df4';
+
+// Entitlement identifiers
+export const ENTITLEMENTS = {
+  PRO: 'pro',
+} as const;
+
+// Product identifiers
+export const PRODUCTS = {
+  PRO_MONTHLY: 'apiclaw_pro_monthly',
+} as const;
+
+// Fee structure
+const FEES = {
+  FREE: 0.05,   // 5% transaction fee
+  PRO: 0.02,    // 2% transaction fee
+} as const;
+
+interface RevenueCatSubscriber {
+  subscriber: {
+    entitlements: Record<string, {
+      product_identifier: string;
+      expires_date: string | null;
+      purchase_date: string;
+    }>;
+    subscriptions: Record<string, {
+      expires_date: string | null;
+      purchase_date: string;
+      product_plan_identifier?: string;
+      billing_issues_detected_at?: string | null;
+      unsubscribe_detected_at?: string | null;
+    }>;
+    non_subscriptions: Record<string, unknown>;
+    first_seen: string;
+    original_app_user_id: string;
+  };
+}
+
+/**
+ * Get RevenueCat API key from environment
+ */
+function getApiKey(): string {
+  const key = process.env.REVENUECAT_SECRET_KEY;
+  if (!key) {
+    throw new Error('REVENUECAT_SECRET_KEY not set');
+  }
+  return key;
+}
+
+/**
+ * Fetch subscriber info from RevenueCat
+ */
+async function getSubscriber(userId: string): Promise<RevenueCatSubscriber | null> {
+  try {
+    const response = await fetch(
+      `${REVENUECAT_API_URL}/subscribers/${encodeURIComponent(userId)}`,
+      {
+        headers: {
+          'Authorization': `Bearer ${getApiKey()}`,
+          'Content-Type': 'application/json',
+        },
+      }
+    );
+
+    if (response.status === 404) {
+      return null; // User doesn't exist in RevenueCat
+    }
+
+    if (!response.ok) {
+      throw new Error(`RevenueCat API error: ${response.status}`);
+    }
+
+    return await response.json() as RevenueCatSubscriber;
+  } catch (error) {
+    console.error('Error fetching subscriber:', error);
+    return null;
+  }
+}
+
+/**
+ * Check if a user has Pro subscription
+ */
+export async function hasProSubscription(userId: string): Promise<boolean> {
+  const subscriber = await getSubscriber(userId);
+  
+  if (!subscriber) {
+    return false;
+  }
+
+  const proEntitlement = subscriber.subscriber.entitlements[ENTITLEMENTS.PRO];
+  
+  if (!proEntitlement) {
+    return false;
+  }
+
+  // Check if entitlement is active (not expired)
+  if (proEntitlement.expires_date) {
+    const expiresAt = new Date(proEntitlement.expires_date);
+    if (expiresAt < new Date()) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Get all entitlements for a user
+ */
+export async function getEntitlements(userId: string): Promise<{
+  pro: boolean;
+  expiresAt: string | null;
+  purchaseDate: string | null;
+}> {
+  const subscriber = await getSubscriber(userId);
+  
+  const result = {
+    pro: false,
+    expiresAt: null as string | null,
+    purchaseDate: null as string | null,
+  };
+
+  if (!subscriber) {
+    return result;
+  }
+
+  const proEntitlement = subscriber.subscriber.entitlements[ENTITLEMENTS.PRO];
+  
+  if (proEntitlement) {
+    const expiresAt = proEntitlement.expires_date 
+      ? new Date(proEntitlement.expires_date) 
+      : null;
+    
+    result.pro = !expiresAt || expiresAt > new Date();
+    result.expiresAt = proEntitlement.expires_date;
+    result.purchaseDate = proEntitlement.purchase_date;
+  }
+
+  return result;
+}
+
+/**
+ * Get fee percentage based on subscription status
+ * Pro = 2%, Free = 5%
+ */
+export async function getFeePercentage(userId: string): Promise<number> {
+  const isPro = await hasProSubscription(userId);
+  return isPro ? FEES.PRO : FEES.FREE;
+}
+
+/**
+ * Calculate platform fee for a transaction
+ */
+export async function calculateFee(userId: string, amountUsd: number): Promise<{
+  feePercentage: number;
+  feeAmount: number;
+  netAmount: number;
+  isPro: boolean;
+}> {
+  const isPro = await hasProSubscription(userId);
+  const feePercentage = isPro ? FEES.PRO : FEES.FREE;
+  const feeAmount = amountUsd * feePercentage;
+  
+  return {
+    feePercentage,
+    feeAmount: Math.round(feeAmount * 100) / 100, // Round to 2 decimals
+    netAmount: Math.round((amountUsd - feeAmount) * 100) / 100,
+    isPro,
+  };
+}
+
+/**
+ * Create or update subscriber attributes
+ */
+export async function setSubscriberAttributes(
+  userId: string,
+  attributes: Record<string, string>
+): Promise<boolean> {
+  try {
+    const formattedAttributes: Record<string, { value: string }> = {};
+    for (const [key, value] of Object.entries(attributes)) {
+      formattedAttributes[`$${key}`] = { value };
+    }
+
+    const response = await fetch(
+      `${REVENUECAT_API_URL}/subscribers/${encodeURIComponent(userId)}/attributes`,
+      {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${getApiKey()}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ attributes: formattedAttributes }),
+      }
+    );
+
+    return response.ok;
+  } catch (error) {
+    console.error('Error setting subscriber attributes:', error);
+    return false;
+  }
+}
+
+/**
+ * Grant promotional entitlement (for testing/promos)
+ */
+export async function grantPromoEntitlement(
+  userId: string,
+  durationDays: number = 30
+): Promise<boolean> {
+  try {
+    const response = await fetch(
+      `${REVENUECAT_API_URL}/subscribers/${encodeURIComponent(userId)}/entitlements/${ENTITLEMENTS.PRO}/promotional`,
+      {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${getApiKey()}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          duration: 'daily',
+          duration_count: durationDays,
+        }),
+      }
+    );
+
+    return response.ok;
+  } catch (error) {
+    console.error('Error granting promo entitlement:', error);
+    return false;
+  }
+}
+
+// Export types for use elsewhere
+export type { RevenueCatSubscriber };

package/src/test.ts

@@ -0,0 +1,97 @@
+/**
+ * Test script for APIvault
+ * Run: pnpm test
+ */
+
+import { discoverAPIs, getAPIDetails, getCategories, getAllAPIs, getAPICount } from './discovery.js';
+import { addCredits, purchaseAPIAccess, getBalanceSummary } from './credits.js';
+
+console.log('🔐 APIvault Test Suite\n');
+console.log('='.repeat(50));
+
+// Test 1: API Count
+console.log('\n📊 Test 1: API Registry');
+console.log('-'.repeat(40));
+console.log(`Total APIs loaded: ${getAPICount()}`);
+
+// Test 2: Discovery
+console.log('\n📡 Test 2: API Discovery');
+console.log('-'.repeat(40));
+
+const smsResults = discoverAPIs('SMS');
+console.log(`Query: "SMS"`);
+console.log(`Results: ${smsResults.length}`);
+smsResults.slice(0, 5).forEach(r => {
+  console.log(`  - ${r.api.name} (score: ${r.relevance_score})`);
+  console.log(`    ${r.api.description.slice(0, 60)}...`);
+});
+
+const weatherResults = discoverAPIs('weather');
+console.log(`\nQuery: "weather"`);
+console.log(`Results: ${weatherResults.length}`);
+weatherResults.slice(0, 5).forEach(r => {
+  console.log(`  - ${r.api.name} (score: ${r.relevance_score})`);
+});
+
+const paymentResults = discoverAPIs('payment');
+console.log(`\nQuery: "payment"`);
+console.log(`Results: ${paymentResults.length}`);
+paymentResults.slice(0, 5).forEach(r => {
+  console.log(`  - ${r.api.name} (score: ${r.relevance_score})`);
+});
+
+// Test 3: Get API Details
+console.log('\n📋 Test 3: API Details');
+console.log('-'.repeat(40));
+
+const stripe = getAPIDetails('stripe');
+if (stripe) {
+  console.log(`\n${stripe.name}:`);
+  console.log(`  Category: ${stripe.category}`);
+  console.log(`  Auth: ${stripe.auth}`);
+  console.log(`  HTTPS: ${stripe.https}`);
+  console.log(`  Link: ${stripe.link}`);
+}
+
+// Test 4: Categories
+console.log('\n📂 Test 4: Categories');
+console.log('-'.repeat(40));
+
+const categories = getCategories();
+console.log(`Total categories: ${categories.length}`);
+console.log(`Sample: ${categories.slice(0, 10).join(', ')}...`);
+
+// Test 5: Credits System
+console.log('\n💰 Test 5: Credit System');
+console.log('-'.repeat(40));
+
+const testAgent = 'agent_test_123';
+
+// Check initial balance
+let balance = getBalanceSummary(testAgent);
+console.log(`Initial balance: $${balance.credits.balance_usd}`);
+
+// Add credits
+addCredits(testAgent, 50);
+balance = getBalanceSummary(testAgent);
+console.log(`After adding $50: $${balance.credits.balance_usd}`);
+
+// Purchase API access
+console.log('\n🛒 Purchasing stripe access for $10...');
+const purchase = purchaseAPIAccess(testAgent, 'stripe', 10);
+if (purchase.success) {
+  console.log(`  ✅ Purchase successful!`);
+  console.log(`  Purchase ID: ${purchase.purchase!.id}`);
+  console.log(`  Credits received: ${purchase.purchase!.credits_purchased}`);
+} else {
+  console.log(`  ❌ Purchase failed: ${purchase.error}`);
+}
+
+// Check updated balance
+balance = getBalanceSummary(testAgent);
+console.log(`\nFinal balance: $${balance.credits.balance_usd}`);
+console.log(`Total spent: $${balance.total_spent_usd}`);
+console.log(`Active purchases: ${balance.active_purchases.length}`);
+
+console.log('\n' + '='.repeat(50));
+console.log('✅ All tests completed!\n');

package/src/types.ts

@@ -0,0 +1,110 @@
+// Core types for APIvault
+
+// Simplified API from public-apis import
+export interface SimpleAPI {
+  id: string;
+  name: string;
+  description: string;
+  category: string;
+  auth: string;
+  https: boolean;
+  cors: string;
+  link: string;
+  pricing: string;
+  keywords: string[];
+}
+
+// Full API provider (for detailed/curated APIs)
+export interface APIProvider {
+  id: string;
+  name: string;
+  description: string;
+  category: string;
+  capabilities: string[];
+  keywords: string[];
+  pricing: APIPricing;
+  auth_type: string; // api_key, basic, oauth, bearer
+  docs_url: string;
+  base_url: string;
+  endpoints: APIEndpoint[];
+  features: string[];
+  compliance: string[];
+  regions: string[];
+  agent_success_rate: number;
+  avg_latency_ms: number;
+}
+
+export interface APIPricing {
+  model: string; // per_unit, per_query, per_token, per_character, subscription
+  free_tier: boolean;
+  minimum_purchase: number | null;
+  [key: string]: string | number | boolean | null | undefined;
+}
+
+export interface APIEndpoint {
+  name: string;
+  method: string;
+  path: string;
+  params: string[];
+}
+
+export interface SearchResult {
+  provider: APIProvider;
+  relevance_score: number;
+  match_reasons: string[];
+}
+
+export interface AgentCredits {
+  agent_id: string;
+  balance_usd: number;
+  currency: string;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface Purchase {
+  id: string;
+  agent_id: string;
+  provider_id: string;
+  amount_usd: number;
+  credits_purchased: number;
+  status: 'pending' | 'active' | 'exhausted' | 'refunded';
+  credentials?: APICredentials;
+  created_at: string;
+}
+
+export interface APICredentials {
+  type: string; // api_key, basic, bearer
+  api_key?: string;
+  username?: string;
+  password?: string;
+  expires_at?: string;
+}
+
+export interface UsageRecord {
+  purchase_id: string;
+  provider_id: string;
+  units_used: number;
+  units_remaining: number;
+  cost_incurred_usd: number;
+  last_used_at: string;
+}
+
+// Subscription types
+export interface UserSubscription {
+  user_id: string;
+  tier: 'free' | 'pro';
+  status: 'active' | 'cancelled' | 'expired' | 'paused' | 'billing_issue';
+  product_id: string | null;
+  expires_at: string | null;
+  fee_percentage: number; // 0.05 for free, 0.02 for pro
+  updated_at: string;
+}
+
+export interface TransactionFee {
+  amount_usd: number;
+  fee_percentage: number;
+  fee_amount_usd: number;
+  net_amount_usd: number;
+  tier: 'free' | 'pro';
+}