web-agent-bridge 2.2.0 → 2.3.0

package/public/script/wab.min.js

@@ -356,6 +356,99 @@
     }).then(function(r) { return r.json(); });
   };
 
+  // ── Agent Mesh Protocol ───────────────────────────────────────────
+
+  WABInstance.prototype.meshJoin = function(role, displayName, capabilities) {
+    if (!this.serverUrl) return Promise.resolve({ error: 'Mesh requires a server URL' });
+    var self = this;
+    return fetch(this.serverUrl + '/api/mesh/agents', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ siteId: this.name, role: role, displayName: displayName, capabilities: capabilities })
+    }).then(function(r) { return r.json(); }).then(function(data) {
+      self._meshAgentId = data.id;
+      self._emit('mesh:joined', data);
+      return data;
+    });
+  };
+
+  WABInstance.prototype.meshPublish = function(channel, messageType, subject, payload, opts) {
+    if (!this.serverUrl || !this._meshAgentId) return Promise.resolve({ error: 'Must join mesh first' });
+    return fetch(this.serverUrl + '/api/mesh/channels/' + encodeURIComponent(channel) + '/messages', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(Object.assign({ senderId: this._meshAgentId, messageType: messageType, subject: subject, payload: payload }, opts || {}))
+    }).then(function(r) { return r.json(); });
+  };
+
+  WABInstance.prototype.meshReceive = function(channel, limit) {
+    if (!this.serverUrl || !this._meshAgentId) return Promise.resolve({ error: 'Must join mesh first' });
+    return fetch(this.serverUrl + '/api/mesh/agents/' + this._meshAgentId + '/messages/' + encodeURIComponent(channel) + '?limit=' + (limit || 20))
+      .then(function(r) { return r.json(); });
+  };
+
+  WABInstance.prototype.meshShareKnowledge = function(knowledgeType, domain, key, value, confidence) {
+    if (!this.serverUrl || !this._meshAgentId) return Promise.resolve({ error: 'Must join mesh first' });
+    return fetch(this.serverUrl + '/api/mesh/knowledge', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ agentId: this._meshAgentId, knowledgeType: knowledgeType, domain: domain, key: key, value: value, confidence: confidence })
+    }).then(function(r) { return r.json(); });
+  };
+
+  WABInstance.prototype.meshAlert = function(subject, details, priority) {
+    if (!this.serverUrl || !this._meshAgentId) return Promise.resolve({ error: 'Must join mesh first' });
+    return fetch(this.serverUrl + '/api/mesh/alerts', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ senderId: this._meshAgentId, subject: subject, details: details, priority: priority })
+    }).then(function(r) { return r.json(); });
+  };
+
+  // ── Agent Symphony Orchestrator ───────────────────────────────────
+
+  WABInstance.prototype.symphonyPerform = function(task, taskType, inputData) {
+    if (!this.serverUrl) return Promise.resolve({ error: 'Symphony requires a server URL' });
+    var self = this;
+    return fetch(this.serverUrl + '/api/mesh/symphony/perform', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ siteId: this.name, task: task, taskType: taskType, inputData: inputData })
+    }).then(function(r) { return r.json(); }).then(function(data) {
+      self._emit('symphony:completed', data);
+      return data;
+    });
+  };
+
+  // ── Agent Learning Engine ─────────────────────────────────────────
+
+  WABInstance.prototype.learnRecord = function(domain, action, context, features) {
+    if (!this.serverUrl || !this._meshAgentId) return Promise.resolve({ error: 'Must join mesh first' });
+    return fetch(this.serverUrl + '/api/mesh/learning/decisions', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ siteId: this.name, agentId: this._meshAgentId, domain: domain, action: action, context: context, features: features })
+    }).then(function(r) { return r.json(); });
+  };
+
+  WABInstance.prototype.learnFeedback = function(decisionId, outcome, reward) {
+    if (!this.serverUrl) return Promise.resolve({ error: 'Learning requires a server URL' });
+    return fetch(this.serverUrl + '/api/mesh/learning/decisions/' + decisionId + '/feedback', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ outcome: outcome, reward: reward })
+    }).then(function(r) { return r.json(); });
+  };
+
+  WABInstance.prototype.learnRecommend = function(domain, actions, context) {
+    if (!this.serverUrl || !this._meshAgentId) return Promise.resolve({ error: 'Must join mesh first' });
+    return fetch(this.serverUrl + '/api/mesh/learning/recommend', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ siteId: this.name, agentId: this._meshAgentId, domain: domain, actions: actions, context: context })
+    }).then(function(r) { return r.json(); });
+  };
+
   // ── Static API ────────────────────────────────────────────────────
 
   var WAB = {
@@ -397,6 +490,51 @@
       return Promise.resolve({ error: 'WAB not initialized' });
     },
 
