@ours.network/cli 0.3.0 → 0.4.0

package/dist/chunk-3RLAHOPS.js

@@ -0,0 +1,57 @@
+// src/service-instance.ts
+import { basename, resolve } from "node:path";
+var DEFAULT_SYSTEMD_UNIT = "ours.service";
+var INSTANCE_RE = /^[A-Za-z0-9](?:[A-Za-z0-9_-]{0,30}[A-Za-z0-9])?$/;
+function normalizeInstanceName(raw) {
+  const s = typeof raw === "string" ? raw.trim() : "";
+  if (!s) return { ok: true, name: "" };
+  if (s.length > 32) {
+    return { ok: false, name: "", reason: "service name must be 32 characters or fewer" };
+  }
+  if (!INSTANCE_RE.test(s)) {
+    return {
+      ok: false,
+      name: "",
+      reason: "service name must be 1\u201332 characters of letters, digits, hyphen or underscore, starting and ending with a letter or digit"
+    };
+  }
+  return { ok: true, name: s };
+}
+function systemdUnitName(instance = "") {
+  const { ok, name } = normalizeInstanceName(instance);
+  if (!ok || !name) return DEFAULT_SYSTEMD_UNIT;
+  return `ours-${name}.service`;
+}
+function serviceDescription(instance = "") {
+  const { ok, name } = normalizeInstanceName(instance);
+  return ok && name ? `ours daemon (instance "${name}")` : "ours shared daemon";
+}
+function instanceNameFromStateDir(stateDir) {
+  const segment = basename(resolve(stateDir));
+  const undotted = segment.startsWith(".") ? segment.slice(1) : segment;
+  if (undotted === "ours") return { ok: true, name: "" };
+  const stripped = undotted.startsWith("ours-") ? undotted.slice("ours-".length) : undotted;
+  const result = normalizeInstanceName(stripped);
+  if (!result.ok) {
+    return {
+      ok: false,
+      name: "",
+      reason: `state directory ${JSON.stringify(resolve(stateDir))} does not yield a usable service name (${JSON.stringify(stripped)}): ${result.reason}`
+    };
+  }
+  return result;
+}
+function unitNameForStateDir(stateDir) {
+  const { ok, name, reason } = instanceNameFromStateDir(stateDir);
+  if (!ok) throw new Error(reason);
+  return systemdUnitName(name);
+}
+
+export {
+  DEFAULT_SYSTEMD_UNIT,
+  normalizeInstanceName,
+  systemdUnitName,
+  serviceDescription,
+  instanceNameFromStateDir,
+  unitNameForStateDir
+};

package/dist/{chunk-67BC2E5U.js → chunk-SSUJ5QGC.js}

@@ -1,3 +1,9 @@
+import {
+  instanceNameFromStateDir,
+  serviceDescription,
+  unitNameForStateDir
+} from "./chunk-3RLAHOPS.js";
+
 // src/service.ts
 import { execFile as nodeExecFile } from "node:child_process";
 import { promisify } from "node:util";
@@ -17,24 +23,44 @@ function systemdEscapeArgument(value) {
   if (/[\n\r]/.test(value)) throw new Error("service arguments must not contain newlines");
   return `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"').replaceAll("%", "%%")}"`;
 }
