stone-lang 0.1.0

package/daemon/daemon.js

@@ -0,0 +1,398 @@
+/**
+ * Stone Daemon - Central process manager for Stone scripts
+ *
+ * The daemon provides:
+ * - Process management (start, kill, list scripts)
+ * - Streaming output to connected clients
+ * - Automatic cleanup when clients disconnect
+ * - Auto-shutdown when idle (no clients, no running processes)
+ *
+ * Usage:
+ *   node daemon.js [--foreground] [--no-auto-shutdown]
+ *
+ * CLI clients connect via IPC to run scripts:
+ *   stone run script.stn -> connects to daemon, streams output
+ */
+
+import { IPCServer } from './IPCServer.js';
+import { ProcessManager } from './ProcessManager.js';
+import { ProcessRunner, runProcess } from './ProcessRunner.js';
+
+const DEFAULT_IDLE_TIMEOUT = 60000; // 1 minute with no activity = shutdown
+
+/**
+ * StoneDaemon - Main daemon class
+ */
+export class StoneDaemon {
+  constructor(options = {}) {
+    this.ipc = new IPCServer(options);
+    this.processManager = new ProcessManager();
+
+    this.autoShutdown = options.autoShutdown !== false;
+    this.idleTimeout = options.idleTimeout || DEFAULT_IDLE_TIMEOUT;
+    this._shutdownTimer = null;
+    this._isShuttingDown = false;
+
+    this._setupMessageHandlers();
+    this._setupEventForwarding();
+  }
+
+  /**
+   * Start the daemon
+   */
+  async start() {
+    console.log('Starting Stone daemon...');
+
+    try {
+      await this.ipc.start();
+      console.log(`Stone daemon listening on: ${this.ipc.getSocketPath()}`);
+
+      // Start idle timer
+      this._resetIdleTimer();
+
+      // Handle process signals
+      process.on('SIGINT', () => this.shutdown());
+      process.on('SIGTERM', () => this.shutdown());
+
+    } catch (err) {
+      console.error('Failed to start daemon:', err.message);
+      process.exit(1);
+    }
+  }
+
+  /**
+   * Shutdown the daemon
+   */
+  async shutdown() {
+    if (this._isShuttingDown) return;
+    this._isShuttingDown = true;
+
+    console.log('Shutting down Stone daemon...');
+
+    // Clear idle timer
+    if (this._shutdownTimer) {
+      clearTimeout(this._shutdownTimer);
+    }
+
+    // Kill all running processes
+    const stats = this.processManager.getProcessStats();
+    if (stats.running > 0) {
+      console.log(`Killing ${stats.running} running processes...`);
+      for (const proc of this.processManager.listProcesses({ status: 'running' })) {
+        this.processManager.killProcess(proc.id);
+      }
+    }
+
+    // Stop IPC server
+    await this.ipc.stop();
+
+    console.log('Stone daemon stopped.');
+    process.exit(0);
+  }
+
+  _setupMessageHandlers() {
+    // Run a script
+    this.ipc.onMessage('run', async (client, message) => {
+      return this._handleRun(client, message);
+    });
+
+    // Kill a process
+    this.ipc.onMessage('kill', async (client, message) => {
+      return this._handleKill(client, message);
+    });
+
+    // List processes
+    this.ipc.onMessage('list', async (client, message) => {
+      return this._handleList(client, message);
+    });
+
+    // Get process info
+    this.ipc.onMessage('info', async (client, message) => {
+      return this._handleInfo(client, message);
+    });
+
+    // Subscribe to process events (for processes not owned by this client)
+    this.ipc.onMessage('subscribe', async (client, message) => {
+      return this._handleSubscribe(client, message);
+    });
+
+    // Ping (keepalive)
+    this.ipc.onMessage('ping', async () => {
+      return { pong: true, time: Date.now() };
+    });
+
+    // Get daemon status
+    this.ipc.onMessage('status', async () => {
+      return {
+        status: 'running',
+        clients: this.ipc.getClientCount(),
+        processes: this.processManager.getProcessStats(),
+        socketPath: this.ipc.getSocketPath(),
+        uptime: process.uptime(),
+      };
+    });
+
+    // Shutdown daemon
+    this.ipc.onMessage('shutdown', async (client, message) => {
+      // Only allow shutdown if no other clients are connected
+      // or if force flag is set
+      if (this.ipc.getClientCount() > 1 && !message.force) {
+        return { error: 'Other clients are connected. Use --force to override.' };
+      }
+
+      // Schedule shutdown (don't await - respond first)
+      setImmediate(() => this.shutdown());
+      return { shutting_down: true };
+    });
+  }
+
+  _setupEventForwarding() {
+    // Client connected
+    this.ipc.on('connection', (client) => {
+      console.log(`Client connected: ${client.clientId}`);
+      this._resetIdleTimer();
+    });
+
+    // Client disconnected
+    this.ipc.on('disconnect', (client) => {
+      console.log(`Client disconnected: ${client.clientId}`);
+
+      // Kill processes owned by this client
+      const killed = this.processManager.killProcessesByOwner(client.clientId);
+      if (killed.length > 0) {
+        console.log(`Killed ${killed.length} processes owned by ${client.clientId}`);
+      }
+
+      // Check for auto-shutdown
+      this._checkIdleShutdown();
+    });
+
+    // Process events - broadcast process:created to ALL clients so they can subscribe
+    this.processManager.on('process:created', (proc) => {
+      // Broadcast to ALL clients (not just subscribers) so desktop can auto-subscribe
+      this.ipc.broadcast({
+        event: 'process:created',
+        processId: proc.id,
+        process: proc.toJSON(),
+      });
+    });
+
+    this.processManager.on('process:started', (proc) => {
+      this.ipc.sendToSubscribers(proc.id, {
+        event: 'process:started',
+        processId: proc.id,
+      });
+    });
+
+    this.processManager.on('process:completed', (proc) => {
+      this.ipc.sendToSubscribers(proc.id, {
+        event: 'process:completed',
+        processId: proc.id,
+        result: proc.result,
+        duration: proc.getDuration(),
+      });
+      this._resetIdleTimer();
+    });
+
+    this.processManager.on('process:failed', (proc) => {
+      this.ipc.sendToSubscribers(proc.id, {
+        event: 'process:failed',
+        processId: proc.id,
+        error: proc.error,
+      });
+      this._resetIdleTimer();
+    });
+
+    this.processManager.on('process:killed', (proc) => {
+      this.ipc.sendToSubscribers(proc.id, {
+        event: 'process:killed',
+        processId: proc.id,
+      });
+      this._resetIdleTimer();
+    });
+  }
+
+  async _handleRun(client, message) {
+    const { script, source, cwd, variables } = message;
+
+    if (!script && !source) {
+      throw new Error('Either script path or source is required');
+    }
+
+    // Create process entry
+    const proc = this.processManager.createProcess(
+      script || '<inline>',
+      client.clientId,
+      { cwd, variables }
+    );
+
+    // Mark as running
+    this.processManager.startProcess(proc.id);
+    client.addOwnedProcess(proc.id);
+
+    // Create runner and set up event forwarding to subscribers
+    const runner = new ProcessRunner(proc, {
+      scriptPath: script,
+      source: source,
+      cwd: cwd || process.cwd(),
+    });
+
+    // Forward runner events to all subscribed clients (owner + subscribers)
+    runner.on('event', (event) => {
+      this.ipc.sendToSubscribers(proc.id, event);
+    });
+
+    // Link runner to process for kill support
+    proc.runner = runner;
+
+    // Run async
+    runner.run().then((result) => {
+      if (result.success) {
+        this.processManager.completeProcess(proc.id, result.result, result.terminalsData);
+      } else {
+        this.processManager.failProcess(proc.id, result.error);
+      }
+    }).catch((err) => {
+      this.processManager.failProcess(proc.id, err.message);
+    });
+
+    // Return immediately with process info
+    return { processId: proc.id, status: 'started' };
+  }
+
+  async _handleKill(client, message) {
+    const { processId } = message;
+
+    if (!processId) {
+      throw new Error('Process ID is required');
+    }
+
+    const success = this.processManager.killProcess(processId, client.clientId);
+
+    if (success) {
+      client.removeOwnedProcess(processId);
+      return { killed: true, processId };
+    } else {
+      return { killed: false, processId, reason: 'Process not running or not found' };
+    }
+  }
+
+  async _handleList(client, message) {
+    const { status, mine } = message;
+
+    const filter = {};
+    if (status) filter.status = status;
+    if (mine) filter.owner = client.clientId;
+
+    const processes = this.processManager.listProcesses(filter);
+
+    return {
+      processes: processes.map(p => p.toJSON()),
+      count: processes.length,
+    };
+  }
+
+  async _handleInfo(client, message) {
+    const { processId } = message;
+
+    if (!processId) {
+      throw new Error('Process ID is required');
+    }
+
+    const proc = this.processManager.getProcess(processId);
+    if (!proc) {
+      return { found: false, processId };
+    }
+
+    return { found: true, process: proc.toJSON() };
+  }
+
+  async _handleSubscribe(client, message) {
+    const { processId } = message;
+
+    if (!processId) {
+      throw new Error('Process ID is required');
+    }
+
+    const proc = this.processManager.getProcess(processId);
+    if (!proc) {
+      return { subscribed: false, reason: 'Process not found' };
+    }
+
+    // Add subscription for this client to receive events for this process
+    client.addSubscription(processId);
+
+    // If process is already complete, send current state including terminalsData
+    if (proc.status === 'completed' || proc.status === 'failed' || proc.status === 'killed') {
+      return {
+        subscribed: true,
+        process: proc.toJSON(),
+        terminalsData: proc.terminalsData,
+        status: proc.status,
+        result: proc.result,
+        error: proc.error,
+      };
+    }
+
+    // Process is still running, client will receive future events
+    return {
+      subscribed: true,
+      process: proc.toJSON(),
+      status: proc.status,
+    };
+  }
+
+  _resetIdleTimer() {
+    if (!this.autoShutdown) return;
+
+    if (this._shutdownTimer) {
+      clearTimeout(this._shutdownTimer);
+      this._shutdownTimer = null;
+    }
+  }
+
+  _checkIdleShutdown() {
+    if (!this.autoShutdown) return;
+
+    // Don't shutdown if there are connected clients
+    if (this.ipc.getClientCount() > 0) return;
+
+    // Don't shutdown if there are running processes
+    if (this.processManager.hasRunningProcesses()) return;
+
+    // Schedule shutdown
+    console.log(`No clients or running processes. Shutting down in ${this.idleTimeout / 1000}s...`);
+    this._shutdownTimer = setTimeout(() => {
+      // Double-check before shutdown
+      if (this.ipc.getClientCount() === 0 && !this.processManager.hasRunningProcesses()) {
+        console.log('Idle timeout reached. Shutting down.');
+        this.shutdown();
+      }
+    }, this.idleTimeout);
+  }
+}
+
+// CLI entry point
+async function main() {
+  const args = process.argv.slice(2);
+
+  const options = {
+    autoShutdown: !args.includes('--no-auto-shutdown'),
+  };
+
+  const daemon = new StoneDaemon(options);
+  await daemon.start();
+
+  // Keep process running
+  console.log('Stone daemon is running. Press Ctrl+C to stop.');
+}
+
+// Run if executed directly
+if (process.argv[1] && process.argv[1].includes('daemon.js')) {
+  main().catch((err) => {
+    console.error('Fatal error:', err);
+    process.exit(1);
+  });
+}
+
+export default StoneDaemon;

package/daemon/index.js

@@ -0,0 +1,16 @@
+/**
+ * Stone Daemon - Process management for Stone scripts
+ *
+ * Exports:
+ * - StoneDaemon - Main daemon class
+ * - IPCServer - IPC server for client connections
+ * - IPCClientConnection - Client for connecting to daemon
+ * - ProcessManager - Process table and lifecycle
+ * - ProcessRunner - Script execution with streaming
+ */
+
+export { StoneDaemon } from './daemon.js';
+export { default as StoneDaemon_default } from './daemon.js';
+export { IPCServer, IPCClientConnection, getSocketPath } from './IPCServer.js';
+export { ProcessManager, StoneProcess } from './ProcessManager.js';
+export { ProcessRunner, runProcess, StreamingOutputAdapter } from './ProcessRunner.js';

package/frontend/analysis/index.js

@@ -0,0 +1,5 @@
+/**
+ * Frontend Analysis - Barrel exports
+ */
+export { LivenessAnalyzer } from './livenessAnalyzer.js';
+export { ImportAnalyzer, TreeShaker, createTreeShaker } from './treeShaker.js';