+    meshJoin: function(role, displayName, capabilities) {
+      if (WAB._instance) return WAB._instance.meshJoin(role, displayName, capabilities);
+      return Promise.resolve({ error: 'WAB not initialized' });
+    },
+
+    meshPublish: function(channel, messageType, subject, payload, opts) {
+      if (WAB._instance) return WAB._instance.meshPublish(channel, messageType, subject, payload, opts);
+      return Promise.resolve({ error: 'WAB not initialized' });
+    },
+
+    meshReceive: function(channel, limit) {
+      if (WAB._instance) return WAB._instance.meshReceive(channel, limit);
+      return Promise.resolve({ error: 'WAB not initialized' });
+    },
+
+    meshShareKnowledge: function(knowledgeType, domain, key, value, confidence) {
+      if (WAB._instance) return WAB._instance.meshShareKnowledge(knowledgeType, domain, key, value, confidence);
+      return Promise.resolve({ error: 'WAB not initialized' });
+    },
+
+    meshAlert: function(subject, details, priority) {
+      if (WAB._instance) return WAB._instance.meshAlert(subject, details, priority);
+      return Promise.resolve({ error: 'WAB not initialized' });
+    },
+
+    symphonyPerform: function(task, taskType, inputData) {
+      if (WAB._instance) return WAB._instance.symphonyPerform(task, taskType, inputData);
+      return Promise.resolve({ error: 'WAB not initialized' });
+    },
+
+    learnRecord: function(domain, action, context, features) {
+      if (WAB._instance) return WAB._instance.learnRecord(domain, action, context, features);
+      return Promise.resolve({ error: 'WAB not initialized' });
+    },
+
+    learnFeedback: function(decisionId, outcome, reward) {
+      if (WAB._instance) return WAB._instance.learnFeedback(decisionId, outcome, reward);
+      return Promise.resolve({ error: 'WAB not initialized' });
+    },
+
+    learnRecommend: function(domain, actions, context) {
+      if (WAB._instance) return WAB._instance.learnRecommend(domain, actions, context);
+      return Promise.resolve({ error: 'WAB not initialized' });
+    },
+
     _instance: null
   };
 

package/script/ai-agent-bridge.js

@@ -1426,6 +1426,132 @@
       this.logger.log('refresh', {});
     }
 
