@hermespilot/link 0.1.2 → 0.1.4

package/dist/cli/index.js

@@ -3,19 +3,530 @@ import {
   LINK_COMMAND,
   LINK_VERSION,
   createApp,
+  createFileLogger,
   ensureHermesApiServerKey,
   ensureIdentity,
   getIdentityStatus,
+  getLinkLogFile,
   loadConfig,
   loadIdentity,
   preparePairing,
   resolveRuntimePaths
-} from "../chunk-E2BRK5JT.js";
+} from "../chunk-T35GPRKF.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
 import qrcode from "qrcode-terminal";
 
+// src/autostart/autostart.ts
+import { execFile } from "child_process";
+import { mkdir as mkdir3, readFile as readFile2, rm as rm3, writeFile as writeFile2 } from "fs/promises";
+import os from "os";
+import path2 from "path";
+import { promisify } from "util";
+
+// src/daemon/process.ts
+import { spawn } from "child_process";
+import { mkdir as mkdir2, open, readFile, rm as rm2 } from "fs/promises";
+import path from "path";
+
+// src/daemon/service.ts
+import { createServer } from "http";
+import { mkdir, rm, writeFile } from "fs/promises";
+
+// src/relay/control-client.ts
+import WebSocket from "ws";
+function connectRelayControl(options) {
+  const wsUrl = new URL(`${options.relayBaseUrl.replace(/\/+$/u, "")}/api/v1/relay/link/connect`);
+  wsUrl.protocol = wsUrl.protocol === "https:" ? "wss:" : "ws:";
+  wsUrl.searchParams.set("link_id", options.linkId);
+  const maxReconnectAttempts = options.maxReconnectAttempts ?? 5;
+  const backoffBaseMs = options.backoffBaseMs ?? 1e3;
+  const backoffMaxMs = options.backoffMaxMs ?? 3e4;
+  let reconnectAttempts = 0;
+  let closedByUser = false;
+  let socket = null;
+  let retryTimer = null;
+  let abortControllers = /* @__PURE__ */ new Map();
+  const connect = () => {
+    options.onStatus?.({ state: "connecting", attempt: reconnectAttempts });
+    socket = new WebSocket(wsUrl, {
+      headers: {
+        "x-hermes-link-version": LINK_VERSION
+      }
+    });
+    socket.on("open", () => {
+      reconnectAttempts = 0;
+      options.onStatus?.({ state: "connected", attempt: reconnectAttempts });
+    });
+    socket.on("message", (raw) => {
+      if (!socket || typeof raw !== "string" && !Buffer.isBuffer(raw)) {
+        return;
+      }
+      void handleFrame(socket, String(raw), options.localPort, abortControllers).catch((error) => {
+        const message = error instanceof Error ? error.message : "Relay request failed";
+        socket?.send(JSON.stringify({ type: "http.error", id: "unknown", status: 502, message }));
+      });
+    });
+    socket.on("error", (error) => {
+      const message = error instanceof Error ? error.message : "Relay websocket error";
+      options.onStatus?.({ state: "disconnected", attempt: reconnectAttempts, message });
+    });
+    socket.on("close", () => {
+      abortAll(abortControllers);
+      abortControllers = /* @__PURE__ */ new Map();
+      if (closedByUser) {
+        options.onStatus?.({ state: "disconnected", attempt: reconnectAttempts });
+        return;
+      }
+      if (reconnectAttempts >= maxReconnectAttempts) {
+        options.onStatus?.({ state: "failed", attempt: reconnectAttempts, message: "Relay reconnect attempts exhausted" });
+        return;
+      }
+      reconnectAttempts += 1;
+      const delay = computeBackoffMs(reconnectAttempts, backoffBaseMs, backoffMaxMs);
+      options.onStatus?.({ state: "retrying", attempt: reconnectAttempts, message: `Retrying in ${delay}ms` });
+      retryTimer = setTimeout(connect, delay);
+      retryTimer.unref?.();
+    });
+  };
+  connect();
+  return {
+    close() {
+      closedByUser = true;
+      if (retryTimer) {
+        clearTimeout(retryTimer);
+      }
+      abortAll(abortControllers);
+      socket?.close();
+    }
+  };
+}
+function abortAll(abortControllers) {
+  for (const controller of abortControllers.values()) {
+    controller.abort();
+  }
+  abortControllers.clear();
+}
+function computeBackoffMs(attempt, baseMs, maxMs) {
+  const exponential = Math.min(maxMs, baseMs * 2 ** Math.max(0, attempt - 1));
+  const jitter = Math.floor(Math.random() * Math.min(1e3, exponential * 0.2));
+  return exponential + jitter;
+}
+async function handleFrame(socket, raw, localPort, abortControllers) {
+  const frame = JSON.parse(raw);
+  if (frame.type === "http.cancel") {
+    abortControllers.get(frame.id)?.abort();
+    abortControllers.delete(frame.id);
+    return;
+  }
+  if (frame.type !== "http.request") {
+    return;
+  }
+  const abortController = new AbortController();
+  abortControllers.set(frame.id, abortController);
+  try {
+    const response = await fetch(`http://127.0.0.1:${localPort}${frame.path}`, {
+      method: frame.method,
+      headers: frame.headers ?? {},
+      body: frame.bodyBase64 ? Buffer.from(frame.bodyBase64, "base64") : void 0,
+      signal: abortController.signal
+    });
+    const headers = Object.fromEntries(response.headers.entries());
+    const contentType = response.headers.get("content-type") ?? "";
+    if (response.body && contentType.includes("text/event-stream")) {
+      socket.send(JSON.stringify({ type: "http.stream.start", id: frame.id, status: response.status, headers }));
+      const reader = response.body.getReader();
+      while (true) {
+        const next = await reader.read();
+        if (next.done) {
+          break;
+        }
+        socket.send(JSON.stringify({ type: "http.stream.chunk", id: frame.id, bodyBase64: Buffer.from(next.value).toString("base64") }));
+      }
+      socket.send(JSON.stringify({ type: "http.stream.end", id: frame.id }));
+      return;
+    }
+    const body = Buffer.from(await response.arrayBuffer()).toString("base64");
+    socket.send(JSON.stringify({ type: "http.response", id: frame.id, status: response.status, headers, bodyBase64: body }));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Relay request failed";
+    socket.send(JSON.stringify({ type: "http.error", id: frame.id, status: 502, message }));
+  } finally {
+    abortControllers.delete(frame.id);
+  }
+}
+
+// src/daemon/service.ts
+async function startLinkService(options = {}) {
+  const paths = options.paths ?? resolveRuntimePaths();
+  const logger = createFileLogger({ paths });
+  const [identity, config] = await Promise.all([loadIdentity(paths), loadConfig(paths)]);
+  await logger.info("service_starting", {
+    port: config.port,
+    mode: identity?.link_id ? "paired" : "local-only"
+  });
+  const app = await createApp({ paths, logger, onPairingClaimed: options.onPairingClaimed });
+  const server = createServer(app.callback());
+  try {
+    await listenServer(server, config.port);
+  } catch (error) {
+    await logger.error("service_start_failed", {
+      port: config.port,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    await logger.flush();
+    throw error;
+  }
+  server.on("error", (error) => {
+    void logger.error("service_error", { error: error.message });
+  });
+  void logger.info("service_started", {
+    port: config.port,
+    link_id: identity?.link_id ?? null
+  });
+  let relay = null;
+  if (identity?.link_id) {
+    relay = connectRelayControl({
+      relayBaseUrl: config.relayBaseUrl,
+      linkId: identity.link_id,
+      localPort: config.port,
+      maxReconnectAttempts: options.relayMaxReconnectAttempts ?? 5,
+      backoffBaseMs: 1e3,
+      backoffMaxMs: 3e4,
+      onStatus: (status) => {
+        void logger.info("relay_status", status);
+      }
+    });
+  } else {
+    void logger.info("relay_skipped", { reason: "link_not_paired" });
+  }
+  if (options.writePidFile) {
+    await writePidFile(paths);
+  }
+  return {
+    async close() {
+      relay?.close();
+      await closeServer(server);
+      await logger.info("service_stopped");
+      await logger.flush();
+      if (options.writePidFile) {
+        await rm(pidFilePath(paths), { force: true }).catch(() => void 0);
+      }
+    }
+  };
+}
+function pidFilePath(paths = resolveRuntimePaths()) {
+  return `${paths.runDir}/hermeslink.pid`;
+}
+async function writePidFile(paths) {
+  await mkdir(paths.runDir, { recursive: true, mode: 448 });
+  await writeFile(pidFilePath(paths), `${process.pid}
+`, { mode: 384 });
+}
+async function closeServer(server) {
+  await new Promise((resolve, reject) => {
+    server.close((error) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+}
+async function listenServer(server, port) {
+  await new Promise((resolve, reject) => {
+    const cleanup = () => {
+      server.off("error", onError);
+      server.off("listening", onListening);
+    };
+    const onError = (error) => {
+      cleanup();
+      reject(error);
+    };
+    const onListening = () => {
+      cleanup();
+      resolve();
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(port);
+  });
+}
+
+// src/daemon/process.ts
+async function startDaemonProcess(paths = resolveRuntimePaths()) {
+  const status = await getDaemonStatus(paths);
+  if (status.running) {
+    return status;
+  }
+  await mkdir2(paths.logsDir, { recursive: true, mode: 448 });
+  await mkdir2(paths.runDir, { recursive: true, mode: 448 });
+  const log = await open(daemonLogFile(paths), "a", 384);
+  const scriptPath = currentCliScriptPath();
+  const child = spawn(process.execPath, [scriptPath, "daemon", "--foreground"], {
+    detached: true,
+    stdio: ["ignore", log.fd, log.fd],
+    env: process.env
+  });
+  child.unref();
+  await log.close();
+  for (let index = 0; index < 12; index += 1) {
+    await wait(250);
+    const next = await getDaemonStatus(paths);
+    if (next.running) {
+      return next;
+    }
+  }
+  return await getDaemonStatus(paths);
+}
+async function stopDaemonProcess(paths = resolveRuntimePaths()) {
+  const status = await getDaemonStatus(paths);
+  if (!status.running || !status.pid) {
+    return status;
+  }
+  try {
+    process.kill(status.pid, "SIGTERM");
+  } catch {
+    await rm2(pidFilePath(paths), { force: true }).catch(() => void 0);
+    return await getDaemonStatus(paths);
+  }
+  for (let index = 0; index < 20; index += 1) {
+    await wait(250);
+    if (!isProcessAlive(status.pid)) {
+      break;
+    }
+  }
+  if (!isProcessAlive(status.pid)) {
+    await rm2(pidFilePath(paths), { force: true }).catch(() => void 0);
+  }
+  return await getDaemonStatus(paths);
+}
+async function getDaemonStatus(paths = resolveRuntimePaths()) {
+  const pidFile = pidFilePath(paths);
+  const pid = await readPid(pidFile);
+  if (pid && !isProcessAlive(pid)) {
+    await rm2(pidFile, { force: true }).catch(() => void 0);
+    return {
+      running: false,
+      pid: null,
+      pidFile,
+      logFile: daemonLogFile(paths)
+    };
+  }
+  return {
+    running: Boolean(pid),
+    pid,
+    pidFile,
+    logFile: daemonLogFile(paths)
+  };
+}
+function daemonLogFile(paths = resolveRuntimePaths()) {
+  return path.join(paths.logsDir, "daemon.log");
+}
+function currentCliScriptPath() {
+  return process.argv[1];
+}
+async function readPid(filePath) {
+  const raw = await readFile(filePath, "utf8").catch(() => null);
+  if (!raw) {
+    return null;
+  }
+  const pid = Number.parseInt(raw.trim(), 10);
+  return Number.isInteger(pid) && pid > 0 ? pid : null;
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/autostart/autostart.ts
+var execFileAsync = promisify(execFile);
+var MACOS_LABEL = "com.hermespilot.link";
+async function enableAutostart() {
+  const definition = await resolveAutostartDefinition();
+  if (!definition) {
+    return unsupportedStatus();
+  }
+  await mkdir3(path2.dirname(definition.filePath), { recursive: true, mode: 448 });
+  await writeFile2(definition.filePath, definition.content, { mode: 384 });
+  if (definition.method === "systemd-user") {
+    await execFileAsync("systemctl", ["--user", "enable", path2.basename(definition.filePath)]).catch(async () => {
+      await rm3(definition.filePath, { force: true }).catch(() => void 0);
+      const fallback = xdgAutostartDefinition();
+      await mkdir3(path2.dirname(fallback.filePath), { recursive: true, mode: 448 });
+      await writeFile2(fallback.filePath, fallback.content, { mode: 384 });
+    });
+  }
+  return await getAutostartStatus();
+}
+async function disableAutostart() {
+  const definitions = await allAutostartDefinitions();
+  for (const definition of definitions) {
+    if (definition.method === "systemd-user") {
+      await execFileAsync("systemctl", ["--user", "disable", path2.basename(definition.filePath)]).catch(() => void 0);
+    }
+    await rm3(definition.filePath, { force: true }).catch(() => void 0);
+  }
+  return await getAutostartStatus();
+}
+async function getAutostartStatus() {
+  const definitions = await allAutostartDefinitions();
+  if (definitions.length === 0) {
+    return unsupportedStatus();
+  }
+  for (const definition of definitions) {
+    const content = await readFile2(definition.filePath, "utf8").catch(() => null);
+    if (content !== null) {
+      return {
+        supported: true,
+        enabled: true,
+        method: definition.method,
+        filePath: definition.filePath
+      };
+    }
+  }
+  const primary = definitions[0];
+  return {
+    supported: true,
+    enabled: false,
+    method: primary.method,
+    filePath: primary.filePath
+  };
+}
+async function resolveAutostartDefinition() {
+  if (process.platform === "darwin") {
+    return launchdDefinition();
+  }
+  if (process.platform === "win32") {
+    return windowsStartupDefinition();
+  }
+  if (process.platform === "linux") {
+    return await hasSystemctlUser() ? systemdUserDefinition() : xdgAutostartDefinition();
+  }
+  return null;
+}
+async function allAutostartDefinitions() {
+  if (process.platform === "darwin") {
+    return [launchdDefinition()];
+  }
+  if (process.platform === "win32") {
+    return [windowsStartupDefinition()];
+  }
+  if (process.platform === "linux") {
+    return [systemdUserDefinition(), xdgAutostartDefinition()];
+  }
+  return [];
+}
+async function hasSystemctlUser() {
+  try {
+    await execFileAsync("systemctl", ["--user", "show-environment"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function launchdDefinition() {
+  const filePath = path2.join(os.homedir(), "Library", "LaunchAgents", `${MACOS_LABEL}.plist`);
+  return {
+    method: "launchd",
+    filePath,
+    content: `<?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>${MACOS_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${xmlEscape(process.execPath)}</string>
+    <string>${xmlEscape(currentCliScriptPath())}</string>
+    <string>daemon</string>
+    <string>--foreground</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <false/>
+  <key>StandardOutPath</key>
+  <string>${xmlEscape(path2.join(os.homedir(), ".hermeslink", "logs", "daemon.log"))}</string>
+  <key>StandardErrorPath</key>
+  <string>${xmlEscape(path2.join(os.homedir(), ".hermeslink", "logs", "daemon.log"))}</string>
+</dict>
+</plist>
+`
+  };
+}
+function systemdUserDefinition() {
+  const filePath = path2.join(os.homedir(), ".config", "systemd", "user", "hermeslink.service");
+  return {
+    method: "systemd-user",
+    filePath,
+    content: `[Unit]
+Description=Hermes Link
+After=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${systemdQuote(process.execPath)} ${systemdQuote(currentCliScriptPath())} daemon --foreground
+Restart=no
+
+[Install]
+WantedBy=default.target
+`
+  };
+}
+function xdgAutostartDefinition() {
+  const filePath = path2.join(os.homedir(), ".config", "autostart", "hermeslink.desktop");
+  return {
+    method: "xdg-autostart",
+    filePath,
+    content: `[Desktop Entry]
+Type=Application
+Name=Hermes Link
+Exec=${desktopQuote(process.execPath)} ${desktopQuote(currentCliScriptPath())} daemon --foreground
+Terminal=false
+X-GNOME-Autostart-enabled=true
+`
+  };
+}
+function windowsStartupDefinition() {
+  const appData = process.env.APPDATA ?? path2.join(os.homedir(), "AppData", "Roaming");
+  const filePath = path2.join(appData, "Microsoft", "Windows", "Start Menu", "Programs", "Startup", "HermesLink.cmd");
+  return {
+    method: "windows-startup",
+    filePath,
+    content: `@echo off\r
+start "" /min "${process.execPath}" "${currentCliScriptPath()}" daemon --foreground\r
+`
+  };
+}
+function unsupportedStatus() {
+  return {
+    supported: false,
+    enabled: false,
+    method: "unsupported",
+    filePath: null
+  };
+}
+function xmlEscape(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+function systemdQuote(value) {
+  return `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+}
+function desktopQuote(value) {
+  return `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+}
+
 // src/i18n.ts
 var messages = {
   en: {
@@ -29,10 +540,30 @@ var messages = {
     "status.linkId": "Link ID: {value}",
     "status.notPaired": "not paired",
     "start.description": "Start Hermes Link daemon",
+    "start.backgroundStarted": "Hermes Link is running in the background. PID: {pid}",
+    "start.alreadyRunning": "Hermes Link is already running. PID: {pid}",
     "start.notPaired": "Hermes Link is not paired yet. Starting in local-only maintenance mode.",
     "start.notPaired.detail": "Relay, Server polling, and LAN entrypoints stay disabled until you run `hermeslink pair`.",
     "start.listening": "Hermes Link API listening on http://127.0.0.1:{port}",
     "start.relayConnecting": "Relay control connecting for {linkId}",
+    "stop.description": "Stop the background Hermes Link daemon",
+    "stop.stopped": "Hermes Link stopped.",
+    "stop.notRunning": "Hermes Link is not running.",
+    "restart.description": "Restart the background Hermes Link daemon",
+    "daemon.description": "Run Hermes Link in the foreground",
+    "daemon.foreground": "Hermes Link foreground daemon is running. Press Ctrl+C to stop.",
+    "logs.description": "Show Hermes Link log paths",
+    "logs.servicePath": "Service log: {path}",
+    "logs.daemonPath": "Daemon stdout/stderr log: {path}",
+    "autostart.description": "Manage boot autostart",
+    "autostart.on.description": "Enable boot autostart",
+    "autostart.off.description": "Disable boot autostart",
+    "autostart.status.description": "Show boot autostart status",
+    "autostart.enabled": "Boot autostart enabled via {method}: {path}",
+    "autostart.disabled": "Boot autostart disabled.",
+    "autostart.status.enabled": "Boot autostart: enabled via {method}: {path}",
+    "autostart.status.disabled": "Boot autostart: disabled. Method: {method}. File: {path}",
+    "autostart.unsupported": "Boot autostart is not supported on this platform yet.",
     "pair.description": "Create a Hermes Link pairing session",
     "pair.preparing": "Preparing pairing session through HermesPilot Server and Relay...",
     "pair.server": "Server: {url}",
@@ -42,6 +573,8 @@ var messages = {
     "pair.localApi": "Local API: http://127.0.0.1:{port}",
     "pair.scan": "Scan this QR code with the HermesPilot App:",
     "pair.expires": "Pairing expires in 10 minutes. Press Ctrl+C to stop Hermes Link.",
+    "pair.claimed": "Pairing succeeded. Starting Hermes Link in the background...",
+    "pair.autostartFailed": "Pairing succeeded, but boot autostart could not be enabled: {message}",
     "doctor.description": "Run local diagnostics",
     "doctor.identityOk": "Runtime identity: OK",
     "doctor.installId": "Install ID: {value}",
@@ -52,6 +585,7 @@ var messages = {
     "error.relayLinkInvalid": "Relay did not return a valid link_id.",
     "error.relayEmpty": "Relay returned an empty response.",
     "error.serverHttp": "HermesPilot Server request failed with HTTP {status}.",
+    "error.portInUse": "Local port {port} is already in use. Stop the existing Hermes Link process, then run `hermeslink pair` again.",
     "error.pairingRequires": "Pairing needs HermesPilot Server and Relay, but this command could not start a complete pairing session.",
     "error.pairingRequires.detail": "The deployed services may be healthy, but the installed Link package must call Server for a short-lived relay bootstrap token before it can request a link_id."
   },
@@ -66,10 +600,30 @@ var messages = {
     "status.linkId": "Link ID\uFF1A{value}",
     "status.notPaired": "\u5C1A\u672A\u914D\u5BF9",
     "start.description": "\u542F\u52A8 Hermes Link \u670D\u52A1",
+    "start.backgroundStarted": "Hermes Link \u5DF2\u5728\u540E\u53F0\u8FD0\u884C\u3002PID\uFF1A{pid}",
+    "start.alreadyRunning": "Hermes Link \u5DF2\u7ECF\u5728\u8FD0\u884C\u3002PID\uFF1A{pid}",
     "start.notPaired": "Hermes Link \u8FD8\u6CA1\u6709\u914D\u5BF9\uFF0C\u5C06\u4EE5\u672C\u5730\u7EF4\u62A4\u6A21\u5F0F\u542F\u52A8\u3002",
     "start.notPaired.detail": "\u5728\u4F60\u8FD0\u884C `hermeslink pair` \u524D\uFF0CRelay\u3001Server \u8F6E\u8BE2\u548C\u5C40\u57DF\u7F51\u5165\u53E3\u90FD\u4F1A\u4FDD\u6301\u5173\u95ED\u3002",
     "start.listening": "Hermes Link API \u6B63\u5728\u76D1\u542C http://127.0.0.1:{port}",
     "start.relayConnecting": "\u6B63\u5728\u4E3A {linkId} \u8FDE\u63A5 Relay \u63A7\u5236\u901A\u9053",
+    "stop.description": "\u505C\u6B62\u540E\u53F0 Hermes Link \u670D\u52A1",
+    "stop.stopped": "Hermes Link \u5DF2\u505C\u6B62\u3002",
+    "stop.notRunning": "Hermes Link \u6CA1\u6709\u5728\u8FD0\u884C\u3002",
+    "restart.description": "\u91CD\u542F\u540E\u53F0 Hermes Link \u670D\u52A1",
+    "daemon.description": "\u4EE5\u524D\u53F0\u65B9\u5F0F\u8FD0\u884C Hermes Link",
+    "daemon.foreground": "Hermes Link \u524D\u53F0\u670D\u52A1\u6B63\u5728\u8FD0\u884C\u3002\u6309 Ctrl+C \u505C\u6B62\u3002",
+    "logs.description": "\u663E\u793A Hermes Link \u65E5\u5FD7\u8DEF\u5F84",
+    "logs.servicePath": "\u670D\u52A1\u65E5\u5FD7\uFF1A{path}",
+    "logs.daemonPath": "Daemon \u6807\u51C6\u8F93\u51FA/\u9519\u8BEF\u65E5\u5FD7\uFF1A{path}",
+    "autostart.description": "\u7BA1\u7406\u5F00\u673A\u81EA\u542F",
+    "autostart.on.description": "\u542F\u7528\u5F00\u673A\u81EA\u542F",
+    "autostart.off.description": "\u5173\u95ED\u5F00\u673A\u81EA\u542F",
+    "autostart.status.description": "\u67E5\u770B\u5F00\u673A\u81EA\u542F\u72B6\u6001",
+    "autostart.enabled": "\u5DF2\u542F\u7528\u5F00\u673A\u81EA\u542F\uFF0C\u65B9\u5F0F\uFF1A{method}\uFF0C\u6587\u4EF6\uFF1A{path}",
+    "autostart.disabled": "\u5DF2\u5173\u95ED\u5F00\u673A\u81EA\u542F\u3002",
+    "autostart.status.enabled": "\u5F00\u673A\u81EA\u542F\uFF1A\u5DF2\u542F\u7528\uFF0C\u65B9\u5F0F\uFF1A{method}\uFF0C\u6587\u4EF6\uFF1A{path}",
+    "autostart.status.disabled": "\u5F00\u673A\u81EA\u542F\uFF1A\u672A\u542F\u7528\u3002\u65B9\u5F0F\uFF1A{method}\uFF0C\u6587\u4EF6\uFF1A{path}",
+    "autostart.unsupported": "\u5F53\u524D\u5E73\u53F0\u6682\u4E0D\u652F\u6301\u5F00\u673A\u81EA\u542F\u3002",
     "pair.description": "\u521B\u5EFA Hermes Link \u914D\u5BF9\u4F1A\u8BDD",
     "pair.preparing": "\u6B63\u5728\u901A\u8FC7 HermesPilot Server \u548C Relay \u521B\u5EFA\u914D\u5BF9\u4F1A\u8BDD...",
     "pair.server": "Server\uFF1A{url}",
@@ -79,6 +633,8 @@ var messages = {
     "pair.localApi": "\u672C\u5730 API\uFF1Ahttp://127.0.0.1:{port}",
     "pair.scan": "\u8BF7\u4F7F\u7528 HermesPilot App \u626B\u63CF\u8FD9\u4E2A\u4E8C\u7EF4\u7801\uFF1A",
     "pair.expires": "\u914D\u5BF9\u4F1A\u8BDD 10 \u5206\u949F\u540E\u8FC7\u671F\u3002\u6309 Ctrl+C \u505C\u6B62 Hermes Link\u3002",
+    "pair.claimed": "\u914D\u5BF9\u5DF2\u6210\u529F\u3002\u6B63\u5728\u628A Hermes Link \u5207\u6362\u5230\u540E\u53F0\u8FD0\u884C...",
+    "pair.autostartFailed": "\u914D\u5BF9\u5DF2\u6210\u529F\uFF0C\u4F46\u542F\u7528\u5F00\u673A\u81EA\u542F\u5931\u8D25\uFF1A{message}",
     "doctor.description": "\u8FD0\u884C\u672C\u673A\u8BCA\u65AD",
     "doctor.identityOk": "\u8FD0\u884C\u8EAB\u4EFD\uFF1A\u6B63\u5E38",
     "doctor.installId": "Install ID\uFF1A{value}",
@@ -89,6 +645,7 @@ var messages = {
     "error.relayLinkInvalid": "Relay \u6CA1\u6709\u8FD4\u56DE\u6709\u6548\u7684 link_id\u3002",
     "error.relayEmpty": "Relay \u8FD4\u56DE\u4E86\u7A7A\u54CD\u5E94\u3002",
     "error.serverHttp": "HermesPilot Server \u8BF7\u6C42\u5931\u8D25\uFF0CHTTP \u72B6\u6001\u7801\uFF1A{status}\u3002",
+    "error.portInUse": "\u672C\u5730\u7AEF\u53E3 {port} \u5DF2\u88AB\u5360\u7528\u3002\u8BF7\u5148\u505C\u6B62\u5DF2\u6709\u7684 Hermes Link \u8FDB\u7A0B\uFF0C\u7136\u540E\u91CD\u65B0\u8FD0\u884C `hermeslink pair`\u3002",
     "error.pairingRequires": "\u914D\u5BF9\u9700\u8981 HermesPilot Server \u548C Relay\uFF0C\u4F46\u5F53\u524D\u547D\u4EE4\u6CA1\u6709\u80FD\u542F\u52A8\u5B8C\u6574\u914D\u5BF9\u4F1A\u8BDD\u3002",
     "error.pairingRequires.detail": "\u4E91\u7AEF\u670D\u52A1\u53EF\u4EE5\u662F\u5DF2\u90E8\u7F72\u4E14\u5065\u5EB7\u7684\uFF1B\u672C\u673A Link \u4ECD\u5FC5\u987B\u5148\u5411 Server \u7533\u8BF7\u77ED\u671F relay bootstrap token\uFF0C\u624D\u80FD\u518D\u5411 Relay \u7533\u8BF7 link_id\u3002"
   }
@@ -143,6 +700,10 @@ function translateKnownError(message, language) {
   if (message === "Relay returned an empty response") {
     return translate(language, "error.relayEmpty");
   }
+  const portInUse = /^listen EADDRINUSE: address already in use .*:(?<port>\d+)$/u.exec(message);
+  if (portInUse?.groups?.port) {
+    return translate(language, "error.portInUse", { port: portInUse.groups.port });
+  }
   const serverHttp = /^HermesPilot Server request failed with HTTP (?<status>\d+)$/u.exec(message);
   if (serverHttp?.groups?.status) {
     return translate(language, "error.serverHttp", { status: serverHttp.groups.status });
@@ -166,83 +727,6 @@ function parseLanguage(value) {
   return null;
 }
 
-// src/relay/control-client.ts
-import WebSocket from "ws";
-function connectRelayControl(options) {
-  const wsUrl = new URL(`${options.relayBaseUrl.replace(/\/+$/u, "")}/api/v1/relay/link/connect`);
-  wsUrl.protocol = wsUrl.protocol === "https:" ? "wss:" : "ws:";
-  wsUrl.searchParams.set("link_id", options.linkId);
-  const socket = new WebSocket(wsUrl, {
-    headers: {
-      "x-hermes-link-version": LINK_VERSION
-    }
-  });
-  const abortControllers = /* @__PURE__ */ new Map();
-  socket.on("message", (raw) => {
-    if (typeof raw !== "string" && !Buffer.isBuffer(raw)) {
-      return;
-    }
-    void handleFrame(socket, String(raw), options.localPort, abortControllers).catch((error) => {
-      const message = error instanceof Error ? error.message : "Relay request failed";
-      socket.send(JSON.stringify({ type: "http.error", id: "unknown", status: 502, message }));
-    });
-  });
-  socket.on("close", () => {
-    for (const controller of abortControllers.values()) {
-      controller.abort();
-    }
-    abortControllers.clear();
-  });
-  return {
-    close() {
-      socket.close();
-    }
-  };
-}
-async function handleFrame(socket, raw, localPort, abortControllers) {
-  const frame = JSON.parse(raw);
-  if (frame.type === "http.cancel") {
-    abortControllers.get(frame.id)?.abort();
-    abortControllers.delete(frame.id);
-    return;
-  }
-  if (frame.type !== "http.request") {
-    return;
-  }
-  const abortController = new AbortController();
-  abortControllers.set(frame.id, abortController);
-  try {
-    const response = await fetch(`http://127.0.0.1:${localPort}${frame.path}`, {
-      method: frame.method,
-      headers: frame.headers ?? {},
-      body: frame.bodyBase64 ? Buffer.from(frame.bodyBase64, "base64") : void 0,
-      signal: abortController.signal
-    });
-    const headers = Object.fromEntries(response.headers.entries());
-    const contentType = response.headers.get("content-type") ?? "";
-    if (response.body && contentType.includes("text/event-stream")) {
-      socket.send(JSON.stringify({ type: "http.stream.start", id: frame.id, status: response.status, headers }));
-      const reader = response.body.getReader();
-      while (true) {
-        const next = await reader.read();
-        if (next.done) {
-          break;
-        }
-        socket.send(JSON.stringify({ type: "http.stream.chunk", id: frame.id, bodyBase64: Buffer.from(next.value).toString("base64") }));
-      }
-      socket.send(JSON.stringify({ type: "http.stream.end", id: frame.id }));
-      return;
-    }
-    const body = Buffer.from(await response.arrayBuffer()).toString("base64");
-    socket.send(JSON.stringify({ type: "http.response", id: frame.id, status: response.status, headers, bodyBase64: body }));
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Relay request failed";
-    socket.send(JSON.stringify({ type: "http.error", id: frame.id, status: 502, message }));
-  } finally {
-    abortControllers.delete(frame.id);
-  }
-}
-
 // src/cli/index.ts
 var program = new Command();
 var helpLanguage = detectSystemLanguage();
@@ -276,26 +760,44 @@ program.command("status").option("--json", helpText("status.json")).description(
   console.log(t("status.linkId", { value: payload.identity?.linkId ?? t("status.notPaired") }));
 });
 program.command("start").description(helpText("start.description")).action(async () => {
-  const [identity, config] = await Promise.all([loadIdentity(), loadConfig()]);
+  const [config, status] = await Promise.all([loadConfig(), getDaemonStatus()]);
   const language = resolveLanguage(config.language);
   const t = translate.bind(null, language);
-  if (!identity?.link_id) {
-    console.log(t("start.notPaired"));
-    console.log(t("start.notPaired.detail"));
-  }
-  const server = await startHttpServer(config.port);
-  const relay = identity?.link_id ? connectRelayControl({
-    relayBaseUrl: config.relayBaseUrl,
-    linkId: identity.link_id,
-    localPort: config.port
-  }) : null;
-  console.log(t("start.listening", { port: config.port }));
-  if (identity?.link_id) {
-    console.log(t("start.relayConnecting", { linkId: identity.link_id }));
+  if (status.running && status.pid) {
+    console.log(t("start.alreadyRunning", { pid: status.pid }));
+    return;
+  }
+  const nextStatus = await startDaemonProcess();
+  console.log(t("start.backgroundStarted", { pid: nextStatus.pid ?? "unknown" }));
+});
+program.command("stop").description(helpText("stop.description")).action(async () => {
+  const config = await loadConfig();
+  const language = resolveLanguage(config.language);
+  const t = translate.bind(null, language);
+  const before = await getDaemonStatus();
+  if (!before.running) {
+    console.log(t("stop.notRunning"));
+    return;
   }
+  await stopDaemonProcess();
+  console.log(t("stop.stopped"));
+});
+program.command("restart").description(helpText("restart.description")).action(async () => {
+  const config = await loadConfig();
+  const language = resolveLanguage(config.language);
+  const t = translate.bind(null, language);
+  await stopDaemonProcess();
+  const status = await startDaemonProcess();
+  console.log(t("start.backgroundStarted", { pid: status.pid ?? "unknown" }));
+});
+program.command("daemon").option("--foreground", "run in foreground").description(helpText("daemon.description")).action(async () => {
+  const config = await loadConfig();
+  const language = resolveLanguage(config.language);
+  const t = translate.bind(null, language);
+  const service = await startLinkService({ writePidFile: true });
+  console.log(t("daemon.foreground"));
   await waitForShutdown(async () => {
-    relay?.close();
-    await new Promise((resolve) => server.close(() => resolve()));
+    await service.close();
   });
 });
 program.command("pair").description(helpText("pair.description")).action(async () => {
@@ -308,11 +810,10 @@ program.command("pair").description(helpText("pair.description")).action(async (
   console.log(t("pair.relay", { url: config.relayBaseUrl }));
   await ensureIdentity(paths);
   const prepared = await preparePairing(paths);
-  const server = await startHttpServer(config.port);
-  const relay = connectRelayControl({
-    relayBaseUrl: prepared.relayBaseUrl,
-    linkId: prepared.linkId,
-    localPort: config.port
+  const pairingClaimed = createDeferred();
+  const service = await startLinkService({
+    paths,
+    onPairingClaimed: () => pairingClaimed.resolve()
   });
   const qrValue = JSON.stringify(prepared.qrPayload);
   console.log(t("pair.linkId", { value: prepared.linkId }));
@@ -321,10 +822,65 @@ program.command("pair").description(helpText("pair.description")).action(async (
   console.log(t("pair.scan"));
   qrcode.generate(qrValue, { small: true });
   console.log(t("pair.expires"));
-  await waitForShutdown(async () => {
-    relay.close();
-    await new Promise((resolve) => server.close(() => resolve()));
-  });
+  const result = await waitForPairingOrShutdown(pairingClaimed.promise);
+  await service.close();
+  if (result === "claimed") {
+    console.log(t("pair.claimed"));
+    try {
+      const autostart2 = await enableAutostart();
+      if (autostart2.supported && autostart2.enabled) {
+        console.log(t("autostart.enabled", { method: autostart2.method, path: autostart2.filePath ?? "" }));
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(t("pair.autostartFailed", { message }));
+    }
+    const status = await startDaemonProcess(paths);
+    console.log(t("start.backgroundStarted", { pid: status.pid ?? "unknown" }));
+  }
+});
+var autostart = program.command("autostart").description(helpText("autostart.description"));
+autostart.command("on").description(helpText("autostart.on.description")).action(async () => {
+  const config = await loadConfig();
+  const language = resolveLanguage(config.language);
+  const t = translate.bind(null, language);
+  const status = await enableAutostart();
+  if (!status.supported) {
+    console.log(t("autostart.unsupported"));
+    return;
+  }
+  console.log(t("autostart.enabled", { method: status.method, path: status.filePath ?? "" }));
+});
+autostart.command("off").description(helpText("autostart.off.description")).action(async () => {
+  const config = await loadConfig();
+  const language = resolveLanguage(config.language);
+  const t = translate.bind(null, language);
+  await disableAutostart();
+  console.log(t("autostart.disabled"));
+});
+autostart.command("status").description(helpText("autostart.status.description")).action(async () => {
+  const config = await loadConfig();
+  const language = resolveLanguage(config.language);
+  const t = translate.bind(null, language);
+  const status = await getAutostartStatus();
+  if (!status.supported) {
+    console.log(t("autostart.unsupported"));
+    return;
+  }
+  console.log(
+    t(status.enabled ? "autostart.status.enabled" : "autostart.status.disabled", {
+      method: status.method,
+      path: status.filePath ?? ""
+    })
+  );
+});
+program.command("logs").description(helpText("logs.description")).action(async () => {
+  const paths = resolveRuntimePaths();
+  const config = await loadConfig(paths);
+  const language = resolveLanguage(config.language);
+  const t = translate.bind(null, language);
+  console.log(t("logs.servicePath", { path: getLinkLogFile(paths) }));
+  console.log(t("logs.daemonPath", { path: daemonLogFile(paths) }));
 });
 program.command("doctor").description(helpText("doctor.description")).action(async () => {
   const [identity, config] = await Promise.all([ensureIdentity(), loadConfig()]);
@@ -350,10 +906,6 @@ async function loadCliLanguage() {
   const config = await loadConfig();
   return resolveLanguage(config.language);
 }
-async function startHttpServer(port) {
-  const app = await createApp();
-  return app.listen(port);
-}
 async function waitForShutdown(cleanup) {
   await new Promise((resolve) => {
     const stop = () => resolve();
@@ -362,4 +914,25 @@ async function waitForShutdown(cleanup) {
   });
   await cleanup();
 }
+async function waitForPairingOrShutdown(pairingClaimed) {
+  let stop = null;
+  const shutdown = new Promise((resolve) => {
+    stop = () => resolve("shutdown");
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+  });
+  const result = await Promise.race([pairingClaimed.then(() => "claimed"), shutdown]);
+  if (stop) {
+    process.off("SIGINT", stop);
+    process.off("SIGTERM", stop);
+  }
+  return result;
+}
+function createDeferred() {
+  let resolve;
+  const promise = new Promise((innerResolve) => {
+    resolve = innerResolve;
+  });
+  return { promise, resolve };
+}
 //# sourceMappingURL=index.js.map