web-agent-bridge 2.5.0 → 2.7.0

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 };

package/server/services/marketplace.js

@@ -0,0 +1,270 @@
+'use strict';
+
+/**
+ * Marketplace Engine
+ *
+ * Tools & integrations marketplace with publishing, discovery, purchasing,
+ * and revenue sharing (15% platform commission).
+ */
+
+const crypto = require('crypto');
+const { bus } = require('../runtime/event-bus');
+const { MARKETPLACE } = require('../config/plans');
+
+class MarketplaceEngine {
+  constructor() {
+    this._listings = new Map();    // listingId → Listing
+    this._purchases = new Map();   // purchaseId → Purchase
+    this._reviews = new Map();     // listingId → Review[]
+    this._earnings = new Map();    // sellerId → EarningsRecord
+  }
+
+  /**
+   * Publish a listing to the marketplace
+   */
+  publish(listing) {
+    if (!listing.name || !listing.type || !listing.sellerId) {
+      throw new Error('name, type, and sellerId are required');
+    }
+    if (!MARKETPLACE.categories.includes(listing.category || 'automation')) {
+      throw new Error(`Invalid category. Must be one of: ${MARKETPLACE.categories.join(', ')}`);
+    }
+    if (listing.price !== undefined && listing.price !== 0) {
+      if (listing.price < MARKETPLACE.minPrice || listing.price > MARKETPLACE.maxPrice) {
+        throw new Error(`Price must be between $${MARKETPLACE.minPrice} and $${MARKETPLACE.maxPrice}`);
+      }
+    }
+
+    const id = `mkt_${crypto.randomBytes(8).toString('hex')}`;
+    const entry = {
+      id,
+      name: listing.name,
+      description: listing.description || '',
+      type: listing.type,         // 'tool', 'template', 'adapter', 'plugin', 'integration'
+      category: listing.category || 'automation',
+      sellerId: listing.sellerId,
+      sellerName: listing.sellerName || 'Anonymous',
+      price: listing.price || 0,  // 0 = free
+      currency: 'usd',
+      version: listing.version || '1.0.0',
+      tags: listing.tags || [],
+      icon: listing.icon || null,
+      readme: listing.readme || '',
+      installCommand: listing.installCommand || null,
+      configSchema: listing.configSchema || null,
+      entryPoint: listing.entryPoint || null,
+
+      // Stats
+      installs: 0,
+      revenue: 0,
+      rating: 0,
+      reviewCount: 0,
+
+      // Status
+      status: 'pending_review',   // pending_review → approved → published | rejected
+      publishedAt: null,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    };
+
+    this._listings.set(id, entry);
+    this._reviews.set(id, []);
+    bus.emit('marketplace.listed', { id, name: entry.name, type: entry.type, price: entry.price });
+    return entry;
+  }
+
+  /**
+   * Approve a listing (admin action)
+   */
+  approve(listingId) {
+    const listing = this._listings.get(listingId);
+    if (!listing) throw new Error('Listing not found');
+    listing.status = 'published';
+    listing.publishedAt = Date.now();
+    listing.updatedAt = Date.now();
+    bus.emit('marketplace.approved', { id: listingId, name: listing.name });
+    return listing;
+  }
+
+  /**
+   * Reject a listing (admin action)
+   */
+  reject(listingId, reason) {
+    const listing = this._listings.get(listingId);
+    if (!listing) throw new Error('Listing not found');
+    listing.status = 'rejected';
+    listing.rejectionReason = reason;
+    listing.updatedAt = Date.now();
+    return listing;
+  }
+
+  /**
+   * Purchase/install a listing
+   */
+  purchase(listingId, buyerId) {
+    const listing = this._listings.get(listingId);
+    if (!listing) throw new Error('Listing not found');
+    if (listing.status !== 'published') throw new Error('Listing not available');
+
+    const purchaseId = `pur_${crypto.randomBytes(8).toString('hex')}`;
+    const commission = listing.price * MARKETPLACE.commission;
+    const sellerEarning = listing.price - commission;
+
+    const purchase = {
+      id: purchaseId,
+      listingId,
+      listingName: listing.name,
+      buyerId,
+      sellerId: listing.sellerId,
+      price: listing.price,
+      commission,
+      sellerEarning,
+      currency: 'usd',
+      status: listing.price === 0 ? 'completed' : 'pending_payment',
+      createdAt: Date.now(),
+    };
+
+    this._purchases.set(purchaseId, purchase);
+    listing.installs++;
+
+    // Track earnings
+    if (sellerEarning > 0) {
+      const earnings = this._earnings.get(listing.sellerId) || { total: 0, pending: 0, paid: 0 };
+      earnings.total += sellerEarning;
+      earnings.pending += sellerEarning;
+      this._earnings.set(listing.sellerId, earnings);
+    }
+
+    listing.revenue += listing.price;
+    bus.emit('marketplace.purchased', { purchaseId, listingId, buyerId, price: listing.price });
+    return purchase;
+  }
+
+  /**
+   * Complete payment for a purchase
+   */
+  completePayment(purchaseId) {
+    const purchase = this._purchases.get(purchaseId);
+    if (!purchase) throw new Error('Purchase not found');
+    purchase.status = 'completed';
+    purchase.completedAt = Date.now();
+    return purchase;
+  }
+
+  /**
+   * Add a review
+   */
+  addReview(listingId, review) {
+    const listing = this._listings.get(listingId);
+    if (!listing) throw new Error('Listing not found');
+
+    const reviews = this._reviews.get(listingId) || [];
+    const entry = {
+      id: `rev_${crypto.randomBytes(6).toString('hex')}`,
+      userId: review.userId,
+      rating: Math.max(1, Math.min(5, review.rating)),
+      comment: review.comment || '',
+      createdAt: Date.now(),
+    };
+    reviews.push(entry);
+    this._reviews.set(listingId, reviews);
+
+    // Update average rating
+    listing.reviewCount = reviews.length;
+    listing.rating = reviews.reduce((sum, r) => sum + r.rating, 0) / reviews.length;
+    listing.rating = Math.round(listing.rating * 10) / 10;
+
+    return entry;
+  }
+
+  /**
+   * Search listings
+   */
+  search(filters = {}, limit = 50) {
+    let results = Array.from(this._listings.values())
+      .filter(l => l.status === 'published');
+
+    if (filters.type) results = results.filter(l => l.type === filters.type);
+    if (filters.category) results = results.filter(l => l.category === filters.category);
+    if (filters.sellerId) results = results.filter(l => l.sellerId === filters.sellerId);
+    if (filters.free) results = results.filter(l => l.price === 0);
+    if (filters.paid) results = results.filter(l => l.price > 0);
+    if (filters.minRating) results = results.filter(l => l.rating >= filters.minRating);
+    if (filters.tag) results = results.filter(l => l.tags.includes(filters.tag));
+    if (filters.query) {
+      const q = filters.query.toLowerCase();
+      results = results.filter(l =>
+        l.name.toLowerCase().includes(q) ||
+        l.description.toLowerCase().includes(q) ||
+        l.tags.some(t => t.toLowerCase().includes(q))
+      );
+    }
+
+    // Sort
+    const sortBy = filters.sortBy || 'installs';
+    results.sort((a, b) => {
+      if (sortBy === 'rating') return b.rating - a.rating;
+      if (sortBy === 'newest') return b.createdAt - a.createdAt;
+      if (sortBy === 'price') return a.price - b.price;
+      return b.installs - a.installs; // default: popular
+    });
+
+    return results.slice(0, limit);
+  }
+
+  /**
+   * Get listing by ID
+   */
+  getListing(id) {
+    return this._listings.get(id) || null;
+  }
+
+  /**
+   * Get reviews for a listing
+   */
+  getReviews(listingId) {
+    return this._reviews.get(listingId) || [];
+  }
+
+  /**
+   * Get seller earnings
+   */
+  getEarnings(sellerId) {
+    return this._earnings.get(sellerId) || { total: 0, pending: 0, paid: 0 };
+  }
+
+  /**
+   * Get purchases for a buyer
+   */
+  getPurchases(buyerId) {
+    return Array.from(this._purchases.values())
+      .filter(p => p.buyerId === buyerId)
+      .sort((a, b) => b.createdAt - a.createdAt);
+  }
+
+  /**
+   * Admin: list pending listings
+   */
+  getPendingListings() {
+    return Array.from(this._listings.values())
+      .filter(l => l.status === 'pending_review')
+      .sort((a, b) => a.createdAt - b.createdAt);
+  }
+
+  getStats() {
+    const listings = Array.from(this._listings.values());
+    return {
+      totalListings: listings.length,
+      published: listings.filter(l => l.status === 'published').length,
+      pending: listings.filter(l => l.status === 'pending_review').length,
+      totalPurchases: this._purchases.size,
+      totalRevenue: listings.reduce((sum, l) => sum + l.revenue, 0),
+      categories: MARKETPLACE.categories,
+      commission: MARKETPLACE.commission,
+    };
+  }
+}
+
+const marketplace = new MarketplaceEngine();
+
+module.exports = { MarketplaceEngine, marketplace };

