feat: restart installed services after webmux update

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: hugocasa

bin/src/service-restart.test.ts

@@ -0,0 +1,85 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { listInstalledServices, restartCommand, type InstalledService } from "./service-restart.ts";
+
+const cleanups: Array<() => Promise<void>> = [];
+
+afterEach(async () => {
+  while (cleanups.length > 0) {
+    const fn = cleanups.pop();
+    if (fn) await fn();
+  }
+});
+
+async function makeTempDir(): Promise<string> {
+  const dir = await mkdtemp(join(tmpdir(), "webmux-service-restart-"));
+  cleanups.push(async () => rm(dir, { recursive: true, force: true }));
+  return dir;
+}
+
+describe("listInstalledServices", () => {
+  it("picks up systemd units and strips the .service suffix", async () => {
+    const systemdDir = await makeTempDir();
+    await writeFile(join(systemdDir, "webmux-alpha.service"), "[Service]\nExecStart=/bin/x\n");
+    await writeFile(join(systemdDir, "webmux-beta.service"), "[Service]\nExecStart=/bin/x\n");
+    await writeFile(join(systemdDir, "unrelated.service"), "[Service]\nExecStart=/bin/x\n");
+
+    const services = listInstalledServices({
+      systemdDir,
+      launchdDir: "/no/such/dir",
+    });
+
+    expect(services.map((s) => s.name).sort()).toEqual(["webmux-alpha", "webmux-beta"]);
+    for (const svc of services) expect(svc.platform).toBe("linux");
+  });
+
+  it("picks up launchd plists and keeps the full label", async () => {
+    const launchdDir = await makeTempDir();
+    await writeFile(join(launchdDir, "com.webmux.alpha.plist"), "<plist></plist>");
+    await writeFile(join(launchdDir, "com.other.thing.plist"), "<plist></plist>");
+
+    const services = listInstalledServices({
+      systemdDir: "/no/such/dir",
+      launchdDir,
+    });
+
+    expect(services.map((s) => s.name)).toEqual(["com.webmux.alpha"]);
+    expect(services[0].platform).toBe("darwin");
+  });
+
+  it("returns empty when neither directory exists", () => {
+    const services = listInstalledServices({
+      systemdDir: "/no/such/systemd",
+      launchdDir: "/no/such/launchd",
+    });
+    expect(services).toEqual([]);
+  });
+});
+
+describe("restartCommand", () => {
+  it("builds the systemctl --user restart command for linux", () => {
+    const svc: InstalledService = {
+      name: "webmux-foo",
+      filePath: "/x/webmux-foo.service",
+      platform: "linux",
+    };
+    expect(restartCommand(svc, 1000)).toEqual({
+      bin: "systemctl",
+      args: ["--user", "restart", "webmux-foo"],
+    });
+  });
+
+  it("builds the launchctl kickstart command for darwin", () => {
+    const svc: InstalledService = {
+      name: "com.webmux.foo",
+      filePath: "/x/com.webmux.foo.plist",
+      platform: "darwin",
+    };
+    expect(restartCommand(svc, 501)).toEqual({
+      bin: "launchctl",
+      args: ["kickstart", "-k", "gui/501/com.webmux.foo"],
+    });
+  });
+});

bin/src/service-restart.ts

@@ -0,0 +1,92 @@
+import { existsSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { run, type RunResult } from "./shared.ts";
+
+export type ServicePlatform = "linux" | "darwin";
+
+export interface InstalledService {
+  /** Full unit name. systemd: "webmux-foo" (no .service suffix). launchd: the
+   *  plist Label, e.g. "com.webmux.foo". */
+  name: string;
+  filePath: string;
+  platform: ServicePlatform;
+}
+
+const DEFAULT_SYSTEMD_DIR = join(homedir(), ".config", "systemd", "user");
+const DEFAULT_LAUNCHD_DIR = join(homedir(), "Library", "LaunchAgents");
+
+/** Enumerate webmux service units installed for the current user, across both
+ *  platforms (one platform's dir is typically absent). Best-effort: unreadable
+ *  directories return nothing rather than throwing. */
+export function listInstalledServices(opts: {
+  systemdDir?: string;
+  launchdDir?: string;
+} = {}): InstalledService[] {
+  const out: InstalledService[] = [];
+  const systemdDir = opts.systemdDir ?? DEFAULT_SYSTEMD_DIR;
+  const launchdDir = opts.launchdDir ?? DEFAULT_LAUNCHD_DIR;
+
+  if (existsSync(systemdDir)) {
+    try {
+      for (const name of readdirSync(systemdDir)) {
+        if (!name.startsWith("webmux-") || !name.endsWith(".service")) continue;
+        out.push({
+          name: name.slice(0, -".service".length),
+          filePath: join(systemdDir, name),
+          platform: "linux",
+        });
+      }
+    } catch {
+      // unreadable dir — skip
+    }
+  }
+
+  if (existsSync(launchdDir)) {
+    try {
+      for (const name of readdirSync(launchdDir)) {
+        if (!name.startsWith("com.webmux.") || !name.endsWith(".plist")) continue;
+        out.push({
+          name: name.slice(0, -".plist".length),
+          filePath: join(launchdDir, name),
+          platform: "darwin",
+        });
+      }
+    } catch {
+      // unreadable dir — skip
+    }
+  }
+
+  return out;
+}
+
+/** Pure command builder for restarting a service. Kept separate from the
+ *  I/O call so it can be unit-tested without spawning processes. */
+export function restartCommand(service: InstalledService, uid: number): { bin: string; args: string[] } {
+  if (service.platform === "linux") {
+    return { bin: "systemctl", args: ["--user", "restart", service.name] };
+  }
+  return { bin: "launchctl", args: ["kickstart", "-k", `gui/${uid}/${service.name}`] };
+}
+
+export interface RestartOutcome {
+  service: InstalledService;
+  ok: boolean;
+  error?: string;
+}
+
+/** Restart a single installed service. Best-effort: a failure (service not
+ *  loaded, masked, etc.) is reported back rather than thrown. */
+export function restartInstalledService(service: InstalledService): RestartOutcome {
+  const uid = typeof process.getuid === "function" ? process.getuid() : 0;
+  const { bin, args } = restartCommand(service, uid);
+  const result: RunResult = run(bin, args);
+  if (!result.success) {
+    return {
+      service,
+      ok: false,
+      error: result.stderr.toString().trim() || `${bin} ${args.join(" ")} failed`,
+    };
+  }
+  return { service, ok: true };
+}

bin/src/webmux.ts

@@ -319,6 +319,21 @@ async function main(args: string[] = process.argv.slice(2)): Promise<void> {
       stderr: "inherit",
     });
     const code = await proc.exited;
+    if (code === 0) {
+      const { listInstalledServices, restartInstalledService } = await import("./service-restart.ts");
+      const services = listInstalledServices();
+      if (services.length > 0) {
+        console.log(`\nRestarting ${services.length} installed webmux service(s) to pick up the new version...`);
+        for (const svc of services) {
+          const outcome = restartInstalledService(svc);
+          if (outcome.ok) {
+            console.log(`  ${svc.name}: restarted`);
+          } else {
+            console.log(`  ${svc.name}: restart failed — ${outcome.error}`);
+          }
+        }
+      }
+    }
     process.exit(code);
   }