@sym-bot/sym 0.1.0 → 0.2.1

package/lib/transport.js

@@ -0,0 +1,88 @@
+'use strict';
+
+const { EventEmitter } = require('events');
+const { FrameParser, sendFrame } = require('./frame-parser');
+
+/**
+ * Transport abstraction for SYM peer connections.
+ *
+ * All transports emit:
+ *   'message' (msg)  — parsed JSON frame from peer
+ *   'close'  ()      — connection closed
+ *   'error'  (err)   — connection error
+ *
+ * All transports implement:
+ *   send(frame)       — send a JSON frame to the peer
+ *   close()           — close the connection
+ */
+
+/**
+ * TcpTransport — wraps a raw TCP socket with length-prefixed framing.
+ */
+class TcpTransport extends EventEmitter {
+
+  constructor(socket) {
+    super();
+    this._socket = socket;
+    this._parser = new FrameParser();
+    this._closed = false;
+
+    socket.on('data', (chunk) => this._parser.feed(chunk));
+    this._parser.on('message', (msg) => this.emit('message', msg));
+    this._parser.on('error', (err) => this.emit('error', err));
+    socket.on('close', () => { this._closed = true; this.emit('close'); });
+    socket.on('error', (err) => this.emit('error', err));
+  }
+
+  send(frame) {
+    if (this._closed) return;
+    sendFrame(this._socket, frame);
+  }
+
+  close() {
+    if (this._closed) return;
+    this._closed = true;
+    try { this._socket.destroy(); } catch {}
+  }
+
+  /** Drain any buffered bytes into a new transport (for handshake hand-off). */
+  get pendingBuffer() {
+    return this._parser.buffer || Buffer.alloc(0);
+  }
+}
+
+/**
+ * RelayPeerTransport — a virtual transport for a specific peer over a shared
+ * WebSocket relay connection.
+ *
+ * Multiple peers share one WebSocket to the relay. Each RelayPeerTransport
+ * targets a specific peer nodeId via the envelope's `to` field.
+ */
+class RelayPeerTransport extends EventEmitter {
+
+  constructor(relayWs, targetNodeId) {
+    super();
+    this._ws = relayWs;
+    this._targetNodeId = targetNodeId;
+    this._closed = false;
+  }
+
+  send(frame) {
+    if (this._closed || !this._ws || this._ws.readyState !== 1) return;
+    this._ws.send(JSON.stringify({ to: this._targetNodeId, payload: frame }));
+  }
+
+  close() {
+    if (this._closed) return;
+    this._closed = true;
+    this.emit('close');
+  }
+
+  /** Called by the relay client when the shared WebSocket closes. */
+  destroy() {
+    this._closed = true;
+    this.emit('close');
+  }
+}
+
+module.exports = { TcpTransport, RelayPeerTransport };

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@sym-bot/sym",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Local AI mesh — every agent is a sovereign node, the mesh is the agents",
   "main": "lib/node.js",
   "bin": {
-    "sym-mcp": "./integrations/claude-code/mcp-server.js"
+    "sym-mcp": "./integrations/claude-code/mcp-server.js",
+    "sym-daemon": "./bin/sym-daemon.js"
   },
   "scripts": {
     "test": "node --test tests/*.test.js"
@@ -33,6 +34,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.27.1",
     "bonjour-service": "^1.3.0",
-    "mesh-cognition": "^1.1.0"
+    "mesh-cognition": "^1.1.0",
+    "ws": "^8.20.0"
   }
 }

package/sym-relay/Dockerfile

@@ -0,0 +1,7 @@
+FROM node:18-alpine
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci --production
+COPY . .
+EXPOSE 8080
+CMD ["node", "server.js"]

package/sym-relay/lib/logger.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const LEVELS = { error: 0, warn: 1, info: 2, debug: 3 };
+
+class Logger {
+
+  constructor(level = 'info') {
+    this._level = LEVELS[level] ?? LEVELS.info;
+  }
+
+  error(msg, ctx) { this._write('error', msg, ctx); }
+  warn(msg, ctx) { this._write('warn', msg, ctx); }
+  info(msg, ctx) { this._write('info', msg, ctx); }
+  debug(msg, ctx) { this._write('debug', msg, ctx); }
+
+  _write(level, msg, ctx) {
+    if (LEVELS[level] > this._level) return;
+    const ts = new Date().toISOString();
+    const prefix = `${ts} [${level.toUpperCase()}]`;
+    if (ctx) {
+      process.stdout.write(`${prefix} ${msg} ${JSON.stringify(ctx)}\n`);
+    } else {
+      process.stdout.write(`${prefix} ${msg}\n`);
+    }
+  }
+}
+
+module.exports = { Logger };

