@nordsym/apiclaw 1.3.5 → 1.3.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nordsym/apiclaw",
-  "version": "1.3.5",
+  "version": "1.3.7",
   "description": "Agent-native API discovery and Direct Call execution via MCP",
   "type": "module",
   "main": "dist/index.js",

package/src/cli.ts

@@ -83,23 +83,73 @@ async function registerOwner(email: string): Promise<void> {
   
   try {
     const fingerprint = getMachineFingerprint();
-    const result = await convex.mutation("workspaces:requestMagicLink" as any, {
-      email,
-      fingerprint,
-    }) as any;
     
-    if (result?.sent) {
+    // Use HTTP endpoint for magic link
+    const response = await fetch(`${CONVEX_URL.replace('.cloud', '.site')}/workspace/magic-link`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ email, fingerprint }),
+    });
+    
+    const result = await response.json() as { success?: boolean; token?: string; error?: string };
+    
+    if (result?.success && result?.token) {
       success(`Magic link sent to ${email}`);
       log(`\n📧 Check your email and click the link to authenticate.`);
-      log(`   Then run ${colors.cyan}status${colors.reset} to verify.\n`);
+      
+      // Start polling for verification
+      log(`\n⏳ Waiting for you to click the link...`);
+      log(`   (Press Ctrl+C to cancel)\n`);
+      
+      await pollForVerification(result.token, fingerprint);
     } else {
-      error(`Failed to send magic link: ${result?.error || 'Unknown error'}`);
+      error(`Failed: ${result?.error || 'Unknown error'}`);
     }
   } catch (err) {
     error(`Failed: ${err instanceof Error ? err.message : 'Unknown error'}`);
   }
 }
 
+async function pollForVerification(token: string, fingerprint: string): Promise<void> {
+  const maxAttempts = 60; // 5 minutes
+  for (let i = 0; i < maxAttempts; i++) {
+    await new Promise(r => setTimeout(r, 5000)); // Poll every 5 seconds
+    
+    try {
+      const response = await fetch(`${CONVEX_URL.replace('.cloud', '.site')}/workspace/poll?token=${token}`);
+      const result = await response.json() as { 
+        verified?: boolean; 
+        sessionToken?: string; 
+        workspaceId?: string; 
+        email?: string;
+      };
+      
+      if (result?.verified && result?.sessionToken) {
+        // Save the real session
+        writeSession(
+          result.sessionToken,
+          result.workspaceId || '',
+          result.email || ''
+        );
+        
+        success(`Authenticated as ${result.email}!`);
+        
+        // Reload workspace context
+        await validateSession();
+        return;
+      }
+    } catch {
+      // Continue polling
+    }
+    
+    // Show progress dot
+    process.stdout.write('.');
+  }
+  
+  log('\n');
+  error('Verification timed out. Please try again.');
+}
+
 async function showStatus(): Promise<void> {
   const valid = await validateSession();
   

package/src/index.ts

@@ -43,6 +43,13 @@ import {
 import { executeCapability, listCapabilities, hasCapability } from './capability-router.js';
 import { readSession, writeSession, clearSession, getMachineFingerprint, SessionData } from './session.js';
 import { ConvexHttpClient } from 'convex/browser';
+import { 
+  getOrCreateCustomer, 
+  createMeteredCheckoutSession, 
+  getUsageSummary,
+  METERED_BILLING 
+} from './stripe.js';
+import { estimateCost } from './metered.js';
 
 // Default agent ID for MVP (in production, this would come from auth)
 const DEFAULT_AGENT_ID = 'agent_default';
@@ -392,6 +399,59 @@ const tools: Tool[] = [
       type: 'object',
       properties: {}
     }
+  },
+  // Metered Billing Tools
+  {
+    name: 'setup_metered_billing',
+    description: 'Set up pay-per-call billing. Creates a subscription that charges $0.002 per API call at end of month.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        email: {
+          type: 'string',
+          description: 'Email for the billing account'
+        },
+        success_url: {
+          type: 'string',
+          description: 'URL to redirect after successful setup',
+          default: 'https://apiclaw.nordsym.com/billing/success'
+        },
+        cancel_url: {
+          type: 'string',
+          description: 'URL to redirect if setup is cancelled',
+          default: 'https://apiclaw.nordsym.com/billing/cancel'
+        }
+      },
+      required: ['email']
+    }
+  },
+  {
+    name: 'get_usage_summary',
+    description: 'Get current billing period usage and estimated cost for metered billing.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        subscription_id: {
+          type: 'string',
+          description: 'Stripe subscription ID (stored after setup_metered_billing)'
+        }
+      },
+      required: ['subscription_id']
+    }
+  },
+  {
+    name: 'estimate_cost',
+    description: 'Estimate the cost for a given number of API calls.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        call_count: {
+          type: 'number',
+          description: 'Number of API calls to estimate cost for'
+        }
+      },
+      required: ['call_count']
+    }
   }
 ];
 
@@ -1201,6 +1261,151 @@ Docs: https://apiclaw.nordsym.com
         }
       }
 
