borgmcp-server 0.1.8 → 0.1.9

package/src/bootstrap.ts

@@ -1,16 +1,23 @@
 import { createHash, randomBytes, randomUUID, X509Certificate } from "node:crypto";
-import { lstat, readFile, stat, writeFile } from "node:fs/promises";
+import { lstat, readFile, stat, unlink, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { generate } from "selfsigned";
 
-import { CredentialAuthority, CredentialDigester } from "./credentials.js";
+import { CredentialAuthority, CredentialDigester, generateSecret } from "./credentials.js";
+import type { PortableServerCredential } from "./portable-credential-store.js";
 import { openStore } from "./store.js";
 
 export interface BootstrapResult {
   readonly serverId: string;
   readonly caFingerprint: string;
+  /** @deprecated Retained for offline administrative compatibility; never rendered by setup. */
   readonly recoveryCredential: string;
+  /** @deprecated The already-consumed bootstrap invitation; never rendered by setup. */
   readonly initialInvitation: string;
+  readonly ownerAccess: {
+    readonly clientId: string;
+    readonly serverCapabilities: readonly ["create_cube"];
+  };
   readonly paths: {
     readonly database: string;
     readonly digestKey: string;
@@ -26,6 +33,7 @@ export async function bootstrapServer(
   dataDirectory: string,
   bindHost = "127.0.0.1",
   clock: () => Date = () => new Date(),
+  persistOwnerCredential: (record: PortableServerCredential) => Promise<void> = async () => undefined,
 ): Promise<BootstrapResult> {
   const directory = resolve(dataDirectory);
   const paths = {
@@ -63,6 +71,7 @@ export async function bootstrapServer(
     .digest("hex");
   const digestKey = randomBytes(32);
   const runtime = await openStore({ path: paths.database, clock });
+  let completed = false;
   try {
     await Promise.all([
       writePrivate(paths.digestKey, digestKey),
@@ -81,20 +90,52 @@ export async function bootstrapServer(
     try {
       const authority = new CredentialAuthority(runtime.credentials, digester, clock);
       const recoveryCredential = authority.createRecoveryCredential();
-      const initialInvitation = authority.createBootstrapInvitation(15 * 60_000);
-      return {
+      const invitation = authority.createBootstrapInvitation(15 * 60_000);
+      const credential = generateSecret();
+      const enrollment = authority.exchangeInvitation({
+        invitation,
+        retryKey: randomUUID(),
+        clientCredential: credential,
+        clientName: "Local owner",
+      });
+      if (enrollment?.purpose !== "owner" || enrollment.serverCapabilities[0] !== "create_cube") {
+        throw new Error("Local owner provisioning failed.");
+      }
+      await persistOwnerCredential(Object.freeze({
+        version: 2,
+        origin: `https://${bindHost === "::1" ? "[::1]" : bindHost}:7091`,
+        trustIdentity: `spki-sha256:${caFingerprint}`,
+        credential,
+        clientId: enrollment.clientId,
+        serverCapabilities: ["create_cube"] as const,
+      }));
+      const result = {
         serverId,
         caFingerprint,
         recoveryCredential,
-        initialInvitation,
+        initialInvitation: invitation,
+        ownerAccess: {
+          clientId: enrollment.clientId,
+          serverCapabilities: ["create_cube"] as const,
+        },
         paths,
       };
+      completed = true;
+      return result;
     } finally {
       digester.destroy();
     }
   } finally {
     digestKey.fill(0);
     runtime.close();
+    if (!completed) {
+      await Promise.all([
+        ...Object.values(paths),
+        `${paths.database}-wal`,
+        `${paths.database}-shm`,
+        `${paths.database}-journal`,
+      ].map((path) => unlink(path).catch(() => undefined)));
+    }
   }
 }
 

package/src/cli.ts

@@ -1,9 +1,11 @@
 import type { ServerService } from "./service.js";
+import { RuntimeUpdateFailure } from "./runtime-operator.js";
 
 export interface CliIo {
   readonly stdout: (message: string) => void;
   readonly stderr: (message: string) => void;
   readonly readSecret?: (prompt: string) => Promise<string>;
+  readonly isTTY?: boolean;
 }
 
 const usage = `Usage: borg-mcp-server <command> [options]
@@ -11,6 +13,9 @@ const usage = `Usage: borg-mcp-server <command> [options]
 Commands:
   setup [--reinitialize]  Prepare an offline server installation
   start    Start the server process
+  status [--json]  Report exact local runtime evidence
+  update [--json]  Verify and activate the latest server artifact
+  invite   Create a single-use invitation in an interactive terminal.
   client-rotate <client-id>  Rotate one client credential offline
   client-revoke <client-id>  Revoke one client and its credentials offline
   client-grant <client-id> <cube-id> <read|write|manage>  Set one offline cube grant
@@ -58,11 +63,109 @@ export async function runCli(
         return 1;
       }
       const result = await service.setup({ reinitialize: extraArgs[0] === "--reinitialize" });
-      io.stdout(`Server setup complete.\nRecovery credential (shown once; keep offline): ${result.recoveryCredential}\nOwner enrollment invitation (single-use, shown once; enroll the owner client): ${result.initialInvitation}\nSetup created no cube.\nNext: start the server with \`borg-mcp-server start\`.`);
+      const artifactIdentity = result.artifact === undefined
+        ? "borgmcp-server@unavailable"
+        : `borgmcp-server@${result.artifact.version}`;
+      const artifact = result.artifact === undefined
+        ? "Artifact: unavailable"
+        : `Artifact: ${artifactIdentity} (${result.artifact.integrity})`;
+      if (io.isTTY === false) {
+        io.stdout(JSON.stringify({
+          status: "prepared",
+          artifact: artifactIdentity,
+          build_identity: result.artifact?.sourceSha ?? null,
+          owner_access: "prepared",
+          process: "stopped",
+        }));
+        return 0;
+      }
+      if ("existing" in result) {
+        io.stdout([
+          "Local server is already prepared.",
+          artifact,
+          `Build identity: ${result.artifact?.sourceSha ?? "unavailable"}`,
+          "Data and identity: unchanged",
+          "No server process started.",
+          "Next: borg-mcp-server start",
+        ].join("\n"));
+        return 0;
+      }
+      io.stdout([
+        "Local server setup completed.",
+        artifact,
+        "Local owner access: prepared.",
+        "No server process started.",
+        "Next: start the server, then run borg assimilate.",
+      ].join("\n"));
       return 0;
     case "start":
       await service.start(extraArgs);
       return 0;
+    case "status": {
+      if (extraArgs.length > 1 || (extraArgs.length === 1 && extraArgs[0] !== "--json") ||
+          service.status === undefined) return invalidArguments(io);
+      const status = await service.status();
+      if (extraArgs[0] === "--json" || io.isTTY === false) {
+        io.stdout(JSON.stringify({
+          status: status.status,
+          artifact: status.artifact === null
+            ? null
+            : `borgmcp-server@${status.artifact.version}`,
+          artifact_integrity: status.artifact?.integrity ?? null,
+          build_identity: status.buildIdentity,
+          endpoint: status.endpoint,
+          mode: status.mode,
+          data_identity: status.dataIdentity,
+        }));
+      } else {
+        io.stdout(renderRuntimeStatus(status));
+      }
+      return 0;
+    }
+    case "update": {
+      if (extraArgs.length > 1 || (extraArgs.length === 1 && extraArgs[0] !== "--json") ||
+          service.update === undefined) return invalidArguments(io);
+      let result: Awaited<ReturnType<NonNullable<ServerService["update"]>>>;
+      try {
+        result = await service.update();
+      } catch (error) {
+        if (!(error instanceof RuntimeUpdateFailure)) throw error;
+        renderUpdateFailure(error, io, extraArgs[0] === "--json" || io.isTTY === false);
+        return 1;
+      }
+      if (extraArgs[0] === "--json" || io.isTTY === false) {
+        io.stdout(JSON.stringify({
+          status: result.outcome,
+          artifact: `borgmcp-server@${result.artifact.version}`,
+          artifact_integrity: result.artifact.integrity,
+          build_identity: result.runningIdentity?.source_sha ?? result.artifact.sourceSha,
+          mode: result.outcome === "updated" ? "managed" : "stopped",
+          data_identity: result.dataIdentity,
+        }));
+      } else if (result.outcome === "updated") {
+        io.stdout([
+          `Verifying borgmcp-server@${result.artifact.version}...`,
+          "Artifact verified and activated.",
+          "Restarting the verified local server...",
+          `Local server is running.`,
+          `Artifact: borgmcp-server@${result.artifact.version} (${result.artifact.integrity})`,
+          `Build identity: ${result.runningIdentity?.source_sha ?? "unavailable"}`,
+          "Data and identity: preserved",
+          "Next: borg-mcp-server status",
+        ].join("\n"));
+      } else {
+        io.stdout([
+          `Verifying borgmcp-server@${result.artifact.version}...`,
+          "Artifact verified and activated.",
+          "No server process started.",
+          `Artifact: borgmcp-server@${result.artifact.version} (${result.artifact.integrity})`,
+          `Build identity: ${result.artifact.sourceSha ?? "unavailable"}`,
+          "Data and identity: preserved",
+          "Next: borg-mcp-server start",
+        ].join("\n"));
+      }
+      return 0;
+    }
     case "client-rotate":
       if (extraArgs.length !== 1 || service.rotateClient === undefined) return invalidArguments(io);
       io.stdout(`Client credential rotated (shown once): ${await service.rotateClient(extraArgs[0]!)}`);
@@ -115,6 +218,16 @@ export async function runCli(
       }
       return 0;
     }
+    case "invite": {
+      if (extraArgs.length !== 0 || service.invite === undefined) return invalidArguments(io);
+      if (io.isTTY !== true) {
+        io.stderr("Invitation creation requires an interactive terminal.");
+        return 1;
+      }
+      const invitation = await service.invite();
+      io.stdout(`Invitation (single-use; shown once): ${invitation}\nShare it only with the intended recipient.`);
+      return 0;
+    }
     case "help":
     case "--help":
     case "-h":
@@ -127,6 +240,63 @@ export async function runCli(
   }
 }
 
+function renderUpdateFailure(failure: RuntimeUpdateFailure, io: CliIo, machine: boolean): void {
+  const state = failure.code === "ARTIFACT_VERIFICATION_FAILED"
+    ? "verification_failed"
+    : failure.recovery === "restored"
+      ? "restored"
+      : failure.recovery === "stopped"
+        ? "stopped"
+        : "recovery_failed";
+  if (machine) {
+    io.stdout(JSON.stringify({
+      status: "failed",
+      error_code: failure.code,
+      recovery: state,
+      data_identity: "preserved",
+    }));
+    return;
+  }
+  if (failure.code === "ARTIFACT_VERIFICATION_FAILED") {
+    io.stderr([
+      "Update stopped: artifact verification failed.",
+      "No activation occurred.",
+      "The last verified runtime remains available.",
+      "Next: borg-mcp-server status",
+    ].join("\n"));
+    return;
+  }
+  io.stderr([
+    "Update stopped: activation did not complete.",
+    failure.recovery === "restored"
+      ? "The last verified runtime was restored."
+      : failure.recovery === "stopped"
+        ? "The server stopped safely."
+        : "Recovery did not complete; inspect server status.",
+    "Data and identity: preserved",
+    "Next: borg-mcp-server status",
+  ].join("\n"));
+}
+
+function renderRuntimeStatus(status: Awaited<ReturnType<NonNullable<ServerService["status"]>>>): string {
+  const heading = status.status === "running"
+    ? status.buildIdentity === null
+      ? "Local server is reachable, but its running build identity is unavailable."
+      : "Local server is running."
+    : "Local server is stopped.";
+  const artifact = status.artifact === null
+    ? "Artifact: unavailable"
+    : `Artifact: borgmcp-server@${status.artifact.version} (${status.artifact.integrity})`;
+  return [
+    heading,
+    artifact,
+    `Build identity: ${status.buildIdentity ?? "unavailable"}`,
+    `Endpoint: ${status.endpoint ?? "unavailable"}`,
+    `Mode: ${status.mode}`,
+    `Data and identity: ${status.dataIdentity}`,
+  ].join("\n");
+}
+
 function parseClientInviteArguments(
   args: readonly string[],
 ): { readonly cubeSelector?: string; readonly access?: "read" | "write" | "manage" } | undefined {

package/src/credentials.ts

@@ -210,6 +210,13 @@ export class CredentialAuthority {
     return this.#createInvitation("client", ttlMs);
   }
 
+  createInvitationForOwnerCredential(clientCredential: string, ttlMs: number): string | null {
+    const principal = this.authenticate(`Bearer ${clientCredential}`);
+    if (principal?.kind !== "client" ||
+        !this.#store.clientHasServerCapability(principal.id, "create_cube")) return null;
+    return this.#createInvitation("client", ttlMs);
+  }
+
   createCubeInvitation(
     recoveryCredential: string,
     cubeSelector: { readonly kind: "id" | "name"; readonly value: string },

package/src/debug-log.ts

@@ -3,6 +3,7 @@ import type { Principal } from "./principal.js";
 export type DebugRoute =
   | "health"
   | "protocol"
+  | "runtime"
   | "enrollment_exchange"
   | "client_attach"
   | "cubes"
@@ -158,7 +159,7 @@ function enumValue<const T extends string>(value: unknown, allowed: readonly T[]
 }
 
 const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
-const DEBUG_ROUTES: readonly DebugRoute[] = ["health", "protocol", "enrollment_exchange", "client_attach", "cubes", "cube", "cube_roles", "cube_role", "cube_role_section_patch", "cube_taxonomy_patch", "cube_drones", "cube_logs", "cube_acks", "cube_decisions", "cube_stream", "unknown"];
+const DEBUG_ROUTES: readonly DebugRoute[] = ["health", "protocol", "runtime", "enrollment_exchange", "client_attach", "cubes", "cube", "cube_roles", "cube_role", "cube_role_section_patch", "cube_taxonomy_patch", "cube_drones", "cube_logs", "cube_acks", "cube_decisions", "cube_stream", "unknown"];
 const HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "OTHER"] as const;
 const AUTH_RESULTS = ["not_required", "missing", "invalid", "expired", "revoked", "evicted", "rejected", "accepted"] as const;
 const AUTHZ_RESULTS = ["not_checked", "accepted", "denied_or_not_found"] as const;

package/src/https-server.ts

@@ -17,6 +17,7 @@ import { resolveBindOptions, type BindOptionsInput } from "./network-policy.js";
 import type { CoordinationRequest, CoordinationResponse } from "./coordination-api.js";
 import type { Principal } from "./principal.js";
 import { disabledDebugLogger, type DebugLogger, type DebugRoute } from "./debug-log.js";
+import { RUNTIME_INFO_PATH, type RuntimeBuildIdentity } from "./runtime-identity.js";
 
 export interface ServiceLimits {
   readonly maxConnections: number;
@@ -66,6 +67,7 @@ export interface RequestHandlerContext {
   ) => Promise<Principal | "missing" | "invalid" | "expired" | "revoked" | "evicted" | "rejected">;
   readonly handleCoordination?: (request: CoordinationRequest) => Promise<CoordinationResponse>;
   readonly debugLogger: DebugLogger;
+  readonly runtimeIdentity?: RuntimeBuildIdentity;
 }
 
 export interface HttpsServerOptions {
@@ -80,6 +82,7 @@ export interface HttpsServerOptions {
   readonly handleCoordination?: RequestHandlerContext["handleCoordination"];
   readonly limits?: ServiceLimits;
   readonly debugLogger?: DebugLogger;
+  readonly runtimeIdentity?: RuntimeBuildIdentity;
   readonly testHooks?: {
     readonly identifyRemoteAddress?: (socket: Socket) => string;
     readonly identifyConnectionAddress?: (socket: Socket) => string;
@@ -183,6 +186,7 @@ export function createRequestHandlerContext(
     ...(options.handleCoordination === undefined
       ? {}
       : { handleCoordination: options.handleCoordination }),
+    ...(options.runtimeIdentity === undefined ? {} : { runtimeIdentity: options.runtimeIdentity }),
     debugLogger: options.debugLogger ?? disabledDebugLogger,
   });
 }
@@ -342,7 +346,7 @@ async function handleRequest(
     return;
   }
 
-  if (isCoordinationPath(path) && context.handleCoordination !== undefined) {
+  if (isAuthenticatedPath(path) && context.authorizeCoordination !== undefined) {
     let decoded: unknown;
     if (requestBody.length === 0) {
       decoded = undefined;
@@ -354,12 +358,7 @@ async function handleRequest(
       }
     }
     const authorization = request.headers.authorization;
-    const authorizeCoordination = context.authorizeCoordination;
-    if (authorizeCoordination === undefined) {
-      sendJson(response, 500, protocolError("INTERNAL_ERROR", "Coordination authentication is unavailable."), true);
-      return;
-    }
-    const authentication = await authorizeCoordination(authorization, signal);
+    const authentication = await context.authorizeCoordination(authorization, signal);
     trace.authentication = typeof authentication === "string" ? authentication : "accepted";
     if (signal.aborted) return;
     if (typeof authentication === "string") {
@@ -376,6 +375,22 @@ async function handleRequest(
       return;
     }
     trace.principal = authentication;
+    if (path === RUNTIME_INFO_PATH) {
+      if (request.method !== "GET" || requestBody.length !== 0) {
+        sendEmpty(response, request.method === "GET" ? 400 : 405, true);
+        return;
+      }
+      if (context.runtimeIdentity === undefined) {
+        sendEmpty(response, 404);
+        return;
+      }
+      sendJson(response, 200, context.runtimeIdentity);
+      return;
+    }
+    if (context.handleCoordination === undefined) {
+      sendJson(response, 500, protocolError("INTERNAL_ERROR", "Coordination handling is unavailable."), true);
+      return;
+    }
     const clientIdentity = credentialRateLimitIdentity(authentication, request.method, path);
     const credentialRetry = credentialRateLimiter.consume(clientIdentity);
     if (credentialRetry !== null) return sendRateLimited(response, credentialRetry);
@@ -431,6 +446,7 @@ function debugRoute(rawUrl: string | undefined): DebugRoute {
   if (path === null) return "unknown";
   if (path === HEALTH_PATH) return "health";
   if (path === PROTOCOL_INFO_PATH) return "protocol";
+  if (path === RUNTIME_INFO_PATH) return "runtime";
   if (path === ENROLLMENT_EXCHANGE_PATH) return "enrollment_exchange";
   if (path === ATTACH_PATH) return "client_attach";
   if (path === "/api/cubes") return "cubes";
@@ -616,6 +632,10 @@ function isCoordinationPath(path: string | null): path is string {
     path?.startsWith("/api/cubes/") === true;
 }
 
+function isAuthenticatedPath(path: string | null): path is string {
+  return path === RUNTIME_INFO_PATH || isCoordinationPath(path);
+}
+
 function credentialRateLimitIdentity(
   principal: Principal,
   method: string | undefined,

package/src/index.ts

@@ -1,3 +1,48 @@
 export { runCli } from "./cli.js";
 export type { CliIo } from "./cli.js";
-export type { ServerService, SetupOptions } from "./service.js";
+export { inspectRuntimeLock } from "./service.js";
+export { inspectNodeRuntime } from "./service.js";
+export type {
+  RuntimeLockStatus,
+  ServerRuntimeStatus,
+  ServerSetupResult,
+  ServerService,
+  SetupOptions,
+} from "./service.js";
+export {
+  createRuntimeBuildIdentity,
+  loadRuntimeBuildIdentity,
+  RUNTIME_INFO_PATH,
+  SERVER_PACKAGE_VERSION,
+} from "./runtime-identity.js";
+export type {
+  LoadRuntimeBuildIdentityInput,
+  RuntimeBuildIdentity,
+  RuntimeBuildIdentityInput,
+} from "./runtime-identity.js";
+export { createManagedServiceDefinition } from "./managed-service.js";
+export type {
+  ManagedServiceDefinition,
+  ManagedServiceInput,
+  ManagedServicePlatform,
+} from "./managed-service.js";
+export {
+  createRuntimeLifecycle,
+  RuntimeActivationError,
+  createUnixNpmArtifactUnpacker,
+  inspectActiveRuntimeArtifact,
+} from "./runtime-lifecycle.js";
+export { createRegistryArtifactSource } from "./registry-artifact.js";
+export type { RegistryArtifactSource, RegistryRuntimeArtifact } from "./registry-artifact.js";
+export { createRuntimeOperator } from "./runtime-operator.js";
+export { RuntimeUpdateFailure } from "./runtime-operator.js";
+export type { RuntimeOperator, RuntimeUpdateResult } from "./runtime-operator.js";
+export type {
+  ActivateRuntimeArtifactInput,
+  RuntimeLifecycle,
+  RuntimeLifecycleDependencies,
+  RuntimeCommandResult,
+  RuntimeCommandRunner,
+  StageRuntimeArtifactInput,
+  VerifiedRuntimeArtifact,
+} from "./runtime-lifecycle.js";

package/src/main.ts

@@ -10,6 +10,7 @@ const io = {
   stdout: (message: string): void => console.log(message),
   stderr: (message: string): void => console.error(message),
   readSecret: readHiddenSecret,
+  isTTY: process.stdout.isTTY === true,
 };
 
 async function readHiddenSecret(prompt: string): Promise<string> {

package/src/managed-service.ts

@@ -0,0 +1,107 @@
+import { isAbsolute, join } from "node:path";
+
+export type ManagedServicePlatform = "launchd" | "systemd";
+
+export interface ManagedServiceInput {
+  readonly platform: ManagedServicePlatform;
+  readonly nodeExecutable: string;
+  readonly runtimeRoot: string;
+  readonly dataDirectory: string;
+  readonly definitionPath: string;
+  readonly launchdDomain?: string;
+}
+
+export interface ManagedServiceDefinition {
+  readonly platform: ManagedServicePlatform;
+  readonly label: "ai.borgmcp.server";
+  readonly definitionPath: string;
+  readonly content: string;
+  readonly install: readonly [string, ...string[]];
+  readonly restart: readonly [string, ...string[]];
+  readonly stop: readonly [string, ...string[]];
+  readonly status: readonly [string, ...string[]];
+}
+
+const serviceLabel = "ai.borgmcp.server" as const;
+
+export function createManagedServiceDefinition(input: ManagedServiceInput): ManagedServiceDefinition {
+  for (const path of [
+    input.nodeExecutable,
+    input.runtimeRoot,
+    input.dataDirectory,
+    input.definitionPath,
+  ]) {
+    if (!isAbsolute(path) || /[\r\n\0]/u.test(path)) {
+      throw new Error("Managed service paths must be absolute and single-line.");
+    }
+  }
+  const entrypoint = join(input.runtimeRoot, "current", "package", "dist", "main.js");
+  if (input.platform === "launchd") {
+    const domain = input.launchdDomain;
+    if (domain === undefined || !/^gui\/[1-9][0-9]*$/u.test(domain)) {
+      throw new Error("Managed launchd domain is invalid.");
+    }
+    const service = `${domain}/${serviceLabel}`;
+    return Object.freeze({
+      platform: "launchd",
+      label: serviceLabel,
+      definitionPath: input.definitionPath,
+      content: launchdDefinition(input.nodeExecutable, entrypoint, input.dataDirectory),
+      install: ["launchctl", "bootstrap", domain, input.definitionPath] as const,
+      restart: ["launchctl", "kickstart", "-k", service] as const,
+      stop: ["launchctl", "kill", "SIGTERM", service] as const,
+      status: ["launchctl", "print", service] as const,
+    });
+  }
+  return Object.freeze({
+    platform: "systemd",
+    label: serviceLabel,
+    definitionPath: input.definitionPath,
+    content: systemdDefinition(input.nodeExecutable, entrypoint, input.dataDirectory),
+    install: ["systemctl", "--user", "enable", "--now", serviceLabel] as const,
+    restart: ["systemctl", "--user", "restart", serviceLabel] as const,
+    stop: ["systemctl", "--user", "stop", serviceLabel] as const,
+    status: ["systemctl", "--user", "show", serviceLabel, "--property=ActiveState,SubState,MainPID"] as const,
+  });
+}
+
+function launchdDefinition(nodeExecutable: string, entrypoint: string, dataDirectory: string): string {
+  return `<?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>${serviceLabel}</string>
+  <key>ProgramArguments</key><array><string>${xml(nodeExecutable)}</string><string>${xml(entrypoint)}</string><string>start</string></array>
+  <key>EnvironmentVariables</key><dict><key>BORG_SERVER_DATA_DIR</key><string>${xml(dataDirectory)}</string><key>BORG_SERVER_PROCESS_MODE</key><string>managed</string></dict>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><dict><key>SuccessfulExit</key><false/></dict>
+  <key>ProcessType</key><string>Background</string>
+</dict></plist>
+`;
+}
+
+function systemdDefinition(nodeExecutable: string, entrypoint: string, dataDirectory: string): string {
+  return `[Unit]
+Description=Borg MCP server
+
+[Service]
+Type=simple
+ExecStart=${systemdQuote(nodeExecutable)} ${systemdQuote(entrypoint)} start
+Environment=${systemdQuote(`BORG_SERVER_DATA_DIR=${dataDirectory}`)}
+Environment="BORG_SERVER_PROCESS_MODE=managed"
+Restart=on-failure
+RestartSec=2
+TimeoutStopSec=15
+
+[Install]
+WantedBy=default.target
+`;
+}
+
+function xml(value: string): string {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+
+function systemdQuote(value: string): string {
+  return `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+}