web-agent-bridge 2.6.0 → 2.7.0

package/server/migrations/005_marketplace_metering.sql

@@ -0,0 +1,126 @@
+-- Migration 005: Marketplace & Usage Metering tables
+
+-- Marketplace listings
+CREATE TABLE IF NOT EXISTS marketplace_listings (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  description TEXT DEFAULT '',
+  type TEXT NOT NULL,
+  category TEXT DEFAULT 'automation',
+  seller_id TEXT NOT NULL,
+  seller_name TEXT DEFAULT 'Anonymous',
+  price REAL DEFAULT 0,
+  currency TEXT DEFAULT 'usd',
+  version TEXT DEFAULT '1.0.0',
+  tags TEXT DEFAULT '[]',
+  icon TEXT,
+  readme TEXT DEFAULT '',
+  install_command TEXT,
+  config_schema TEXT DEFAULT '{}',
+  entry_point TEXT,
+  installs INTEGER DEFAULT 0,
+  revenue REAL DEFAULT 0,
+  rating REAL DEFAULT 0,
+  review_count INTEGER DEFAULT 0,
+  status TEXT DEFAULT 'pending_review',
+  rejection_reason TEXT,
+  published_at INTEGER,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_mkt_listings_status ON marketplace_listings(status);
+CREATE INDEX IF NOT EXISTS idx_mkt_listings_category ON marketplace_listings(category);
+CREATE INDEX IF NOT EXISTS idx_mkt_listings_seller ON marketplace_listings(seller_id);
+
+-- Marketplace purchases
+CREATE TABLE IF NOT EXISTS marketplace_purchases (
+  id TEXT PRIMARY KEY,
+  listing_id TEXT NOT NULL,
+  listing_name TEXT,
+  buyer_id TEXT NOT NULL,
+  seller_id TEXT NOT NULL,
+  price REAL DEFAULT 0,
+  commission REAL DEFAULT 0,
+  seller_earning REAL DEFAULT 0,
+  currency TEXT DEFAULT 'usd',
+  status TEXT DEFAULT 'pending_payment',
+  created_at INTEGER NOT NULL,
+  completed_at INTEGER,
+  FOREIGN KEY (listing_id) REFERENCES marketplace_listings(id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_mkt_purchases_buyer ON marketplace_purchases(buyer_id);
+CREATE INDEX IF NOT EXISTS idx_mkt_purchases_seller ON marketplace_purchases(seller_id);
+
+-- Marketplace reviews
+CREATE TABLE IF NOT EXISTS marketplace_reviews (
+  id TEXT PRIMARY KEY,
+  listing_id TEXT NOT NULL,
+  user_id TEXT NOT NULL,
+  rating INTEGER NOT NULL,
+  comment TEXT DEFAULT '',
+  created_at INTEGER NOT NULL,
+  FOREIGN KEY (listing_id) REFERENCES marketplace_listings(id)
+);
+
+-- Seller earnings
+CREATE TABLE IF NOT EXISTS marketplace_earnings (
+  seller_id TEXT PRIMARY KEY,
+  total REAL DEFAULT 0,
+  pending REAL DEFAULT 0,
+  paid REAL DEFAULT 0,
+  last_payout INTEGER
+);
+
+-- Usage metering daily records
+CREATE TABLE IF NOT EXISTS usage_metering (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  entity_id TEXT NOT NULL,
+  metric TEXT NOT NULL,
+  date TEXT NOT NULL,
+  count INTEGER DEFAULT 0,
+  overage INTEGER DEFAULT 0,
+  overage_cost REAL DEFAULT 0,
+  UNIQUE(entity_id, metric, date)
+);
+
+CREATE INDEX IF NOT EXISTS idx_usage_entity ON usage_metering(entity_id);
+CREATE INDEX IF NOT EXISTS idx_usage_date ON usage_metering(date);
+
+-- Hosted runtime instances
+CREATE TABLE IF NOT EXISTS hosted_instances (
+  id TEXT PRIMARY KEY,
+  agent_id TEXT NOT NULL,
+  tier TEXT DEFAULT 'starter',
+  region TEXT DEFAULT 'auto',
+  cpu TEXT DEFAULT '0.5',
+  memory TEXT DEFAULT '512',
+  status TEXT DEFAULT 'starting',
+  execution_count INTEGER DEFAULT 0,
+  compute_minutes REAL DEFAULT 0,
+  errors INTEGER DEFAULT 0,
+  started_at INTEGER NOT NULL,
+  stopped_at INTEGER,
+  last_activity INTEGER
+);
+
+CREATE INDEX IF NOT EXISTS idx_hosted_agent ON hosted_instances(agent_id);
+CREATE INDEX IF NOT EXISTS idx_hosted_status ON hosted_instances(status);
+
+-- Hosted executions
+CREATE TABLE IF NOT EXISTS hosted_executions (
+  id TEXT PRIMARY KEY,
+  instance_id TEXT NOT NULL,
+  agent_id TEXT NOT NULL,
+  task_type TEXT,
+  task_action TEXT,
+  status TEXT DEFAULT 'running',
+  started_at INTEGER NOT NULL,
+  completed_at INTEGER,
+  compute_ms INTEGER DEFAULT 0,
+  error TEXT,
+  FOREIGN KEY (instance_id) REFERENCES hosted_instances(id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_hexe_instance ON hosted_executions(instance_id);

package/server/routes/runtime.js

@@ -28,6 +28,11 @@ const { commandRegistry, siteRegistry, templateRegistry } = require('../registry
 const { certificationEngine } = require('../registry/certification');
 const { adapterManager, mcpAdapter, restAdapter, browserAdapter } = require('../adapters');
 const { replayEngine } = require('../runtime/replay');
+const { featureGate, usageLimit } = require('../middleware/featureGate');
+const { listPlans, getPlan, USAGE_PRICING, MARKETPLACE } = require('../config/plans');
+const metering = require('../services/metering');
+const { marketplace } = require('../services/marketplace');
+const { hostedRuntime } = require('../services/hosted-runtime');
 const { sessionEngine } = require('../runtime/session-engine');
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -48,6 +53,8 @@ const PUBLIC_PATHS = [
   '/registry/commands',
   '/registry/sites',
   '/registry/templates',
+  '/plans',
+  '/marketplace',
 ];
 
 function authMiddleware(req, res, next) {
@@ -99,6 +106,7 @@ function authMiddleware(req, res, next) {
 }
 
 router.use(authMiddleware);
+router.use(featureGate);
 
 // ═══════════════════════════════════════════════════════════════════════════
 // PROTOCOL ENDPOINTS
@@ -241,7 +249,7 @@ router.delete('/agents/:agentId', (req, res) => {
 /**
  * Submit a task
  */
-router.post('/tasks', (req, res) => {
+router.post('/tasks', usageLimit('tasksPerDay'), (req, res) => {
   try {
     const result = runtime.submitTask(req.body);
     metrics.increment('tasks.submitted', 1, { type: req.body.type });
@@ -299,7 +307,7 @@ router.post('/tasks/:taskId/resume', (req, res) => {
 /**
  * Execute a semantic action
  */
-router.post('/execute', async (req, res) => {
+router.post('/execute', usageLimit('executionsPerDay'), async (req, res) => {
   try {
     const result = await executor.execute(req.body);
     res.json(result);
@@ -523,6 +531,9 @@ router.get('/observability/health', (req, res) => {
   health.sessions = sessionEngine.getStats();
   health.failures = failureAnalyzer.getStats();
   health.certification = certificationEngine.getStats();
+  health.marketplace = marketplace.getStats();
+  health.hostedRuntime = hostedRuntime.getStats();
+  health.metering = metering.getStats();
   res.json(health);
 });
 
@@ -634,7 +645,7 @@ router.get('/registry/templates/:templateId', (req, res) => {
 /**
  * LLM completion
  */
-router.post('/llm/complete', async (req, res) => {
+router.post('/llm/complete', usageLimit('executionsPerDay'), async (req, res) => {
   try {
     const result = await llm.complete(req.body.prompt, req.body.options || req.body);
     metrics.increment('llm.api.requests');
@@ -1133,4 +1144,303 @@ router.delete('/certification/:domain', (req, res) => {
   res.json({ success: true });
 });
 
+// ═══════════════════════════════════════════════════════════════════════════
+// PLANS & PRICING
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * List available plans
+ */
+router.get('/plans', (req, res) => {
+  const plans = listPlans().map(p => ({
+    id: p.id,
+    name: p.name,
+    price: p.price,
+    interval: p.interval,
+    description: p.description,
+    limits: p.limits,
+    features: Object.entries(p.features)
+      .filter(([, v]) => v === true)
+      .map(([k]) => k),
+  }));
+  res.json({ plans, usagePricing: USAGE_PRICING });
+});
+
+/**
+ * Get specific plan details
+ */
+router.get('/plans/:planId', (req, res) => {
+  const plan = getPlan(req.params.planId);
+  if (!plan || plan.id === 'free' && req.params.planId !== 'free') {
+    return res.status(404).json({ error: 'Plan not found' });
+  }
+  res.json(plan);
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// USAGE METERING
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Get usage for current agent
+ */
+router.get('/usage', (req, res) => {
+  const entityId = req.agentId || req.ip;
+  const tier = req.agentTier || req.session?.tier || 'free';
+  res.json(metering.getUsage(entityId, tier));
+});
+
+/**
+ * Get billing summary (overages)
+ */
+router.get('/usage/billing', (req, res) => {
+  const entityId = req.agentId || req.ip;
+  res.json(metering.getBillingSummary(entityId));
+});
+
+/**
+ * Get metering stats (admin)
+ */
+router.get('/usage/stats', (req, res) => {
+  res.json(metering.getStats());
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// MARKETPLACE
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Search marketplace
+ */
+router.get('/marketplace', (req, res) => {
+  const listings = marketplace.search({
+    type: req.query.type,
+    category: req.query.category,
+    query: req.query.q,
+    tag: req.query.tag,
+    free: req.query.free === 'true',
+    paid: req.query.paid === 'true',
+    minRating: req.query.minRating ? parseFloat(req.query.minRating) : undefined,
+    sortBy: req.query.sortBy,
+  }, parseInt(req.query.limit) || 50);
+  res.json({ listings, total: listings.length });
+});
+
+/**
+ * Get listing
+ */
+router.get('/marketplace/:listingId', (req, res) => {
+  const listing = marketplace.getListing(req.params.listingId);
+  if (!listing) return res.status(404).json({ error: 'Listing not found' });
+  res.json(listing);
+});
+
+/**
+ * Get reviews
+ */
+router.get('/marketplace/:listingId/reviews', (req, res) => {
+  res.json({ reviews: marketplace.getReviews(req.params.listingId) });
+});
+
+/**
+ * Publish listing
+ */
+router.post('/marketplace/publish', (req, res) => {
+  try {
+    const listing = marketplace.publish({
+      ...req.body,
+      sellerId: req.agentId || req.body.sellerId,
+    });
+    res.json(listing);
+  } catch (err) {
+    res.status(400).json({ error: err.message });
+  }
+});
+
+/**
+ * Purchase/install listing
+ */
+router.post('/marketplace/:listingId/purchase', (req, res) => {
+  try {
+    const buyerId = req.agentId || req.body.buyerId;
+    if (!buyerId) return res.status(400).json({ error: 'buyerId required' });
+    const purchase = marketplace.purchase(req.params.listingId, buyerId);
+    res.json(purchase);
+  } catch (err) {
+    res.status(400).json({ error: err.message });
+  }
+});
+
+/**
+ * Add review
+ */
+router.post('/marketplace/:listingId/review', (req, res) => {
+  try {
+    const review = marketplace.addReview(req.params.listingId, {
+      userId: req.agentId || req.body.userId,
+      rating: req.body.rating,
+      comment: req.body.comment,
+    });
+    res.json(review);
+  } catch (err) {
+    res.status(400).json({ error: err.message });
+  }
+});
+
+/**
+ * Get my purchases
+ */
+router.get('/marketplace/my/purchases', (req, res) => {
+  const buyerId = req.agentId || req.query.buyerId;
+  res.json({ purchases: marketplace.getPurchases(buyerId) });
+});
+
+/**
+ * Get seller earnings
+ */
+router.get('/marketplace/my/earnings', (req, res) => {
+  const sellerId = req.agentId || req.query.sellerId;
+  res.json(marketplace.getEarnings(sellerId));
+});
+
+/**
+ * Admin: pending listings
+ */
+router.get('/marketplace/admin/pending', (req, res) => {
+  res.json({ listings: marketplace.getPendingListings() });
+});
+
+/**
+ * Admin: approve listing
+ */
+router.post('/marketplace/admin/:listingId/approve', (req, res) => {
+  try {
+    const listing = marketplace.approve(req.params.listingId);
+    res.json(listing);
+  } catch (err) {
+    res.status(400).json({ error: err.message });
+  }
+});
+
+/**
+ * Admin: reject listing
+ */
+router.post('/marketplace/admin/:listingId/reject', (req, res) => {
+  try {
+    const listing = marketplace.reject(req.params.listingId, req.body.reason);
+    res.json(listing);
+  } catch (err) {
+    res.status(400).json({ error: err.message });
+  }
+});
+
+/**
+ * Marketplace stats
+ */
+router.get('/marketplace/stats', (req, res) => {
+  res.json(marketplace.getStats());
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// HOSTED RUNTIME
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Launch hosted instance
+ */
+router.post('/hosted/launch', (req, res) => {
+  try {
+    const instance = hostedRuntime.launch({
+      agentId: req.agentId || req.body.agentId,
+      tier: req.agentTier || req.session?.tier || 'starter',
+      region: req.body.region,
+      cpu: req.body.cpu,
+      memory: req.body.memory,
+      timeout: req.body.timeout,
+    });
+    res.json(instance);
+  } catch (err) {
+    res.status(400).json({ error: err.message });
+  }
+});
+
+/**
+ * Execute on hosted instance
+ */
+router.post('/hosted/:instanceId/execute', async (req, res) => {
+  try {
+    const execution = await hostedRuntime.execute(req.params.instanceId, req.body);
+    res.json(execution);
+  } catch (err) {
+    res.status(400).json({ error: err.message });
+  }
+});
+
+/**
+ * Complete execution
+ */
+router.post('/hosted/executions/:executionId/complete', (req, res) => {
+  const execution = hostedRuntime.completeExecution(
+    req.params.executionId,
+    req.body.result,
+    req.body.error ? new Error(req.body.error) : null
+  );
+  if (!execution) return res.status(404).json({ error: 'Execution not found' });
+  res.json(execution);
+});
+
+/**
+ * Stop hosted instance
+ */
+router.post('/hosted/:instanceId/stop', (req, res) => {
+  const success = hostedRuntime.stop(req.params.instanceId);
+  res.json({ success });
+});
+
+/**
+ * Get hosted instance
+ */
+router.get('/hosted/:instanceId', (req, res) => {
+  const instance = hostedRuntime.getInstance(req.params.instanceId);
+  if (!instance) return res.status(404).json({ error: 'Instance not found' });
+  res.json(instance);
+});
+
+/**
+ * List instances
+ */
+router.get('/hosted', (req, res) => {
+  const instances = hostedRuntime.listInstances({
+    agentId: req.query.agentId,
+    status: req.query.status,
+    region: req.query.region,
+  }, parseInt(req.query.limit) || 50);
+  res.json({ instances, total: instances.length });
+});
+
+/**
+ * List executions for instance
+ */
+router.get('/hosted/:instanceId/executions', (req, res) => {
+  const executions = hostedRuntime.listExecutions(
+    req.params.instanceId,
+    parseInt(req.query.limit) || 50
+  );
+  res.json({ executions, total: executions.length });
+});
+
+/**
+ * Get compute usage
+ */
+router.get('/hosted/usage/:agentId', (req, res) => {
+  res.json(hostedRuntime.getComputeUsage(req.params.agentId));
+});
+
+/**
+ * Hosted runtime stats
+ */
+router.get('/hosted/stats', (req, res) => {
+  res.json(hostedRuntime.getStats());
+});
+
 module.exports = router;

package/server/services/hosted-runtime.js

@@ -0,0 +1,205 @@
+'use strict';
+
+/**
+ * Hosted Runtime Service
+ *
+ * Cloud execution abstraction for running agents without local infrastructure.
+ * Pay-as-you-go model with auto-scaling, resource tracking, and multi-region support.
+ */
+
+const crypto = require('crypto');
+const { bus } = require('../runtime/event-bus');
+const metering = require('./metering');
+
+class HostedRuntime {
+  constructor() {
+    this._instances = new Map();    // instanceId → RuntimeInstance
+    this._executions = new Map();   // executionId → Execution
+    this._maxInstances = 1000;
+  }
+
+  /**
+   * Launch a hosted runtime instance for an agent
+   */
+  launch(config) {
+    if (!config.agentId) throw new Error('agentId required');
+
+    const instanceId = `hrt_${crypto.randomBytes(8).toString('hex')}`;
+    const instance = {
+      id: instanceId,
+      agentId: config.agentId,
+      tier: config.tier || 'starter',
+      region: config.region || 'auto',
+      resources: {
+        cpu: config.cpu || '0.5',        // vCPU
+        memory: config.memory || '512',  // MB
+        timeout: config.timeout || 300000, // 5 min default
+      },
+      status: 'starting',
+      startedAt: Date.now(),
+      lastActivity: Date.now(),
+      executionCount: 0,
+      computeMinutes: 0,
+      errors: 0,
+    };
+
+    this._instances.set(instanceId, instance);
+
+    // Simulate startup (in real deployment, this would provision container/lambda)
+    instance.status = 'running';
+    bus.emit('hosted.launched', { instanceId, agentId: config.agentId, region: instance.region });
+
+    return instance;
+  }
+
+  /**
+   * Execute a task on a hosted instance
+   */
+  async execute(instanceId, task) {
+    const instance = this._instances.get(instanceId);
+    if (!instance) throw new Error('Instance not found');
+    if (instance.status !== 'running') throw new Error(`Instance not running (status: ${instance.status})`);
+
+    const executionId = `hexe_${crypto.randomBytes(8).toString('hex')}`;
+    const execution = {
+      id: executionId,
+      instanceId,
+      agentId: instance.agentId,
+      task: {
+        type: task.type,
+        action: task.action,
+        params: task.params || {},
+      },
+      status: 'running',
+      startedAt: Date.now(),
+      completedAt: null,
+      result: null,
+      error: null,
+      computeMs: 0,
+      resources: {
+        cpuUsage: 0,
+        memoryUsage: 0,
+        networkCalls: 0,
+      },
+    };
+
+    this._executions.set(executionId, execution);
+    instance.executionCount++;
+    instance.lastActivity = Date.now();
+
+    // Record metering
+    metering.record(instance.agentId, 'executionsPerDay', instance.tier, 1);
+
+    bus.emit('hosted.execution.started', { executionId, instanceId, type: task.type });
+
+    // Return execution handle (actual execution is async in real deployment)
+    return execution;
+  }
+
+  /**
+   * Complete an execution (called by worker after task finishes)
+   */
+  completeExecution(executionId, result, error = null) {
+    const execution = this._executions.get(executionId);
+    if (!execution) return null;
+
+    execution.status = error ? 'failed' : 'completed';
+    execution.completedAt = Date.now();
+    execution.result = result;
+    execution.error = error ? { message: error.message || String(error) } : null;
+    execution.computeMs = execution.completedAt - execution.startedAt;
+
+    // Update instance stats
+    const instance = this._instances.get(execution.instanceId);
+    if (instance) {
+      const minutes = execution.computeMs / 60000;
+      instance.computeMinutes += minutes;
+      metering.record(instance.agentId, 'computeMinutesPerDay', instance.tier, minutes);
+      if (error) instance.errors++;
+    }
+
+    bus.emit('hosted.execution.completed', {
+      executionId, instanceId: execution.instanceId,
+      status: execution.status, computeMs: execution.computeMs,
+    });
+
+    return execution;
+  }
+
+  /**
+   * Stop a hosted instance
+   */
+  stop(instanceId) {
+    const instance = this._instances.get(instanceId);
+    if (!instance) return false;
+    instance.status = 'stopped';
+    instance.stoppedAt = Date.now();
+    bus.emit('hosted.stopped', { instanceId, agentId: instance.agentId });
+    return true;
+  }
+
+  /**
+   * Get instance
+   */
+  getInstance(instanceId) {
+    return this._instances.get(instanceId) || null;
+  }
+
+  /**
+   * List instances
+   */
+  listInstances(filters = {}, limit = 50) {
+    let instances = Array.from(this._instances.values());
+    if (filters.agentId) instances = instances.filter(i => i.agentId === filters.agentId);
+    if (filters.status) instances = instances.filter(i => i.status === filters.status);
+    if (filters.region) instances = instances.filter(i => i.region === filters.region);
+    return instances.slice(0, limit);
+  }
+
+  /**
+   * Get execution
+   */
+  getExecution(executionId) {
+    return this._executions.get(executionId) || null;
+  }
+
+  /**
+   * List executions for an instance
+   */
+  listExecutions(instanceId, limit = 50) {
+    return Array.from(this._executions.values())
+      .filter(e => e.instanceId === instanceId)
+      .sort((a, b) => b.startedAt - a.startedAt)
+      .slice(0, limit);
+  }
+
+  /**
+   * Get compute usage for an agent
+   */
+  getComputeUsage(agentId) {
+    const instances = Array.from(this._instances.values())
+      .filter(i => i.agentId === agentId);
+
+    return {
+      activeInstances: instances.filter(i => i.status === 'running').length,
+      totalExecutions: instances.reduce((sum, i) => sum + i.executionCount, 0),
+      totalComputeMinutes: Math.round(instances.reduce((sum, i) => sum + i.computeMinutes, 0) * 100) / 100,
+      totalErrors: instances.reduce((sum, i) => sum + i.errors, 0),
+    };
+  }
+
+  getStats() {
+    const instances = Array.from(this._instances.values());
+    return {
+      totalInstances: instances.length,
+      running: instances.filter(i => i.status === 'running').length,
+      stopped: instances.filter(i => i.status === 'stopped').length,
+      totalExecutions: this._executions.size,
+      totalComputeMinutes: Math.round(instances.reduce((sum, i) => sum + i.computeMinutes, 0) * 100) / 100,
+    };
+  }
+}
+
+const hostedRuntime = new HostedRuntime();
+
+module.exports = { HostedRuntime, hostedRuntime };