@sirenodeck/sirenodeck 0.1.1-alpha.0

package/src/cli/commands/service/install.ts

@@ -0,0 +1,121 @@
+import { execSync } from "node:child_process"
+import { existsSync, mkdirSync, writeFileSync } from "node:fs"
+import { homedir } from "node:os"
+import { join } from "node:path"
+
+import { currentOS, renderTemplate, type TemplateVars } from "./render-template"
+
+export interface InstallOptions {
+  readonly logger: import("pino").Logger
+  readonly system?: boolean
+}
+
+const DAEMON_NAME = "sirenodeck"
+const SERVICE_NAME = `${DAEMON_NAME}.service`
+
+// ponytail: ExecStart calls `start` — no flags. The systemd-started process
+// detects `INVOCATION_ID` and runs in-process, reading config + flags from
+// runtimeDir. Keeps the unit stable; config changes don't require reinstall.
+//
+// Spawn through the CURRENT node binary rather than letting the supervisor exec
+// the .js directly. bin/sirenodeck.js starts `#!/usr/bin/env node`, and
+// launchd's PATH is only /usr/bin:/bin:/usr/sbin:/sbin — a Homebrew, nvm or
+// Volta node isn't on it, so the agent died with "env: node: No such file or
+// directory" and KeepAlive respawned it forever. process.execPath is absolute
+// and always correct. Both paths are quoted because splitExec (and systemd)
+// honour quotes, and macOS install locations routinely contain spaces.
+const getExecStart = (): string => {
+  const script = process.argv[1]
+  if (script === undefined) return "sirenodeck start"
+  return `"${process.execPath}" "${script}" start`
+}
+
+const getTemplateVars = (): TemplateVars => {
+  const home = homedir()
+  return {
+    name: DAEMON_NAME,
+    displayName: "Sireno Deck",
+    description: "Sireno Deck daemon service",
+    execStart: getExecStart(),
+    restartPolicy: "always",
+    workingDirectory: home,
+    logPath: join(home, "Library", "Logs", `${DAEMON_NAME}.log`),
+  }
+}
+
+const ensureDir = (dir: string, mode: number): void => {
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true, mode })
+}
+
+export const installService = async (
+  options: InstallOptions,
+): Promise<void> => {
+  const { logger, system = false } = options
+  const os = currentOS()
+  const vars = getTemplateVars()
+  const userLevel = !system
+
+  if (os === "linux") {
+    const unitDir = userLevel
+      ? join(homedir(), ".config", "systemd", "user")
+      : "/etc/systemd/system"
+    const unitPath = join(unitDir, SERVICE_NAME)
+    const content = renderTemplate(
+      os,
+      {
+        ...vars,
+        ...(userLevel ? {} : { user: "root", group: "root" }),
+      },
+      { userLevel },
+    )
+
+    try {
+      if (userLevel) ensureDir(unitDir, 0o755)
+      writeFileSync(unitPath, content, { mode: 0o644 })
+      logger.info({ path: unitPath }, "install: systemd unit installed")
+
+      const systemctl = userLevel ? "systemctl --user" : "systemctl"
+      execSync(`${systemctl} daemon-reload`, { stdio: "ignore" })
+      logger.info({ userLevel }, "install: systemd daemon reloaded")
+      execSync(`${systemctl} enable ${SERVICE_NAME}`, { stdio: "ignore" })
+      logger.info({ service: SERVICE_NAME, userLevel }, "install: enabled")
+    } catch (err) {
+      logger.error(
+        { err, userLevel },
+        userLevel
+          ? "install: failed to install user-level systemd service"
+          : "install: failed to install system systemd service (needs root)",
+      )
+      process.exitCode = 1
+    }
+  } else if (os === "darwin") {
+    const plistDir = join(homedir(), "Library", "LaunchAgents")
+    const plistPath = join(plistDir, `${DAEMON_NAME}.plist`)
+    const logDir = join(homedir(), "Library", "Logs")
+    try {
+      ensureDir(plistDir, 0o755)
+      ensureDir(logDir, 0o755)
+      const content = renderTemplate(os, vars, { userLevel })
+      writeFileSync(plistPath, content, { mode: 0o644 })
+      logger.info({ path: plistPath }, "install: launchd plist installed")
+      // ponytail: install used the legacy `launchctl load` while
+      // invokeManager drives the modern bootstrap/kickstart API. Mixing the two
+      // made the very next `start` fail — bootstrap returns EALREADY (5: Input/
+      // output error) against a service the legacy call had already loaded.
+      // Writing the plist is enough; invokeManager bootstraps it. Leaving the
+      // service un-loaded here is intentional and keeps one API in play.
+      logger.info(
+        { service: SERVICE_NAME },
+        "install: plist written — bootstrap happens on start",
+      )
+    } catch (err) {
+      logger.error({ err }, "install: failed to install launchd service")
+      process.exitCode = 1
+    }
+  } else {
+    logger.error(
+      "install: native service installation not supported on this platform",
+    )
+    process.exitCode = 1
+  }
+}

