@danypops/tickets 0.10.0 → 0.10.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/tickets",
-  "version": "0.10.0",
+  "version": "0.10.2",
   "description": "Unified CLI, daemon, and TypeScript library for issue tracking across GitHub, GitLab, and Jira.",
   "type": "module",
   "license": "MIT",
@@ -25,7 +25,7 @@
   },
   "dependencies": {
     "@danypops/vehicle-core": "^0.12.3",
-    "@danypops/vehicle-server": "^0.17.1",
+    "@danypops/vehicle-server": "^0.18.2",
     "@danypops/vehicle-client": "^0.5.0",
     "@danypops/enigma-client": "^0.6.1",
     "@gitbeaker/rest": "^43.8.0",

package/src/auth/browser.ts

@@ -9,8 +9,15 @@ import { spawn } from "node:child_process";
 
 export type Spawner = (command: string, args: string[]) => void;
 
-const defaultSpawner: Spawner = (command, args) => {
+// A spawn() failure (e.g. no `xdg-open` on a minimal Linux install) surfaces asynchronously as
+// an unlistened "error" event under Node, which is an uncaught exception that kills the whole
+// host process -- this runs from inside the long-lived pi-tickets extension host (tui.ts), not
+// just the standalone CLI, so that crash is a real live risk, not just a CLI inconvenience.
+export const defaultSpawner: Spawner = (command, args) => {
   const child = spawn(command, args, { stdio: "ignore", detached: true });
+  child.on("error", (error) => {
+    console.error(`failed to open URL via ${command}: ${error instanceof Error ? error.message : String(error)}`);
+  });
   child.unref();
 };
 

package/src/cli/index.ts

@@ -15,8 +15,9 @@ import { promptMaskedSecret } from "../auth/masked-prompt.js";
 import { deleteToken, isTokenFresh, listStoredBackends, loadToken, saveToken } from "../auth/token-store.js";
 import type { CreateInput, ListFilter, Priority, Status, UpdateInput } from "../issue/issue.js";
 import { parseStatus } from "../issue/issue.js";
+import { serveMain } from "../process/main.js";
 import type { StagePatchFields, StagePayload } from "../stage/store.js";
-import { installTicketsService, systemctlTickets, systemdUnitPath } from "./systemd-service.js";
+import { ticketsServiceCli } from "./systemd-service.js";
 import { createTicketsClient, type TicketsRpcClient } from "./tickets-client.js";
 
 function printJson(value: unknown): void {
@@ -489,32 +490,53 @@ daemon
     }
   });
 
+program
+  .command("serve")
+  .description("run the tickets daemon in the foreground -- Armada's service spec launches exactly this (see ./systemd-service.js)")
+  .action(async () => {
+    await serveMain();
+  });
+
 const service = program
   .command("service")
   .description(
-    "deploy the tickets daemon as a persistent systemd --user service (Linux; survives logout/reboot, unlike `daemon start`'s on-demand spawn)",
+    "deploy the tickets daemon as a persistent, Armada-supervised service (Linux/macOS/Windows; survives logout/reboot and restarts on crash, unlike `daemon start`'s on-demand spawn)",
   );
 
 service
   .command("install")