+    // ── Agent Mesh Protocol (Client-Side) ───────────────────────────────
+
+    /**
+     * Join the agent mesh — register this agent and return its mesh identity.
+     */
+    async meshJoin(role, displayName, capabilities) {
+      const base = this._resolveApiBase();
+      const res = await fetch(`${base}/api/mesh/agents`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ siteId: this.config.siteId, role, displayName, capabilities })
+      });
+      const data = await res.json();
+      this._meshAgentId = data.id;
+      this.events.emit('mesh:joined', data);
+      return data;
+    }
+
+    /**
+     * Publish a message to a mesh channel.
+     */
+    async meshPublish(channel, messageType, subject, payload, opts) {
+      if (!this._meshAgentId) throw new Error('Must call meshJoin() first');
+      const base = this._resolveApiBase();
+      const res = await fetch(`${base}/api/mesh/channels/${encodeURIComponent(channel)}/messages`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ senderId: this._meshAgentId, messageType, subject, payload, ...opts })
+      });
+      return res.json();
+    }
+
+    /**
+     * Get unread mesh messages for this agent on a channel.
+     */
+    async meshReceive(channel, limit) {
+      if (!this._meshAgentId) throw new Error('Must call meshJoin() first');
+      const base = this._resolveApiBase();
+      const res = await fetch(`${base}/api/mesh/agents/${this._meshAgentId}/messages/${encodeURIComponent(channel)}?limit=${limit || 20}`);
+      return res.json();
+    }
+
+    /**
+     * Share knowledge to the mesh.
+     */
+    async meshShareKnowledge(knowledgeType, domain, key, value, confidence) {
+      if (!this._meshAgentId) throw new Error('Must call meshJoin() first');
+      const base = this._resolveApiBase();
+      const res = await fetch(`${base}/api/mesh/knowledge`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ agentId: this._meshAgentId, knowledgeType, domain, key, value, confidence })
+      });
+      return res.json();
+    }
+
+    /**
+     * Broadcast an alert to all mesh agents.
+     */
+    async meshAlert(subject, details, priority) {
+      if (!this._meshAgentId) throw new Error('Must call meshJoin() first');
+      const base = this._resolveApiBase();
+      const res = await fetch(`${base}/api/mesh/alerts`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ senderId: this._meshAgentId, subject, details, priority })
+      });
+      return res.json();
+    }
+
+    /**
+     * Run a full symphony — orchestrate specialized agents for a task.
+     */
+    async symphonyPerform(task, taskType, inputData) {
+      const base = this._resolveApiBase();
+      const res = await fetch(`${base}/api/mesh/symphony/perform`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ siteId: this.config.siteId, task, taskType, inputData })
+      });
+      const data = await res.json();
+      this.events.emit('symphony:completed', data);
+      return data;
+    }
+
+    /**
+     * Record a decision for the learning engine and get prediction.
+     */
+    async learnRecord(domain, action, context, features) {
+      if (!this._meshAgentId) throw new Error('Must call meshJoin() first');
+      const base = this._resolveApiBase();
+      const res = await fetch(`${base}/api/mesh/learning/decisions`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ siteId: this.config.siteId, agentId: this._meshAgentId, domain, action, context, features })
+      });
+      return res.json();
+    }
+
+    /**
+     * Provide feedback on a decision — the learning signal.
+     */
+    async learnFeedback(decisionId, outcome, reward) {
+      const base = this._resolveApiBase();
+      const res = await fetch(`${base}/api/mesh/learning/decisions/${decisionId}/feedback`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ outcome, reward })
+      });
+      return res.json();
+    }
+
+    /**
+     * Get recommendation from learning engine.
+     */
+    async learnRecommend(domain, actions, context) {
+      if (!this._meshAgentId) throw new Error('Must call meshJoin() first');
+      const base = this._resolveApiBase();
+      const res = await fetch(`${base}/api/mesh/learning/recommend`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ siteId: this.config.siteId, agentId: this._meshAgentId, domain, actions, context })
+      });
+      return res.json();
+    }
+
     destroy() {
       this.events.emit('destroy');
       if (this._mutationObserver) {

package/sdk/agent-mesh.js

@@ -0,0 +1,333 @@
+/**
+ * WAB Agent Mesh SDK
+ *
+ * Provides a high-level client for interacting with the Private Agent Mesh:
+ *   - Join the mesh and communicate with other agents
+ *   - Share and query collective knowledge
+ *   - Run symphony orchestrations (Researcher → Analyst → Negotiator → Guardian)
+ *   - Learn from user decisions via local reinforcement learning
+ *
+ * Usage:
+ *   const { WABAgentMesh } = require('web-agent-bridge-sdk/agent-mesh');
+ *   const mesh = new WABAgentMesh('https://your-wab-server.com');
+ *
+ *   const agent = await mesh.join('researcher', 'PriceBot');
+ *   await mesh.shareKnowledge('price', 'amazon.com', 'iphone-15', { price: 999, currency: 'USD' });
+ *   const result = await mesh.symphony('Find the best deal on iPhone 15', 'purchase', { products: [...] });
+ */
+
+class WABAgentMesh {
+  /**
+   * @param {string} serverUrl — WAB server base URL
+   * @param {object} [options]
+   * @param {string} [options.siteId] — Site identifier
+   * @param {number} [options.heartbeatInterval=30000] — Heartbeat interval in ms
+   */
+  constructor(serverUrl, options = {}) {
+    this.serverUrl = serverUrl.replace(/\/$/, '');
+    this.siteId = options.siteId || 'default';
+    this.heartbeatInterval = options.heartbeatInterval || 30000;
+    this.agentId = null;
+    this.role = null;
+    this._heartbeatTimer = null;
+  }
+
+  // ─── Mesh Management ──────────────────────────────────────────────
+
+  /**
+   * Join the agent mesh with a role.
+   * @param {string} role — Agent role (researcher, negotiator, analyst, guardian, etc.)
+   * @param {string} [displayName] — Human-readable name
+   * @param {string[]} [capabilities] — List of capabilities
+   * @returns {Promise<{id: string, role: string, displayName: string}>}
+   */
+  async join(role, displayName, capabilities = []) {
+    const data = await this._post('/api/mesh/agents', {
+      siteId: this.siteId, role, displayName, capabilities
+    });
+    this.agentId = data.id;
+    this.role = role;
+
+    // Start heartbeat
+    this._heartbeatTimer = setInterval(() => {
+      this._post(`/api/mesh/agents/${this.agentId}/heartbeat`, {}).catch(() => {});
+    }, this.heartbeatInterval);
+    if (this._heartbeatTimer.unref) this._heartbeatTimer.unref();
+
+    return data;
+  }
+
+  /**
+   * Leave the mesh.
+   */
+  async leave() {
+    if (this._heartbeatTimer) {
+      clearInterval(this._heartbeatTimer);
+      this._heartbeatTimer = null;
+    }
+    if (this.agentId) {
+      await this._patch(`/api/mesh/agents/${this.agentId}/status`, { status: 'offline' });
+      this.agentId = null;
+    }
+  }
+
+  /**
+   * Get all active agents in the mesh.
+   */
+  async getAgents() {
+    return this._get('/api/mesh/agents');
+  }
+
+  /**
+   * Get agents by role.
+   */
+  async getAgentsByRole(role) {
+    return this._get(`/api/mesh/agents/role/${encodeURIComponent(role)}`);
+  }
+
+  // ─── Messaging ────────────────────────────────────────────────────
+
+  /**
+   * Publish a message to a channel.
+   */
+  async publish(channel, messageType, subject, payload = {}, options = {}) {
+    this._requireAgent();
+    return this._post(`/api/mesh/channels/${encodeURIComponent(channel)}/messages`, {
+      senderId: this.agentId, messageType, subject, payload,
+      priority: options.priority, ttl: options.ttl, targetId: options.targetId
+    });
+  }
+
+  /**
+   * Get unread messages for this agent on a channel.
+   */
+  async receive(channel, limit = 20) {
+    this._requireAgent();
+    return this._get(`/api/mesh/agents/${this.agentId}/messages/${encodeURIComponent(channel)}?limit=${limit}`);
+  }
+
+  /**
+   * Acknowledge a message.
+   */
+  async acknowledge(messageId) {
+    this._requireAgent();
+    return this._post(`/api/mesh/agents/${this.agentId}/messages/${messageId}/ack`, {});
+  }
+
+  /**
+   * Get unread count.
+   */
+  async getUnreadCount() {
+    this._requireAgent();
+    return this._get(`/api/mesh/agents/${this.agentId}/unread`);
+  }
+
+  /**
+   * Broadcast an alert to all mesh agents.
+   */
+  async alert(subject, details = {}, priority = 2) {
+    this._requireAgent();
+    return this._post('/api/mesh/alerts', { senderId: this.agentId, subject, details, priority });
+  }
+
+  /**
+   * Share a tactic with the mesh.
+   */
+  async shareTactic(domain, tactic, confidence = 1.0) {
+    this._requireAgent();
+    return this._post('/api/mesh/tactics', {
+      senderId: this.agentId, domain, tactic, confidence
+    });
+  }
+
+  /**
+   * Request help from other agents.
+   */
+  async requestHelp(subject, question, targetRole = null) {
+    this._requireAgent();
+    return this._post('/api/mesh/help', {
+      senderId: this.agentId, subject, question, targetRole
+    });
+  }
+
+  // ─── Knowledge ────────────────────────────────────────────────────
+
+  /**
+   * Share knowledge to the mesh.
+   */
+  async shareKnowledge(knowledgeType, domain, key, value, confidence = 1.0) {
+    this._requireAgent();
+    return this._post('/api/mesh/knowledge', {
+      agentId: this.agentId, knowledgeType, domain, key, value, confidence
+    });
+  }
+
+  /**
+   * Query knowledge by domain and key.
+   */
+  async queryKnowledge(domain, key) {
+    return this._get(`/api/mesh/knowledge/${encodeURIComponent(domain)}/${encodeURIComponent(key)}`);
+  }
+
+  /**
+   * Search knowledge by domain.
+   */
+  async searchKnowledge(domain, limit = 20) {
+    return this._get(`/api/mesh/knowledge/${encodeURIComponent(domain)}?limit=${limit}`);
+  }
+
+  // ─── Symphony Orchestrator ────────────────────────────────────────
+
+  /**
+   * Run a full symphony — coordinate researcher, analyst, negotiator, guardian.
+   * @param {string} task — Task description
+   * @param {string} taskType — purchase, price_comparison, negotiation, exploration, verification
+   * @param {object} [inputData] — Data to pass to symphony phases
+   * @param {object} [agentIds] — Map role → agentId for specific agents
+   */
+  async symphony(task, taskType, inputData = {}, agentIds = {}) {
+    return this._post('/api/mesh/symphony/perform', {
+      siteId: this.siteId, task, taskType, inputData, agentIds
+    });
+  }
+
+  /**
+   * Compose a symphony step-by-step.
+   */
+  async symphonyCompose(task, taskType, agentIds = {}) {
+    return this._post('/api/mesh/symphony/compose', {
+      siteId: this.siteId, task, taskType, agentIds
+    });
+  }
+
+  /**
+   * Execute a single symphony phase.
+   */
+  async symphonyPhase(compositionId, phase, input = {}) {
+    return this._post(`/api/mesh/symphony/${compositionId}/phase`, { phase, input });
+  }
+
+  /**
+   * Get composition details.
+   */
+  async getComposition(compositionId) {
+    return this._get(`/api/mesh/symphony/${compositionId}`);
+  }
+
+  /**
+   * Get available symphony templates.
+   */
+  async getTemplates() {
+    return this._get('/api/mesh/symphony/templates/all');
+  }
+
+  // ─── Learning Engine ──────────────────────────────────────────────
+
+  /**
+   * Record a decision for the learning engine.
+   */
+  async recordDecision(domain, action, context = {}, features = {}) {
+    this._requireAgent();
+    return this._post('/api/mesh/learning/decisions', {
+      siteId: this.siteId, agentId: this.agentId, domain, action, context, features
+    });
+  }
+
+  /**
+   * Provide feedback on a decision.
+   * @param {string} decisionId
+   * @param {string} outcome — accepted, rejected, modified
+   * @param {number} reward — 0.0 to 1.0
+   */
+  async feedback(decisionId, outcome, reward) {
+    return this._post(`/api/mesh/learning/decisions/${decisionId}/feedback`, { outcome, reward });
+  }
+
+  /**
+   * Get recommendation based on learned preferences.
+   * @param {string} domain
+   * @param {string[]} actions — Available actions to choose from
+   * @param {object} [context] — Current context
+   */
+  async recommend(domain, actions, context = {}) {
+    this._requireAgent();
+    return this._post('/api/mesh/learning/recommend', {
+      siteId: this.siteId, agentId: this.agentId, domain, actions, context
+    });
+  }
+
+  /**
+   * Get learned preferences for a domain.
+   */
+  async getPreferences(domain) {
+    this._requireAgent();
+    return this._get(`/api/mesh/learning/preferences/${encodeURIComponent(this.siteId)}/${this.agentId}/${encodeURIComponent(domain)}`);
+  }
+
+  /**
+   * Get learning stats.
+   */
+  async getLearningStats() {
+    this._requireAgent();
+    return this._get(`/api/mesh/learning/stats/${encodeURIComponent(this.siteId)}/${this.agentId}`);
+  }
+
+  // ─── Stats ────────────────────────────────────────────────────────
+
+  /**
+   * Get mesh statistics.
+   */
+  async getStats() {
+    return this._get('/api/mesh/stats');
+  }
+
+  /**
+   * Get full dashboard data (agents, channels, templates, stats).
+   */
+  async getDashboard() {
+    return this._get('/api/mesh/dashboard');
+  }
+
+  // ─── Internal ─────────────────────────────────────────────────────
+
+  _requireAgent() {
+    if (!this.agentId) throw new Error('Must call join() first');
+  }
+
+  async _get(path) {
+    const res = await fetch(`${this.serverUrl}${path}`);
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({ error: res.statusText }));
+      throw new Error(err.error || `HTTP ${res.status}`);
+    }
+    return res.json();
+  }
+
+  async _post(path, body) {
+    const res = await fetch(`${this.serverUrl}${path}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({ error: res.statusText }));
+      throw new Error(err.error || `HTTP ${res.status}`);
+    }
+    return res.json();
+  }
+
+  async _patch(path, body) {
+    const res = await fetch(`${this.serverUrl}${path}`, {
+      method: 'PATCH',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({ error: res.statusText }));
+      throw new Error(err.error || `HTTP ${res.status}`);
+    }
+    return res.json();
+  }
+}
+
+module.exports = { WABAgentMesh };

package/sdk/index.js

@@ -255,5 +255,6 @@ class WABAgent {
 }
 
 const { WABMultiAgent } = require('./multi-agent');
+const { WABAgentMesh } = require('./agent-mesh');
 
-module.exports = { WABAgent, WABMultiAgent };
+module.exports = { WABAgent, WABMultiAgent, WABAgentMesh };

package/sdk/package.json

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

package/server/index.js

@@ -19,6 +19,7 @@ const licenseRoutes = require('./routes/license');
 const adminRoutes = require('./routes/admin');
 const billingRoutes = require('./routes/billing');
 const sovereignRoutes = require('./routes/sovereign');
+const meshRoutes = require('./routes/mesh');
 const { handleWebhookRequest } = require('./services/stripe');
 
 const app = express();
@@ -113,10 +114,14 @@ app.use('/api/license', licenseLimiter, licenseRoutes);
 app.use('/api/admin', apiLimiter, adminRoutes);
 app.use('/api/billing', apiLimiter, billingRoutes);
 app.use('/api/sovereign', apiLimiter, sovereignRoutes);
+app.use('/api/mesh', apiLimiter, meshRoutes);
 
 app.get('/dashboard', (req, res) => {
   res.sendFile(path.join(__dirname, '..', 'public', 'dashboard.html'));
 });
+app.get('/mesh-dashboard', (req, res) => {
+  res.sendFile(path.join(__dirname, '..', 'public', 'mesh-dashboard.html'));
+});
 app.get('/docs', (req, res) => {
   res.sendFile(path.join(__dirname, '..', 'public', 'docs.html'));
 });