@sym-bot/sym 0.2.0 → 0.2.1

package/lib/ipc-client.js

@@ -0,0 +1,241 @@
+'use strict';
+
+/**
+ * IPC client for connecting to sym-daemon as a virtual node.
+ *
+ * Communicates via Unix socket with newline-delimited JSON.
+ * Provides the same API surface as SymNode so consumers
+ * (MCP server, etc.) can use either transparently.
+ *
+ * Copyright (c) 2026 SYM.BOT Ltd. Apache 2.0 License.
+ */
+
+const net = require('net');
+const { EventEmitter } = require('events');
+
+const DEFAULT_SOCKET = '/tmp/sym.sock';
+
+class SymDaemonClient extends EventEmitter {
+
+  constructor(opts = {}) {
+    super();
+    this._socketPath = opts.socketPath || DEFAULT_SOCKET;
+    this._name = opts.name || 'virtual-node';
+    this._cognitiveProfile = opts.cognitiveProfile || null;
+    this._socket = null;
+    this._buffer = '';
+    this._connected = false;
+    this._requestId = 0;
+    this._pendingRequests = new Map(); // id → { resolve, reject, timeout }
+  }
+
+  /** Whether the client is connected to the daemon. */
+  get connected() { return this._connected; }
+
+  /** Connect to the daemon and register as a virtual node. */
+  async connect() {
+    return new Promise((resolve, reject) => {
+      const socket = net.createConnection(this._socketPath, () => {
+        this._socket = socket;
+        this._connected = true;
+
+        // Register as virtual node
+        this._send({
+          type: 'register',
+          name: this._name,
+          cognitiveProfile: this._cognitiveProfile,
+        });
+
+        // Wait for registered response
+        const onFirstMessage = (msg) => {
+          if (msg.type === 'registered') {
+            this._nodeId = msg.nodeId;
+            this._nodeName = msg.name;
+            resolve({ nodeId: msg.nodeId, name: msg.name, relay: msg.relay });
+          }
+        };
+        this.once('_raw', onFirstMessage);
+
+        // Timeout registration
+        setTimeout(() => {
+          this.removeListener('_raw', onFirstMessage);
+          reject(new Error('Daemon registration timeout'));
+        }, 5000);
+      });
+
+      socket.on('data', (data) => this._onData(data));
+
+      socket.on('close', () => {
+        this._connected = false;
+        this._socket = null;
+        this.emit('disconnected');
+      });
+
+      socket.on('error', (err) => {
+        this._connected = false;
+        if (err.code === 'ENOENT' || err.code === 'ECONNREFUSED') {
+          reject(new Error('sym-daemon not running'));
+        } else {
+          reject(err);
+        }
+      });
+    });
+  }
+
+  /** Disconnect from the daemon. */
+  disconnect() {
+    if (this._socket) {
+      this._socket.end();
+      this._socket = null;
+    }
+    this._connected = false;
+  }
+
+  // ── SymNode-compatible API ─────────────────────────────────
+
+  /** Broadcast mood to the mesh via daemon. */
+  broadcastMood(mood, opts = {}) {
+    this._send({ type: 'mood', mood, context: opts.context });
+  }
+
+  /** Store a memory in the mesh via daemon. */
+  remember(content, opts = {}) {
+    this._send({ type: 'remember', content, tags: opts.tags });
+    return { key: `pending-${Date.now()}` };
+  }
+
+  /** Search memories via daemon. Returns a promise. */
+  async recall(query) {
+    const result = await this._request({ type: 'recall', query });
+    return result.results || [];
+  }
+
+  /** Send a message to all peers via daemon. */
+  send(message) {
+    this._send({ type: 'send', message });
+  }
+
+  /** Get connected peers via daemon. Returns a promise. */
+  async peers() {
+    const result = await this._request({ type: 'peers' });
+    return result.peers || [];
+  }
+
+  /** Get full status via daemon. Returns a promise. */
+  async status() {
+    const result = await this._request({ type: 'status' });
+    return result.status || {};
+  }
+
+  /** No-op for SymNode compatibility. */
+  start() {}
+
+  /** Disconnect. */
+  stop() { this.disconnect(); }
+
+  // ── Internal ───────────────────────────────────────────────
+
+  _send(msg) {
+    if (!this._socket || !this._connected) return;
+    try {
+      this._socket.write(JSON.stringify(msg) + '\n');
+    } catch {}
+  }
+
+  /** Send a request and wait for matching result. */
+  _request(msg) {
+    return new Promise((resolve, reject) => {
+      const action = msg.type;
+      this._send(msg);
+
+      // Listen for next result with matching action
+      const handler = (raw) => {
+        if (raw.type === 'result' && raw.action === action) {
+          this.removeListener('_raw', handler);
+          clearTimeout(timer);
+          resolve(raw);
+        }
+      };
+      this.on('_raw', handler);
+
+      const timer = setTimeout(() => {
+        this.removeListener('_raw', handler);
+        reject(new Error(`Daemon request timeout: ${action}`));
+      }, 10000);
+    });
+  }
+
+  _onData(data) {
+    this._buffer += data.toString();
+    let idx;
+    while ((idx = this._buffer.indexOf('\n')) !== -1) {
+      const line = this._buffer.slice(0, idx);
+      this._buffer = this._buffer.slice(idx + 1);
+      if (!line.trim()) continue;
+
+      try {
+        const msg = JSON.parse(line);
+        this.emit('_raw', msg);
+
+        // Forward mesh events as SymNode-compatible events
+        if (msg.type === 'event') {
+          switch (msg.event) {
+            case 'mood-accepted':
+              this.emit('mood-accepted', msg.data);
+              break;
+            case 'mood-rejected':
+              this.emit('mood-rejected', msg.data);
+              break;
+            case 'message':
+              this.emit('message', msg.data.from, msg.data.content, msg.data);
+              break;
+            case 'peer-joined':
+              this.emit('peer-joined', msg.data);
+              break;
+            case 'peer-left':
+              this.emit('peer-left', msg.data);
+              break;
+            case 'coupling-decision':
+              this.emit('coupling-decision', msg.data);
+              break;
+            case 'memory-received':
+              this.emit('memory-received', msg.data);
+              break;
+          }
+        }
+      } catch {}
+    }
+  }
+}
+
+/**
+ * Try to connect to sym-daemon. If not running, fall back to a standalone SymNode.
+ *
+ * Returns an object with the same API surface either way:
+ *   { node, isDaemon: boolean }
+ */
+async function connectOrFallback(opts = {}) {
+  const client = new SymDaemonClient({
+    socketPath: opts.socketPath || DEFAULT_SOCKET,
+    name: opts.name || 'claude-code',
+    cognitiveProfile: opts.cognitiveProfile,
+  });
+
+  try {
+    await client.connect();
+    return { node: client, isDaemon: true };
+  } catch {
+    // Daemon not running — fall back to standalone SymNode
+    const { SymNode } = require('./node');
+    const node = new SymNode({
+      name: opts.name || 'claude-code',
+      cognitiveProfile: opts.cognitiveProfile,
+      silent: opts.silent ?? true,
+      relay: opts.relay,
+      relayToken: opts.relayToken,
+    });
+    return { node, isDaemon: false };
+  }
+}
+
+module.exports = { SymDaemonClient, connectOrFallback };

package/lib/node.js

@@ -806,7 +806,8 @@ class SymNode extends EventEmitter {
     const knownPeers = [];
     for (const [id, wc] of this._peerWakeChannels) {
       if (id !== peer.peerId) {
-        knownPeers.push({ nodeId: id, wakeChannel: wc, lastSeen: Date.now() });
+        const peerEntry = this._peers.get(id);
+        knownPeers.push({ nodeId: id, name: peerEntry?.name || 'unknown', wakeChannel: wc, lastSeen: Date.now() });
       }
     }
     if (knownPeers.length > 0) {

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@sym-bot/sym",
-  "version": "0.2.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"