stone-lang 0.1.0

package/cli/commands/daemon.js

@@ -0,0 +1,189 @@
+/**
+ * daemon command - Manage the Stone daemon
+ *
+ * Usage:
+ *   stone daemon status    - Check daemon status
+ *   stone daemon start     - Start daemon (usually auto-started)
+ *   stone daemon stop      - Stop daemon
+ */
+
+import { spawn } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { DaemonClient } from '../DaemonClient.js';
+import { getSocketPath } from '../../daemon/IPCServer.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Daemon management command
+ * @param {string} action - Action to perform (status, start, stop)
+ * @param {Object} options - Command options
+ */
+export async function daemonCommand(action, options = {}) {
+  const { json = false, force = false } = options;
+
+  switch (action) {
+    case 'status':
+      await statusAction(json);
+      break;
+
+    case 'start':
+      await startAction(json);
+      break;
+
+    case 'stop':
+      await stopAction(json, force);
+      break;
+
+    default:
+      if (json) {
+        console.log(JSON.stringify({ error: `Unknown action: ${action}` }));
+      } else {
+        console.error(`Unknown action: ${action}`);
+        console.log('Usage: stone daemon <status|start|stop>');
+      }
+      process.exit(1);
+  }
+}
+
+async function statusAction(json) {
+  try {
+    const isRunning = await DaemonClient.isDaemonRunning();
+
+    if (!isRunning) {
+      if (json) {
+        console.log(JSON.stringify({ running: false }));
+      } else {
+        console.log('Stone daemon is not running.');
+        console.log(`Socket path: ${getSocketPath()}`);
+      }
+      return;
+    }
+
+    const client = new DaemonClient({ autoStartDaemon: false });
+    await client.connect();
+    const status = await client.status();
+    client.disconnect();
+
+    if (json) {
+      console.log(JSON.stringify({ running: true, ...status }));
+    } else {
+      console.log('Stone daemon is running.');
+      console.log(`Socket path: ${status.socketPath}`);
+      console.log(`Connected clients: ${status.clients}`);
+      console.log(`Uptime: ${Math.round(status.uptime)}s`);
+      console.log(`Processes: ${JSON.stringify(status.processes)}`);
+    }
+  } catch (err) {
+    if (json) {
+      console.log(JSON.stringify({ running: false, error: err.message }));
+    } else {
+      console.error(`Error checking status: ${err.message}`);
+    }
+    process.exit(1);
+  }
+}
+
+async function startAction(json) {
+  try {
+    const isRunning = await DaemonClient.isDaemonRunning();
+
+    if (isRunning) {
+      if (json) {
+        console.log(JSON.stringify({ started: false, reason: 'Already running' }));
+      } else {
+        console.log('Stone daemon is already running.');
+      }
+      return;
+    }
+
+    // Start daemon
+    const daemonPath = path.join(__dirname, '..', '..', 'daemon', 'daemon.js');
+
+    const daemon = spawn(process.execPath, [daemonPath], {
+      detached: true,
+      stdio: 'ignore',
+    });
+
+    daemon.unref();
+
+    // Wait for daemon to start
+    let started = false;
+    for (let i = 0; i < 20; i++) {
+      await new Promise(r => setTimeout(r, 250));
+      if (await DaemonClient.isDaemonRunning()) {
+        started = true;
+        break;
+      }
+    }
+
+    if (json) {
+      console.log(JSON.stringify({ started }));
+    } else {
+      if (started) {
+        console.log('Stone daemon started.');
+        console.log(`Socket path: ${getSocketPath()}`);
+      } else {
+        console.error('Failed to start daemon.');
+        process.exit(1);
+      }
+    }
+  } catch (err) {
+    if (json) {
+      console.log(JSON.stringify({ started: false, error: err.message }));
+    } else {
+      console.error(`Error starting daemon: ${err.message}`);
+    }
+    process.exit(1);
+  }
+}
+
+async function stopAction(json, force) {
+  try {
+    const isRunning = await DaemonClient.isDaemonRunning();
+
+    if (!isRunning) {
+      if (json) {
+        console.log(JSON.stringify({ stopped: true, reason: 'Was not running' }));
+      } else {
+        console.log('Stone daemon is not running.');
+      }
+      return;
+    }
+
+    const client = new DaemonClient({ autoStartDaemon: false });
+    await client.connect();
+
+    try {
+      await client.shutdown(force);
+
+      if (json) {
+        console.log(JSON.stringify({ stopped: true }));
+      } else {
+        console.log('Stone daemon stopped.');
+      }
+    } catch (err) {
+      if (json) {
+        console.log(JSON.stringify({ stopped: false, error: err.message }));
+      } else {
+        console.error(`Failed to stop daemon: ${err.message}`);
+        if (err.message.includes('Other clients')) {
+          console.log('Use --force to override.');
+        }
+      }
+      process.exit(1);
+    }
+
+    client.disconnect();
+  } catch (err) {
+    if (json) {
+      console.log(JSON.stringify({ stopped: false, error: err.message }));
+    } else {
+      console.error(`Error: ${err.message}`);
+    }
+    process.exit(1);
+  }
+}
+
+export default daemonCommand;

package/cli/commands/kill.js

@@ -0,0 +1,66 @@
+/**
+ * kill command - Kill a running Stone process
+ *
+ * Usage:
+ *   stone kill <processId>
+ */
+
+import { DaemonClient } from '../DaemonClient.js';
+
+/**
+ * Kill a running process
+ * @param {string} processId - Process ID to kill
+ * @param {Object} options - Command options
+ */
+export async function killCommand(processId, options = {}) {
+  const { json = false } = options;
+
+  if (!processId) {
+    if (json) {
+      console.log(JSON.stringify({ error: 'Process ID required' }));
+    } else {
+      console.error('Error: Process ID required');
+      console.log('Usage: stone kill <processId>');
+    }
+    process.exit(1);
+  }
+
+  try {
+    const client = new DaemonClient({ autoStartDaemon: false });
+
+    const isRunning = await DaemonClient.isDaemonRunning();
+    if (!isRunning) {
+      if (json) {
+        console.log(JSON.stringify({ error: 'Daemon not running' }));
+      } else {
+        console.error('Error: No Stone daemon running.');
+      }
+      process.exit(1);
+    }
+
+    await client.connect();
+
+    const killed = await client.kill(processId);
+
+    if (json) {
+      console.log(JSON.stringify({ processId, killed }));
+    } else {
+      if (killed) {
+        console.log(`Killed process ${processId}`);
+      } else {
+        console.log(`Process ${processId} not found or not running`);
+      }
+    }
+
+    client.disconnect();
+  } catch (err) {
+    if (json) {
+      console.log(JSON.stringify({ error: err.message }));
+    } else {
+      console.error(`Error: ${err.message}`);
+    }
+    process.exit(1);
+  }
+}
+
+export default killCommand;