web-agent-bridge 2.1.0 → 2.2.0

package/README.ar.md

@@ -41,6 +41,7 @@
 - **لوحة السيادة** — مركز قيادة لحظي يعرض رادار العدالة، درع الخصوصية، سجل التفاوض، فحوصات التحقق، ومبدّل نماذج الذكاء الاصطناعي
 - **متجر قوالب الوكلاء** — ١١ قالب YAML جاهز (حجز فنادق، مقارنة بقالة، سوق حرفيين، صفقات طيران، إلخ) مع تشغيل من سطر الأوامر: `npx wab-agent run template.yaml`
 - **تبديل عقل الوكيل** — بدّل بين Llama 3، GPT-4، Claude، Gemini، Mistral، أو Ollama (محلي) بدون إعادة إعداد
+- **تنسيق الوكيل عبر المواقع** — وكيل واحد يدير عدة مواقع WAB في نفس الوقت عبر `WABMultiAgent`. قارن الأسعار بين المتاجر، اجمع البيانات، نفّذ إجراءات متوازية، واعثر على أفضل صفقة تلقائياً
 
 ---
 

package/README.md

@@ -65,6 +65,7 @@ WAB is an open-source middleware layer that bridges AI agents and websites — l
 - **Sovereign Dashboard** — Real-time command center with fairness radar, privacy shield, negotiation logs, verification checks, and AI model switcher
 - **Community Agent Hub** — 11 pre-built YAML agent templates (hotel booking, grocery comparison, artisan marketplace, flight deals, etc.) with CLI runner: `npx wab-agent run template.yaml`
 - **AI Brain Swapping** — Switch between Llama 3, GPT-4, Claude, Gemini, Mistral, or Ollama (local) without reconfiguration
+- **Cross-Site Agent Orchestration** — One agent manages multiple WAB-enabled sites simultaneously via `WABMultiAgent`. Compare prices across stores, aggregate data, run parallel actions, and find the best deal automatically
 
 ---
 

package/examples/cross-site-agent.js

