stone-lang 0.1.0

package/daemon/IPCServer.js

@@ -0,0 +1,455 @@
+/**
+ * IPCServer - Cross-platform IPC server for Stone Daemon
+ *
+ * Provides inter-process communication between:
+ * - CLI clients running `stone run script.stn`
+ * - Riva desktop app
+ * - Other Stone tools
+ *
+ * Uses:
+ * - Unix domain sockets on Linux/macOS
+ * - Named pipes on Windows
+ *
+ * Protocol: JSON-RPC style messages over newline-delimited JSON
+ */
+
+import net from 'net';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { EventEmitter } from 'events';
+
+// Socket/pipe path based on platform
+const getSocketPath = () => {
+  if (process.platform === 'win32') {
+    return '\\\\.\\pipe\\stone-daemon';
+  }
+  // Unix socket in user's runtime directory or tmp
+  const runtimeDir = process.env.XDG_RUNTIME_DIR || os.tmpdir();
+  return path.join(runtimeDir, `stone-daemon-${process.getuid ? process.getuid() : 'user'}.sock`);
+};
+
+/**
+ * Client connection wrapper
+ */
+class IPCClient extends EventEmitter {
+  constructor(socket, clientId) {
+    super();
+    this.socket = socket;
+    this.clientId = clientId;
+    this.buffer = '';
+    this.ownedProcesses = new Set(); // Process IDs owned by this client
+    this.subscriptions = new Set(); // Process IDs this client is subscribed to (may not own)
+
+    this.socket.setEncoding('utf8');
+
+    this.socket.on('data', (data) => {
+      this.buffer += data;
+      this._processBuffer();
+    });
+
+    this.socket.on('close', () => {
+      this.emit('close');
+    });
+
+    this.socket.on('error', (err) => {
+      this.emit('error', err);
+    });
+  }
+
+  _processBuffer() {
+    const lines = this.buffer.split('\n');
+    this.buffer = lines.pop() || ''; // Keep incomplete line in buffer
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const message = JSON.parse(line);
+        this.emit('message', message);
+      } catch (err) {
+        this.emit('error', new Error(`Invalid JSON: ${line}`));
+      }
+    }
+  }
+
+  send(message) {
+    if (this.socket.writable) {
+      this.socket.write(JSON.stringify(message) + '\n');
+    }
+  }
+
+  close() {
+    this.socket.end();
+  }
+
+  addOwnedProcess(processId) {
+    this.ownedProcesses.add(processId);
+  }
+
+  removeOwnedProcess(processId) {
+    this.ownedProcesses.delete(processId);
+  }
+
+  addSubscription(processId) {
+    this.subscriptions.add(processId);
+  }
+
+  removeSubscription(processId) {
+    this.subscriptions.delete(processId);
+  }
+
+  isSubscribedTo(processId) {
+    return this.subscriptions.has(processId) || this.ownedProcesses.has(processId);
+  }
+}
+
+/**
+ * IPC Server
+ */
+export class IPCServer extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    this.socketPath = options.socketPath || getSocketPath();
+    this.server = null;
+    this.clients = new Map(); // clientId -> IPCClient
+    this.clientCounter = 0;
+    this.messageHandlers = new Map(); // command -> handler function
+  }
+
+  /**
+   * Register a message handler
+   * @param {string} command - Command name (e.g., 'run', 'kill', 'list')
+   * @param {Function} handler - Handler function (client, message) => response
+   */
+  onMessage(command, handler) {
+    this.messageHandlers.set(command, handler);
+  }
+
+  /**
+   * Start the IPC server
+   * @returns {Promise<void>}
+   */
+  async start() {
+    // Clean up stale socket file on Unix
+    if (process.platform !== 'win32') {
+      try {
+        await fs.promises.unlink(this.socketPath);
+      } catch (err) {
+        if (err.code !== 'ENOENT') {
+          // Check if another daemon is running
+          try {
+            const testSocket = net.connect(this.socketPath);
+            await new Promise((resolve, reject) => {
+              testSocket.on('connect', () => {
+                testSocket.end();
+                reject(new Error('Another Stone daemon is already running'));
+              });
+              testSocket.on('error', () => {
+                resolve(); // Socket exists but no one is listening
+              });
+            });
+          } catch (e) {
+            if (e.message.includes('Another Stone daemon')) {
+              throw e;
+            }
+          }
+          // Try to remove stale socket
+          await fs.promises.unlink(this.socketPath);
+        }
+      }
+    }
+
+    return new Promise((resolve, reject) => {
+      this.server = net.createServer((socket) => {
+        this._handleConnection(socket);
+      });
+
+      this.server.on('error', (err) => {
+        if (err.code === 'EADDRINUSE') {
+          reject(new Error('Another Stone daemon is already running'));
+        } else {
+          reject(err);
+        }
+      });
+
+      this.server.listen(this.socketPath, () => {
+        // Set socket permissions on Unix
+        if (process.platform !== 'win32') {
+          fs.chmod(this.socketPath, 0o600, () => {});
+        }
+        this.emit('listening', this.socketPath);
+        resolve();
+      });
+    });
+  }
+
+  /**
+   * Stop the IPC server
+   */
+  async stop() {
+    // Close all client connections
+    for (const client of this.clients.values()) {
+      client.close();
+    }
+    this.clients.clear();
+
+    // Close server
+    if (this.server) {
+      return new Promise((resolve) => {
+        this.server.close(() => {
+          // Clean up socket file on Unix
+          if (process.platform !== 'win32') {
+            fs.unlink(this.socketPath, () => {});
+          }
+          resolve();
+        });
+      });
+    }
+  }
+
+  _handleConnection(socket) {
+    const clientId = `client_${++this.clientCounter}`;
+    const client = new IPCClient(socket, clientId);
+    this.clients.set(clientId, client);
+
+    this.emit('connection', client);
+
+    client.on('message', async (message) => {
+      await this._handleMessage(client, message);
+    });
+
+    client.on('close', () => {
+      this.emit('disconnect', client);
+      this.clients.delete(clientId);
+    });
+
+    client.on('error', (err) => {
+      this.emit('clientError', client, err);
+    });
+  }
+
+  async _handleMessage(client, message) {
+    const { cmd, id } = message;
+
+    if (!cmd) {
+      client.send({ id, error: 'Missing command' });
+      return;
+    }
+
+    const handler = this.messageHandlers.get(cmd);
+    if (!handler) {
+      client.send({ id, error: `Unknown command: ${cmd}` });
+      return;
+    }
+
+    try {
+      const response = await handler(client, message);
+      client.send({ id, ...response });
+    } catch (err) {
+      client.send({ id, error: err.message });
+    }
+  }
+
+  /**
+   * Broadcast a message to all connected clients
+   * @param {Object} message - Message to broadcast
+   */
+  broadcast(message) {
+    for (const client of this.clients.values()) {
+      client.send(message);
+    }
+  }
+
+  /**
+   * Send a message to a specific client
+   * @param {string} clientId - Client ID
+   * @param {Object} message - Message to send
+   */
+  sendTo(clientId, message) {
+    const client = this.clients.get(clientId);
+    if (client) {
+      client.send(message);
+    }
+  }
+
+  /**
+   * Send a message to all clients subscribed to a process
+   * @param {string} processId - Process ID
+   * @param {Object} message - Message to send
+   */
+  sendToSubscribers(processId, message) {
+    for (const client of this.clients.values()) {
+      if (client.isSubscribedTo(processId)) {
+        client.send(message);
+      }
+    }
+  }
+
+  /**
+   * Get connected client count
+   * @returns {number}
+   */
+  getClientCount() {
+    return this.clients.size;
+  }
+
+  /**
+   * Get the socket path
+   * @returns {string}
+   */
+  getSocketPath() {
+    return this.socketPath;
+  }
+}
+
+/**
+ * IPC Client for connecting to the daemon
+ */
+export class IPCClientConnection extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    this.socketPath = options.socketPath || getSocketPath();
+    this.socket = null;
+    this.buffer = '';
+    this.pendingRequests = new Map(); // id -> { resolve, reject, timeout }
+    this.requestCounter = 0;
+    this.connected = false;
+  }
+
+  /**
+   * Connect to the daemon
+   * @returns {Promise<void>}
+   */
+  async connect() {
+    return new Promise((resolve, reject) => {
+      this.socket = net.connect(this.socketPath);
+
+      this.socket.setEncoding('utf8');
+
+      this.socket.on('connect', () => {
+        this.connected = true;
+        this.emit('connect');
+        resolve();
+      });
+
+      this.socket.on('data', (data) => {
+        this.buffer += data;
+        this._processBuffer();
+      });
+
+      this.socket.on('close', () => {
+        this.connected = false;
+        this.emit('close');
+        // Reject any pending requests
+        for (const [id, request] of this.pendingRequests.entries()) {
+          clearTimeout(request.timeout);
+          request.reject(new Error('Connection closed'));
+          this.pendingRequests.delete(id);
+        }
+      });
+
+      this.socket.on('error', (err) => {
+        if (!this.connected) {
+          reject(err);
+        } else {
+          this.emit('error', err);
+        }
+      });
+    });
+  }
+
+  _processBuffer() {
+    const lines = this.buffer.split('\n');
+    this.buffer = lines.pop() || '';
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const message = JSON.parse(line);
+        this._handleMessage(message);
+      } catch (err) {
+        this.emit('error', new Error(`Invalid JSON from server: ${line}`));
+      }
+    }
+  }
+
+  _handleMessage(message) {
+    const { id } = message;
+
+    // Check if this is a response to a pending request
+    if (id !== undefined && this.pendingRequests.has(id)) {
+      const request = this.pendingRequests.get(id);
+      clearTimeout(request.timeout);
+      this.pendingRequests.delete(id);
+
+      if (message.error) {
+        request.reject(new Error(message.error));
+      } else {
+        request.resolve(message);
+      }
+      return;
+    }
+
+    // Otherwise, it's an event from the server
+    if (message.event) {
+      this.emit('event', message);
+      this.emit(message.event, message);
+    }
+  }
+
+  /**
+   * Send a request and wait for response
+   * @param {string} cmd - Command name
+   * @param {Object} params - Command parameters
+   * @param {number} timeout - Timeout in ms (default 30000)
+   * @returns {Promise<Object>} Response
+   */
+  async request(cmd, params = {}, timeout = 30000) {
+    if (!this.connected) {
+      throw new Error('Not connected to daemon');
+    }
+
+    const id = ++this.requestCounter;
+    const message = { id, cmd, ...params };
+
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(new Error(`Request timeout: ${cmd}`));
+      }, timeout);
+
+      this.pendingRequests.set(id, { resolve, reject, timeout: timeoutId });
+      this.socket.write(JSON.stringify(message) + '\n');
+    });
+  }
+
+  /**
+   * Send a message without waiting for response
+   * @param {Object} message - Message to send
+   */
+  send(message) {
+    if (this.connected) {
+      this.socket.write(JSON.stringify(message) + '\n');
+    }
+  }
+
+  /**
+   * Disconnect from the daemon
+   */
+  disconnect() {
+    if (this.socket) {
+      this.socket.end();
+    }
+  }
+
+  /**
+   * Check if connected
+   * @returns {boolean}
+   */
+  isConnected() {
+    return this.connected;
+  }
+}
+
+export { getSocketPath };
+export default IPCServer;