web-agent-bridge 1.2.0 → 2.1.0

package/public/script/wab.min.js

@@ -0,0 +1,405 @@
+/**
+ * WAB Client v2.0.0 — Add this script to make any website AI-agent-ready
+ * https://webagentbridge.com
+ *
+ * Usage (zero setup):
+ *   <script src="https://webagentbridge.com/script/wab.min.js"></script>
+ *   <script>
+ *     WAB.init({
+ *       name: "My Store",
+ *       actions: {
+ *         buy:      { description: "Buy product", run: () => { ... } },
+ *         getPrice: { description: "Get price",   run: () => ({ price: "$49" }) }
+ *       }
+ *     });
+ *   </script>
+ *
+ * That's it. Your site now supports:
+ *   - In-browser agent access via window.__wab_protocol
+ *   - Discovery via WAB.discover()
+ *   - Execution via WAB.execute("actionName", params)
+ *   - Cross-frame sync (postMessage) for embedded demos
+ *   - Auto-connection to WAB server endpoints if available
+ *
+ * License: MIT
+ */
+(function(global) {
+  'use strict';
+
+  var VERSION = '2.0.0';
+
+  // ── WAB Instance ──────────────────────────────────────────────────
+  function WABInstance(config) {
+    this.name = config.name || document.title || 'WAB Site';
+    this.serverUrl = config.serverUrl || '';
+    this.actions = {};
+    this._auditLog = [];
+    this._listeners = {};
+    this._ready = false;
+
+    if (config.actions) {
+      for (var key in config.actions) {
+        if (!config.actions.hasOwnProperty(key)) continue;
+        var action = config.actions[key];
+        if (typeof action === 'function') {
+          this.actions[key] = { description: key, params: [], run: action };
+        } else {
+          this.actions[key] = {
+            description: action.description || key,
+            params: action.params || [],
+            run: action.run || action.handler || function() { return { error: 'no handler' }; }
+          };
+        }
+      }
+    }
+
+    this._exposeProtocol();
+    this._setupCrossFrame();
+    this._ready = true;
+    this._emit('ready', { name: this.name, actions: Object.keys(this.actions) });
+  }
+
+  // Expose window.__wab_protocol for in-browser agents
+  WABInstance.prototype._exposeProtocol = function() {
+    var self = this;
+    global.__wab_protocol = {
+      version: VERSION,
+      protocol: '1.0',
+      name: this.name,
+      actions: Object.keys(this.actions).map(function(k) {
+        return { name: k, description: self.actions[k].description, params: self.actions[k].params };
+      }),
+      transport: ['javascript', 'http'],
+      ready: true,
+      discover: function() { return self.discover(); },
+      execute: function(name, params) { return self.execute(name, params); },
+      negotiate: function(agentId, proposal) { return self.negotiate(agentId, proposal); },
+      getReputation: function(siteId) { return self.getReputation(siteId); },
+      verifyPrice: function(productId, domPrice, visionPrice) { return self.verifyPrice(productId, domPrice, visionPrice); }
+    };
+
+    // Also expose on window.AICommands for broad compatibility
+    global.AICommands = global.AICommands || {};
+    global.AICommands.negotiate = function(agentId, proposal) { return self.negotiate(agentId, proposal); };
+    global.AICommands.getReputation = function(siteId) { return self.getReputation(siteId); };
+    global.AICommands.verifyPrice = function(productId, domP, visP) { return self.verifyPrice(productId, domP, visP); };
+  };
+
+  // Cross-frame communication for embedded demos
+  WABInstance.prototype._setupCrossFrame = function() {
+    var self = this;
+
+    global.addEventListener('message', function(e) {
+      if (!e.data || e.data.source === 'wab-store') return;
+
+      // Handle requests from parent (agent demo page)
+      if (e.data.source === 'wab-agent' && e.data.type === 'refresh') {
+        self._emit('refresh');
+      }
+      if (e.data.source === 'wab-agent' && e.data.type === 'discover') {
+        self.discover().then(function(doc) {
+          e.source.postMessage({ source: 'wab-store', type: 'discover-response', detail: doc }, '*');
+        });
+      }
+      if (e.data.source === 'wab-agent' && e.data.type === 'execute') {
+        self.execute(e.data.action, e.data.params).then(function(result) {
+          e.source.postMessage({ source: 'wab-store', type: 'execute-response', action: e.data.action, detail: result }, '*');
+        });
+      }
+      // Negotiation protocol via postMessage
+      if (e.data.source === 'wab-agent' && e.data.type === 'negotiate') {
+        self.negotiate(e.data.agentId, e.data.proposal).then(function(result) {
+          e.source.postMessage({ source: 'wab-store', type: 'negotiate-response', detail: result }, '*');
+        });
+      }
+    });
+
+    // Notify parent that store is ready
+    this._notifyParent('store-ready', { name: this.name, actions: Object.keys(this.actions) });
+  };
+
+  WABInstance.prototype._notifyParent = function(type, detail) {
+    try {
+      if (global.parent !== global) {
+        global.parent.postMessage({ source: 'wab-store', type: type, detail: detail }, '*');
+      }
+    } catch(e) {}
+  };
+
+  // Event system
+  WABInstance.prototype.on = function(event, fn) {
+    if (!this._listeners[event]) this._listeners[event] = [];
+    this._listeners[event].push(fn);
+    return this;
+  };
+
+  WABInstance.prototype._emit = function(event, data) {
+    var fns = this._listeners[event] || [];
+    for (var i = 0; i < fns.length; i++) {
+      try { fns[i](data); } catch(e) {}
+    }
+  };
+
+  // ── Core API ──────────────────────────────────────────────────────
+
+  WABInstance.prototype.discover = function() {
+    var self = this;
+    var actionList = [];
+    for (var key in this.actions) {
+      if (this.actions.hasOwnProperty(key)) {
+        actionList.push({ name: key, description: this.actions[key].description, params: this.actions[key].params });
+      }
+    }
+
+    // If server URL is configured, fetch from server for authoritative discovery
+    if (this.serverUrl) {
+      return fetch(this.serverUrl + '/.well-known/wab.json')
+        .then(function(r) { return r.json(); })
+        .catch(function() {
+          return { wab_version: VERSION, protocol: '1.0', name: self.name, actions: actionList, transport: ['javascript'] };
+        });
+    }
+
+    return Promise.resolve({
+      wab_version: VERSION,
+      protocol: '1.0',
+      name: this.name,
+      actions: actionList,
+      transport: ['javascript', 'http']
+    });
+  };
+
+  WABInstance.prototype.execute = function(actionName, params) {
+    var self = this;
+    var action = this.actions[actionName];
+    params = params || {};
+
+    // If server URL configured and action not local, proxy to server
+    if (!action && this.serverUrl) {
+      return fetch(this.serverUrl + '/wab/execute', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ action: actionName, params: params })
+      }).then(function(r) { return r.json(); });
+    }
+
+    if (!action) {
+      return Promise.resolve({ success: false, error: 'Action not found: ' + actionName });
+    }
+
+    var start = Date.now();
+    try {
+      var result = action.run(params);
+      var handleResult = function(res) {
+        var duration = Date.now() - start;
+        self._auditLog.push({ action: actionName, params: params, result: res, duration_ms: duration, timestamp: new Date().toISOString() });
+        if (self._auditLog.length > 200) self._auditLog.shift();
+        self._notifyParent('action-executed', { action: actionName, result: res, duration_ms: duration });
+        self._emit('execute', { action: actionName, params: params, result: res, duration_ms: duration });
+        return res;
+      };
+      if (result && typeof result.then === 'function') {
+        return result.then(handleResult);
+      }
+      return Promise.resolve(handleResult(result));
+    } catch (e) {
+      return Promise.resolve({ success: false, error: e.message });
+    }
+  };
+
+  WABInstance.prototype.getActions = function() {
+    return Object.keys(this.actions);
+  };
+
+  WABInstance.prototype.getAuditLog = function() {
+    return this._auditLog.slice();
+  };
+
+  // ── Negotiation Support ─────────────────────────────────────────
+  // Sites can define negotiation rules; agents can open sessions and propose
+
+  WABInstance.prototype.setNegotiationRules = function(rules) {
+    this._negotiationRules = rules || {};
+    // Expose in protocol
+    if (global.__wab_protocol) {
+      global.__wab_protocol.negotiation = { available: true, rules: Object.keys(rules) };
+    }
+    return this;
+  };
+
+  WABInstance.prototype.negotiate = function(agentId, proposal) {
+    var self = this;
+    // Support in-browser negotiation rules (no server needed)
+    if (this._negotiationRules && !this.serverUrl) {
+      return this._handleLocalNegotiation(agentId, proposal);
+    }
+    if (!this.serverUrl) {
+      return Promise.resolve({ error: 'Negotiation requires a server URL or local rules' });
+    }
+    return fetch(this.serverUrl + '/api/sovereign/negotiation/sessions', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        siteId: self.name,
+        agentId: agentId,
+        itemId: proposal.itemId || null,
+        itemName: proposal.itemName || 'item',
+        originalPrice: proposal.originalPrice || 0
+      })
+    }).then(function(r) { return r.json(); })
+    .then(function(session) {
+      if (!session.sessionId) return session;
+      return fetch(self.serverUrl + '/api/sovereign/negotiation/sessions/' + session.sessionId + '/propose', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          strategy: proposal.strategy || 'instant_payment',
+          proposedDiscount: proposal.proposedDiscount || 5,
+          arguments: proposal.arguments || []
+        })
+      }).then(function(r) { return r.json(); });
+    });
+  };
+
+  // Local in-browser negotiation (no server required)
+  WABInstance.prototype._handleLocalNegotiation = function(agentId, proposal) {
+    var rules = this._negotiationRules;
+    var strategy = proposal.strategy || 'custom';
+    var rule = rules[strategy];
+    if (!rule) {
+      return Promise.resolve({
+        status: 'rejected',
+        reason: 'no_applicable_rule',
+        message: 'No rule matches strategy: ' + strategy
+      });
+    }
+    var requested = proposal.proposedDiscount || 0;
+    var maxAllowed = rule.maxDiscount || 20;
+    var offered = rule.discount || 0;
+    var actual = Math.min(requested, maxAllowed, offered);
+    var originalPrice = proposal.originalPrice || 0;
+    var finalPrice = Math.round(originalPrice * (1 - actual / 100) * 100) / 100;
+
+    if (requested <= offered) {
+      this._emit('negotiation', { status: 'accepted', agentId: agentId, discount: actual, finalPrice: finalPrice });
+      return Promise.resolve({
+        status: 'agreed',
+        discount: actual,
+        originalPrice: originalPrice,
+        finalPrice: finalPrice,
+        message: 'Deal accepted! ' + actual + '% off. Price: $' + finalPrice
+      });
+    }
+    // Counter-offer
+    this._emit('negotiation', { status: 'counter', agentId: agentId, counterDiscount: offered });
+    return Promise.resolve({
+      status: 'counter_offer',
+      counterDiscount: offered,
+      counterPrice: Math.round(originalPrice * (1 - offered / 100) * 100) / 100,
+      message: 'We can offer ' + offered + '% off for ' + strategy.replace(/_/g, ' ')
+    });
+  };
+
+  // ── Reputation Support ────────────────────────────────────────────
+
+  WABInstance.prototype.submitAttestation = function(agentId, targetSiteId, interactionType, outcome, extras) {
+    if (!this.serverUrl) {
+      return Promise.resolve({ error: 'Reputation requires a server URL' });
+    }
+    var body = {
+      siteId: targetSiteId,
+      agentId: agentId,
+      interactionType: interactionType || 'purchase',
+      outcome: outcome || 'success'
+    };
+    if (extras) {
+      if (extras.priceAccuracy != null) body.priceAccuracy = extras.priceAccuracy;
+      if (extras.responseTimeMs != null) body.responseTimeMs = extras.responseTimeMs;
+      if (extras.dataIntegrity != null) body.dataIntegrity = extras.dataIntegrity;
+      if (extras.visionVerified != null) body.visionVerified = extras.visionVerified;
+      if (extras.details) body.details = extras.details;
+    }
+    return fetch(this.serverUrl + '/api/sovereign/reputation/attestations', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body)
+    }).then(function(r) { return r.json(); });
+  };
+
+  WABInstance.prototype.getReputation = function(siteId) {
+    if (!this.serverUrl) {
+      return Promise.resolve({ error: 'Reputation requires a server URL' });
+    }
+    return fetch(this.serverUrl + '/api/sovereign/reputation/sites/' + encodeURIComponent(siteId))
+      .then(function(r) { return r.json(); });
+  };
+
+  // ── Verification Support ──────────────────────────────────────────
+
+  WABInstance.prototype.verifyPrice = function(opts) {
+    if (!this.serverUrl) {
+      return Promise.resolve({ error: 'Verification requires a server URL' });
+    }
+    var body = {
+      siteId: opts.siteId || this.name,
+      agentId: opts.agentId || null,
+      url: opts.url || null,
+      domValue: opts.domValue || opts.domPrice,
+      visionValue: opts.visionValue || opts.visionPrice,
+      category: opts.category || null,
+      itemName: opts.itemName || null
+    };
+    return fetch(this.serverUrl + '/api/sovereign/verify/price', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body)
+    }).then(function(r) { return r.json(); });
+  };
+
+  // ── Static API ────────────────────────────────────────────────────
+
+  var WAB = {
+    version: VERSION,
+
+    init: function(config) {
+      var instance = new WABInstance(config || {});
+      WAB._instance = instance;
+      return instance;
+    },
+
+    // Connect to a remote WAB server (for client pages that don't define actions)
+    connect: function(serverUrl) {
+      return new WABInstance({ name: 'WAB Client', serverUrl: serverUrl });
+    },
+
+    discover: function() {
+      if (WAB._instance) return WAB._instance.discover();
+      return Promise.resolve({ error: 'WAB not initialized. Call WAB.init() first.' });
+    },
+
+    execute: function(actionName, params) {
+      if (WAB._instance) return WAB._instance.execute(actionName, params);
+      return Promise.resolve({ error: 'WAB not initialized. Call WAB.init() first.' });
+    },
+
+    negotiate: function(agentId, proposal) {
+      if (WAB._instance) return WAB._instance.negotiate(agentId, proposal);
+      return Promise.resolve({ error: 'WAB not initialized' });
+    },
+
+    getReputation: function(siteId) {
+      if (WAB._instance) return WAB._instance.getReputation(siteId);
+      return Promise.resolve({ error: 'WAB not initialized' });
+    },
+
+    verifyPrice: function(opts) {
+      if (WAB._instance) return WAB._instance.verifyPrice(opts);
+      return Promise.resolve({ error: 'WAB not initialized' });
+    },
+
+    _instance: null
+  };
+
+  global.WAB = WAB;
+
+})(typeof window !== 'undefined' ? window : this);

