@darksol/terminal 0.10.0 → 0.11.0

package/src/daemon/manager.js

@@ -0,0 +1,148 @@
+/**
+ * Service registry and lifecycle manager for the daemon.
+ * Services register with the manager and can be started/stopped/queried.
+ */
+
+const services = new Map();
+
+/**
+ * Register a service with the daemon manager.
+ * @param {string} name - Unique service name (e.g. 'telegram', 'web-shell')
+ * @param {{start: Function, stop: Function, status: Function}} handler
+ */
+export function registerService(name, handler) {
+  if (services.has(name)) {
+    throw new Error(`Service "${name}" is already registered`);
+  }
+  services.set(name, {
+    name,
+    handler,
+    state: 'stopped',
+    startedAt: null,
+    error: null,
+  });
+}
+
+/**
+ * Unregister a service.
+ * @param {string} name
+ */
+export function unregisterService(name) {
+  services.delete(name);
+}
+
+/**
+ * Start a registered service.
+ * @param {string} name
+ * @param {object} [opts]
+ * @returns {Promise<void>}
+ */
+export async function startService(name, opts = {}) {
+  const svc = services.get(name);
+  if (!svc) throw new Error(`Unknown service: ${name}`);
+  if (svc.state === 'running') return;
+
+  try {
+    svc.state = 'starting';
+    svc.error = null;
+    await svc.handler.start(opts);
+    svc.state = 'running';
+    svc.startedAt = new Date().toISOString();
+  } catch (err) {
+    svc.state = 'error';
+    svc.error = err.message;
+    throw err;
+  }
+}
+
+/**
+ * Stop a registered service.
+ * @param {string} name
+ * @returns {Promise<void>}
+ */
+export async function stopService(name) {
+  const svc = services.get(name);
+  if (!svc) return;
+  if (svc.state !== 'running' && svc.state !== 'starting') return;
+
+  try {
+    await svc.handler.stop();
+  } catch {
+    // best-effort stop
+  }
+  svc.state = 'stopped';
+  svc.startedAt = null;
+}
+
+/**
+ * Stop all running services.
+ * @returns {Promise<void>}
+ */
+export async function stopAllServices() {
+  for (const [name] of services) {
+    await stopService(name);
+  }
+}
+
+/**
+ * Get status of a specific service.
+ * @param {string} name
+ * @returns {object|null}
+ */
+export function getServiceStatus(name) {
+  const svc = services.get(name);
+  if (!svc) return null;
+
+  let extra = {};
+  if (svc.handler.status) {
+    try {
+      extra = svc.handler.status() || {};
+    } catch {
+      // ignore
+    }
+  }
+
+  return {
+    name: svc.name,
+    state: svc.state,
+    startedAt: svc.startedAt,
+    error: svc.error,
+    ...extra,
+  };
+}
+
+/**
+ * Get health summary for all registered services.
+ * @returns {Array<object>}
+ */
+export function getAllServiceStatus() {
+  const result = [];
+  for (const [name] of services) {
+    result.push(getServiceStatus(name));
+  }
+  return result;
+}
+
+/**
+ * List names of all registered services.
+ * @returns {string[]}
+ */
+export function listServices() {
+  return [...services.keys()];
+}
+
+/**
+ * Check if a service is registered.
+ * @param {string} name
+ * @returns {boolean}
+ */
+export function hasService(name) {
+  return services.has(name);
+}
+
+/**
+ * Reset the manager (for testing).
+ */
+export function resetManager() {
+  services.clear();
+}

package/src/daemon/pid.js

@@ -0,0 +1,80 @@
+import { readFileSync, writeFileSync, unlinkSync, existsSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+
+const DARKSOL_DIR = join(homedir(), '.darksol');
+const PID_FILE = join(DARKSOL_DIR, 'daemon.pid');
+
+function ensureDir() {
+  if (!existsSync(DARKSOL_DIR)) mkdirSync(DARKSOL_DIR, { recursive: true });
+}
+
+/**
+ * Write the current process PID (or a custom one) to the PID file.
+ * @param {number} [pid]
+ */
+export function writePid(pid) {
+  ensureDir();
+  writeFileSync(PID_FILE, String(pid || process.pid), 'utf8');
+}
+
+/**
+ * Read the stored PID. Returns null if no PID file exists.
+ * @returns {number|null}
+ */
+export function readPid() {
+  if (!existsSync(PID_FILE)) return null;
+  try {
+    const raw = readFileSync(PID_FILE, 'utf8').trim();
+    const pid = parseInt(raw, 10);
+    return Number.isFinite(pid) ? pid : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Remove the PID file.
+ */
+export function removePid() {
+  try {
+    if (existsSync(PID_FILE)) unlinkSync(PID_FILE);
+  } catch {
+    // ignore - file may already be gone
+  }
+}
+
+/**
+ * Check if a process with the given PID is alive.
+ * @param {number} pid
+ * @returns {boolean}
+ */
+export function isProcessAlive(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if the daemon is currently running.
+ * Cleans up stale PID files.
+ * @returns {{running: boolean, pid: number|null}}
+ */
+export function getDaemonStatus() {
+  const pid = readPid();
+  if (!pid) return { running: false, pid: null };
+
+  if (isProcessAlive(pid)) {
+    return { running: true, pid };
+  }
+
+  // Stale PID file — process is gone
+  removePid();
+  return { running: false, pid: null };
+}
+
+export { PID_FILE, DARKSOL_DIR };