package/src/cli/commands/service/render-template.ts

@@ -0,0 +1,158 @@
+import { dirname } from "node:path"
+import { platform } from "node:process"
+
+export type OS = "linux" | "darwin" | "win32"
+
+export const currentOS = (): OS => {
+  const p = platform
+  if (p === "darwin") return "darwin"
+  if (p === "win32") return "win32"
+  return "linux"
+}
+
+export interface TemplateVars {
+  name: string
+  displayName: string
+  description: string
+  execStart: string
+  restartPolicy: string
+  workingDirectory: string
+  user?: string
+  group?: string
+  logPath: string
+}
+
+export interface SystemdOptions {
+  userLevel: boolean
+}
+
+export const renderSystemd = (
+  vars: TemplateVars,
+  options: SystemdOptions,
+): string => {
+  const lines: string[] = [
+    "[Unit]",
+    `Description=${vars.description}`,
+    "After=network-online.target",
+    "Wants=network-online.target",
+    "",
+    "[Service]",
+    "Type=simple",
+    `ExecStart=${vars.execStart}`,
+    `Restart=${vars.restartPolicy}`,
+    "RestartSec=5",
+    `WorkingDirectory=${vars.workingDirectory}`,
+  ]
+  if (vars.user !== undefined) lines.push(`User=${vars.user}`)
+  if (vars.group !== undefined) lines.push(`Group=${vars.group}`)
+  lines.push("Environment=NODE_ENV=production")
+  lines.push("")
+  lines.push("[Install]")
+  lines.push(
+    `WantedBy=${options.userLevel ? "default.target" : "multi-user.target"}`,
+  )
+  return `${lines.join("\n")}\n`
+}
+
+const splitExec = (execStart: string): readonly string[] => {
+  const tokens: string[] = []
+  let buf = ""
+  let quote: string | null = null
+  for (const ch of execStart) {
+    if (quote !== null) {
+      if (ch === quote) {
+        quote = null
+      } else {
+        buf += ch
+      }
+    } else if (ch === '"' || ch === "'") {
+      quote = ch
+    } else if (ch === " ") {
+      if (buf.length > 0) {
+        tokens.push(buf)
+        buf = ""
+      }
+    } else {
+      buf += ch
+    }
+  }
+  if (buf.length > 0) tokens.push(buf)
+  return tokens
+}
+
+// ponytail: launchd hands an agent a bare PATH (/usr/bin:/bin:/usr/sbin:/sbin).
+// The daemon spawns node-based children (vite) and shells out to Homebrew tools,
+// none of which live there. Prepend the usual Homebrew prefixes and the
+// directory of the node binary launching us, so children resolve the same
+// binaries an interactive shell would.
+const darwinPathEntries = (program: string | undefined): string => {
+  const entries = [
+    ...(program !== undefined ? [dirname(program)] : []),
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+    "/usr/bin",
+    "/bin",
+    "/usr/sbin",
+    "/sbin",
+  ]
+  return [...new Set(entries)].join(":")
+}
+
+export const renderDarwinPlist = (vars: TemplateVars): string => {
+  const [program, ...restArgs] = splitExec(vars.execStart)
+  const lines: string[] = [
+    '<?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>${vars.name}</string>`,
+    "  <key>ProgramArguments</key>",
+    "  <array>",
+    ...(program !== undefined ? [`    <string>${program}</string>`] : []),
+    ...restArgs.map((arg) => `    <string>${arg}</string>`),
+    "  </array>",
+    "  <key>RunAtLoad</key>",
+    "  <true/>",
+    "  <key>KeepAlive</key>",
+    `  <${vars.restartPolicy === "always" ? "true" : "false"}/>`,
+    "  <key>EnvironmentVariables</key>",
+    "  <dict>",
+    "    <key>PATH</key>",
+    `    <string>${darwinPathEntries(program)}</string>`,
+    "  </dict>",
+    "  <key>WorkingDirectory</key>",
+    `  <string>${vars.workingDirectory}</string>`,
+    "  <key>StandardOutPath</key>",
+    `  <string>${vars.logPath}</string>`,
+    "  <key>StandardErrorPath</key>",
+    `  <string>${vars.logPath}</string>`,
+    "</dict>",
+    "</plist>",
+  ]
+  return `${lines.join("\n")}\n`
+}
+
+export const renderWindowsSvc = (vars: TemplateVars): string => {
+  return `@echo off
+REM ${vars.description}
+sc create ${vars.name} binPath= "${vars.execStart}" start= auto
+sc description ${vars.name} "${vars.description}"
+sc failure "${vars.name}" reset= 86400 actions= restart/5000/restart/10000/restart/30000
+`
+}
+
+export const renderTemplate = (
+  os: OS,
+  vars: TemplateVars,
+  options: SystemdOptions,
+): string => {
+  switch (os) {
+    case "linux":
+      return renderSystemd(vars, options)
+    case "darwin":
+      return renderDarwinPlist(vars)
+    case "win32":
+      return renderWindowsSvc(vars)
+  }
+}