-  .description("write, enable, and (re)start a tickets-daemon.service systemd --user unit pointed at this install")
+  .description("register this install with Armada as the tickets vehicle and reconcile it (write/enable/start its systemd unit)")
   .action(() => {
-    try {
-      const { unitPath } = installTicketsService();
-      printJson({ status: "installed", unitPath });
-    } catch (err) {
-      process.stderr.write(`error: ${err instanceof Error ? err.message : String(err)}\n`);
+    const cli = ticketsServiceCli();
+    const result = cli.install();
+    if (!result.installed) {
+      process.stderr.write(`error: ${result.reason}\n`);
+      process.exitCode = 1;
+      return;
+    }
+    printJson({ status: "installed", unitName: cli.unitName, via: "armada" });
+  });
+
+service
+  .command("uninstall")
+  .description("remove this vehicle from Armada's fleet (stops and un-enrolls the tickets-daemon service)")
+  .action(() => {
+    const result = ticketsServiceCli().uninstall();
+    if (!result.installed) {
+      process.stderr.write(`error: ${result.reason}\n`);
       process.exitCode = 1;
+      return;
     }
+    printJson({ status: "uninstalled", via: "armada" });
   });
 
 for (const action of ["start", "stop", "restart", "status"] as const) {
   service
     .command(action)
-    .description(`systemctl --user ${action} tickets-daemon.service`)
+    .description(`systemctl --user ${action} the Armada-managed tickets unit`)
     .action(() => {
       try {
-        systemctlTickets(action);
+        ticketsServiceCli().action(action);
       } catch (err) {
         process.stderr.write(`error: ${err instanceof Error ? err.message : String(err)}\n`);
         process.exitCode = 1;
@@ -522,13 +544,6 @@ for (const action of ["start", "stop", "restart", "status"] as const) {
     });
 }
 
-service
-  .command("path")
-  .description("print where the systemd unit file would be written")
-  .action(() => {
-    printJson({ unitPath: systemdUnitPath() });
-  });
-
 const auth = program.command("auth").description("delegated OAuth login (device flow for GitHub/GitLab, authorization code for Jira)");
 
 auth

package/src/cli/systemd-service.ts

@@ -1,97 +1,36 @@
 /**
- * Deploys the tickets daemon as a persistent systemd --user service, so it
- * survives logout/reboot instead of only existing for as long as some CLI
- * command's on-demand auto-spawn keeps it alive. Mirrors papyrus's own
- * `papyrus service <install|start|stop|restart|status>` pattern exactly
- * (see ~/Projects/papyrus/src/cli.ts) -- same shape, same systemctl --user
- * verbs, same install order (write unit -> daemon-reload -> enable ->
- * restart). Every side effect (file write, directory creation, systemctl
- * invocation) is injectable so this is fully testable without touching a
- * real filesystem or spawning a real systemctl process.
+ * Deploys the tickets daemon as an Armada-supervised service. Builds the
+ * spec; createServiceCli (vehicle-server) owns install/uninstall/systemctl
+ * wiring shared by every Vehicle-backed daemon's CLI.
  */
-import { execFileSync } from "node:child_process";
-import { mkdirSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createServiceCli, type ServiceCli, type ServiceSpec } from "@danypops/vehicle-server/service";
+import { readPackageVersion } from "@danypops/vehicle-server/version";
 import { TICKETS_DAEMON_NAMES } from "../rpc/ops.js";
-import { resolveDaemonEntryPath } from "./tickets-client.js";
+import { ticketsPaths } from "./tickets-client.js";
 
-export interface SystemdUnitOptions {
-  bunBin: string;
-  daemonMainPath: string;
+export interface TicketsServiceSpecOptions {
+  version?: string;
+  /** Overridden in tests. */
+  cliEntryPath?: string;
 }
 
-export function renderSystemdUnit(options: SystemdUnitOptions): string {
-  return `[Unit]
-Description=Tickets daemon -- unified GitHub/GitLab/Jira issue tracking
-After=default.target
-
-[Service]
-Type=simple
-ExecStart=${options.bunBin} run ${options.daemonMainPath}
-Restart=always
-RestartSec=2
-
-[Install]
-WantedBy=default.target
-`;
-}
-
-/** XDG_CONFIG_HOME/systemd/user/tickets-daemon.service, falling back to ~/.config like systemd itself does. */
-export function systemdUnitPath(env: Record<string, string | undefined> = process.env): string {
-  const configHome = env.XDG_CONFIG_HOME ?? join(env.HOME ?? "", ".config");
-  return join(configHome, "systemd", "user", TICKETS_DAEMON_NAMES.systemdUnitName);
-}
-
-export type CommandRunner = (command: string, args: string[]) => void;
-
-const defaultRunner: CommandRunner = (command, args) => {
-  try {
-    execFileSync(command, args, { stdio: "inherit" });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    throw new Error(`${command} ${args.join(" ")} failed (is systemd --user available? this feature is Linux-only): ${message}`);
-  }
-};
-
-export type SystemctlAction = "start" | "stop" | "restart" | "status" | "enable" | "daemon-reload";
-
-/** Always targets the tickets unit name under --user scope; daemon-reload takes no unit argument. */
-export function systemctlTickets(action: SystemctlAction, runner: CommandRunner = defaultRunner): void {
-  const args = action === "daemon-reload" ? ["--user", "daemon-reload"] : ["--user", action, TICKETS_DAEMON_NAMES.systemdUnitName];
-  runner("systemctl", args);
-}
-
-export interface InstallOptions {
-  bunBin?: string;
-  daemonMainPath?: string;
-  env?: Record<string, string | undefined>;
-  runner?: CommandRunner;
-  writeFile?: (path: string, content: string) => void;
-  ensureDir?: (path: string) => void;
+/** The daemon is launched as `<bin> <this CLI's entry path> serve`. */
+export function ticketsServiceSpec(opts: TicketsServiceSpecOptions = {}): ServiceSpec {
+  const cliEntryPath = opts.cliEntryPath ?? fileURLToPath(new URL("./index.js", import.meta.url));
+  const version = opts.version ?? readPackageVersion(new URL("../../package.json", import.meta.url), "Tickets");
+  return {
+    name: TICKETS_DAEMON_NAMES.stateDirectoryName,
+    displayName: "Tickets daemon",
+    version,
+    binPath: process.execPath,
+    args: [cliEntryPath, "serve"],
+    handlePath: ticketsPaths().handle,
+    restartOnFailure: true,
+    restartSec: 2,
+  };
 }
 
-/**
- * Writes the unit file, then daemon-reload -> enable -> restart, in that
- * order -- systemd must see the file before enable/restart can act on it,
- * and restart (not start) so re-running install after an upgrade picks up
- * a changed ExecStart path immediately rather than requiring a manual stop.
- */
-export function installTicketsService(opts: InstallOptions = {}): { unitPath: string } {
-  const unitPath = systemdUnitPath(opts.env);
-  const ensureDir = opts.ensureDir ?? ((dir: string) => mkdirSync(dir, { recursive: true }));
-  const writeFile = opts.writeFile ?? writeFileSync;
-  const runner = opts.runner ?? defaultRunner;
-
-  ensureDir(dirname(unitPath));
-  writeFile(
-    unitPath,
-    renderSystemdUnit({
-      bunBin: opts.bunBin ?? process.execPath,
-      daemonMainPath: opts.daemonMainPath ?? resolveDaemonEntryPath(),
-    }),
-  );
-  systemctlTickets("daemon-reload", runner);
-  systemctlTickets("enable", runner);
-  systemctlTickets("restart", runner);
-  return { unitPath };
+export function ticketsServiceCli(opts: TicketsServiceSpecOptions = {}): ServiceCli {
+  return createServiceCli(ticketsServiceSpec(opts));
 }

package/src/cli/tickets-client.ts

@@ -29,14 +29,22 @@ async function isAlive(handle: DaemonHandle, token: string): Promise<boolean> {
   }
 }
 
-/** Absolute path to the daemon's real entry point, resolved from this package's own root. Used both to spawn it on demand and to point a systemd unit's ExecStart at it (see cli/systemd-service.ts). */
+/** Absolute path to the daemon's real entry point, resolved from this package's own root. Used to spawn it on demand -- Armada's own ServiceSpec (see cli/systemd-service.ts) launches the CLI's own `serve` command instead, not this path directly. */
 export function resolveDaemonEntryPath(): string {
   const root = packageRoot(dirname(fileURLToPath(import.meta.url)));
   return join(root, "src", "process", "main.ts");
 }
 
-function spawnDaemon(): void {
+// A spawn() failure surfaces asynchronously as an unlistened "error" event under Node, which is
+// an uncaught exception that kills the whole host process. createTicketsClient (which calls
+// this via ensureDaemonRunning) runs from inside the long-lived pi-tickets extension host
+// (tui.ts) as well as the CLI, so a missing/misconfigured `bun` binary would otherwise crash
+// the whole Pi session, not just this one connect attempt.
+export function spawnDaemon(): void {
   const child = spawn("bun", ["run", resolveDaemonEntryPath()], { detached: true, stdio: "ignore" });
+  child.on("error", (error) => {
+    console.error(`tickets daemon auto-spawn failed: ${error instanceof Error ? error.message : String(error)}`);
+  });
   child.unref();
 }
 

package/src/process/main.ts

@@ -1,20 +1,28 @@
 #!/usr/bin/env bun
 /**
  * The real tickets-daemon binary. Requires Bun (bun:sqlite, Bun.serve via
- * vehicle-server). Everything else in this package (the library, the CLI, the
- * pi-tickets extension) is plain Node-compatible TypeScript and talks to
- * this process only over the loopback HTTP RPC surface — see client.ts.
+ * vehicle-server). Everything else in this package talks to this process
+ * only over the loopback HTTP RPC surface — see client.ts.
+ *
+ * serveMain() is also what `tickets serve` (cli/index.ts) runs directly --
+ * that's the command Armada's ServiceSpec launches.
  */
 import { runDaemonProcess } from "@danypops/vehicle-server/daemon";
 import { readPackageVersion } from "@danypops/vehicle-server/version";
 import { bootstrap } from "./bootstrap.js";
 
-const version = readPackageVersion(new URL("../../package.json", import.meta.url), "Tickets");
-const { options } = await bootstrap({ version });
+export async function serveMain(): Promise<void> {
+  const version = readPackageVersion(new URL("../../package.json", import.meta.url), "Tickets");
+  const { options } = await bootstrap({ version });
 
-runDaemonProcess({
-  ...options,
-  onListen: (info) => {
-    options.logger?.info("tickets daemon listening", { host: info.host, port: info.port, version });
-  },
-});
+  runDaemonProcess({
+    ...options,
+    onListen: (info) => {
+      options.logger?.info("tickets daemon listening", { host: info.host, port: info.port, version });
+    },
+  });
+}
+
+if (import.meta.main) {
+  await serveMain();
+}