@scrylog/cli 0.1.0

package/src/service/manager.ts

@@ -0,0 +1,242 @@
+import { existsSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { getResolvedConfigPath } from "../shared/config";
+import {
+  ensureParentDir,
+  getLaunchAgentPath,
+  getServiceLabel,
+  getSystemdUnitName,
+  getSystemdUnitPath,
+  getUserUid,
+} from "../shared/paths";
+import { IS_LINUX, IS_MAC, IS_WSL } from "../shared/platform";
+import { maybeRunCommand } from "../shared/utils";
+
+export interface ServiceStatus {
+  platform: "macos" | "linux" | "wsl" | "unsupported" | "linux-no-systemd";
+  installed: boolean;
+  running: boolean;
+  detail: string;
+}
+
+export interface ServiceManager {
+  readonly platform: ServiceStatus["platform"];
+  install(configPath?: string): void;
+  uninstall(): void;
+  start(): void;
+  stop(): void;
+  restart(): void;
+  status(): ServiceStatus;
+}
+
+export function getServiceManagerOrThrow(): ServiceManager {
+  if (IS_MAC) return new LaunchdServiceManager();
+  if (IS_LINUX) {
+    if (!hasSystemd()) {
+      const reason = IS_WSL
+        ? "WSL detected without systemd. Enable systemd in /etc/wsl.conf to use service management."
+        : "No running systemd user session detected. Service management requires systemd --user.";
+      return new UnsupportedServiceManager(IS_WSL ? "wsl" : "linux-no-systemd", reason);
+    }
+    return new SystemdUserServiceManager();
+  }
+  return new UnsupportedServiceManager("unsupported", "Daemon service management is only supported on macOS and Linux. On Windows, run scrylogd manually or use Task Scheduler.");
+}
+
+function hasSystemd(): boolean {
+  const result = maybeRunCommand(["systemctl", "--user", "is-system-running"]);
+  return result.ok && result.output.trim() === "running";
+}
+
+function daemonScriptPath(): string {
+  return join(import.meta.dir, "../daemon/index.ts");
+}
+
+function daemonExec(configPath?: string): string[] {
+  const resolvedConfigPath = getResolvedConfigPath(configPath);
+  return [process.execPath, "run", daemonScriptPath(), "--config", resolvedConfigPath];
+}
+
+export function renderLaunchAgentPlist(configPath?: string): string {
+  const [execPath, runArg, scriptPath, configFlag, resolvedConfigPath] = daemonExec(configPath);
+  return `<?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>${getServiceLabel()}</string>
+    <key>ProgramArguments</key>
+    <array>
+      <string>${execPath}</string>
+      <string>${runArg}</string>
+      <string>${scriptPath}</string>
+      <string>${configFlag}</string>
+      <string>${resolvedConfigPath}</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+  </dict>
+</plist>
+`;
+}
+
+export function renderSystemdUserUnit(configPath?: string): string {
+  const [execPath, runArg, scriptPath, configFlag, resolvedConfigPath] = daemonExec(configPath);
+  return `[Unit]
+Description=scrylog daemon
+After=default.target
+
+[Service]
+ExecStart=${shellQuote(execPath)} ${shellQuote(runArg)} ${shellQuote(scriptPath)} ${shellQuote(configFlag)} ${shellQuote(resolvedConfigPath)}
+Restart=on-failure
+RestartSec=3
+
+[Install]
+WantedBy=default.target
+`;
+}
+
+function run(command: string[], allowFailure = false): string {
+  const proc = Bun.spawnSync(command, { stdout: "pipe", stderr: "pipe" });
+  const stdout = Buffer.from(proc.stdout).toString("utf8").trim();
+  const stderr = Buffer.from(proc.stderr).toString("utf8").trim();
+  if (proc.exitCode !== 0 && !allowFailure) {
+    throw new Error(stderr || stdout || `Command failed: ${command.join(" ")}`);
+  }
+  return stdout || stderr;
+}
+
+class LaunchdServiceManager implements ServiceManager {
+  readonly platform = "macos" as const;
+
+  install(configPath?: string): void {
+    const filePath = getLaunchAgentPath();
+    ensureParentDir(filePath);
+    writeFileSync(filePath, renderLaunchAgentPlist(configPath), "utf8");
+    this.stop();
+    run(["launchctl", "bootstrap", `gui/${getUserUid()}`, filePath], true);
+    this.start();
+  }
+
+  uninstall(): void {
+    this.stop();
+    const filePath = getLaunchAgentPath();
+    if (existsSync(filePath)) {
+      rmSync(filePath, { force: true });
+    }
+  }
+
+  start(): void {
+    const filePath = getLaunchAgentPath();
+    if (!existsSync(filePath)) {
+      throw new Error("LaunchAgent is not installed");
+    }
+    run(["launchctl", "bootstrap", `gui/${getUserUid()}`, filePath], true);
+    run(["launchctl", "kickstart", "-k", `gui/${getUserUid()}/${getServiceLabel()}`], true);
+  }
+
+  stop(): void {
+    const filePath = getLaunchAgentPath();
+    run(["launchctl", "bootout", `gui/${getUserUid()}`, filePath], true);
+    run(["launchctl", "bootout", `gui/${getUserUid()}/${getServiceLabel()}`], true);
+  }
+
+  restart(): void {
+    this.stop();
+    this.start();
+  }
+
+  status(): ServiceStatus {
+    const installed = existsSync(getLaunchAgentPath());
+    const detail = run(["launchctl", "print", `gui/${getUserUid()}/${getServiceLabel()}`], true);
+    const running = /state = running/i.test(detail) || /pid = \d+/i.test(detail);
+    return { platform: this.platform, installed, running, detail: detail || "No launchd job loaded" };
+  }
+}
+
+class SystemdUserServiceManager implements ServiceManager {
+  readonly platform = "linux" as const;
+
+  install(configPath?: string): void {
+    const filePath = getSystemdUnitPath();
+    ensureParentDir(filePath);
+    writeFileSync(filePath, renderSystemdUserUnit(configPath), "utf8");
+    run(["systemctl", "--user", "daemon-reload"]);
+    run(["systemctl", "--user", "enable", "--now", getSystemdUnitName()]);
+  }
+
+  uninstall(): void {
+    run(["systemctl", "--user", "disable", "--now", getSystemdUnitName()], true);
+    const filePath = getSystemdUnitPath();
+    if (existsSync(filePath)) {
+      rmSync(filePath, { force: true });
+    }
+    run(["systemctl", "--user", "daemon-reload"], true);
+  }
+
+  start(): void {
+    run(["systemctl", "--user", "start", getSystemdUnitName()]);
+  }
+
+  stop(): void {
+    run(["systemctl", "--user", "stop", getSystemdUnitName()], true);
+  }
+
+  restart(): void {
+    run(["systemctl", "--user", "restart", getSystemdUnitName()]);
+  }
+
+  status(): ServiceStatus {
+    const installed = existsSync(getSystemdUnitPath()) && run(["systemctl", "--user", "is-enabled", getSystemdUnitName()], true).includes("enabled");
+    const active = run(["systemctl", "--user", "is-active", getSystemdUnitName()], true);
+    const detail = run(["systemctl", "--user", "status", getSystemdUnitName(), "--no-pager"], true);
+    return {
+      platform: this.platform,
+      installed,
+      // `is-active` returns "inactive" for a missing/stopped unit, which contains the
+      // substring "active" — only an exact match means the unit is actually running.
+      running: active.trim() === "active",
+      detail: detail || active || "Unit not loaded",
+    };
+  }
+}
+
+class UnsupportedServiceManager implements ServiceManager {
+  readonly platform: ServiceStatus["platform"];
+  private readonly detail: string;
+
+  constructor(platform: "wsl" | "unsupported" | "linux-no-systemd", detail: string) {
+    this.platform = platform;
+    this.detail = detail;
+  }
+
+  install(): void {
+    throw new Error(this.detail);
+  }
+
+  uninstall(): void {
+    // Nothing to uninstall on unsupported platforms.
+  }
+
+  start(): void {
+    throw new Error(this.detail);
+  }
+
+  stop(): void {
+    // Nothing to stop.
+  }
+
+  restart(): void {
+    throw new Error(this.detail);
+  }
+
+  status(): ServiceStatus {
+    return { platform: this.platform, installed: false, running: false, detail: this.detail };
+  }
+}
+
+function shellQuote(value: string): string {
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}