+function systemdUnescapeArgument(value) {
+  const trimmed = value.trim();
+  if (!trimmed.startsWith('"') || !trimmed.endsWith('"') || trimmed.length < 2) return void 0;
+  return trimmed.slice(1, -1).replaceAll("%%", "%").replaceAll('\\"', '"').replaceAll("\\\\", "\\");
+}
+function bakedStateDir(unit) {
+  for (const line of unit.split("\n")) {
+    if (!line.startsWith("Environment=OURS_STATE_DIR=")) continue;
+    return systemdUnescapeArgument(line.slice("Environment=OURS_STATE_DIR=".length));
+  }
+  return void 0;
+}
+function resolveStateDir(context) {
+  return resolve(context.stateDir ?? join(context.homeDir ?? homedir(), ".ours"));
+}
 function createLinuxUserSystemdAdapter(deps = defaultDeps) {
   if (deps.platform !== "linux") throw new Error(`service management is not supported on ${deps.platform}; use an external launcher for \`ours daemon serve\``);
   return {
     name: "systemd-user",
     async install(context) {
       const home = context.homeDir ?? homedir();
-      const serviceFile = join(home, ".config", "systemd", "user", SERVICE_NAME);
+      const stateDir = resolveStateDir(context);
+      const unitName = unitNameForStateDir(stateDir);
+      const serviceFile = join(home, ".config", "systemd", "user", unitName);
+      const unitConfig = context.configPath ? resolve(context.configPath) : void 0;
       const args = [process.execPath, resolve(context.cliPath), "daemon", "serve"];
-      if (context.configPath) args.push("--config", resolve(context.configPath));
+      if (unitConfig) args.push("--config", unitConfig);
+      const environment = `Environment=OURS_STATE_DIR=${systemdEscapeArgument(stateDir)}
+`;
       const unit = `${MARKER}
 [Unit]
-Description=ours shared daemon
+Description=${serviceDescription(instanceNameFromStateDir(stateDir).name)}
 After=network-online.target
 
 [Service]
 Type=simple
 ExecStart=${args.map(systemdEscapeArgument).join(" ")}
-Restart=on-failure
+${environment}Restart=on-failure
 RestartSec=2
 
 [Install]
@@ -45,34 +71,45 @@ WantedBy=default.target
         if (!previous.startsWith(MARKER) && !context.force) {
           throw new Error(`${serviceFile} is not managed by @ours.network/cli; refusing to overwrite it without --force`);
         }
-        if (previous === unit) return { adapter: this.name, action: "install", serviceFile, commands: [], changed: false, dryRun: context.dryRun === true };
+        const owner = previous.startsWith(MARKER) ? bakedStateDir(previous) : void 0;
+        if (owner !== void 0 && owner !== stateDir && !context.force) {
+          throw new Error(`${serviceFile} is the boot service for the daemon at ${owner}, not ${stateDir}; refusing to overwrite it without --force`);
+        }
+        if (previous === unit) return { adapter: this.name, action: "install", serviceFile, unitName, stateDir, configPath: unitConfig, commands: [], changed: false, dryRun: context.dryRun === true };
       }
-      const commands = [["systemctl", "--user", "daemon-reload"], ["systemctl", "--user", "enable", "--now", SERVICE_NAME]];
+      const commands = [["systemctl", "--user", "daemon-reload"], ["systemctl", "--user", "enable", "--now", unitName]];
       if (!context.dryRun) {
         mkdirSync(dirname(serviceFile), { recursive: true });
         writeFileSync(serviceFile, unit, { mode: 420 });
         for (const [command, ...args2] of commands) await deps.run(command, args2);
       }
-      return { adapter: this.name, action: "install", serviceFile, commands, changed: true, dryRun: context.dryRun === true };
+      return { adapter: this.name, action: "install", serviceFile, unitName, stateDir, configPath: unitConfig, commands, changed: true, dryRun: context.dryRun === true };
     },
     async uninstall(context) {
       const home = context.homeDir ?? homedir();
-      const serviceFile = join(home, ".config", "systemd", "user", SERVICE_NAME);
-      if (!existsSync(serviceFile)) return { adapter: this.name, action: "uninstall", serviceFile, commands: [], changed: false, dryRun: context.dryRun === true };
+      const stateDir = resolveStateDir(context);
+      const unitName = unitNameForStateDir(stateDir);
+      const serviceFile = join(home, ".config", "systemd", "user", unitName);
+      if (!existsSync(serviceFile)) return { adapter: this.name, action: "uninstall", serviceFile, unitName, stateDir, commands: [], changed: false, dryRun: context.dryRun === true };
       const previous = readFileSync(serviceFile, "utf8");
       if (!previous.startsWith(MARKER)) throw new Error(`${serviceFile} is not managed by @ours.network/cli; refusing to remove it`);
-      const commands = [["systemctl", "--user", "disable", "--now", SERVICE_NAME], ["systemctl", "--user", "daemon-reload"]];
+      const owner = bakedStateDir(previous);
+      if (owner !== void 0 && owner !== stateDir && !context.force) {
+        throw new Error(`${serviceFile} is the boot service for the daemon at ${owner}, not ${stateDir}; refusing to remove it without --force`);
+      }
+      const commands = [["systemctl", "--user", "disable", "--now", unitName], ["systemctl", "--user", "daemon-reload"]];
       if (!context.dryRun) {
         await deps.run(commands[0][0], commands[0].slice(1));
         unlinkSync(serviceFile);
         await deps.run(commands[1][0], commands[1].slice(1));
       }
-      return { adapter: this.name, action: "uninstall", serviceFile, commands, changed: true, dryRun: context.dryRun === true };
+      return { adapter: this.name, action: "uninstall", serviceFile, unitName, stateDir, commands, changed: true, dryRun: context.dryRun === true };
     }
   };
 }
 
 export {
   SERVICE_NAME,
+  bakedStateDir,
   createLinuxUserSystemdAdapter
 };

package/dist/{chunk-HNBWRI4O.js → chunk-VGWQD7CJ.js}

@@ -103,8 +103,8 @@ function nativeDaemonOptions(action) {
   const install = action === "install-service";
   const rows = [
     ["--endpoint URL", selected ? action === "serve" || action === "start" || action === "restart" ? "Rejected: this action must start a local selected daemon." : "Select a running endpoint; pair it with --state-dir." : "Compatibility-only/ignored for service management."],
-    ["--port N", selected ? "Select daemon port 1\u201365535." : "Compatibility-only/ignored for service management."],
-    ["--state-dir PATH", selected ? "Select the daemon state directory." : "Compatibility-only/ignored for service management."],
+    ["--port N", selected ? "Select daemon port 1\u201365535." : "Checked against the port recorded for this state directory; a disagreement is refused and nothing is written."],
+    ["--state-dir PATH", selected ? "Select the daemon state directory." : "Select the daemon whose unit this is; the unit name derives from it (~/.ours \u2192 ours.service, ~/.ours-tg \u2192 ours-tg.service)."],
     ["--config PATH", selected ? "Use this daemon config for lifecycle selection." : action === "install-service" ? "Embed this config file\u2019s absolute path in the installed unit." : "Compatibility-only/ignored by uninstall-service."],
     ["--identity NAME", "Compatibility-only/ignored by daemon lifecycle and service commands."],
     ["--json", action === "serve" ? "Compatibility-only/ignored because serve runs until interrupted." : "Write one JSON result to stdout."],

package/dist/help.js

@@ -3,7 +3,7 @@ import {
   helpRequestPath,
   renderHelp,
   renderTopHelp
-} from "./chunk-HNBWRI4O.js";
+} from "./chunk-VGWQD7CJ.js";
 import "./chunk-QRNZFPNJ.js";
 import "./chunk-6NFATG6P.js";
 import "./chunk-YSHMCQ2B.js";

package/dist/main.js

@@ -5,7 +5,10 @@ import {
 } from "./chunk-YC7QBGVC.js";
 import {
   createLinuxUserSystemdAdapter
-} from "./chunk-67BC2E5U.js";
+} from "./chunk-SSUJ5QGC.js";
+import {
+  instanceNameFromStateDir
+} from "./chunk-3RLAHOPS.js";
 import {
   setupConfig,
   showConfig
@@ -14,7 +17,7 @@ import {
   helpHint,
   helpRequestPath,
   renderHelp
-} from "./chunk-HNBWRI4O.js";
+} from "./chunk-VGWQD7CJ.js";
 import {
   invokeOperation,
   isOperationName,
@@ -49,9 +52,10 @@ import {
 } from "./chunk-6W3RHW3C.js";
 
 // src/main.ts
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
-var CLI_VERSION = false ? "0.0.0-dev" : "0.3.0";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+var CLI_VERSION = false ? "0.0.0-dev" : "0.4.0";
 var COMMON_VALUES = /* @__PURE__ */ new Set(["--endpoint", "--port", "--state-dir", "--config", "--identity"]);
 var COMMON_BOOLEANS = /* @__PURE__ */ new Set(["--json", "--yes", "--help"]);
 function selectionFrom(values) {
@@ -62,6 +66,41 @@ function selectionFrom(values) {
     configPath: values["--config"]
   };
 }
+function readDaemonConfig(path) {
+  if (!existsSync(path)) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(path, "utf8"));
+  } catch (error) {
+    throw new CliUsageError(`${path} is not readable JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new CliUsageError(`${path} must contain a JSON object`);
+  }
+  return parsed;
+}
+function serviceTarget(values) {
+  const namedConfig = values["--config"] ?? process.env.OURS_CONFIG;
+  const seedConfigPath = namedConfig ?? defaultConfigPath();
+  const seedConfig = readDaemonConfig(resolve(seedConfigPath));
+  const fromFile = typeof seedConfig?.stateDir === "string" ? seedConfig.stateDir : void 0;
+  const stateDir = resolve(
+    values["--state-dir"] ?? process.env.OURS_STATE_DIR ?? fromFile ?? join(homedir(), ".ours")
+  );
+  const configPath = namedConfig ?? join(stateDir, "config.json");
+  const ownConfig = join(stateDir, "config.json");
+  const unitConfigPath = values["--config"] ?? (existsSync(ownConfig) ? ownConfig : void 0);
+  return { stateDir, configPath, unitConfigPath };
+}
+function assertPortAgrees(port, target) {
+  if (port === void 0 || target.configPath === void 0) return;
+  const config = readDaemonConfig(resolve(target.configPath));
+  const recorded = config?.port;
+  if (typeof recorded !== "number" || recorded === port) return;
+  throw new CliUsageError(
+    `--port ${port} disagrees with port ${recorded}, which ${resolve(target.configPath)} records for the daemon at ${target.stateDir}. Re-run without --port to use the recorded port, or change the recorded port first. Nothing was written.`
+  );
+}
 function requireYes(operation, yes) {
   if (DESTRUCTIVE_OPERATIONS.has(operation) && !yes) throw new CliUsageError(`${operation} is destructive; re-run with --yes`);
 }
@@ -184,8 +223,12 @@ async function runDaemon(args, io) {
   if (handler === "install-service" || handler === "uninstall-service") {
     const dryRun = flags.booleans.has("--dry-run");
     if (!dryRun && !flags.booleans.has("--yes")) throw new CliUsageError(`${handler} changes the user service manager; re-run with --yes or preview with --dry-run`);
+    const target = serviceTarget(flags.values);
+    const derived = instanceNameFromStateDir(target.stateDir);
+    if (!derived.ok) throw new CliUsageError(derived.reason ?? `cannot derive a service name from ${target.stateDir}`);
+    assertPortAgrees(selection.port, target);
     const adapter = createLinuxUserSystemdAdapter();
-    const context = { cliPath: process.argv[1], configPath: selection.configPath, dryRun, force: flags.booleans.has("--force") };
+    const context = { cliPath: process.argv[1], configPath: target.unitConfigPath, stateDir: target.stateDir, dryRun, force: flags.booleans.has("--force") };
     const result = handler === "install-service" ? await adapter.install(context) : await adapter.uninstall(context);
     writeResult(io, result, json, handler);
     return 0;

package/dist/service-instance.d.ts

@@ -0,0 +1,12 @@
+export declare const DEFAULT_SYSTEMD_UNIT = "ours.service";
+export interface InstanceResult {
+    ok: boolean;
+    /** '' means "the default, unnamed daemon" — the historical single-unit behaviour. */
+    name: string;
+    reason?: string;
+}
+export declare function normalizeInstanceName(raw: unknown): InstanceResult;
+export declare function systemdUnitName(instance?: string): string;
+export declare function serviceDescription(instance?: string): string;
+export declare function instanceNameFromStateDir(stateDir: string): InstanceResult;
+export declare function unitNameForStateDir(stateDir: string): string;

package/dist/service-instance.js

@@ -0,0 +1,16 @@
+import {
+  DEFAULT_SYSTEMD_UNIT,
+  instanceNameFromStateDir,
+  normalizeInstanceName,
+  serviceDescription,
+  systemdUnitName,
+  unitNameForStateDir
+} from "./chunk-3RLAHOPS.js";
+export {
+  DEFAULT_SYSTEMD_UNIT,
+  instanceNameFromStateDir,
+  normalizeInstanceName,
+  serviceDescription,
+  systemdUnitName,
+  unitNameForStateDir
+};

package/dist/service.d.ts

@@ -1,8 +1,17 @@
+/**
+ * The unit for the default, unnamed daemon. Kept as a named export because it
+ * is the historical public constant; every other unit name comes from
+ * `unitNameForStateDir`, which returns exactly this string for `~/.ours`.
+ */
 export declare const SERVICE_NAME = "ours.service";
 export interface ServicePlan {
     adapter: string;
     action: 'install' | 'uninstall';
     serviceFile: string;
+    unitName: string;
+    stateDir: string;
+    /** The config file the unit's ExecStart selects, or undefined when it selects none. */
+    configPath?: string;
     commands: string[][];
     changed: boolean;
     dryRun: boolean;
@@ -10,6 +19,13 @@ export interface ServicePlan {
 export interface ServiceContext {
     cliPath: string;
     configPath?: string;
+    /**
+     * The state directory this unit belongs to. It decides the unit NAME and is
+     * baked into the unit FILE, so a unit can always be traced back to its
+     * daemon. Defaults to `<home>/.ours`, which derives the historical
+     * `ours.service`.
+     */
+    stateDir?: string;
     homeDir?: string;
     dryRun?: boolean;
     force?: boolean;
@@ -23,4 +39,9 @@ export interface ServiceAdapter {
     install(context: ServiceContext): Promise<ServicePlan>;
     uninstall(context: ServiceContext): Promise<ServicePlan>;
 }
+/**
+ * The state directory a CLI-managed unit was installed for, or undefined for a
+ * unit written before this CLI baked one in.
+ */
+export declare function bakedStateDir(unit: string): string | undefined;
 export declare function createLinuxUserSystemdAdapter(deps?: ServiceDeps): ServiceAdapter;

package/dist/service.js

@@ -1,8 +1,11 @@
 import {
   SERVICE_NAME,
+  bakedStateDir,
   createLinuxUserSystemdAdapter
-} from "./chunk-67BC2E5U.js";
+} from "./chunk-SSUJ5QGC.js";
+import "./chunk-3RLAHOPS.js";
 export {
   SERVICE_NAME,
+  bakedStateDir,
   createLinuxUserSystemdAdapter
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/cli",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Transport-neutral operator CLI for the ours shared daemon",
   "type": "module",
   "license": "FSL-1.1-Apache-2.0",