stone-lang 0.1.0

package/daemon/ProcessManager.js

@@ -0,0 +1,327 @@
+/**
+ * ProcessManager - Manages Stone script execution processes
+ *
+ * Tracks running scripts, their owners, and provides lifecycle management.
+ * When a client disconnects, all its owned processes are killed.
+ *
+ * Process states:
+ * - pending: Waiting to start
+ * - running: Currently executing
+ * - completed: Finished successfully
+ * - failed: Finished with error
+ * - killed: Terminated by user
+ */
+
+import { EventEmitter } from 'events';
+
+/**
+ * Process entry in the process table
+ */
+class StoneProcess {
+  constructor(id, script, owner, options = {}) {
+    this.id = id;
+    this.script = script; // Script path or source
+    this.owner = owner; // Client ID that started this process
+    this.status = 'pending';
+    this.startTime = null;
+    this.endTime = null;
+    this.result = null;
+    this.error = null;
+    this.terminalsData = {};
+
+    // Execution options
+    this.cwd = options.cwd || process.cwd();
+    this.variables = options.variables || {};
+    this.maxIterations = options.maxIterations || 100000;
+
+    // Runner reference (set when execution starts)
+    this.runner = null;
+
+    // Kill signal
+    this._killRequested = false;
+  }
+
+  toJSON() {
+    return {
+      id: this.id,
+      script: this.script,
+      owner: this.owner,
+      status: this.status,
+      startTime: this.startTime,
+      endTime: this.endTime,
+      duration: this.getDuration(),
+    };
+  }
+
+  getDuration() {
+    if (!this.startTime) return 0;
+    const end = this.endTime || Date.now();
+    return end - this.startTime;
+  }
+
+  requestKill() {
+    this._killRequested = true;
+    if (this.runner && typeof this.runner.kill === 'function') {
+      this.runner.kill();
+    }
+  }
+
+  isKillRequested() {
+    return this._killRequested;
+  }
+}
+
+/**
+ * ProcessManager - Central process table and lifecycle management
+ */
+export class ProcessManager extends EventEmitter {
+  constructor() {
+    super();
+    this.processes = new Map(); // processId -> StoneProcess
+    this.processCounter = 0;
+
+    // Owner tracking: clientId -> Set of processIds
+    this.ownerProcesses = new Map();
+  }
+
+  /**
+   * Create a new process entry
+   * @param {string} script - Script path or source
+   * @param {string} owner - Client ID that owns this process
+   * @param {Object} options - Execution options
+   * @returns {StoneProcess} The created process
+   */
+  createProcess(script, owner, options = {}) {
+    const id = `p${++this.processCounter}`;
+    const process = new StoneProcess(id, script, owner, options);
+    this.processes.set(id, process);
+
+    // Track owner
+    if (!this.ownerProcesses.has(owner)) {
+      this.ownerProcesses.set(owner, new Set());
+    }
+    this.ownerProcesses.get(owner).add(id);
+
+    this.emit('process:created', process);
+    return process;
+  }
+
+  /**
+   * Start a process
+   * @param {string} processId - Process ID
+   */
+  startProcess(processId) {
+    const process = this.processes.get(processId);
+    if (!process) {
+      throw new Error(`Process not found: ${processId}`);
+    }
+    if (process.status !== 'pending') {
+      throw new Error(`Process ${processId} is not in pending state`);
+    }
+
+    process.status = 'running';
+    process.startTime = Date.now();
+    this.emit('process:started', process);
+  }
+
+  /**
+   * Complete a process successfully
+   * @param {string} processId - Process ID
+   * @param {any} result - Execution result
+   * @param {Object} terminalsData - Terminal data
+   */
+  completeProcess(processId, result, terminalsData = {}) {
+    const process = this.processes.get(processId);
+    if (!process) return;
+
+    process.status = 'completed';
+    process.endTime = Date.now();
+    process.result = result;
+    process.terminalsData = terminalsData;
+
+    this.emit('process:completed', process);
+  }
+
+  /**
+   * Fail a process
+   * @param {string} processId - Process ID
+   * @param {Error|string} error - Error that caused failure
+   */
+  failProcess(processId, error) {
+    const process = this.processes.get(processId);
+    if (!process) return;
+
+    process.status = 'failed';
+    process.endTime = Date.now();
+    process.error = error instanceof Error ? error.message : error;
+
+    this.emit('process:failed', process);
+  }
+
+  /**
+   * Kill a process
+   * @param {string} processId - Process ID
+   * @param {string} requestedBy - Client ID requesting the kill (for auth)
+   * @returns {boolean} Whether the kill was successful
+   */
+  killProcess(processId, requestedBy = null) {
+    const process = this.processes.get(processId);
+    if (!process) {
+      return false;
+    }
+
+    // Check authorization (only owner can kill, unless admin)
+    if (requestedBy && process.owner !== requestedBy) {
+      throw new Error(`Not authorized to kill process ${processId}`);
+    }
+
+    // Only kill running processes
+    if (process.status !== 'running') {
+      return false;
+    }
+
+    process.requestKill();
+    process.status = 'killed';
+    process.endTime = Date.now();
+
+    this.emit('process:killed', process);
+    return true;
+  }
+
+  /**
+   * Get a process by ID
+   * @param {string} processId - Process ID
+   * @returns {StoneProcess|null}
+   */
+  getProcess(processId) {
+    return this.processes.get(processId) || null;
+  }
+
+  /**
+   * List all processes
+   * @param {Object} filter - Optional filter { status, owner }
+   * @returns {StoneProcess[]}
+   */
+  listProcesses(filter = {}) {
+    let result = Array.from(this.processes.values());
+
+    if (filter.status) {
+      result = result.filter(p => p.status === filter.status);
+    }
+
+    if (filter.owner) {
+      result = result.filter(p => p.owner === filter.owner);
+    }
+
+    return result;
+  }
+
+  /**
+   * Get processes owned by a client
+   * @param {string} owner - Client ID
+   * @returns {StoneProcess[]}
+   */
+  getProcessesByOwner(owner) {
+    const processIds = this.ownerProcesses.get(owner) || new Set();
+    return Array.from(processIds).map(id => this.processes.get(id)).filter(Boolean);
+  }
+
+  /**
+   * Kill all processes owned by a client
+   * Called when a client disconnects
+   * @param {string} owner - Client ID
+   * @returns {string[]} IDs of killed processes
+   */
+  killProcessesByOwner(owner) {
+    const killed = [];
+    const processIds = this.ownerProcesses.get(owner) || new Set();
+
+    for (const processId of processIds) {
+      const process = this.processes.get(processId);
+      if (process && process.status === 'running') {
+        this.killProcess(processId);
+        killed.push(processId);
+      }
+    }
+
+    return killed;
+  }
+
+  /**
+   * Clean up a process entry
+   * Called after process completes/fails and client has retrieved result
+   * @param {string} processId - Process ID
+   */
+  removeProcess(processId) {
+    const process = this.processes.get(processId);
+    if (!process) return;
+
+    // Remove from owner tracking
+    const ownerSet = this.ownerProcesses.get(process.owner);
+    if (ownerSet) {
+      ownerSet.delete(processId);
+      if (ownerSet.size === 0) {
+        this.ownerProcesses.delete(process.owner);
+      }
+    }
+
+    this.processes.delete(processId);
+    this.emit('process:removed', process);
+  }
+
+  /**
+   * Clean up old completed/failed processes
+   * @param {number} maxAge - Max age in ms (default 1 hour)
+   */
+  cleanupOldProcesses(maxAge = 3600000) {
+    const now = Date.now();
+    const toRemove = [];
+
+    for (const [id, process] of this.processes.entries()) {
+      if (process.status === 'completed' ||
+          process.status === 'failed' ||
+          process.status === 'killed') {
+        if (process.endTime && (now - process.endTime) > maxAge) {
+          toRemove.push(id);
+        }
+      }
+    }
+
+    for (const id of toRemove) {
+      this.removeProcess(id);
+    }
+
+    return toRemove.length;
+  }
+
+  /**
+   * Get process count by status
+   * @returns {Object} { pending, running, completed, failed, killed }
+   */
+  getProcessStats() {
+    const stats = { pending: 0, running: 0, completed: 0, failed: 0, killed: 0, total: 0 };
+
+    for (const process of this.processes.values()) {
+      stats[process.status] = (stats[process.status] || 0) + 1;
+      stats.total++;
+    }
+
+    return stats;
+  }
+
+  /**
+   * Check if there are any running processes
+   * @returns {boolean}
+   */
+  hasRunningProcesses() {
+    for (const process of this.processes.values()) {
+      if (process.status === 'running') {
+        return true;
+      }
+    }
+    return false;
+  }
+}
+
+export { StoneProcess };
+export default ProcessManager;