package/src/cli/commands/service-manager.ts

@@ -0,0 +1,184 @@
+import { execFileSync } from "node:child_process"
+import { existsSync } from "node:fs"
+import { homedir } from "node:os"
+import { join } from "node:path"
+import { platform } from "node:process"
+
+import type { Logger } from "pino"
+
+export type ServiceAction = "start" | "stop" | "restart" | "reload"
+
+export interface EnsureInstalledOptions {
+  readonly logger: Logger
+  readonly system?: boolean
+}
+
+export interface InvokeManagerOptions {
+  readonly action: ServiceAction
+  readonly logger: Logger
+}
+
+const DAEMON_NAME = "sirenodeck"
+
+const systemctl = (userLevel: boolean, args: ReadonlyArray<string>): void => {
+  const cmd = userLevel ? "systemctl" : "systemctl"
+  const fullArgs = userLevel ? ["--user", ...args] : [...args]
+  execFileSync(cmd, fullArgs, { stdio: "ignore" })
+}
+
+const launchctl = (sub: string, args: ReadonlyArray<string>): void => {
+  execFileSync("launchctl", [sub, ...args], { stdio: "ignore" })
+}
+
+const sleep = (ms: number): Promise<void> =>
+  new Promise((resolve) => setTimeout(resolve, ms))
+
+/**
+ * Is launchd still holding this job? `print` fails for a label it does not
+ * know, which is the only reliable "is it gone yet" signal available.
+ */
+const isJobLoaded = (uid: string, label: string): boolean => {
+  try {
+    execFileSync("launchctl", ["print", `gui/${uid}/${label}`], {
+      stdio: "ignore",
+      timeout: 5_000,
+    })
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * ponytail: `launchctl bootout` returns before launchd has finished tearing
+ * the job down. Bootstrapping straight afterwards fails with a bare I/O error,
+ * and because that threw out of `invokeManager`, a restart could end with the
+ * agent booted out and never brought back — no daemon at all, which is a worse
+ * place than it started. Wait for the label to actually disappear, then
+ * bootstrap, retrying while launchd settles. If the job turns out to be loaded
+ * already, a kickstart is the right move rather than another bootstrap.
+ */
+const bootstrapWithRetry = async (
+  uid: string,
+  plist: string,
+  label: string,
+  timeoutMs = 15_000,
+): Promise<void> => {
+  const deadline = Date.now() + timeoutMs
+  let lastError: unknown = null
+  while (Date.now() < deadline) {
+    if (isJobLoaded(uid, label)) {
+      try {
+        launchctl("enable", [`gui/${uid}/${label}`])
+      } catch {
+        // already enabled
+      }
+      launchctl("kickstart", [`gui/${uid}/${label}`])
+      return
+    }
+    try {
+      launchctl("bootstrap", [`gui/${uid}`, plist])
+      try {
+        launchctl("enable", [`gui/${uid}/${label}`])
+      } catch {
+        // already enabled
+      }
+      launchctl("kickstart", [`gui/${uid}/${label}`])
+      return
+    } catch (err) {
+      lastError = err
+      await sleep(300)
+    }
+  }
+  throw lastError instanceof Error
+    ? lastError
+    : new Error(`launchctl: could not bootstrap ${label} within ${timeoutMs}ms`)
+}
+
+const currentOS = (): "linux" | "darwin" | "win32" => {
+  if (platform === "darwin") return "darwin"
+  if (platform === "win32") return "win32"
+  return "linux"
+}
+
+export const isUnitInstalled = (userLevel = true): boolean => {
+  const os = currentOS()
+  if (os === "linux") {
+    const unitPath = userLevel
+      ? join(homedir(), ".config", "systemd", "user", `${DAEMON_NAME}.service`)
+      : `/etc/systemd/system/${DAEMON_NAME}.service`
+    return existsSync(unitPath)
+  }
+  if (os === "darwin") {
+    return existsSync(
+      join(homedir(), "Library", "LaunchAgents", `${DAEMON_NAME}.plist`),
+    )
+  }
+  return false
+}
+
+export const ensureInstalled = async (
+  options: EnsureInstalledOptions,
+): Promise<void> => {
+  const { logger, system = false } = options
+  const userLevel = !system
+  if (isUnitInstalled(userLevel)) {
+    logger.debug({ userLevel }, "ensureInstalled: unit already present")
+    return
+  }
+  const { installService } = await import("./service/install")
+  await installService({ logger, system })
+}
+
+export const invokeManager = async (
+  options: InvokeManagerOptions,
+): Promise<void> => {
+  const { logger, action } = options
+  const os = currentOS()
+
+  if (os === "linux") {
+    const verb = action === "reload" ? "reload-or-restart" : action
+    systemctl(true, [verb, `${DAEMON_NAME}.service`])
+    logger.info(
+      { action, userLevel: true },
+      "ensureInstalled: invoked systemctl",
+    )
+    return
+  }
+  if (os === "darwin") {
+    const plist = join(
+      homedir(),
+      "Library",
+      "LaunchAgents",
+      `${DAEMON_NAME}.plist`,
+    )
+    const uid = String(process.getuid?.() ?? 0)
+    if (action === "start") {
+      // Same settling problem as restart: bootstrapping a label launchd is
+      // still holding throws, so go through the retry.
+      await bootstrapWithRetry(uid, plist, DAEMON_NAME)
+    } else if (action === "stop") {
+      launchctl("bootout", [`gui/${uid}/${DAEMON_NAME}`])
+    } else if (action === "restart") {
+      try {
+        launchctl("bootout", [`gui/${uid}/${DAEMON_NAME}`])
+      } catch {
+        // not bootstrapped — ignore
+      }
+      const goneBy = Date.now() + 10_000
+      while (Date.now() < goneBy && isJobLoaded(uid, DAEMON_NAME)) {
+        await sleep(200)
+      }
+      await bootstrapWithRetry(uid, plist, DAEMON_NAME)
+    } else {
+      launchctl("kill", ["-SIGUSR1", `gui/${uid}/${DAEMON_NAME}`])
+    }
+    logger.info({ action }, "ensureInstalled: invoked launchctl")
+    return
+  }
+  logger.error(
+    { os, action },
+    "ensureInstalled: native service management not supported on this platform",
+  )
+  process.exitCode = 1
+}