package/public/sitemap.xml

@@ -0,0 +1,93 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+  <url>
+    <loc>https://webagentbridge.com/</loc>
+    <lastmod>2026-03-28</lastmod>
+    <changefreq>weekly</changefreq>
+    <priority>1.0</priority>
+  </url>
+  <url>
+    <loc>https://webagentbridge.com/docs</loc>
+    <lastmod>2026-03-28</lastmod>
+    <changefreq>weekly</changefreq>
+    <priority>0.9</priority>
+  </url>
+  <url>
+    <loc>https://webagentbridge.com/premium</loc>
+    <lastmod>2026-03-28</lastmod>
+    <changefreq>monthly</changefreq>
+    <priority>0.8</priority>
+  </url>
+  <url>
+    <loc>https://webagentbridge.com/register</loc>
+    <lastmod>2026-03-28</lastmod>
+    <changefreq>monthly</changefreq>
+    <priority>0.7</priority>
+  </url>
+  <url>
+    <loc>https://webagentbridge.com/login</loc>
+    <lastmod>2026-03-28</lastmod>
+    <changefreq>monthly</changefreq>
+    <priority>0.5</priority>
+  </url>
+  <url>
+    <loc>https://webagentbridge.com/privacy</loc>
+    <lastmod>2026-03-28</lastmod>
+    <changefreq>yearly</changefreq>
+    <priority>0.3</priority>
+  </url>
+  <url>
+    <loc>https://webagentbridge.com/terms</loc>
+    <lastmod>2026-03-28</lastmod>
+    <changefreq>yearly</changefreq>
+    <priority>0.3</priority>
+  </url>
+  <url>
+    <loc>https://webagentbridge.com/cookies</loc>
+    <lastmod>2026-03-28</lastmod>
+    <changefreq>yearly</changefreq>
+    <priority>0.2</priority>
+  </url>
+  <url>
+    <loc>https://webagentbridge.com/llms.txt</loc>
+    <lastmod>2026-03-28</lastmod>
+    <changefreq>monthly</changefreq>
+    <priority>0.6</priority>
+  </url>
+  <url>
+    <loc>https://webagentbridge.com/llms-full.txt</loc>
+    <lastmod>2026-03-28</lastmod>
+    <changefreq>monthly</changefreq>
+    <priority>0.6</priority>
+  </url>
+  <url>
+    <loc>https://webagentbridge.com/agent-bridge.json</loc>
+    <lastmod>2026-03-28</lastmod>
+    <changefreq>monthly</changefreq>
+    <priority>0.7</priority>
+  </url>
+  <url>
+    <loc>https://webagentbridge.com/demo</loc>
+    <lastmod>2026-03-28</lastmod>
+    <changefreq>weekly</changefreq>
+    <priority>0.9</priority>
+  </url>
+  <url>
+    <loc>https://webagentbridge.com/ai</loc>
+    <lastmod>2026-03-28</lastmod>
+    <changefreq>weekly</changefreq>
+    <priority>0.8</priority>
+  </url>
+  <url>
+    <loc>https://webagentbridge.com/openapi.json</loc>
+    <lastmod>2026-03-28</lastmod>
+    <changefreq>monthly</changefreq>
+    <priority>0.6</priority>
+  </url>
+  <url>
+    <loc>https://webagentbridge.com/feed.xml</loc>
+    <lastmod>2026-03-28</lastmod>
+    <changefreq>weekly</changefreq>
+    <priority>0.5</priority>
+  </url>
+</urlset>