package/sym-relay/lib/relay.js

@@ -0,0 +1,388 @@
+'use strict';
+
+const { Logger } = require('./logger');
+
+/**
+ * SymRelay — a peer node in the MMP mesh.
+ *
+ * The relay is a full mesh participant with its own identity. It forwards
+ * frames between authenticated nodes without inspecting payloads (dumb
+ * transport), but participates in peer gossip — storing wake channels
+ * and peer metadata so that newly-connecting nodes can learn about
+ * sleeping peers they've never met.
+ *
+ * All coupling decisions remain on-device. The relay never evaluates
+ * cognitive state.
+ *
+ * MMP v0.2.0 Protocol:
+ *   1. Client connects via WebSocket
+ *   2. Client sends: { type: 'relay-auth', nodeId, name, token?, wakeChannel? }
+ *   3. Relay validates, registers, updates peer directory
+ *   4. Relay sends: { type: 'relay-peers', peers: [{ nodeId, name, wakeChannel?, offline? }] }
+ *      — includes disconnected peers with wake channels (gossip)
+ *   5. Relay notifies others: { type: 'relay-peer-joined', nodeId, name }
+ *   6. Client sends: { to?: nodeId, payload: <MMP frame> }
+ *   7. Relay forwards: { from: nodeId, fromName: name, payload: <MMP frame> }
+ *   8. Relay intercepts peer-info and wake-channel payloads to update directory
+ *   9. On disconnect: { type: 'relay-peer-left', nodeId, name }
+ */
+class SymRelay {
+
+  constructor(opts = {}) {
+    this._token = opts.token || null;
+    this._log = opts.logger || new Logger(opts.logLevel || 'info');
+    this._pingInterval = opts.pingInterval || 30000;
+    this._pingTimeout = opts.pingTimeout || 10000;
+
+    /** Active WebSocket connections. nodeId → ConnectionState */
+    this._connections = new Map();
+
+    /**
+     * Peer directory — retained across disconnects for gossip.
+     * nodeId → { name: string, wakeChannel?: WakeChannel, lastSeen: number }
+     *
+     * This is what makes the relay a gossip hub: when a new node connects,
+     * the relay shares what it knows about peers the new node has never met.
+     */
+    this._peerDirectory = new Map();
+    this._peerDirectoryTTL = opts.peerDirectoryTTL || 7 * 24 * 60 * 60 * 1000; // 7 days
+
+    this._pingTimer = null;
+  }
+
+  // ── Public API ──────────────────────────────────────────────
+
+  get connectionCount() {
+    return this._connections.size;
+  }
+
+  get directorySize() {
+    return this._peerDirectory.size;
+  }
+
+  start() {
+    this._pingTimer = setInterval(() => this._heartbeat(), this._pingInterval);
+  }
+
+  stop() {
+    if (this._pingTimer) clearInterval(this._pingTimer);
+    for (const [, conn] of this._connections) {
+      conn.ws.close(1001, 'Server shutting down');
+    }
+    this._connections.clear();
+  }
+
+  /**
+   * Handle a new WebSocket connection. Called by the server on 'connection'.
+   */
+  handleConnection(ws) {
+    let authenticated = false;
+    const authTimeout = setTimeout(() => {
+      if (!authenticated) {
+        this._log.warn('Auth timeout — closing connection');
+        ws.close(4001, 'Auth timeout');
+      }
+    }, 10000);
+
+    ws.on('message', (data) => {
+      let msg;
+      try { msg = JSON.parse(data.toString()); } catch {
+        this._log.warn('Invalid JSON received');
+        return;
+      }
+
+      if (!authenticated) {
+        authenticated = this._authenticate(ws, msg, authTimeout);
+        return;
+      }
+
+      this._onMessage(msg, ws);
+    });
+
+    ws.on('close', () => {
+      clearTimeout(authTimeout);
+      this._removeBySocket(ws);
+    });
+
+    ws.on('error', (err) => {
+      this._log.warn(`WebSocket error: ${err.message}`);
+    });
+  }
+
+  // ── Authentication ─────────────────────────────────────────
+
+  _authenticate(ws, msg, authTimeout) {
+    if (msg.type !== 'relay-auth' || !msg.nodeId || !msg.name) {
+      this._log.warn('Invalid auth message', { type: msg.type });
+      ws.close(4002, 'Invalid auth');
+      clearTimeout(authTimeout);
+      return false;
+    }
+
+    if (this._token && msg.token !== this._token) {
+      this._log.warn('Auth rejected — invalid token', { name: msg.name });
+      ws.send(JSON.stringify({ type: 'relay-error', message: 'Invalid token' }));
+      ws.close(4003, 'Invalid token');
+      clearTimeout(authTimeout);
+      return false;
+    }
+
+    // Replace duplicate nodeId connection
+    if (this._connections.has(msg.nodeId)) {
+      const existing = this._connections.get(msg.nodeId);
+      this._log.info('Duplicate nodeId — closing old connection', { name: msg.name });
+      existing.ws.close(4004, 'Replaced by new connection');
+      this._removeConnection(msg.nodeId);
+    }
+
+    clearTimeout(authTimeout);
+
+    // Register active connection
+    this._connections.set(msg.nodeId, {
+      ws,
+      nodeId: msg.nodeId,
+      name: msg.name,
+      connectedAt: Date.now(),
+      lastSeen: Date.now(),
+      alive: true,
+    });
+
+    // Update peer directory
+    this._updateDirectory(msg.nodeId, msg.name, msg.wakeChannel);
+
+    this._log.info(`Peer authenticated: ${msg.name} (${msg.nodeId.slice(0, 8)})`, {
+      connections: this._connections.size,
+      directory: this._peerDirectory.size,
+    });
+
+    // Send peer list with gossip (connected + offline peers with wake channels)
+    ws.send(JSON.stringify({
+      type: 'relay-peers',
+      peers: this._buildPeerList(msg.nodeId),
+    }));
+
+    // Notify existing peers
+    this._broadcast(msg.nodeId, {
+      type: 'relay-peer-joined',
+      nodeId: msg.nodeId,
+      name: msg.name,
+    });
+
+    return true;
+  }
+
+  // ── Peer Directory ──────────────────────────────────────────
+
+  /**
+   * Update the peer directory with the latest information about a node.
+   * The directory survives disconnects — this is the gossip state.
+   */
+  _updateDirectory(nodeId, name, wakeChannel) {
+    const existing = this._peerDirectory.get(nodeId) || {};
+    const entry = {
+      ...existing,
+      name: name || existing.name,
+      lastSeen: Date.now(),
+    };
+    if (wakeChannel && this._isValidWakeChannel(wakeChannel)) {
+      entry.wakeChannel = wakeChannel;
+    }
+    this._peerDirectory.set(nodeId, entry);
+  }
+
+  /**
+   * Validate wake channel structure.
+   */
+  _isValidWakeChannel(wc) {
+    return wc
+      && typeof wc.platform === 'string'
+      && wc.platform !== 'none'
+      && typeof wc.token === 'string'
+      && wc.token.length > 0;
+  }
+
+  /**
+   * Build the peer list for a newly-connected node.
+   * Includes connected peers AND offline peers with wake channels (gossip).
+   */
+  _buildPeerList(excludeNodeId) {
+    const peers = [];
+    const seen = new Set();
+
+    // Connected peers (with wake channels from directory if available)
+    for (const [id, conn] of this._connections) {
+      if (id === excludeNodeId) continue;
+      seen.add(id);
+      const dir = this._peerDirectory.get(id);
+      const entry = { nodeId: conn.nodeId, name: conn.name };
+      if (dir?.wakeChannel) entry.wakeChannel = dir.wakeChannel;
+      peers.push(entry);
+    }
+
+    // Offline peers with wake channels (the gossip value-add)
+    for (const [id, dir] of this._peerDirectory) {
+      if (id === excludeNodeId || seen.has(id)) continue;
+      if (!dir.wakeChannel) continue;
+      peers.push({
+        nodeId: id,
+        name: dir.name,
+        wakeChannel: dir.wakeChannel,
+        offline: true,
+      });
+    }
+
+    return peers;
+  }
+
+  // ── Message Routing ────────────────────────────────────────
+
+  _onMessage(msg, ws) {
+    const sender = this._findBySocket(ws);
+    if (!sender) return;
+
+    sender.lastSeen = Date.now();
+
+    // Relay control messages
+    if (msg.type === 'relay-pong') {
+      sender.alive = true;
+      return;
+    }
+
+    // Intercept peer metadata from payloads (relay participates in gossip)
+    this._interceptPeerMetadata(sender, msg);
+
+    // Forward to specific peer or broadcast
+    if (msg.to) {
+      this._sendTo(msg.to, {
+        from: sender.nodeId,
+        fromName: sender.name,
+        payload: msg.payload,
+      });
+    } else if (msg.payload) {
+      this._broadcast(sender.nodeId, {
+        from: sender.nodeId,
+        fromName: sender.name,
+        payload: msg.payload,
+      });
+    }
+  }
+
+  /**
+   * Intercept MMP frames that carry peer metadata to update the directory.
+   * The relay doesn't inspect cognitive payloads — only peer discovery metadata.
+   */
+  _interceptPeerMetadata(sender, msg) {
+    const payload = msg.payload;
+    if (!payload || typeof payload !== 'object') return;
+
+    // peer-info gossip frame
+    if (payload.type === 'peer-info' && Array.isArray(payload.peers)) {
+      for (const p of payload.peers) {
+        if (!p.nodeId || p.nodeId === sender.nodeId) continue;
+        if (p.wakeChannel && this._isValidWakeChannel(p.wakeChannel)) {
+          this._updateDirectory(p.nodeId, p.name, p.wakeChannel);
+        }
+      }
+    }
+
+    // wake-channel frame (direct declaration from sender)
+    if (payload.type === 'wake-channel' && this._isValidWakeChannel(payload)) {
+      this._updateDirectory(sender.nodeId, sender.name, {
+        platform: payload.platform,
+        token: payload.token,
+        environment: payload.environment,
+      });
+      this._log.info(`Wake channel stored: ${sender.name} (${payload.platform})`);
+    }
+  }
+
+  // ── Transport ──────────────────────────────────────────────
+
+  _sendTo(targetNodeId, envelope) {
+    const conn = this._connections.get(targetNodeId);
+    if (!conn) return;
+    try {
+      conn.ws.send(JSON.stringify(envelope));
+    } catch (err) {
+      this._log.warn(`Send failed to ${conn.name}: ${err.message}`);
+    }
+  }
+
+  _broadcast(excludeNodeId, envelope) {
+    const data = JSON.stringify(envelope);
+    for (const [id, conn] of this._connections) {
+      if (id === excludeNodeId) continue;
+      try {
+        conn.ws.send(data);
+      } catch (err) {
+        this._log.warn(`Broadcast failed to ${conn.name}: ${err.message}`);
+      }
+    }
+  }
+
+  // ── Connection Management ──────────────────────────────────
+
+  _findBySocket(ws) {
+    for (const [, conn] of this._connections) {
+      if (conn.ws === ws) return conn;
+    }
+    return null;
+  }
+
+  _removeBySocket(ws) {
+    const conn = this._findBySocket(ws);
+    if (conn) this._removeConnection(conn.nodeId);
+  }
+
+  _removeConnection(nodeId) {
+    const conn = this._connections.get(nodeId);
+    if (!conn) return;
+
+    this._connections.delete(nodeId);
+
+    // Update directory lastSeen on disconnect (keeps the entry alive for gossip)
+    const dir = this._peerDirectory.get(nodeId);
+    if (dir) dir.lastSeen = Date.now();
+
+    this._log.info(`Peer disconnected: ${conn.name} (${nodeId.slice(0, 8)})`, {
+      connections: this._connections.size,
+    });
+
+    this._broadcast(nodeId, {
+      type: 'relay-peer-left',
+      nodeId: conn.nodeId,
+      name: conn.name,
+    });
+  }
+
+  // ── Heartbeat ──────────────────────────────────────────────
+
+  _heartbeat() {
+    // Expire stale directory entries (disconnected peers beyond TTL)
+    const now = Date.now();
+    for (const [nodeId, dir] of this._peerDirectory) {
+      if (!this._connections.has(nodeId) && now - dir.lastSeen > this._peerDirectoryTTL) {
+        this._peerDirectory.delete(nodeId);
+        this._log.info(`Directory expired: ${dir.name} (${nodeId.slice(0, 8)})`);
+      }
+    }
+
+    // Ping active connections
+    for (const [nodeId, conn] of this._connections) {
+      if (!conn.alive) {
+        this._log.info(`Heartbeat timeout: ${conn.name}`);
+        conn.ws.close(4005, 'Heartbeat timeout');
+        this._removeConnection(nodeId);
+        continue;
+      }
+      conn.alive = false;
+      try {
+        conn.ws.send(JSON.stringify({ type: 'relay-ping' }));
+      } catch {
+        this._removeConnection(nodeId);
+      }
+    }
+  }
+}
+
+module.exports = { SymRelay };

