daemora 1.0.0

package/src/daemon/DaemonManager.js

@@ -0,0 +1,301 @@
+import { execSync, execFileSync } from "child_process";
+import { writeFileSync, readFileSync, existsSync, unlinkSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { config } from "../config/default.js";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SERVICE_NAME = "daemora-agent";
+const SERVICE_LABEL = "com.daemora.agent";
+
+/**
+ * Daemon Manager — native OS service management.
+ *
+ * Like OpenClaw: uses the OS's native service system, NOT pm2.
+ * - macOS: LaunchAgent (launchctl) — ~/Library/LaunchAgents/
+ * - Linux: systemd user service — ~/.config/systemd/user/
+ * - Windows: Scheduled Task (schtasks)
+ *
+ * Features:
+ * - Auto-starts on machine boot/login
+ * - User can stop/start/restart via CLI
+ * - Graceful shutdown
+ * - Crash auto-restart
+ * - Logs to data/logs/
+ */
+
+export class DaemonManager {
+  constructor() {
+    this.platform = process.platform;
+    this.entryPoint = join(config.rootDir, "src", "index.js");
+    this.nodeExe = process.execPath;
+    this.logsDir = join(config.dataDir, "logs");
+  }
+
+  /**
+   * Install the daemon service (auto-start on boot).
+   */
+  install() {
+    mkdirSync(this.logsDir, { recursive: true });
+
+    if (this.platform === "darwin") {
+      return this.installMacOS();
+    } else if (this.platform === "linux") {
+      return this.installLinux();
+    } else if (this.platform === "win32") {
+      return this.installWindows();
+    } else {
+      throw new Error(`Unsupported platform: ${this.platform}`);
+    }
+  }
+
+  /**
+   * Uninstall the daemon service (remove auto-start).
+   */
+  uninstall() {
+    if (this.platform === "darwin") {
+      return this.uninstallMacOS();
+    } else if (this.platform === "linux") {
+      return this.uninstallLinux();
+    } else if (this.platform === "win32") {
+      return this.uninstallWindows();
+    }
+  }
+
+  /**
+   * Start the daemon.
+   */
+  start() {
+    if (this.platform === "darwin") {
+      execSync(`launchctl load ~/Library/LaunchAgents/${SERVICE_LABEL}.plist 2>/dev/null; launchctl start ${SERVICE_LABEL}`);
+    } else if (this.platform === "linux") {
+      execSync(`systemctl --user start ${SERVICE_NAME}`);
+    } else if (this.platform === "win32") {
+      execSync(`schtasks /Run /TN "${SERVICE_NAME}"`);
+    }
+    console.log(`[Daemon] Started`);
+  }
+
+  /**
+   * Stop the daemon.
+   */
+  stop() {
+    if (this.platform === "darwin") {
+      execSync(`launchctl stop ${SERVICE_LABEL} 2>/dev/null || true`);
+    } else if (this.platform === "linux") {
+      execSync(`systemctl --user stop ${SERVICE_NAME} 2>/dev/null || true`);
+    } else if (this.platform === "win32") {
+      execSync(`taskkill /IM node.exe /F 2>nul || true`);
+    }
+    console.log(`[Daemon] Stopped`);
+  }
+
+  /**
+   * Restart the daemon.
+   */
+  restart() {
+    this.stop();
+    this.start();
+    console.log(`[Daemon] Restarted`);
+  }
+
+  /**
+   * Get daemon status.
+   */
+  status() {
+    try {
+      if (this.platform === "darwin") {
+        const out = execSync(`launchctl list ${SERVICE_LABEL} 2>/dev/null`, { encoding: "utf-8" });
+        const pidMatch = out.match(/"PID"\s*=\s*(\d+)/);
+        return { running: !!pidMatch, pid: pidMatch ? parseInt(pidMatch[1]) : null, platform: "launchd" };
+      } else if (this.platform === "linux") {
+        const out = execSync(`systemctl --user is-active ${SERVICE_NAME} 2>/dev/null`, { encoding: "utf-8" }).trim();
+        return { running: out === "active", platform: "systemd" };
+      }
+    } catch {
+      return { running: false, platform: this.platform };
+    }
+    return { running: false, platform: this.platform };
+  }
+
+  // ===== macOS LaunchAgent =====
+
+  installMacOS() {
+    const plistPath = join(
+      process.env.HOME,
+      "Library",
+      "LaunchAgents",
+      `${SERVICE_LABEL}.plist`
+    );
+
+    const envPath = join(config.rootDir, ".env");
+
+    const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${SERVICE_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${this.nodeExe}</string>
+    <string>${this.entryPoint}</string>
+  </array>
+  <key>WorkingDirectory</key>
+  <string>${config.rootDir}</string>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <dict>
+    <key>SuccessfulExit</key>
+    <false/>
+  </dict>
+  <key>ThrottleInterval</key>
+  <integer>10</integer>
+  <key>StandardOutPath</key>
+  <string>${this.logsDir}/daemon-stdout.log</string>
+  <key>StandardErrorPath</key>
+  <string>${this.logsDir}/daemon-stderr.log</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>NODE_ENV</key>
+    <string>production</string>
+    <key>DAEMON_MODE</key>
+    <string>true</string>
+  </dict>
+</dict>
+</plist>`;
+
+    mkdirSync(dirname(plistPath), { recursive: true });
+    writeFileSync(plistPath, plist, "utf-8");
+
+    // Load the service
+    try {
+      execSync(`launchctl unload ${plistPath} 2>/dev/null || true`);
+    } catch {}
+    execSync(`launchctl load ${plistPath}`);
+
+    console.log(`[Daemon] macOS LaunchAgent installed: ${plistPath}`);
+    console.log(`[Daemon] Will auto-start on login`);
+    console.log(`[Daemon] Logs: ${this.logsDir}/daemon-*.log`);
+    return { plistPath };
+  }
+
+  uninstallMacOS() {
+    const plistPath = join(
+      process.env.HOME,
+      "Library",
+      "LaunchAgents",
+      `${SERVICE_LABEL}.plist`
+    );
+    try {
+      execSync(`launchctl unload ${plistPath} 2>/dev/null || true`);
+    } catch {}
+    if (existsSync(plistPath)) {
+      unlinkSync(plistPath);
+    }
+    console.log(`[Daemon] macOS LaunchAgent uninstalled`);
+  }
+
+  // ===== Linux systemd =====
+
+  installLinux() {
+    const unitDir = join(process.env.HOME, ".config", "systemd", "user");
+    const unitPath = join(unitDir, `${SERVICE_NAME}.service`);
+
+    const unit = `[Unit]
+Description=Daemora — 24/7 AI Digital Worker
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${this.nodeExe} ${this.entryPoint}
+WorkingDirectory=${config.rootDir}
+Environment=NODE_ENV=production
+Environment=DAEMON_MODE=true
+Restart=always
+RestartSec=5
+KillMode=process
+StandardOutput=append:${this.logsDir}/daemon-stdout.log
+StandardError=append:${this.logsDir}/daemon-stderr.log
+
+[Install]
+WantedBy=default.target
+`;
+
+    mkdirSync(unitDir, { recursive: true });
+    writeFileSync(unitPath, unit, "utf-8");
+
+    execSync("systemctl --user daemon-reload");
+    execSync(`systemctl --user enable ${SERVICE_NAME}`);
+    execSync(`systemctl --user start ${SERVICE_NAME}`);
+
+    // Enable lingering so service runs even when user is not logged in
+    try {
+      execSync(`loginctl enable-linger ${process.env.USER}`);
+    } catch {
+      console.log(`[Daemon] Warning: Could not enable linger. Service may stop on logout.`);
+    }
+
+    console.log(`[Daemon] systemd user service installed: ${unitPath}`);
+    console.log(`[Daemon] Will auto-start on boot`);
+    console.log(`[Daemon] Logs: ${this.logsDir}/daemon-*.log`);
+    return { unitPath };
+  }
+
+  uninstallLinux() {
+    try {
+      execSync(`systemctl --user stop ${SERVICE_NAME} 2>/dev/null || true`);
+      execSync(`systemctl --user disable ${SERVICE_NAME} 2>/dev/null || true`);
+    } catch {}
+    const unitPath = join(
+      process.env.HOME,
+      ".config",
+      "systemd",
+      "user",
+      `${SERVICE_NAME}.service`
+    );
+    if (existsSync(unitPath)) {
+      unlinkSync(unitPath);
+    }
+    try {
+      execSync("systemctl --user daemon-reload");
+    } catch {}
+    console.log(`[Daemon] systemd user service uninstalled`);
+  }
+
+  // ===== Windows Scheduled Task =====
+
+  installWindows() {
+    const batPath = join(config.dataDir, `${SERVICE_NAME}.cmd`);
+    const bat = `@echo off
+set NODE_ENV=production
+set DAEMON_MODE=true
+cd /d "${config.rootDir}"
+"${this.nodeExe}" "${this.entryPoint}" >> "${this.logsDir}\\daemon-stdout.log" 2>> "${this.logsDir}\\daemon-stderr.log"
+`;
+    writeFileSync(batPath, bat, "utf-8");
+
+    try {
+      execSync(`schtasks /Delete /TN "${SERVICE_NAME}" /F 2>nul`, { stdio: "ignore" });
+    } catch {}
+    execSync(
+      `schtasks /Create /TN "${SERVICE_NAME}" /TR "${batPath}" /SC ONLOGON /RL LIMITED /F`
+    );
+
+    console.log(`[Daemon] Windows Scheduled Task installed: ${SERVICE_NAME}`);
+    console.log(`[Daemon] Will auto-start on login`);
+    return { batPath };
+  }
+
+  uninstallWindows() {
+    try {
+      execSync(`schtasks /Delete /TN "${SERVICE_NAME}" /F 2>nul`);
+    } catch {}
+    console.log(`[Daemon] Windows Scheduled Task uninstalled`);
+  }
+}
+
+const daemonManager = new DaemonManager();
+export default daemonManager;

package/src/hooks/HookRunner.js

@@ -0,0 +1,230 @@
+import { execSync } from "child_process";
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { config } from "../config/default.js";
+import eventBus from "../core/EventBus.js";
+
+/**
+ * Hook Runner — event-driven interception at tool lifecycle points.
+ * Inspired by Claude Code's hook system.
+ *
+ * Supports:
+ * - PreToolUse: Before a tool executes. Can block/allow/modify.
+ * - PostToolUse: After a tool executes. Can log/warn/react.
+ * - TaskStart: When a task begins processing.
+ * - TaskEnd: When a task completes.
+ * - MemoryWrite: Before writing to memory. Can validate.
+ *
+ * Hook types:
+ * - "command": Run a shell command. Receives env vars TOOL_NAME, TOOL_INPUT, etc.
+ * - "js": Run a JavaScript function inline.
+ *
+ * Hook output: { decision: "allow"|"block"|"ask", reason: string, modifiedInput?: object }
+ */
+
+const HOOK_EVENTS = [
+  "PreToolUse",
+  "PostToolUse",
+  "TaskStart",
+  "TaskEnd",
+  "MemoryWrite",
+];
+
+class HookRunner {
+  constructor() {
+    this.hooks = {};
+    this.loaded = false;
+  }
+
+  /**
+   * Load hooks from config/hooks.json
+   */
+  load() {
+    const hooksPath = join(config.rootDir, "config", "hooks.json");
+
+    if (!existsSync(hooksPath)) {
+      // Create default hooks file
+      this.hooks = {};
+      this.loaded = true;
+      console.log(`[HookRunner] No hooks.json found — hooks disabled`);
+      return;
+    }
+
+    try {
+      const raw = readFileSync(hooksPath, "utf-8");
+      this.hooks = JSON.parse(raw);
+      this.loaded = true;
+
+      const count = Object.values(this.hooks).reduce(
+        (sum, arr) => sum + (Array.isArray(arr) ? arr.length : 0),
+        0
+      );
+      console.log(`[HookRunner] Loaded ${count} hooks from hooks.json`);
+    } catch (error) {
+      console.log(`[HookRunner] Error loading hooks: ${error.message}`);
+      this.hooks = {};
+      this.loaded = true;
+    }
+  }
+
+  /**
+   * Run all hooks for an event.
+   *
+   * @param {string} event - Hook event name (e.g., "PreToolUse")
+   * @param {object} context - Event context { toolName, toolInput, taskId, ... }
+   * @returns {object} Merged result: { decision, reason, modifiedInput }
+   */
+  async run(event, context) {
+    if (!this.loaded) this.load();
+
+    const eventHooks = this.hooks[event];
+    if (!eventHooks || !Array.isArray(eventHooks) || eventHooks.length === 0) {
+      return { decision: "allow" };
+    }
+
+    const results = [];
+
+    for (const hook of eventHooks) {
+      // Check matcher
+      if (hook.matcher && hook.matcher !== "*") {
+        if (context.toolName && context.toolName !== hook.matcher) {
+          continue;
+        }
+      }
+
+      try {
+        const result = await this.executeHook(hook, event, context);
+        results.push(result);
+
+        // If any hook blocks, stop immediately
+        if (result.decision === "block") {
+          eventBus.emitEvent("hook:blocked", {
+            event,
+            hook: hook.matcher || "*",
+            reason: result.reason,
+            toolName: context.toolName,
+          });
+          return result;
+        }
+      } catch (error) {
+        console.log(
+          `[HookRunner] Hook error (${event}/${hook.matcher}): ${error.message}`
+        );
+        // Hook errors don't block execution — fail open
+      }
+    }
+
+    // Merge results: first "ask" wins, otherwise "allow"
+    const askResult = results.find((r) => r.decision === "ask");
+    if (askResult) return askResult;
+
+    // Check for modified input
+    const modifiedResult = results.find((r) => r.modifiedInput);
+    if (modifiedResult) {
+      return { decision: "allow", modifiedInput: modifiedResult.modifiedInput };
+    }
+
+    return { decision: "allow" };
+  }
+
+  /**
+   * Execute a single hook.
+   */
+  async executeHook(hook, event, context) {
+    const timeout = hook.timeout || 5000;
+
+    if (hook.type === "command") {
+      return this.runCommandHook(hook.command, context, timeout);
+    }
+
+    if (hook.type === "js") {
+      return this.runJsHook(hook.code, context);
+    }
+
+    return { decision: "allow" };
+  }
+
+  /**
+   * Run a shell command hook.
+   * Environment variables: TOOL_NAME, TOOL_INPUT, TASK_ID, EVENT
+   */
+  runCommandHook(command, context, timeout) {
+    const env = {
+      ...process.env,
+      TOOL_NAME: context.toolName || "",
+      TOOL_INPUT: JSON.stringify(context.toolInput || {}),
+      TASK_ID: context.taskId || "",
+      EVENT: context.event || "",
+    };
+
+    try {
+      const output = execSync(command, {
+        encoding: "utf-8",
+        timeout,
+        env,
+      }).trim();
+
+      // Try parsing JSON output
+      try {
+        return JSON.parse(output);
+      } catch {
+        // Non-JSON output = allow
+        return { decision: "allow", output };
+      }
+    } catch (error) {
+      // Command failed — treat as allow (fail open)
+      return { decision: "allow", error: error.message };
+    }
+  }
+
+  /**
+   * Run an inline JavaScript hook.
+   */
+  runJsHook(code, context) {
+    try {
+      const fn = new Function("context", code);
+      const result = fn(context);
+      if (result && typeof result === "object" && result.decision) {
+        return result;
+      }
+      return { decision: "allow" };
+    } catch (error) {
+      return { decision: "allow", error: error.message };
+    }
+  }
+
+  /**
+   * Convenience: run PreToolUse hooks.
+   */
+  async preToolUse(toolName, toolInput, taskId) {
+    return this.run("PreToolUse", { toolName, toolInput, taskId });
+  }
+
+  /**
+   * Convenience: run PostToolUse hooks.
+   */
+  async postToolUse(toolName, toolInput, toolOutput, taskId) {
+    return this.run("PostToolUse", {
+      toolName,
+      toolInput,
+      toolOutput,
+      taskId,
+    });
+  }
+
+  /**
+   * Get hook stats.
+   */
+  stats() {
+    if (!this.loaded) this.load();
+    return Object.fromEntries(
+      Object.entries(this.hooks).map(([k, v]) => [
+        k,
+        Array.isArray(v) ? v.length : 0,
+      ])
+    );
+  }
+}
+
+const hookRunner = new HookRunner();
+export default hookRunner;