package/daemon/ProcessRunner.js

@@ -0,0 +1,307 @@
+/**
+ * ProcessRunner - Executes Stone scripts and streams events
+ *
+ * Uses the StoneEngine with a streaming OutputAdapter to send
+ * real-time updates to connected clients via the IPC server.
+ *
+ * Events emitted:
+ * - terminal:create - New terminal created
+ * - terminal:add - Data added to terminal
+ * - terminal:set - Terminal data replaced
+ * - terminal:clear - Terminal cleared
+ * - print - Print output
+ * - error - Execution error
+ * - complete - Execution completed
+ */
+
+import { EventEmitter } from 'events';
+import { OutputAdapter } from '../adapters/OutputAdapter.js';
+import { StoneEngine } from '../StoneEngine.js';
+import { createNodePackageContext } from '../packages/packageResolver.js';
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * StreamingOutputAdapter - Streams output events to the process runner
+ */
+class StreamingOutputAdapter extends OutputAdapter {
+  constructor(processId, eventEmitter) {
+    super();
+    this.processId = processId;
+    this.emitter = eventEmitter;
+    this.terminalsData = {}; // Local copy for backward compat
+  }
+
+  print(text) {
+    this.emitter.emit('event', {
+      event: 'print',
+      processId: this.processId,
+      value: text,
+    });
+  }
+
+  createTerminal(id, type, config) {
+    this.terminalsData[id] = {
+      type,
+      config,
+      plots: type === 'graph2d' ? [] : undefined,
+      objects: type === 'graph3d' ? [] : undefined,
+      lines: type === 'console' ? [] : undefined,
+    };
+
+    this.emitter.emit('event', {
+      event: 'terminal:create',
+      processId: this.processId,
+      id,
+      type,
+      terminalType: type, // Alias for renderer compatibility
+      config,
+    });
+  }
+
+  addToTerminal(id, data) {
+    const terminal = this.terminalsData[id];
+    if (terminal) {
+      const items = Array.isArray(data) ? data : [data];
+      switch (terminal.type) {
+        case 'graph2d':
+          terminal.plots.push(...items);
+          break;
+        case 'graph3d':
+          terminal.objects.push(...items);
+          break;
+        case 'console':
+          terminal.lines.push(...items);
+          break;
+      }
+    }
+
+    this.emitter.emit('event', {
+      event: 'terminal:add',
+      processId: this.processId,
+      id,
+      data,
+    });
+  }
+
+  setTerminal(id, data) {
+    const terminal = this.terminalsData[id];
+    if (terminal) {
+      const items = Array.isArray(data) ? data : [data];
+      switch (terminal.type) {
+        case 'graph2d':
+          terminal.plots = items;
+          break;
+        case 'graph3d':
+          terminal.objects = items;
+          break;
+        case 'console':
+          terminal.lines = items;
+          break;
+      }
+    }
+
+    this.emitter.emit('event', {
+      event: 'terminal:set',
+      processId: this.processId,
+      id,
+      data,
+    });
+  }
+
+  clearTerminal(id) {
+    const terminal = this.terminalsData[id];
+    if (terminal) {
+      switch (terminal.type) {
+        case 'graph2d':
+          terminal.plots = [];
+          break;
+        case 'graph3d':
+          terminal.objects = [];
+          break;
+        case 'console':
+          terminal.lines = [];
+          break;
+      }
+    }
+
+    this.emitter.emit('event', {
+      event: 'terminal:clear',
+      processId: this.processId,
+      id,
+    });
+  }
+
+  error(message, location) {
+    this.emitter.emit('event', {
+      event: 'error',
+      processId: this.processId,
+      message,
+      location,
+    });
+  }
+
+  finish(success, result) {
+    // Don't emit here - ProcessRunner handles completion
+  }
+
+  getTerminalsData() {
+    return this.terminalsData;
+  }
+}
+
+/**
+ * ProcessRunner - Runs a Stone script and streams output
+ */
+export class ProcessRunner extends EventEmitter {
+  constructor(stoneProcess, options = {}) {
+    super();
+    this.process = stoneProcess;
+    this.engine = null;
+    this.adapter = null;
+    this._killed = false;
+
+    // Options
+    this.scriptPath = options.scriptPath || null;
+    this.source = options.source || null;
+    this.cwd = options.cwd || process.cwd();
+  }
+
+  /**
+   * Run the script
+   * @returns {Promise<Object>} Execution result
+   */
+  async run() {
+    if (this._killed) {
+      return { success: false, error: 'Process was killed before starting' };
+    }
+
+    try {
+      // Create streaming adapter
+      this.adapter = new StreamingOutputAdapter(this.process.id, this);
+
+      // Create engine with adapter
+      this.engine = new StoneEngine({
+        outputAdapter: this.adapter,
+        debug: false,
+      });
+
+      // Set up package context for stone_modules resolution
+      try {
+        const packageContext = await createNodePackageContext();
+        this.engine.setPackageContext(packageContext);
+      } catch (e) {
+        // Package context not available, continue without it
+      }
+
+      // Load source code
+      let source = this.source;
+      let filename = '<stdin>';
+
+      if (!source && this.scriptPath) {
+        // Read from file
+        const fullPath = path.isAbsolute(this.scriptPath)
+          ? this.scriptPath
+          : path.join(this.cwd, this.scriptPath);
+
+        if (!fs.existsSync(fullPath)) {
+          throw new Error(`Script not found: ${fullPath}`);
+        }
+
+        source = fs.readFileSync(fullPath, 'utf8');
+        filename = this.scriptPath;
+      }
+
+      if (!source) {
+        throw new Error('No script source provided');
+      }
+
+      // Emit start event
+      this.emit('event', {
+        event: 'process:start',
+        processId: this.process.id,
+        script: filename,
+      });
+
+      // Check for kill before expensive operations
+      if (this._killed) {
+        return { success: false, error: 'Process was killed' };
+      }
+
+      // Execute
+      const result = await this.engine.execute(source, {
+        filename,
+        currentPath: this.scriptPath ? path.dirname(path.resolve(this.cwd, this.scriptPath)) : this.cwd,
+        variables: this.process.variables || {},
+        maxIterations: this.process.maxIterations || 100000,
+      });
+
+      // Emit completion
+      this.emit('event', {
+        event: 'process:end',
+        processId: this.process.id,
+        success: result.success,
+        result: result.result,
+        error: result.error || null,
+        duration: result.duration,
+      });
+
+      return {
+        success: result.success,
+        result: result.result,
+        error: result.error,
+        terminalsData: this.adapter.getTerminalsData(),
+        duration: result.duration,
+      };
+    } catch (error) {
+      // Emit error event
+      this.emit('event', {
+        event: 'process:end',
+        processId: this.process.id,
+        success: false,
+        error: error.message,
+      });
+
+      return {
+        success: false,
+        error: error.message,
+        terminalsData: this.adapter ? this.adapter.getTerminalsData() : {},
+      };
+    }
+  }
+
+  /**
+   * Kill the running script
+   */
+  kill() {
+    this._killed = true;
+    // The VM/executor will check for kill flag
+    // In the future, could use AbortController pattern
+  }
+
+  /**
+   * Check if process was killed
+   * @returns {boolean}
+   */
+  isKilled() {
+    return this._killed;
+  }
+}
+
+/**
+ * Create and run a process
+ * @param {StoneProcess} stoneProcess - Process entry from ProcessManager
+ * @param {Object} options - Runner options
+ * @returns {Promise<Object>} Execution result
+ */
+export async function runProcess(stoneProcess, options = {}) {
+  const runner = new ProcessRunner(stoneProcess, options);
+
+  // Link runner to process for kill support
+  stoneProcess.runner = runner;
+
+  return runner.run();
+}
+
+export { StreamingOutputAdapter };
+export default ProcessRunner;