package/server/services/metering.js

@@ -0,0 +1,182 @@
+'use strict';
+
+/**
+ * Usage Metering Service
+ *
+ * Tracks executions, agents, compute time, API calls, and storage per agent/site.
+ * Enforces plan limits and records overages for billing.
+ */
+
+const db = require('../models/db').db || require('../models/db');
+const { getLimit, isUnlimited, USAGE_PRICING } = require('../config/plans');
+const { bus } = require('../runtime/event-bus');
+
+// ─── Storage ────────────────────────────────────────────────────────
+
+// In-memory counters with periodic flush to DB
+const _counters = new Map(); // key → { count, lastReset }
+
+function _key(entityId, metric) {
+  return `${entityId}:${metric}`;
+}
+
+function _today() {
+  return new Date().toISOString().slice(0, 10); // YYYY-MM-DD
+}
+
+function _getCounter(entityId, metric) {
+  const key = _key(entityId, metric);
+  const entry = _counters.get(key);
+  const today = _today();
+
+  // Reset daily counters
+  if (!entry || entry.lastReset !== today) {
+    _counters.set(key, { count: 0, lastReset: today, overage: 0 });
+    return _counters.get(key);
+  }
+  return entry;
+}
+
+// ─── Public API ─────────────────────────────────────────────────────
+
+/**
+ * Record a usage event and check limits
+ * @returns {{ allowed: boolean, current: number, limit: number, overage: boolean }}
+ */
+function record(entityId, metric, tier, amount = 1) {
+  const counter = _getCounter(entityId, metric);
+  const limit = getLimit(tier, metric);
+
+  counter.count += amount;
+
+  // Unlimited
+  if (isUnlimited(tier, metric)) {
+    bus.emit('metering.recorded', { entityId, metric, amount, current: counter.count });
+    return { allowed: true, current: counter.count, limit: -1, overage: false };
+  }
+
+  const isOver = counter.count > limit;
+  if (isOver) {
+    counter.overage += amount;
+    bus.emit('metering.overage', { entityId, metric, current: counter.count, limit, overage: counter.overage });
+  } else {
+    bus.emit('metering.recorded', { entityId, metric, amount, current: counter.count });
+  }
+
+  return {
+    allowed: !isOver,
+    current: counter.count,
+    limit,
+    overage: isOver,
+    overageAmount: isOver ? counter.overage : 0,
+    overageCost: isOver ? counter.overage * (USAGE_PRICING[metric]?.price || 0) : 0,
+  };
+}
+
+/**
+ * Check if a usage would exceed the limit (without recording)
+ */
+function check(entityId, metric, tier, amount = 1) {
+  const counter = _getCounter(entityId, metric);
+  const limit = getLimit(tier, metric);
+
+  if (isUnlimited(tier, metric)) {
+    return { allowed: true, current: counter.count, limit: -1, remaining: Infinity };
+  }
+
+  const remaining = Math.max(0, limit - counter.count);
+  return {
+    allowed: counter.count + amount <= limit,
+    current: counter.count,
+    limit,
+    remaining,
+  };
+}
+
+/**
+ * Get current usage for an entity
+ */
+function getUsage(entityId, tier) {
+  const metrics = [
+    'agents', 'tasksPerDay', 'executionsPerDay', 'sessions',
+    'computeMinutesPerDay', 'apiCallsPerMinute',
+  ];
+
+  const usage = {};
+  for (const metric of metrics) {
+    const counter = _getCounter(entityId, metric);
+    const limit = getLimit(tier, metric);
+    usage[metric] = {
+      current: counter.count,
+      limit: isUnlimited(tier, metric) ? -1 : limit,
+      percentage: isUnlimited(tier, metric) ? 0 : (limit > 0 ? Math.round((counter.count / limit) * 100) : 0),
+      overage: counter.overage || 0,
+    };
+  }
+
+  return usage;
+}
+
+/**
+ * Get usage summary for billing
+ */
+function getBillingSummary(entityId) {
+  const overages = {};
+  let totalCost = 0;
+
+  for (const [key, counter] of _counters) {
+    if (!key.startsWith(entityId + ':')) continue;
+    if (counter.overage > 0) {
+      const metric = key.split(':')[1];
+      const pricing = USAGE_PRICING[metric];
+      const cost = pricing ? counter.overage * pricing.price : 0;
+      overages[metric] = {
+        overage: counter.overage,
+        unitPrice: pricing?.price || 0,
+        cost,
+      };
+      totalCost += cost;
+    }
+  }
+
+  return { entityId, overages, totalCost, period: _today() };
+}
+
+/**
+ * Reset counters (for testing or admin)
+ */
+function reset(entityId, metric = null) {
+  if (metric) {
+    _counters.delete(_key(entityId, metric));
+  } else {
+    for (const key of _counters.keys()) {
+      if (key.startsWith(entityId + ':')) _counters.delete(key);
+    }
+  }
+}
+
+/**
+ * Get global stats
+ */
+function getStats() {
+  let totalEntities = new Set();
+  let totalEvents = 0;
+  for (const [key, counter] of _counters) {
+    totalEntities.add(key.split(':')[0]);
+    totalEvents += counter.count;
+  }
+  return {
+    trackedEntities: totalEntities.size,
+    totalEvents,
+    counterEntries: _counters.size,
+  };
+}
+
+module.exports = {
+  record,
+  check,
+  getUsage,
+  getBillingSummary,
+  reset,
+  getStats,
+};