ework-aio 0.1.17 → 0.2.0

package/src/systemd.ts

@@ -0,0 +1,234 @@
+// systemd unit file generation + systemctl wrapper. Opt-in only — never
+// invoked from default install path. Replaces bash here-doc + systemctl
+// calls with TS string templates + spawnSync.
+
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { InstallError } from "./log.ts";
+
+export type ServiceName = "ework-web" | "ework-daemon";
+
+export type SystemdScope = "user" | "system";
+
+export interface UnitContext {
+  user: string;
+  group: string;
+  binPath: string;            // resolved binary path (e.g. /home/u/.bun/bin/bun)
+  mainScript: string;         // entry script (e.g. /usr/lib/node_modules/ework-web/bin/ework-web.js)
+  envFile: string;
+  workingDirectory: string;
+  // Absolute path the service should pipe stdout/stderr to. Must match the
+  // PID-file mode log path (paths.webLogFile / paths.daemonLogFile) so
+  // `ework-aio logs <svc>` reads the same file regardless of how the
+  // service was started.
+  logFile: string;
+  restart?: "always" | "on-failure" | "no";
+  description?: string;
+  // Drives WantedBy: system → multi-user.target (the sysv-init successor);
+  // user → default.target (graphical-session.user). Defaults to "user" for
+  // back-compat with callers that haven't been updated.
+  scope?: SystemdScope;
+}
+
+// User/Group values are interpolated verbatim into the unit file. Reject
+// anything outside systemd's POSIX-ish portable set so a typo can't smuggle
+// in a unit-file directive (e.g. `User=alice\nRestart=always`).
+const SYSTEMD_NAME_RE = /^[A-Za-z0-9._-]+$/;
+
+// systemd allows %-specifiers (Unit, Spec, %h, %H, ...) but they're not
+// meaningful for our paths and look like a typo or injection attempt.
+// Paths must be absolute; we never want a relative path here.
+function escapePath(p: string, field: string): string {
+  if (!path.isAbsolute(p)) {
+    throw new InstallError(
+      `systemd ${field} must be an absolute path (got '${p}')`,
+    );
+  }
+  if (p.includes("\n") || p.includes("\r")) {
+    throw new InstallError(
+      `systemd ${field} must not contain newlines (got ${JSON.stringify(p)})`,
+    );
+  }
+  // Quoting rules: systemd treats "…" in unit files literally for path-valued
+  // keys. Empty values are forbidden by the unit grammar. Spaces, quotes,
+  // and dollar signs are kept inside the quoted form.
+  if (/^[A-Za-z0-9._\/\-]+$/.test(p)) return p;
+  if (p.includes('"') || p.includes("\\")) {
+    throw new InstallError(
+      `systemd ${field} contains unsupported characters (quotes/backslashes): ${JSON.stringify(p)}`,
+    );
+  }
+  return `"${p}"`;
+}
+
+function validateName(name: string, field: string): string {
+  if (!SYSTEMD_NAME_RE.test(name)) {
+    throw new InstallError(
+      `systemd ${field}='${name}' must match ${SYSTEMD_NAME_RE.source}`,
+    );
+  }
+  return name;
+}
+
+export function generateUnitFile(svc: ServiceName, ctx: UnitContext): string {
+  const restart = ctx.restart ?? "always";
+  const description = ctx.description ?? (svc === "ework-web" ? "ework-web (issue tracker)" : "ework-daemon (AI bridge)");
+  const scope: SystemdScope = ctx.scope ?? "user";
+  const wantedBy = scope === "system" ? "multi-user.target" : "default.target";
+
+  const user = validateName(ctx.user, "User");
+  const group = validateName(ctx.group, "Group");
+  const workingDirectory = escapePath(ctx.workingDirectory, "WorkingDirectory");
+  const envFile = escapePath(ctx.envFile, "EnvironmentFile");
+  const logFile = escapePath(ctx.logFile, "StandardOutput/StandardError target");
+  const binPath = escapePath(ctx.binPath, "ExecStart binary");
+  const mainScript = escapePath(ctx.mainScript, "ExecStart main script");
+
+  return `# Generated by ework-aio. Edits will be overwritten on next install.
+[Unit]
+Description=${description}
+After=network.target
+
+[Service]
+Type=simple
+User=${user}
+Group=${group}
+WorkingDirectory=${workingDirectory}
+EnvironmentFile=${envFile}
+ExecStart=${binPath} ${mainScript}
+Restart=${restart}
+RestartSec=3
+StandardOutput=append:${logFile}
+StandardError=append:${logFile}
+
+[Install]
+WantedBy=${wantedBy}
+`;
+}
+
+export async function writeUnitFile(unitFile: string, content: string): Promise<void> {
+  const dir = path.dirname(unitFile);
+  await fs.promises.mkdir(dir, { recursive: true });
+  const tmp = path.join(dir, `.unit.tmp.${process.pid}.${Date.now()}`);
+  await fs.promises.writeFile(tmp, content, { mode: 0o644 });
+  try {
+    await fs.promises.rename(tmp, unitFile);
+  } catch (err) {
+    await fs.promises.unlink(tmp).catch(() => {});
+    throw err;
+  }
+}
+
+export interface SystemctlOptions {
+  scope: "user" | "system";
+  // If scope=user, whether to also run `loginctl enable-linger` (only meaningful for user mode).
+  enableLinger?: boolean;
+  // For tests: override systemctl binary path.
+  systemctlBin?: string;
+  // For tests: capture stdout/stderr of invocations.
+  captureIO?: boolean;
+}
+
+export interface SystemctlResult {
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+}
+
+function systemctlBase(opts: SystemctlOptions): string {
+  return opts.systemctlBin ?? "systemctl";
+}
+
+function systemctlArgs(opts: SystemctlOptions, args: string[]): string[] {
+  return opts.scope === "user" ? ["--user", ...args] : args;
+}
+
+export function runSystemctl(args: string[], opts: SystemctlOptions): SystemctlResult {
+  const bin = systemctlBase(opts);
+  const fullArgs = systemctlArgs(opts, args);
+  const r = spawnSync(bin, fullArgs, {
+    encoding: "utf8",
+    // For --user scope, XDG_RUNTIME_DIR must be set; caller's env has it.
+    env: process.env,
+  });
+  return {
+    exitCode: r.status ?? -1,
+    stdout: r.stdout ?? "",
+    stderr: r.stderr ?? "",
+  };
+}
+
+// install_unit: writes unit file, runs daemon-reload + enable. Atomic — if
+// any systemctl call fails, returns the error without leaving half-state.
+// Caller decides whether to roll back (delete the unit file).
+export async function installUnit(svc: ServiceName, unitFile: string, content: string, opts: SystemctlOptions): Promise<void> {
+  await writeUnitFile(unitFile, content);
+
+  const reload = runSystemctl(["daemon-reload"], opts);
+  if (reload.exitCode !== 0) {
+    throw new InstallError(
+      `systemctl daemon-reload failed for ${svc}: ${reload.stderr.trim() || reload.stdout.trim()}`,
+    );
+  }
+
+  const enable = runSystemctl(["enable", `${svc}.service`], opts);
+  if (enable.exitCode !== 0) {
+    throw new InstallError(
+      `systemctl enable ${svc} failed: ${enable.stderr.trim() || enable.stdout.trim()}`,
+    );
+  }
+}
+
+export async function startUnit(svc: ServiceName, opts: SystemctlOptions): Promise<void> {
+  const r = runSystemctl(["start", `${svc}.service`], opts);
+  if (r.exitCode !== 0) {
+    throw new InstallError(
+      `systemctl start ${svc} failed: ${r.stderr.trim() || r.stdout.trim()}`,
+    );
+  }
+}
+
+export async function stopUnit(svc: ServiceName, opts: SystemctlOptions): Promise<void> {
+  // stop is best-effort — ignore "unit not loaded" errors
+  const r = runSystemctl(["stop", `${svc}.service`], opts);
+  if (r.exitCode !== 0 && !/not loaded/i.test(r.stderr)) {
+    throw new InstallError(
+      `systemctl stop ${svc} failed: ${r.stderr.trim() || r.stdout.trim()}`,
+    );
+  }
+}
+
+export async function disableUnit(svc: ServiceName, opts: SystemctlOptions): Promise<void> {
+  const r = runSystemctl(["disable", `${svc}.service`], opts);
+  if (r.exitCode !== 0 && !/not loaded/i.test(r.stderr)) {
+    throw new InstallError(
+      `systemctl disable ${svc} failed: ${r.stderr.trim() || r.stdout.trim()}`,
+    );
+  }
+}
+
+export type ServiceState = "active" | "inactive" | "failed" | "unknown";
+
+export function getUnitState(svc: ServiceName, opts: SystemctlOptions): ServiceState {
+  const r = runSystemctl(["is-active", `${svc}.service`], opts);
+  const out = r.stdout.trim().toLowerCase();
+  if (r.exitCode === 0) return "active";
+  if (out === "inactive" || out === "deactivating") return "inactive";
+  if (out === "failed") return "failed";
+  return "unknown";
+}
+
+export async function removeUnit(svc: ServiceName, unitFile: string, opts: SystemctlOptions): Promise<void> {
+  await disableUnit(svc, opts);
+  await stopUnit(svc, opts);
+  const r = runSystemctl(["daemon-reload"], opts);
+  if (r.exitCode !== 0) {
+    // reload failure is non-fatal during uninstall
+  }
+  try {
+    await fs.promises.unlink(unitFile);
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code !== "ENOENT") throw err;
+  }
+}