package/sym-relay/package-lock.json

@@ -0,0 +1,40 @@
+{
+  "name": "@sym-bot/relay",
+  "version": "0.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "@sym-bot/relay",
+      "version": "0.1.0",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "ws": "^8.18.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/ws": {
+      "version": "8.20.0",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.20.0.tgz",
+      "integrity": "sha512-sAt8BhgNbzCtgGbt2OxmpuryO63ZoDk/sqaB/znQm94T4fCEsy/yV+7CdC1kJhOU9lboAEU7R3kquuycDoibVA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    }
+  }
+}

package/sym-relay/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@sym-bot/relay",
+  "version": "0.1.0",
+  "description": "SYM mesh relay — WebSocket transport for internet-scale cognitive coupling",
+  "main": "server.js",
+  "scripts": {
+    "start": "node server.js"
+  },
+  "keywords": ["sym", "mesh", "relay", "websocket", "p2p"],
+  "author": "SYM.BOT Ltd <info@sym.bot> (https://sym.bot)",
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "ws": "^8.18.0"
+  }
+}

package/sym-relay/render.yaml

@@ -0,0 +1,14 @@
+services:
+  - type: web
+    name: sym-relay
+    runtime: node
+    plan: free
+    buildCommand: cd sym-relay && npm ci --production
+    startCommand: cd sym-relay && node server.js
+    envVars:
+      - key: PORT
+        value: 8080
+      - key: SYM_RELAY_TOKEN
+        sync: false
+      - key: LOG_LEVEL
+        value: info