+      // Metered Billing Tools
+      case 'setup_metered_billing': {
+        const { email, success_url, cancel_url } = args as {
+          email: string;
+          success_url?: string;
+          cancel_url?: string;
+        };
+
+        if (!email) {
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({ status: 'error', error: 'Email is required' }, null, 2)
+            }],
+            isError: true
+          };
+        }
+
+        // Create or get customer
+        const customerResult = await getOrCreateCustomer(email, email);
+        if ('error' in customerResult) {
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({ status: 'error', error: customerResult.error }, null, 2)
+            }],
+            isError: true
+          };
+        }
+
+        // Create checkout session for metered subscription
+        const checkoutResult = await createMeteredCheckoutSession(
+          email,
+          success_url || 'https://apiclaw.nordsym.com/billing/success',
+          cancel_url || 'https://apiclaw.nordsym.com/billing/cancel'
+        );
+
+        if ('error' in checkoutResult) {
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({ status: 'error', error: checkoutResult.error }, null, 2)
+            }],
+            isError: true
+          };
+        }
+
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              status: 'checkout_ready',
+              message: 'Complete checkout to activate pay-per-call billing',
+              checkout_url: checkoutResult.url,
+              session_id: checkoutResult.sessionId,
+              customer_id: customerResult.customerId,
+              pricing: {
+                per_call: '$0.002',
+                billing_period: 'monthly',
+                billed_at: 'end of period based on usage'
+              }
+            }, null, 2)
+          }]
+        };
+      }
+
+      case 'get_usage_summary': {
+        const { subscription_id } = args as { subscription_id: string };
+
+        if (!subscription_id) {
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({ status: 'error', error: 'subscription_id is required' }, null, 2)
+            }],
+            isError: true
+          };
+        }
+
+        const usage = await getUsageSummary(subscription_id);
+        if ('error' in usage) {
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({ status: 'error', error: usage.error }, null, 2)
+            }],
+            isError: true
+          };
+        }
+
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              status: 'success',
+              billing_period: {
+                start: new Date(usage.period.start * 1000).toISOString(),
+                end: new Date(usage.period.end * 1000).toISOString()
+              },
+              usage: {
+                total_calls: usage.totalCalls,
+                price_per_call: METERED_BILLING.pricePerCall,
+                estimated_cost: `$${usage.totalCost.toFixed(4)}`
+              }
+            }, null, 2)
+          }]
+        };
+      }
+
+      case 'estimate_cost': {
+        const { call_count } = args as { call_count: number };
+
+        if (!call_count || call_count < 0) {
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({ status: 'error', error: 'Valid call_count is required' }, null, 2)
+            }],
+            isError: true
+          };
+        }
+
+        const estimate = estimateCost(call_count);
+
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              status: 'success',
+              estimate: {
+                calls: estimate.calls,
+                price_per_call: `$${estimate.pricePerCall}`,
+                total_cost: `$${estimate.totalCost.toFixed(4)}`,
+                currency: estimate.currency
+              },
+              examples: {
+                '100 calls': `$${(100 * METERED_BILLING.pricePerCall).toFixed(2)}`,
+                '1,000 calls': `$${(1000 * METERED_BILLING.pricePerCall).toFixed(2)}`,
+                '10,000 calls': `$${(10000 * METERED_BILLING.pricePerCall).toFixed(2)}`
+              }
+            }, null, 2)
+          }]
+        };
+      }
+
       default:
         return {
           content: [

package/src/metered.ts

@@ -0,0 +1,149 @@
+/**
+ * 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';
+
+interface MeteredResult {
+  success: boolean;
+  provider: string;
+  action: string;
+  data?: unknown;
+  error?: string;
+  cost?: number;
+  billing?: {
+    tracked: boolean;
+    customerId?: string;
+    pricePerCall: number;
+  };
+}
+
+interface MeteredOptions {
+  /** Stripe customer ID for usage tracking */
+  customerId?: string;
+  /** Skip usage reporting (for testing/free tier) */
+  skipBilling?: boolean;
+  /** Provider-specific API key (Direct Call mode) */
+  customerKey?: string;
+  /** User ID for dynamic providers */
+  userId?: string;
+}
+
+/**
+ * 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: string,
+  action: string,
+  params: Record<string, unknown>,
+  options: MeteredOptions = {}
+): Promise<MeteredResult> {
+  const { customerId, skipBilling, customerKey, userId } = options;
+
+  // Execute the API call
+  const result = await executeAPICall(
+    providerId,
+    action,
+    params,
+    userId,
+    customerKey
+  );
+
+  // Build response
+  const response: MeteredResult = {
+    ...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: Array<{
+    provider: string;
+    action: string;
+    params: Record<string, unknown>;
+  }>,
+  options: MeteredOptions = {}
+): Promise<MeteredResult[]> {
+  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: number): {
+  calls: number;
+  pricePerCall: number;
+  totalCost: number;
+  currency: string;
+} {
+  return {
+    calls: callCount,
+    pricePerCall: METERED_BILLING.pricePerCall,
+    totalCost: callCount * METERED_BILLING.pricePerCall,
+    currency: 'USD',
+  };
+}
+
+/**
+ * Get metered billing configuration
+ */
+export function getMeteredConfig(): typeof METERED_BILLING {
+  return METERED_BILLING;
+}