stone-lang 0.1.0

package/cli/DaemonClient.js

@@ -0,0 +1,349 @@
+/**
+ * DaemonClient - High-level client for Stone daemon
+ *
+ * Provides a convenient API for CLI commands:
+ * - Auto-starts daemon if not running
+ * - Handles connection management
+ * - Streams script output to adapters
+ */
+
+import { spawn } from 'child_process';
+import { IPCClientConnection, getSocketPath } from '../daemon/IPCServer.js';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+/**
+ * DaemonClient - Client for Stone daemon
+ */
+export class DaemonClient {
+  constructor(options = {}) {
+    this.connection = null;
+    this.outputAdapter = options.outputAdapter || null;
+    this.autoStartDaemon = options.autoStartDaemon !== false;
+    this.daemonStartTimeout = options.daemonStartTimeout || 5000;
+  }
+
+  /**
+   * Connect to the daemon, starting it if necessary
+   */
+  async connect() {
+    if (this.connection && this.connection.isConnected()) {
+      return;
+    }
+
+    try {
+      this.connection = new IPCClientConnection();
+      await this.connection.connect();
+    } catch (err) {
+      // Daemon not running - try to start it
+      if (this.autoStartDaemon && err.code === 'ENOENT' || err.code === 'ECONNREFUSED') {
+        await this.startDaemon();
+        // Retry connection
+        this.connection = new IPCClientConnection();
+        await this.connection.connect();
+      } else {
+        throw err;
+      }
+    }
+
+    // Set up event handling
+    this.connection.on('event', (event) => {
+      this._handleEvent(event);
+    });
+  }
+
+  /**
+   * Start the daemon as a background process
+   */
+  async startDaemon() {
+    const daemonPath = path.join(__dirname, '..', 'daemon', 'daemon.js');
+
+    return new Promise((resolve, reject) => {
+      // Spawn daemon in background
+      const daemon = spawn(process.execPath, [daemonPath], {
+        detached: true,
+        stdio: 'ignore',
+        env: { ...process.env },
+      });
+
+      daemon.unref();
+
+      // Wait for daemon to start
+      let attempts = 0;
+      const maxAttempts = 20;
+      const checkInterval = this.daemonStartTimeout / maxAttempts;
+
+      const checkDaemon = async () => {
+        attempts++;
+
+        try {
+          const testConn = new IPCClientConnection();
+          await testConn.connect();
+          testConn.disconnect();
+          resolve();
+        } catch (err) {
+          if (attempts >= maxAttempts) {
+            reject(new Error('Daemon failed to start'));
+          } else {
+            setTimeout(checkDaemon, checkInterval);
+          }
+        }
+      };
+
+      // Give daemon a moment to start before first check
+      setTimeout(checkDaemon, 200);
+    });
+  }
+
+  /**
+   * Disconnect from the daemon
+   */
+  disconnect() {
+    if (this.connection) {
+      this.connection.disconnect();
+      this.connection = null;
+    }
+  }
+
+  /**
+   * Run a script
+   * @param {string} scriptPath - Path to script file
+   * @param {Object} options - Run options
+   * @returns {Promise<Object>} Execution result
+   */
+  async run(scriptPath, options = {}) {
+    await this.connect();
+
+    const response = await this.connection.request('run', {
+      script: scriptPath,
+      cwd: options.cwd || process.cwd(),
+      variables: options.variables || {},
+    });
+
+    if (response.error) {
+      throw new Error(response.error);
+    }
+
+    const processId = response.processId;
+
+    // Wait for process completion
+    return this._waitForProcess(processId);
+  }
+
+  /**
+   * Run inline source code
+   * @param {string} source - Stone source code
+   * @param {Object} options - Run options
+   * @returns {Promise<Object>} Execution result
+   */
+  async runSource(source, options = {}) {
+    await this.connect();
+
+    const response = await this.connection.request('run', {
+      source,
+      cwd: options.cwd || process.cwd(),
+      variables: options.variables || {},
+    });
+
+    if (response.error) {
+      throw new Error(response.error);
+    }
+
+    const processId = response.processId;
+
+    // Wait for process completion
+    return this._waitForProcess(processId);
+  }
+
+  /**
+   * Kill a running process
+   * @param {string} processId - Process ID
+   * @returns {Promise<boolean>} Whether kill succeeded
+   */
+  async kill(processId) {
+    await this.connect();
+
+    const response = await this.connection.request('kill', { processId });
+
+    if (response.error) {
+      throw new Error(response.error);
+    }
+
+    return response.killed;
+  }
+
+  /**
+   * List processes
+   * @param {Object} filter - Filter options { status, mine }
+   * @returns {Promise<Array>} List of processes
+   */
+  async list(filter = {}) {
+    await this.connect();
+
+    const response = await this.connection.request('list', filter);
+
+    if (response.error) {
+      throw new Error(response.error);
+    }
+
+    return response.processes;
+  }
+
+  /**
+   * Get daemon status
+   * @returns {Promise<Object>} Daemon status
+   */
+  async status() {
+    await this.connect();
+
+    const response = await this.connection.request('status');
+
+    if (response.error) {
+      throw new Error(response.error);
+    }
+
+    return response;
+  }
+
+  /**
+   * Shutdown the daemon
+   * @param {boolean} force - Force shutdown even if other clients connected
+   * @returns {Promise<boolean>}
+   */
+  async shutdown(force = false) {
+    await this.connect();
+
+    const response = await this.connection.request('shutdown', { force });
+
+    if (response.error) {
+      throw new Error(response.error);
+    }
+
+    return response.shutting_down;
+  }
+
+  /**
+   * Wait for a process to complete
+   * @param {string} processId - Process ID
+   * @returns {Promise<Object>} Process result
+   */
+  async _waitForProcess(processId) {
+    return new Promise((resolve, reject) => {
+      const handleEvent = (event) => {
+        if (event.processId !== processId) return;
+
+        switch (event.event) {
+          case 'process:end':
+            this.connection.off('event', handleEvent);
+            resolve({
+              success: event.success,
+              result: event.result,
+              error: event.error,
+              duration: event.duration,
+            });
+            break;
+
+          case 'process:completed':
+            this.connection.off('event', handleEvent);
+            resolve({
+              success: true,
+              result: event.result,
+              duration: event.duration,
+            });
+            break;
+
+          case 'process:failed':
+            this.connection.off('event', handleEvent);
+            resolve({
+              success: false,
+              error: event.error,
+            });
+            break;
+
+          case 'process:killed':
+            this.connection.off('event', handleEvent);
+            resolve({
+              success: false,
+              error: 'Process was killed',
+              killed: true,
+            });
+            break;
+        }
+      };
+
+      this.connection.on('event', handleEvent);
+    });
+  }
+
+  /**
+   * Handle events from daemon
+   */
+  _handleEvent(event) {
+    if (!this.outputAdapter) return;
+
+    switch (event.event) {
+      case 'print':
+        this.outputAdapter.print(event.value);
+        break;
+
+      case 'terminal:create':
+        this.outputAdapter.createTerminal(event.id, event.type, event.config);
+        break;
+
+      case 'terminal:add':
+        this.outputAdapter.addToTerminal(event.id, event.data);
+        break;
+
+      case 'terminal:set':
+        this.outputAdapter.setTerminal(event.id, event.data);
+        break;
+
+      case 'terminal:clear':
+        this.outputAdapter.clearTerminal(event.id);
+        break;
+
+      case 'error':
+        this.outputAdapter.error(event.message, event.location);
+        break;
+
+      case 'process:end':
+        this.outputAdapter.finish(event.success, event.result);
+        break;
+    }
+  }
+
+  /**
+   * Set the output adapter
+   * @param {OutputAdapter} adapter
+   */
+  setOutputAdapter(adapter) {
+    this.outputAdapter = adapter;
+  }
+
+  /**
+   * Check if daemon is running
+   * @returns {Promise<boolean>}
+   */
+  static async isDaemonRunning() {
+    try {
+      const conn = new IPCClientConnection();
+      await conn.connect();
+      conn.disconnect();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get the daemon socket path
+   * @returns {string}
+   */
+  static getSocketPath() {
+    return getSocketPath();
+  }
+}
+
+export default DaemonClient;

package/cli/JSONOutputAdapter.js

@@ -0,0 +1,135 @@
+/**
+ * JSONOutputAdapter - JSON Lines streaming output
+ *
+ * Outputs Stone execution events as newline-delimited JSON (NDJSON).
+ * Useful for:
+ * - IDE integrations (VS Code, IntelliJ)
+ * - Desktop app communication (Riva)
+ * - CI/CD pipelines
+ * - Log processing
+ *
+ * Each line is a complete JSON object with a "type" field.
+ */
+
+import { OutputAdapter } from '../adapters/OutputAdapter.js';
+
+/**
+ * JSONOutputAdapter - Outputs events as JSON Lines
+ */
+export class JSONOutputAdapter extends OutputAdapter {
+  constructor(options = {}) {
+    super();
+    this.stream = options.stream || process.stdout;
+    this.includeTimestamps = options.timestamps !== false;
+    this.processId = options.processId || null;
+
+    // Track terminals for final output
+    this.terminals = {};
+  }
+
+  _emit(event) {
+    if (this.includeTimestamps) {
+      event.timestamp = Date.now();
+    }
+    if (this.processId) {
+      event.processId = this.processId;
+    }
+    this.stream.write(JSON.stringify(event) + '\n');
+  }
+
+  print(text) {
+    this._emit({
+      type: 'print',
+      value: text,
+    });
+  }
+
+  createTerminal(id, type, config) {
+    this.terminals[id] = {
+      type,
+      config,
+      data: [],
+    };
+
+    this._emit({
+      type: 'terminal:create',
+      id,
+      terminalType: type,
+      config,
+    });
+  }
+
+  addToTerminal(id, data) {
+    const terminal = this.terminals[id];
+    if (terminal) {
+      const items = Array.isArray(data) ? data : [data];
+      terminal.data.push(...items);
+    }
+
+    this._emit({
+      type: 'terminal:add',
+      id,
+      data,
+    });
+  }
+
+  setTerminal(id, data) {
+    const terminal = this.terminals[id];
+    if (terminal) {
+      terminal.data = Array.isArray(data) ? data : [data];
+    }
+
+    this._emit({
+      type: 'terminal:set',
+      id,
+      data,
+    });
+  }
+
+  clearTerminal(id) {
+    const terminal = this.terminals[id];
+    if (terminal) {
+      terminal.data = [];
+    }
+
+    this._emit({
+      type: 'terminal:clear',
+      id,
+    });
+  }
+
+  error(message, location) {
+    this._emit({
+      type: 'error',
+      message,
+      location,
+    });
+  }
+
+  finish(success, result) {
+    this._emit({
+      type: 'finish',
+      success,
+      result: success ? result : undefined,
+      error: !success && result ? (result.message || String(result)) : undefined,
+      terminals: this.terminals,
+    });
+  }
+
+  progress(info) {
+    this._emit({
+      type: 'progress',
+      ...info,
+    });
+  }
+
+  /**
+   * Get all terminal data
+   * @returns {Object}
+   */
+  getTerminals() {
+    return this.terminals;
+  }
+}
+
+export default JSONOutputAdapter;