package/sym-relay/server.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+'use strict';
+
+const http = require('http');
+const { WebSocketServer } = require('ws');
+const { SymRelay } = require('./lib/relay');
+const { Logger } = require('./lib/logger');
+
+// ── Configuration ──────────────────────────────────────────────
+
+const PORT = parseInt(process.env.PORT, 10) || 8080;
+const TOKEN = process.env.SYM_RELAY_TOKEN || null;
+const LOG_LEVEL = process.env.LOG_LEVEL || 'info';
+
+const log = new Logger(LOG_LEVEL);
+
+// ── HTTP Server ────────────────────────────────────────────────
+
+const httpServer = http.createServer((req, res) => {
+  if (req.method === 'GET' && req.url === '/health') {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+      status: 'ok',
+      connections: relay.connectionCount,
+      uptime: Math.floor(process.uptime()),
+    }));
+    return;
+  }
+  res.writeHead(404);
+  res.end();
+});
+
+// ── WebSocket Server ───────────────────────────────────────────
+
+const wss = new WebSocketServer({ server: httpServer });
+const relay = new SymRelay({ token: TOKEN, logger: log, logLevel: LOG_LEVEL });
+
+wss.on('connection', (ws) => {
+  relay.handleConnection(ws);
+});
+
+relay.start();
+
+// ── Start ──────────────────────────────────────────────────────
+
+httpServer.listen(PORT, () => {
+  log.info(`SYM relay listening on port ${PORT}`, {
+    auth: TOKEN ? 'token required' : 'open',
+  });
+});
+
+// ── Graceful Shutdown ──────────────────────────────────────────
+
+function shutdown(signal) {
+  log.info(`${signal} received — shutting down`);
+  relay.stop();
+  wss.close(() => {
+    httpServer.close(() => {
+      process.exit(0);
+    });
+  });
+  // Force exit after 5s if graceful shutdown stalls
+  setTimeout(() => process.exit(1), 5000);
+}
+
+process.on('SIGTERM', () => shutdown('SIGTERM'));
+process.on('SIGINT', () => shutdown('SIGINT'));

package/.mcp.json

@@ -1,12 +0,0 @@
-{
-  "mcpServers": {
-    "sym": {
-      "type": "stdio",
-      "command": "node",
-      "args": [
-        "/Users/hongwei/Documents/dev/sym/integrations/claude-code/mcp-server.js"
-      ],
-      "env": {}
-    }
-  }
-}