nemoris 0.1.0

package/src/cli/runtime-control.js

@@ -0,0 +1,704 @@
+import fs from "node:fs";
+import path from "node:path";
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
+import {
+  DAEMON_ERR_LOG,
+  DAEMON_OUT_LOG,
+  DAEMON_PID_FILE,
+  detectPlatform,
+  hasDaemonServiceUnit,
+  isDaemonRunning,
+  loadDaemon,
+  stopDaemonService,
+} from "../onboarding/platform.js";
+import { DAEMON_LOCK_FILE } from "../runtime/daemon.js";
+
+export const NO_DAEMON_MESSAGE = "No daemon is running.";
+export const NO_PID_FILE_MESSAGE = "No daemon running (no PID file found).";
+export const NO_LOG_FILE_MESSAGE = "No log file found. Start the daemon first with nemoris start.";
+export const WINDOWS_PM2_REQUIRED_MESSAGE = [
+  "PM2 is required for daemon management on Windows.",
+  "Install it: npm install -g pm2",
+  "",
+  "Or run in foreground: nemoris start --foreground",
+].join("\n");
+export const MCP_EMPTY_STATE_MESSAGE = [
+  "No MCP servers configured. Add one to config/mcp.toml:",
+  "",
+  "  [servers.context7]",
+  "  command = \"npx\"",
+  "  args = [\"-y\", \"@upstash/context7-mcp@latest\"]",
+  "  enabled = true",
+  "",
+  "Run nemoris doctor to verify the server is reachable.",
+].join("\n");
+
+const DEFAULT_PLATFORM_API = {
+  detectPlatform,
+  hasDaemonServiceUnit,
+  isDaemonRunning,
+  loadDaemon,
+  stopDaemonService,
+};
+const execFileAsync = promisify(execFile);
+
+export function getDaemonPaths(projectRoot) {
+  const stateDir = path.join(projectRoot, "state");
+  return {
+    stateDir,
+    pidFile: path.join(stateDir, DAEMON_PID_FILE),
+    lockFile: path.join(stateDir, DAEMON_LOCK_FILE),
+    stdoutLog: path.join(stateDir, DAEMON_OUT_LOG),
+    stderrLog: path.join(stateDir, DAEMON_ERR_LOG),
+  };
+}
+
+export function parseLogsArgs(args = []) {
+  let lineCount = 50;
+  let follow = false;
+  let raw = false;
+  let numericSeen = false;
+
+  for (const arg of args) {
+    if (arg === "--follow" || arg === "-f") {
+      follow = true;
+      continue;
+    }
+    if (arg === "--raw") {
+      raw = true;
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      continue;
+    }
+    if (numericSeen) {
+      return { error: "Usage: nemoris logs [n] [--follow|-f] [--raw]" };
+    }
+    const parsed = Number.parseInt(arg, 10);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+      return { error: "Line count must be a positive integer." };
+    }
+    lineCount = parsed;
+    numericSeen = true;
+  }
+
+  return { lineCount, follow, raw };
+}
+
+function normalizeLogTimestamp(value) {
+  if (value === null || value === undefined || value === "") {
+    return "??:??:??";
+  }
+
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? String(value) : date.toISOString();
+}
+
+function stringifyLogValue(value) {
+  if (typeof value === "string") return value;
+  if (value === null || value === undefined) return "";
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+
+function summarizeLogMessage(entry) {
+  const direct = [entry.message, entry.reason, entry.error].find(
+    (value) => value !== null && value !== undefined && value !== ""
+  );
+  if (direct !== undefined) {
+    return stringifyLogValue(direct);
+  }
+
+  const extras = Object.entries(entry)
+    .filter(([key, value]) => ![
+      "timestamp",
+      "ts",
+      "time",
+      "at",
+      "service",
+      "component",
+      "scope",
+      "status",
+      "ok",
+      "message",
+      "reason",
+      "error",
+    ].includes(key) && value !== null && value !== undefined && value !== "")
+    .map(([key, value]) => `${key}=${stringifyLogValue(value)}`);
+  return extras.join(", ");
+}
+
+export function formatLogLine(jsonStr) {
+  const line = String(jsonStr ?? "");
+  const trimmed = line.trim();
+  if (!trimmed) {
+    return "";
+  }
+
+  try {
+    const obj = JSON.parse(trimmed);
+    if (!obj || typeof obj !== "object" || Array.isArray(obj)) {
+      return line;
+    }
+
+    const timestamp = normalizeLogTimestamp(obj.timestamp ?? obj.ts ?? obj.time ?? obj.at);
+    const service = obj.service || obj.component || obj.scope || "unknown";
+    const status = obj.status ?? (obj.ok === true ? "ok" : obj.ok === false ? "error" : "unknown");
+    const message = summarizeLogMessage(obj);
+    return `[${timestamp}] ${service}: ${status}${message ? ` — ${message}` : ""}`;
+  } catch {
+    return line;
+  }
+}
+
+function formatLogOutput(content, { raw = false } = {}) {
+  if (raw) return content;
+  return String(content ?? "")
+    .split(/\r?\n/)
+    .map((line) => formatLogLine(line))
+    .join("\n");
+}
+
+function formatLogChunk(chunk, { raw = false, carry = "" } = {}) {
+  const text = `${carry}${chunk}`;
+  const parts = text.split(/\r?\n/);
+  const endsWithNewline = /\r?\n$/.test(text);
+  const nextCarry = endsWithNewline ? "" : (parts.pop() ?? "");
+  const complete = parts.join("\n");
+  return {
+    output: complete ? formatLogOutput(complete, { raw }) : "",
+    carry: nextCarry,
+  };
+}
+
+export function readLastLines(filePath, lineCount = 50, { fsImpl = fs, raw = false } = {}) {
+  const content = fsImpl.readFileSync(filePath, "utf8");
+  const lines = content.split(/\r?\n/);
+  if (lines.at(-1) === "") {
+    lines.pop();
+  }
+  return formatLogOutput(lines.slice(-lineCount).join("\n"), { raw });
+}
+
+export async function followLogFile(
+  filePath,
+  { lineCount = 50, raw = false, stdout = process.stdout, fsImpl = fs, processImpl = process } = {},
+) {
+  const initial = readLastLines(filePath, lineCount, { fsImpl, raw });
+  if (initial) {
+    stdout.write(initial.endsWith("\n") ? initial : `${initial}\n`);
+  }
+
+  let position = fsImpl.statSync(filePath).size;
+  let carry = "";
+
+  await new Promise((resolve) => {
+    const poll = () => {
+      try {
+        const nextSize = fsImpl.statSync(filePath).size;
+        if (nextSize <= position) {
+          return;
+        }
+        const fd = fsImpl.openSync(filePath, "r");
+        const buffer = Buffer.alloc(nextSize - position);
+        fsImpl.readSync(fd, buffer, 0, buffer.length, position);
+        fsImpl.closeSync(fd);
+        position = nextSize;
+        const formatted = formatLogChunk(buffer.toString("utf8"), { raw, carry });
+        carry = formatted.carry;
+        if (formatted.output) {
+          stdout.write(`${formatted.output}\n`);
+        }
+      } catch {
+        // Best effort tailing only.
+      }
+    };
+
+    const timer = setInterval(poll, 500);
+    const stop = () => {
+      clearInterval(timer);
+      processImpl.off("SIGINT", stop);
+      processImpl.off("SIGTERM", stop);
+      resolve();
+    };
+
+    processImpl.on("SIGINT", stop);
+    processImpl.on("SIGTERM", stop);
+  });
+}
+
+export async function runLogsCommand({
+  projectRoot,
+  args = [],
+  fsImpl = fs,
+  stdout = process.stdout,
+  stderr = process.stderr,
+  followLogFileImpl = followLogFile,
+} = {}) {
+  const parsed = parseLogsArgs(args);
+  if (parsed.error) {
+    return { exitCode: 1, message: parsed.error, stream: stderr };
+  }
+
+  const { stdoutLog } = getDaemonPaths(projectRoot);
+  if (!fsImpl.existsSync(stdoutLog)) {
+    return { exitCode: 0, message: NO_LOG_FILE_MESSAGE, stream: stdout };
+  }
+
+  if (parsed.follow) {
+    await followLogFileImpl(stdoutLog, {
+      lineCount: parsed.lineCount,
+      raw: parsed.raw,
+      stdout,
+      fsImpl,
+    });
+    return { exitCode: 0, stream: stdout };
+  }
+
+  return {
+    exitCode: 0,
+    message: readLastLines(stdoutLog, parsed.lineCount, { fsImpl, raw: parsed.raw }),
+    stream: stdout,
+  };
+}
+
+export function safeUnlink(filePath, fsImpl) {
+  try {
+    fsImpl.unlinkSync(filePath);
+  } catch {
+    // Best effort cleanup.
+  }
+}
+
+function isNoProcessError(error) {
+  const message = String(error?.message || "");
+  return error?.code === "ESRCH" ||
+    error?.code === "ENOENT" ||
+    /no such process/i.test(message) ||
+    /process does not exist/i.test(message) ||
+    /could not find/i.test(message);
+}
+
+export function readTrackedPid(pidFile, { fsImpl = fs } = {}) {
+  try {
+    const pid = Number.parseInt(fsImpl.readFileSync(pidFile, "utf8").trim(), 10);
+    return Number.isInteger(pid) && pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
+
+export function isPidRunning(pid, { processImpl = process } = {}) {
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return false;
+  }
+
+  try {
+    processImpl.kill(pid, 0);
+    return true;
+  } catch (error) {
+    if (isNoProcessError(error)) {
+      return false;
+    }
+    return true;
+  }
+}
+
+function parsePidList(stdout = "") {
+  return [...new Set(
+    String(stdout)
+      .split(/\s+/)
+      .map((value) => Number.parseInt(value, 10))
+      .filter((value) => Number.isInteger(value) && value > 0),
+  )].sort((a, b) => a - b);
+}
+
+function parseSinglePid(stdout = "") {
+  const parsed = Number.parseInt(String(stdout || "").trim(), 10);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
+}
+
+function parseWindowsTasklist(stdout = "") {
+  return String(stdout)
+    .split(/\r?\n/)
+    .filter((line) => /serve-daemon/i.test(line))
+    .map((line) => {
+      const match = line.match(/"node\.exe","(\d+)"/i);
+      return match ? Number.parseInt(match[1], 10) : null;
+    })
+    .filter((value) => Number.isInteger(value) && value > 0);
+}
+
+async function hasPm2Available({
+  platform = process.platform,
+  execFileImpl = execFileAsync,
+} = {}) {
+  if (platform === "win32") {
+    try {
+      await execFileImpl("where", ["pm2"], { timeout: 3000 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  try {
+    await execFileImpl("which", ["pm2"], { timeout: 3000 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function writeTrackedPidFile({
+  projectRoot,
+  platform = process.platform,
+  fsImpl = fs,
+  execFileImpl = execFileAsync,
+} = {}) {
+  const { stateDir, pidFile } = getDaemonPaths(projectRoot);
+  let pid = null;
+
+  if (platform === "win32") {
+    try {
+      const { stdout } = await execFileImpl("pm2", ["pid", "nemoris"], { timeout: 5000 });
+      pid = parseSinglePid(stdout);
+    } catch {
+      pid = null;
+    }
+  }
+
+  if (!pid) {
+    const pids = await listServeDaemonPids({ platform, execFileImpl });
+    pid = pids[0] || null;
+  }
+
+  if (pid) {
+    fsImpl.mkdirSync(stateDir, { recursive: true });
+    fsImpl.writeFileSync(pidFile, `${pid}\n`);
+  }
+}
+
+export async function listServeDaemonPids({
+  platform = process.platform,
+  execFileImpl = execFileAsync,
+} = {}) {
+  if (platform === "win32") {
+    try {
+      const { stdout } = await execFileImpl("tasklist", ["/FI", "IMAGENAME eq node.exe", "/FO", "CSV", "/V"], { timeout: 5000 });
+      return parseWindowsTasklist(stdout);
+    } catch {
+      return [];
+    }
+  }
+
+  try {
+    const { stdout } = await execFileImpl("pgrep", ["-f", "serve-daemon"], { timeout: 5000 });
+    return parsePidList(stdout);
+  } catch (error) {
+    const stderr = String(error?.stderr || "");
+    if (
+      error?.code === 1
+      || error?.code === 3
+      || error?.code === "ENOENT"
+      || /Cannot get process list/i.test(stderr)
+      || /sysmond service not found/i.test(stderr)
+    ) {
+      return parsePidList(error?.stdout || "");
+    }
+    throw error;
+  }
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export async function cleanupOrphanedDaemonProcesses({
+  projectRoot,
+  platform = process.platform,
+  fsImpl = fs,
+  processImpl = process,
+  execFileImpl = execFileAsync,
+  sleepImpl = sleep,
+} = {}) {
+  const { pidFile, lockFile } = getDaemonPaths(projectRoot);
+  const foundPids = await listServeDaemonPids({ platform, execFileImpl });
+  const orphanPids = foundPids.filter((pid) => pid !== processImpl.pid);
+
+  if (orphanPids.length === 0) {
+    safeUnlink(pidFile, fsImpl);
+    safeUnlink(lockFile, fsImpl);
+    return { ok: true, foundPids, terminatedPids: [], escalatedPids: [] };
+  }
+
+  for (const pid of orphanPids) {
+    try {
+      processImpl.kill(pid, "SIGTERM");
+    } catch (error) {
+      if (!isNoProcessError(error)) {
+        return { ok: false, foundPids, terminatedPids: [], escalatedPids: [], failedPids: [pid], message: `Failed to stop orphaned daemon process ${pid}: ${error.message}` };
+      }
+    }
+  }
+
+  await sleepImpl(2000);
+
+  const escalatedPids = [];
+  for (const pid of orphanPids) {
+    if (!isPidRunning(pid, { processImpl })) {
+      continue;
+    }
+    try {
+      processImpl.kill(pid, "SIGKILL");
+      escalatedPids.push(pid);
+    } catch (error) {
+      if (!isNoProcessError(error)) {
+        return { ok: false, foundPids, terminatedPids: orphanPids, escalatedPids, failedPids: [pid], message: `Failed to force-stop orphaned daemon process ${pid}: ${error.message}` };
+      }
+    }
+  }
+
+  const failedPids = orphanPids.filter((pid) => isPidRunning(pid, { processImpl }));
+  if (failedPids.length > 0) {
+    return {
+      ok: false,
+      foundPids,
+      terminatedPids: orphanPids,
+      escalatedPids,
+      failedPids,
+      message: `Failed to stop orphaned daemon process(es): ${failedPids.join(", ")}`,
+    };
+  }
+
+  safeUnlink(pidFile, fsImpl);
+  safeUnlink(lockFile, fsImpl);
+  return {
+    ok: true,
+    foundPids,
+    terminatedPids: orphanPids,
+    escalatedPids,
+  };
+}
+
+export async function startDirectDaemon({
+  projectRoot,
+  cliEntryPath = path.join(projectRoot, "src", "cli.js"),
+  fsImpl = fs,
+  spawnImpl = spawn,
+  processImpl = process,
+} = {}) {
+  const { stateDir, pidFile, stdoutLog, stderrLog } = getDaemonPaths(projectRoot);
+  fsImpl.mkdirSync(stateDir, { recursive: true });
+  const stdoutFd = fsImpl.openSync(stdoutLog, "a");
+  const stderrFd = fsImpl.openSync(stderrLog, "a");
+
+  try {
+    const child = spawnImpl(processImpl.execPath, [cliEntryPath, "serve-daemon", "live"], {
+      cwd: projectRoot,
+      detached: true,
+      env: {
+        ...processImpl.env,
+        NEMORIS_INSTALL_DIR: projectRoot,
+      },
+      stdio: ["ignore", stdoutFd, stderrFd],
+    });
+    child.unref?.();
+    fsImpl.writeFileSync(pidFile, `${child.pid}\n`);
+    return {
+      exitCode: 0,
+      message: `Started daemon in the background (pid ${child.pid}).`,
+    };
+  } catch (error) {
+    safeUnlink(pidFile, fsImpl);
+    return {
+      exitCode: 1,
+      message: `Failed to start daemon: ${error.message}`,
+    };
+  } finally {
+    fsImpl.closeSync(stdoutFd);
+    fsImpl.closeSync(stderrFd);
+  }
+}
+
+export async function startDaemonCommand({
+  projectRoot,
+  platform = process.platform,
+  fsImpl = fs,
+  spawnImpl = spawn,
+  processImpl = process,
+  execFileImpl = execFileAsync,
+  sleepImpl = sleep,
+  platformApi = DEFAULT_PLATFORM_API,
+} = {}) {
+  const { pidFile } = getDaemonPaths(projectRoot);
+  const trackedPid = readTrackedPid(pidFile, { fsImpl });
+  if (trackedPid && isPidRunning(trackedPid, { processImpl })) {
+    return { exitCode: 0, message: `Daemon already running (pid ${trackedPid}).` };
+  }
+
+  if (trackedPid && !isPidRunning(trackedPid, { processImpl })) {
+    safeUnlink(pidFile, fsImpl);
+  }
+
+  if (platformApi.hasDaemonServiceUnit({ platform })) {
+    if (platformApi.isDaemonRunning()) {
+      return { exitCode: 0, message: "Daemon already running." };
+    }
+    const orphanCleanup = await cleanupOrphanedDaemonProcesses({
+      projectRoot,
+      platform,
+      fsImpl,
+      processImpl,
+      execFileImpl,
+      sleepImpl,
+    });
+    if (!orphanCleanup.ok) {
+      return { exitCode: 1, message: orphanCleanup.message || "Failed to stop orphaned daemon processes." };
+    }
+    const result = await platformApi.loadDaemon(projectRoot, { platform });
+    if (!result.ok) {
+      return { exitCode: 1, message: result.message || "Failed to start daemon service." };
+    }
+    await writeTrackedPidFile({ projectRoot, platform, fsImpl, execFileImpl });
+    const manager = platform === "darwin" ? "launchd" : "systemd";
+    return { exitCode: 0, message: `Started daemon with ${manager}.` };
+  }
+
+  if (platform === "win32") {
+    const hasPm2 = await hasPm2Available({ platform, execFileImpl });
+    if (hasPm2) {
+      const orphanCleanup = await cleanupOrphanedDaemonProcesses({
+        projectRoot,
+        platform,
+        fsImpl,
+        processImpl,
+        execFileImpl,
+        sleepImpl,
+      });
+      if (!orphanCleanup.ok) {
+        return { exitCode: 1, message: orphanCleanup.message || "Failed to stop orphaned daemon processes." };
+      }
+      const result = await platformApi.loadDaemon(projectRoot, { platform });
+      if (result.ok) {
+        await writeTrackedPidFile({ projectRoot, platform, fsImpl, execFileImpl });
+      }
+      return {
+        exitCode: result.ok ? 0 : 1,
+        message: result.ok ? "Started daemon with PM2." : (result.message || "Failed to start daemon with PM2."),
+      };
+    }
+    return {
+      exitCode: 1,
+      message: WINDOWS_PM2_REQUIRED_MESSAGE,
+    };
+  }
+
+  const orphanCleanup = await cleanupOrphanedDaemonProcesses({
+    projectRoot,
+    platform,
+    fsImpl,
+    processImpl,
+    execFileImpl,
+    sleepImpl,
+  });
+  if (!orphanCleanup.ok) {
+    return { exitCode: 1, message: orphanCleanup.message || "Failed to stop orphaned daemon processes." };
+  }
+
+  return startDirectDaemon({
+    projectRoot,
+    fsImpl,
+    spawnImpl,
+    processImpl,
+  });
+}
+
+export async function stopDaemonCommand({
+  projectRoot,
+  platform = process.platform,
+  fsImpl = fs,
+  processImpl = process,
+  execFileImpl = execFileAsync,
+  platformApi = DEFAULT_PLATFORM_API,
+} = {}) {
+  const { pidFile } = getDaemonPaths(projectRoot);
+
+  if (platform === "win32") {
+    const hasPm2 = await hasPm2Available({ platform, execFileImpl });
+    if (hasPm2) {
+      let stopped = false;
+      try {
+        await execFileImpl("pm2", ["stop", "nemoris"], { timeout: 5000 });
+        stopped = true;
+      } catch (error) {
+        if (!isNoProcessError(error)) {
+          return { exitCode: 1, message: `Failed to stop daemon with PM2: ${error.message}` };
+        }
+      }
+      try {
+        await execFileImpl("pm2", ["delete", "nemoris"], { timeout: 5000 });
+        stopped = true;
+      } catch (error) {
+        if (!isNoProcessError(error)) {
+          return { exitCode: 1, message: `Failed to delete PM2 process: ${error.message}` };
+        }
+      }
+      try {
+        await execFileImpl("pm2", ["save"], { timeout: 5000 });
+      } catch {
+        // Best effort persistence only.
+      }
+      safeUnlink(pidFile, fsImpl);
+      return { exitCode: 0, message: stopped ? "Stopped daemon with PM2." : NO_DAEMON_MESSAGE };
+    }
+  }
+
+  if (!fsImpl.existsSync(pidFile) && !platformApi.hasDaemonServiceUnit({ platform })) {
+    return { exitCode: 0, message: NO_PID_FILE_MESSAGE };
+  }
+
+  const trackedPid = readTrackedPid(pidFile, { fsImpl });
+
+  if (trackedPid) {
+    try {
+      processImpl.kill(trackedPid, "SIGTERM");
+      safeUnlink(pidFile, fsImpl);
+      return { exitCode: 0, message: `Stopping daemon (pid ${trackedPid}).` };
+    } catch (error) {
+      safeUnlink(pidFile, fsImpl);
+      if (!isNoProcessError(error)) {
+        return { exitCode: 1, message: `Failed to stop daemon: ${error.message}` };
+      }
+    }
+  }
+
+  if (platformApi.hasDaemonServiceUnit({ platform })) {
+    const result = await platformApi.stopDaemonService({ platform });
+    if (result.ok) {
+      return { exitCode: 0, message: "Stopped daemon service." };
+    }
+    if (result.notRunning || isNoProcessError(result)) {
+      return { exitCode: 0, message: NO_DAEMON_MESSAGE };
+    }
+    return { exitCode: 1, message: result.message || "Failed to stop daemon service." };
+  }
+
+  return { exitCode: 0, message: NO_DAEMON_MESSAGE };
+}
+
+export async function restartDaemonCommand(options = {}) {
+  const stopCommandImpl = options.stopCommandImpl || stopDaemonCommand;
+  const startCommandImpl = options.startDaemonCommandImpl || startDaemonCommand;
+
+  const stopResult = await stopCommandImpl(options);
+  if (stopResult.exitCode !== 0) {
+    return stopResult;
+  }
+
+  return startCommandImpl(options);
+}