package/src/types.ts

@@ -0,0 +1,95 @@
+// Shared types for the CLI surface. Kept in a dedicated module so commands
+// don't need to import from cli.ts (which would create a cycle: cli imports
+// commands, commands import types from cli).
+//
+// Design note: GlobalOptions is the parsed-argv shape every command receives.
+// CLI stays the only place that knows about flag parsing; commands consume
+// the typed result.
+
+export type Scope = "user" | "system";
+
+// Which service(s) a command targets. `ps` and `status` use "both";
+// `start web`/`stop daemon` use a single target.
+export type ServiceTarget = "web" | "daemon" | "both";
+
+export interface GlobalOptions {
+  // Install-time knobs (defaults live in src/types.ts DEFAULTS).
+  workPort: number;            // --port
+  daemonPort: number;          // --daemon-port
+  botName: string;             // --bot-name
+  scope: Scope;                // --user | --system
+  useSystemd: boolean;         // true when invoked as `install systemd`
+  assumeYes: boolean;          // --yes / -y
+  allowRoot: boolean;          // --allow-root
+  asUser?: string;             // --as-user <login> (re-exec target)
+  noRestart: boolean;          // --no-restart (config set)
+  noStart: boolean;            // --no-start (install)
+  // Optional path overrides.
+  dataDir?: string;            // --data-dir
+}
+
+export const DEFAULTS = {
+  workPort: 3002,
+  daemonPort: 3101,
+  botName: "ework-daemon",
+  scope: "user" as Scope,
+} as const;
+
+// SETTABLE_KEYS: the allow-list for `config set`. Secrets (WORK_TOKEN,
+// *_WEBHOOK_SECRET, BOT_TOKEN), DB paths, and the web<->daemon contract
+// keys (GITEA_URL/TOKEN, WORK_DAEMON_WEBHOOK_*) are deliberately excluded
+// — changing them by hand breaks the install.
+//
+// Each row mirrors the bash SETTABLE_KEYS array: KEY | SERVICE | DESCRIPTION.
+// `propagate` is set for keys whose change requires updating the other
+// service's .env (cross-link).
+export interface SettableKeySpec {
+  key: string;
+  service: "web" | "daemon";
+  description: string;
+  // If set, when this key changes the listed cross-link key in the other
+  // service's .env is also rewritten. Used for WORK_PORT / DAEMON_PORT.
+  propagate?: {
+    targetService: "web" | "daemon";
+    targetKey: string;
+    template: (value: string) => string;
+  };
+}
+
+export const SETTABLE_KEYS: readonly SettableKeySpec[] = [
+  { key: "WORK_PORT",             service: "web",    description: "ework-web listen port (default 3002)",
+    propagate: { targetService: "daemon", targetKey: "GITEA_URL", template: (v) => `http://127.0.0.1:${v}` } },
+  { key: "WORK_HOST",             service: "web",    description: "ework-web bind address (default 127.0.0.1; 0.0.0.0 for LAN)" },
+  { key: "WORK_OPERATOR_LOGIN",   service: "web",    description: "login auto-promoted to admin" },
+  { key: "WORK_TRANSLATE_URL",    service: "web",    description: "OpenAI-compat /v1/chat/completions endpoint for translate" },
+  { key: "WORK_TRANSLATE_MODEL",  service: "web",    description: "translate model name" },
+  { key: "WORK_TTS_SPEED",        service: "web",    description: "TTS playback rate (default 1.0)" },
+  { key: "WORK_FILE_ROOTS",       service: "web",    description: "comma-separated file-viewer roots" },
+  { key: "WORK_COMMENT_SORT",     service: "web",    description: "comment sort order: desc|asc" },
+  { key: "DAEMON_PORT",           service: "daemon", description: "ework-daemon listen port (default 3101)",
+    propagate: { targetService: "web", targetKey: "WORK_DAEMON_WEBHOOK_URL", template: (v) => `http://127.0.0.1:${v}` } },
+  { key: "DAEMON_HOST",           service: "daemon", description: "ework-daemon bind address (default 127.0.0.1)" },
+  { key: "OPENCODE_BINARY",       service: "daemon", description: "opencode binary path" },
+  { key: "OPENCODE_BASE_WORKDIR", service: "daemon", description: "opencode working directory base" },
+  { key: "COMPLETION_CHECK_API_KEY",  service: "daemon", description: "completion-check API key" },
+  { key: "COMPLETION_CHECK_BASE_URL", service: "daemon", description: "completion-check API base URL" },
+  { key: "COMPLETION_CHECK_MODEL",    service: "daemon", description: "completion-check model name" },
+] as const;
+
+// For a given key, which service(s) need to restart on change. WORK_PORT
+// and DAEMON_PORT fan out to "both" because their cross-link touches the
+// other service's .env.
+export function serviceForKey(key: string): ServiceTarget | null {
+  if (key === "WORK_PORT" || key === "DAEMON_PORT") return "both";
+  for (const entry of SETTABLE_KEYS) {
+    if (entry.key === key) return entry.service;
+  }
+  return null;
+}
+
+export function findSettableKey(key: string): SettableKeySpec | null {
+  for (const entry of SETTABLE_KEYS) {
+    if (entry.key === key) return entry;
+  }
+  return null;
+}