@@ -0,0 +1,91 @@
+/**
+ * Example: Cross-Site Agent Orchestration
+ *
+ * One agent manages multiple WAB-enabled sites simultaneously.
+ * Compares prices, aggregates product data, and finds the best deal.
+ *
+ * Prerequisites:
+ *   npm install puppeteer web-agent-bridge-sdk
+ *
+ * Usage:
+ *   node examples/cross-site-agent.js site1.com site2.com site3.com
+ */
+
+const { WABMultiAgent } = require('../sdk');
+
+const sites = process.argv.slice(2);
+if (sites.length < 2) {
+  console.log('Usage: node cross-site-agent.js <url1> <url2> [url3 ...]');
+  console.log('Example: node cross-site-agent.js https://shop1.com https://shop2.com');
+  process.exit(1);
+}
+
+// Ensure URLs have protocol
+const urls = sites.map((s) => (s.startsWith('http') ? s : `https://${s}`));
+
+async function main() {
+  console.log('\n🌐 WAB Cross-Site Agent Orchestration');
+  console.log(`   Sites: ${urls.length}\n`);
+
+  // 1. Create multi-agent and connect to all sites
+  const multiAgent = new WABMultiAgent(urls, {
+    timeout: 20000,
+    headless: true
+  });
+
+  console.log('⏳ Launching browsers and connecting...');
+  const { connected, failed } = await multiAgent.launch();
+
+  for (const site of connected) console.log(`  ✓ Connected: ${site}`);
+  for (const site of failed) console.log(`  ✗ Failed: ${site}`);
+
+  if (connected.length === 0) {
+    console.log('\n✗ No sites connected. Exiting.');
+    await multiAgent.close();
+    return;
+  }
+
+  // 2. Discover all sites
+  console.log('\n📡 Discovering WAB capabilities...');
+  const discoveries = await multiAgent.discoverAll();
+  for (const d of discoveries) {
+    console.log(`  ${d.site}: ${d.actions.length} actions`);
+  }
+
+  // 3. Compare prices for a product
+  console.log('\n💰 Comparing prices...');
+  const comparison = await multiAgent.comparePrices('product-sku');
+  for (const r of comparison.results) {
+    if (r.price != null) {
+      console.log(`  ${r.site}: ${r.currency} ${r.price.toFixed(2)} — ${r.product}`);
+    } else {
+      console.log(`  ${r.site}: ${r.error || 'No price data'}`);
+    }
+  }
+
+  if (comparison.cheapest) {
+    console.log(`\n🏆 Best deal: ${comparison.cheapest.site}`);
+    console.log(`   Price: ${comparison.cheapest.currency} ${comparison.cheapest.price.toFixed(2)}`);
+    if (comparison.savings != null) {
+      console.log(`   You save: ${comparison.cheapest.currency} ${comparison.savings.toFixed(2)}`);
+    }
+  }
+
+  // 4. Execute a common action across all sites
+  console.log('\n🔄 Executing getPageInfo on all sites...');
+  const infos = await multiAgent.executeAll('getPageInfo');
+  for (const info of infos) {
+    if (info.status === 'fulfilled' && info.value) {
+      console.log(`  ${info.site}: "${info.value.title}" (v${info.value.bridgeVersion})`);
+    }
+  }
+
+  // 5. Cleanup
+  await multiAgent.close();
+  console.log('\n✓ All sessions closed. Done!\n');
+}
+
+main().catch((err) => {
+  console.error('Error:', err.message);
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "web-agent-bridge",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Open-source middleware that bridges AI agents and websites — providing a standardized command interface for intelligent automation",
   "main": "server/index.js",
   "bin": {

package/public/index.html

@@ -212,7 +212,18 @@
             <li>Supports negotiation + verification</li>
           </ul>
         </div>
-        <div class="card fade-in fade-in-delay-2" style="border-left: 3px solid #06b6d4;">
+        <div class="card fade-in fade-in-delay-2" style="border-left: 3px solid #0ea5e9;">
+          <div class="card-icon cyan">🌐</div>
+          <h3>Cross-Site Agent Orchestration</h3>
+          <p>One agent manages multiple WAB-enabled sites simultaneously. Compare prices across stores, aggregate product data, run parallel actions — all from a single <code>WABMultiAgent</code> instance in the SDK.</p>
+          <ul style="margin-top:12px;font-size:0.85rem;color:var(--text-secondary);list-style:disc;padding-left:20px;">
+            <li>Parallel multi-site browser sessions</li>
+            <li>comparePrices() with cheapest-deal finder</li>
+            <li>Schema.org + WAB action price extraction</li>
+            <li>Cross-site screenshots for vision verification</li>
+          </ul>
+        </div>
+        <div class="card fade-in" style="border-left: 3px solid #06b6d4;">
           <div class="card-icon cyan">🔄</div>
           <h3>AI Brain Swapping</h3>
           <p>WAB is the bridge — the AI model is your choice. Switch between Llama 3, GPT-4, Claude, Gemini, Mistral, or run fully local with Ollama. Your data, your model, your sovereignty.</p>

package/public/script/wab.min.js

@@ -26,7 +26,7 @@
 (function(global) {
   'use strict';
 
-  var VERSION = '2.0.0';
+  var VERSION = '2.2.0';
 
   // ── WAB Instance ──────────────────────────────────────────────────
   function WABInstance(config) {

package/public/sovereign.html

@@ -445,7 +445,7 @@
   </div>
 
   <footer class="footer">
-    Web Agent Bridge v2.0.0 &mdash; Digital Fortress for Internet Sovereignty<br>
+    Web Agent Bridge v2.2.0 &mdash; Digital Fortress for Internet Sovereignty<br>
     <span style="color:var(--accent-blue);">Digital fairness starts here</span>
   </footer>
 

package/script/ai-agent-bridge.js

@@ -7,7 +7,7 @@
 (function (global) {
   'use strict';
 
-  const VERSION = '2.0.0';
+  const VERSION = '2.2.0';
   const LICENSING_SERVER = 'https://api.webagentbridge.com';
 
   // ─── Default Configuration ────────────────────────────────────────────

package/sdk/README.md

@@ -52,4 +52,48 @@ await agent.execute('click-login');
 | `authenticate(apiKey, meta?)` | Authenticate the agent |
 | `navigateAndWait(url)` | Navigate and wait for bridge |
 | `executeSteps(steps)` | Execute multiple actions in sequence |
+| `executeParallel(actions)` | Execute multiple actions in parallel |
 | `getBiDiContext()` | Get BiDi context (BiDi mode only) |
+
+## Cross-Site Agent Orchestration
+
+Manage multiple WAB-enabled sites simultaneously with `WABMultiAgent`:
+
+```javascript
+const { WABMultiAgent } = require('web-agent-bridge-sdk');
+
+const multiAgent = new WABMultiAgent([
+  'https://site1.com',
+  'https://site2.com',
+  'https://site3.com'
+]);
+
+await multiAgent.launch();
+
+// Compare prices across all sites
+const comparison = await multiAgent.comparePrices('product-sku');
+console.log(comparison.cheapest);  // { site, price, currency }
+console.log(`You save: $${comparison.savings}`);
+
+// Execute any action on all sites in parallel
+const infos = await multiAgent.executeAll('getPageInfo');
+
+// Discover capabilities across all sites
+const discoveries = await multiAgent.discoverAll();
+
+await multiAgent.close();
+```
+
+### WABMultiAgent API
+
+| Method | Description |
+|---|---|
+| `launch()` | Connect to all sites |
+| `discoverAll()` | Discover actions on all sites |
+| `executeAll(action, params?)` | Run action on all sites in parallel |
+| `comparePrices(sku)` | Compare prices and find cheapest deal |
+| `compareAction(action, params?, rankFn?)` | Compare action results with custom ranking |
+| `navigateAll(path)` | Navigate all sessions to a path |
+| `screenshotAll(opts?)` | Screenshot all sites |
+| `status()` | Get connection summary |
+| `close()` | Close all browser sessions |

package/sdk/index.d.ts

@@ -116,3 +116,96 @@ export declare class WABAgent {
   /** Take a screenshot and return as base64. */
   screenshot(opts?: { fullPage?: boolean }): Promise<string>;
 }
+
+// ─── WABMultiAgent — Cross-Site Agent Orchestration ────────────────────
+
+export interface WABMultiAgentOptions {
+  /** Per-site timeout in ms (default 15000). */
+  timeout?: number;
+  /** Launch headless browsers (default true). */
+  headless?: boolean;
+  /** Puppeteer launch options. */
+  launchOptions?: Record<string, unknown>;
+  /** Use BiDi protocol. */
+  useBiDi?: boolean;
+}
+
+export interface MultiAgentLaunchResult {
+  connected: string[];
+  failed: string[];
+}
+
+export interface MultiAgentSiteResult {
+  site: string;
+  status: 'fulfilled' | 'rejected';
+  value?: any;
+  error?: string;
+}
+
+export interface MultiAgentDiscovery {
+  site: string;
+  actions: WABActionDescriptor[];
+  meta: Record<string, unknown>;
+  error?: string;
+}
+
+export interface PriceResult {
+  site: string;
+  product?: string;
+  price?: number;
+  currency?: string;
+  error?: string;
+}
+
+export interface PriceComparison {
+  results: PriceResult[];
+  cheapest: PriceResult | null;
+  savings: number | null;
+}
+
+export interface MultiAgentNavigateResult {
+  site: string;
+  ok: boolean;
+  error?: string;
+}
+
+export interface MultiAgentScreenshotResult {
+  site: string;
+  screenshot?: string;
+  error?: string;
+}
+
+export declare class WABMultiAgent {
+  constructor(sites: string[], options?: WABMultiAgentOptions);
+
+  /** Launch browsers and connect to all sites. */
+  launch(): Promise<MultiAgentLaunchResult>;
+
+  /** Discover all sites — return actions and metadata per site. */
+  discoverAll(): Promise<MultiAgentDiscovery[]>;
+
+  /** Execute an action on all connected sites in parallel. */
+  executeAll(actionName: string, params?: Record<string, unknown>): Promise<MultiAgentSiteResult[]>;
+
+  /** Compare prices for a product across all sites. */
+  comparePrices(sku: string): Promise<PriceComparison>;
+
+  /** Compare a specific action result across all sites with optional ranking. */
+  compareAction(
+    actionName: string,
+    params?: Record<string, unknown>,
+    rankFn?: (results: MultiAgentSiteResult[]) => MultiAgentSiteResult[]
+  ): Promise<{ results: MultiAgentSiteResult[]; ranked: MultiAgentSiteResult[] }>;
+
+  /** Navigate all sessions to a new path. */
+  navigateAll(path: string): Promise<MultiAgentNavigateResult[]>;
+
+  /** Take screenshots from all sites. */
+  screenshotAll(opts?: { fullPage?: boolean }): Promise<MultiAgentScreenshotResult[]>;
+
+  /** Get a summary of all sessions. */
+  status(): { total: number; connected: string[] };
+
+  /** Close all browser sessions. */
+  close(): Promise<void>;
+}

package/sdk/index.js

@@ -254,4 +254,6 @@ class WABAgent {
   }
 }
 
-module.exports = { WABAgent };
+const { WABMultiAgent } = require('./multi-agent');
+
+module.exports = { WABAgent, WABMultiAgent };

package/sdk/multi-agent.js

@@ -0,0 +1,318 @@
+/**
+ * WABMultiAgent — Cross-Site Agent Orchestration
+ *
+ * Manages multiple WAB sessions across different domains simultaneously.
+ * One agent, many sites — compare prices, aggregate data, run parallel actions.
+ *
+ * @example
+ *   const { WABMultiAgent } = require('web-agent-bridge-sdk/multi-agent');
+ *   const multi = new WABMultiAgent([
+ *     'https://site1.com',
+ *     'https://site2.com',
+ *     'https://site3.com'
+ *   ]);
+ *   await multi.launch();
+ *   const comparison = await multi.comparePrices('laptop-sku-123');
+ *   console.log(comparison.cheapest);  // { site, price, currency }
+ *   await multi.close();
+ */
+
+const { WABAgent } = require('./index');
+
+class WABMultiAgent {
+  /**
+   * @param {string[]} sites — Array of URLs
+   * @param {object} [options]
+   * @param {number} [options.timeout=15000] — Per-site timeout
+   * @param {boolean} [options.headless=true] — Launch headless browsers
+   * @param {object} [options.launchOptions] — Puppeteer launch options
+   * @param {boolean} [options.useBiDi=false] — Use BiDi protocol
+   */
+  constructor(sites, options = {}) {
+    if (!Array.isArray(sites) || sites.length === 0) {
+      throw new Error('WABMultiAgent requires at least one site URL');
+    }
+    this.sites = sites;
+    this.timeout = options.timeout || 15000;
+    this.headless = options.headless !== false;
+    this.launchOptions = options.launchOptions || {};
+    this.useBiDi = options.useBiDi || false;
+    this._sessions = []; // { url, browser, page, agent }
+    this._launched = false;
+  }
+
+  /**
+   * Launch browsers and connect to all sites.
+   * Creates a separate browser context per site for isolation.
+   * @returns {Promise<{ connected: string[], failed: string[] }>}
+   */
+  async launch() {
+    let puppeteer;
+    try {
+      puppeteer = require('puppeteer');
+    } catch {
+      throw new Error('puppeteer is required: npm install puppeteer');
+    }
+
+    const connected = [];
+    const failed = [];
+
+    const results = await Promise.allSettled(
+      this.sites.map(async (url) => {
+        const browser = await puppeteer.launch({
+          headless: this.headless ? 'new' : false,
+          ...this.launchOptions
+        });
+        const page = await browser.newPage();
+        await page.goto(url, { waitUntil: 'networkidle2', timeout: this.timeout });
+
+        const agent = new WABAgent(page, {
+          timeout: this.timeout,
+          useBiDi: this.useBiDi
+        });
+
+        const hasBridge = await agent.hasBridge();
+        if (!hasBridge) {
+          await browser.close();
+          throw new Error(`No WAB bridge found on ${url}`);
+        }
+
+        return { url, browser, page, agent };
+      })
+    );
+
+    for (const r of results) {
+      if (r.status === 'fulfilled') {
+        this._sessions.push(r.value);
+        connected.push(r.value.url);
+      } else {
+        const urlMatch = r.reason.message.match(/on (.+)$/);
+        failed.push(urlMatch ? urlMatch[1] : r.reason.message);
+      }
+    }
+
+    this._launched = true;
+    return { connected, failed };
+  }
+
+  /**
+   * Discover all sites — return actions and metadata per site.
+   * @returns {Promise<Array<{ site: string, actions: Array, meta: object, error?: string }>>}
+   */
+  async discoverAll() {
+    this._ensureLaunched();
+    return Promise.all(
+      this._sessions.map(async (s) => {
+        try {
+          const discovery = await s.agent.discover();
+          return { site: s.url, actions: discovery.actions || [], meta: discovery.meta || {} };
+        } catch (err) {
+          return { site: s.url, actions: [], meta: {}, error: err.message };
+        }
+      })
+    );
+  }
+
+  /**
+   * Execute an action on all connected sites in parallel.
+   * @param {string} actionName
+   * @param {object} [params]
+   * @returns {Promise<Array<{ site: string, status: string, value?: any, error?: string }>>}
+   */
+  async executeAll(actionName, params) {
+    this._ensureLaunched();
+    return Promise.all(
+      this._sessions.map(async (s) => {
+        try {
+          const result = await s.agent.execute(actionName, params);
+          return { site: s.url, status: 'fulfilled', value: result };
+        } catch (err) {
+          return { site: s.url, status: 'rejected', error: err.message };
+        }
+      })
+    );
+  }
+
+  /**
+   * Compare prices for a product across all sites.
+   * Queries each site via WAB getOfferPrice / getProductFromSchema actions,
+   * and falls back to schema.org JSON-LD extraction from page HTML.
+   *
+   * @param {string} sku — Product SKU or identifier
+   * @returns {Promise<{
+   *   results: Array<{ site: string, product?: string, price?: number, currency?: string, error?: string }>,
+   *   cheapest: { site: string, product?: string, price: number, currency: string } | null,
+   *   savings: number | null
+   * }>}
+   */
+  async comparePrices(sku) {
+    this._ensureLaunched();
+    const { extractProductsFromHtml } = require('./schema-discovery');
+
+    const results = await Promise.all(
+      this._sessions.map(async (s) => {
+        try {
+          // Strategy 1: Try WAB getOfferPrice action
+          const hasAction = await s.page.evaluate((name) => {
+            if (window.AICommands && typeof window.AICommands.getAction === 'function') {
+              return !!window.AICommands.getAction(name);
+            }
+            return false;
+          }, 'getOfferPrice');
+
+          if (hasAction) {
+            const offer = await s.agent.execute('getOfferPrice', { sku });
+            if (offer && offer.price != null) {
+              return {
+                site: s.url,
+                product: offer.name || sku,
+                price: parseFloat(offer.price),
+                currency: offer.currency || offer.priceCurrency || 'USD'
+              };
+            }
+          }
+
+          // Strategy 2: Extract from schema.org JSON-LD in page HTML
+          const html = await s.page.content();
+          const products = extractProductsFromHtml(html);
+
+          // Find product matching the SKU (or take first one)
+          const match = products.find((p) => p.sku === sku) || products[0];
+          if (match && match.offers) {
+            const offer = Array.isArray(match.offers) ? match.offers[0] : match.offers;
+            const price = parseFloat(offer.price || offer.lowPrice || 0);
+            if (price > 0) {
+              return {
+                site: s.url,
+                product: match.name || sku,
+                price,
+                currency: offer.priceCurrency || 'USD'
+              };
+            }
+          }
+
+          // Strategy 3: Try generic getProductInfo action
+          try {
+            const pInfo = await s.agent.execute('getProductInfo', { sku });
+            if (pInfo && pInfo.price != null) {
+              return {
+                site: s.url,
+                product: pInfo.name || sku,
+                price: parseFloat(pInfo.price),
+                currency: pInfo.currency || 'USD'
+              };
+            }
+          } catch {
+            // action not available — that's fine
+          }
+
+          return { site: s.url, error: 'No price data found' };
+        } catch (err) {
+          return { site: s.url, error: err.message };
+        }
+      })
+    );
+
+    // Find cheapest
+    const priced = results.filter((r) => r.price != null);
+    let cheapest = null;
+    let savings = null;
+
+    if (priced.length > 0) {
+      priced.sort((a, b) => a.price - b.price);
+      cheapest = priced[0];
+
+      if (priced.length >= 2) {
+        savings = priced[priced.length - 1].price - priced[0].price;
+      }
+    }
+
+    return { results, cheapest, savings };
+  }
+
+  /**
+   * Compare a specific action result across all sites.
+   * @param {string} actionName
+   * @param {object} [params]
+   * @param {function} [rankFn] — Custom ranking function, receives array of results, returns sorted
+   * @returns {Promise<{ results: Array, ranked: Array }>}
+   */
+  async compareAction(actionName, params, rankFn) {
+    const results = await this.executeAll(actionName, params);
+    const successful = results.filter((r) => r.status === 'fulfilled');
+    const ranked = rankFn ? rankFn(successful) : successful;
+    return { results, ranked };
+  }
+
+  /**
+   * Navigate all sessions to a new path (keeps each domain).
+   * @param {string} path — e.g. '/products/laptop'
+   * @returns {Promise<Array<{ site: string, ok: boolean, error?: string }>>}
+   */
+  async navigateAll(path) {
+    this._ensureLaunched();
+    return Promise.all(
+      this._sessions.map(async (s) => {
+        try {
+          const url = new URL(path, s.url).href;
+          await s.agent.navigateAndWait(url);
+          return { site: s.url, ok: true };
+        } catch (err) {
+          return { site: s.url, ok: false, error: err.message };
+        }
+      })
+    );
+  }
+
+  /**
+   * Take screenshots from all sites (useful for vision verification).
+   * @param {{ fullPage?: boolean }} [opts]
+   * @returns {Promise<Array<{ site: string, screenshot?: string, error?: string }>>}
+   */
+  async screenshotAll(opts = {}) {
+    this._ensureLaunched();
+    return Promise.all(
+      this._sessions.map(async (s) => {
+        try {
+          const screenshot = await s.agent.screenshot(opts);
+          return { site: s.url, screenshot };
+        } catch (err) {
+          return { site: s.url, error: err.message };
+        }
+      })
+    );
+  }
+
+  /**
+   * Get a summary of all sessions.
+   * @returns {{ total: number, connected: string[] }}
+   */
+  status() {
+    return {
+      total: this.sites.length,
+      connected: this._sessions.map((s) => s.url)
+    };
+  }
+
+  /**
+   * Close all browser sessions.
+   * @returns {Promise<void>}
+   */
+  async close() {
+    const closings = this._sessions.map((s) =>
+      s.browser.close().catch(() => {})
+    );
+    await Promise.all(closings);
+    this._sessions = [];
+    this._launched = false;
+  }
+
+  /** @private */
+  _ensureLaunched() {
+    if (!this._launched || this._sessions.length === 0) {
+      throw new Error('Call launch() before using WABMultiAgent');
+    }
+  }
+}
+
+module.exports = { WABMultiAgent };

package/sdk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "web-agent-bridge-sdk",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "description": "SDK for building AI agents that interact with Web Agent Bridge (WAB)",
   "main": "index.js",
   "license": "MIT",