@hermespilot/link 0.1.9 → 0.2.1

package/dist/cli/index.js

@@ -2,20 +2,31 @@
 import {
   LINK_COMMAND,
   LINK_VERSION,
+  LinkHttpError,
   clearPairingClaim,
-  createApp,
-  createFileLogger,
+  currentCliScriptPath,
+  daemonLogFile,
   ensureHermesApiServerAvailable,
   ensureHermesApiServerConfig,
   ensureIdentity,
+  getDaemonStatus,
   getIdentityStatus,
   getLinkLogFile,
+  hasActiveDevices,
   loadConfig,
   loadIdentity,
   preparePairing,
+  probeLocalLinkService,
+  readHermesApiServerConfig,
   readPairingClaim,
-  resolveRuntimePaths
-} from "../chunk-QAPDGN52.js";
+  resolveHermesConfigPath,
+  resolveHermesProfileDir,
+  resolveRuntimePaths,
+  runDaemonSupervisor,
+  startDaemonProcess,
+  startLinkService,
+  stopDaemonProcess
+} from "../chunk-YQX7OQFH.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
@@ -23,366 +34,10 @@ 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 { mkdir, readFile, rm, writeFile } 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 probeLocalLinkService(options) {
-  const unreachable = {
-    reachable: false,
-    reusable: false,
-    linkId: null,
-    version: null
-  };
-  let response;
-  try {
-    response = await fetch(`http://127.0.0.1:${options.port}/api/v1/bootstrap`, {
-      headers: { accept: "application/json" },
-      signal: AbortSignal.timeout(options.timeoutMs ?? 1e3)
-    });
-  } catch {
-    return unreachable;
-  }
-  if (!response.ok) {
-    return unreachable;
-  }
-  const payload = await response.json().catch(() => null);
-  if (!payload || payload.api_version !== 1) {
-    return unreachable;
-  }
-  const linkId = typeof payload.link_id === "string" ? payload.link_id : null;
-  return {
-    reachable: true,
-    reusable: options.linkId ? linkId === options.linkId : true,
-    linkId,
-    version: typeof payload.version === "string" ? payload.version : null
-  };
-}
-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
+import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 var MACOS_LABEL = "com.hermespilot.link";
 async function enableAutostart() {
@@ -390,14 +45,14 @@ async function enableAutostart() {
   if (!definition) {
     return unsupportedStatus();
   }
-  await mkdir3(path2.dirname(definition.filePath), { recursive: true, mode: 448 });
-  await writeFile2(definition.filePath, definition.content, { mode: 384 });
+  await mkdir(path.dirname(definition.filePath), { recursive: true, mode: 448 });
+  await writeFile(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);
+    await execFileAsync("systemctl", ["--user", "enable", path.basename(definition.filePath)]).catch(async () => {
+      await rm(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 });
+      await mkdir(path.dirname(fallback.filePath), { recursive: true, mode: 448 });
+      await writeFile(fallback.filePath, fallback.content, { mode: 384 });
     });
   }
   return await getAutostartStatus();
@@ -406,9 +61,9 @@ 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 execFileAsync("systemctl", ["--user", "disable", path.basename(definition.filePath)]).catch(() => void 0);
     }
-    await rm3(definition.filePath, { force: true }).catch(() => void 0);
+    await rm(definition.filePath, { force: true }).catch(() => void 0);
   }
   return await getAutostartStatus();
 }
@@ -418,7 +73,7 @@ async function getAutostartStatus() {
     return unsupportedStatus();
   }
   for (const definition of definitions) {
-    const content = await readFile2(definition.filePath, "utf8").catch(() => null);
+    const content = await readFile(definition.filePath, "utf8").catch(() => null);
     if (content !== null) {
       return {
         supported: true,
@@ -469,7 +124,7 @@ async function hasSystemctlUser() {
   }
 }
 function launchdDefinition() {
-  const filePath = path2.join(os.homedir(), "Library", "LaunchAgents", `${MACOS_LABEL}.plist`);
+  const filePath = path.join(os.homedir(), "Library", "LaunchAgents", `${MACOS_LABEL}.plist`);
   return {
     method: "launchd",
     filePath,
@@ -483,24 +138,19 @@ function launchdDefinition() {
   <array>
     <string>${xmlEscape(process.execPath)}</string>
     <string>${xmlEscape(currentCliScriptPath())}</string>
-    <string>daemon</string>
-    <string>--foreground</string>
+    <string>daemon-supervisor</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");
+  const filePath = path.join(os.homedir(), ".config", "systemd", "user", "hermeslink.service");
   return {
     method: "systemd-user",
     filePath,
@@ -510,7 +160,7 @@ After=network-online.target
 
 [Service]
 Type=simple
-ExecStart=${systemdQuote(process.execPath)} ${systemdQuote(currentCliScriptPath())} daemon --foreground
+ExecStart=${systemdQuote(process.execPath)} ${systemdQuote(currentCliScriptPath())} daemon-supervisor
 Restart=no
 
 [Install]
@@ -519,27 +169,27 @@ WantedBy=default.target
   };
 }
 function xdgAutostartDefinition() {
-  const filePath = path2.join(os.homedir(), ".config", "autostart", "hermeslink.desktop");
+  const filePath = path.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
+Exec=${desktopQuote(process.execPath)} ${desktopQuote(currentCliScriptPath())} daemon-supervisor
 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");
+  const appData = process.env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming");
+  const filePath = path.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
+start "" /min "${process.execPath}" "${currentCliScriptPath()}" daemon-supervisor\r
 `
   };
 }
@@ -598,7 +248,11 @@ var messages = {
     "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.",
+    "autostart.alreadyEnabled": "Boot autostart is already enabled via {method}: {path}",
     "pair.description": "Create a Hermes Link pairing session",
+    "pair.preflight": "Checking local Hermes configuration before pairing...",
+    "pair.hermesHome": "Hermes home: {path}",
+    "pair.apiReady": "Hermes API Server is ready on 127.0.0.1:{port}",
     "pair.preparing": "Preparing pairing session through HermesPilot Server and Relay...",
     "pair.server": "Server: {url}",
     "pair.relay": "Relay: {url}",
@@ -609,6 +263,7 @@ var messages = {
     "pair.expires": "Pairing expires in 10 minutes. Press Ctrl+C to cancel waiting.",
     "pair.claimed": "Pairing succeeded. Starting Hermes Link in the background...",
     "pair.claimedRunning": "Pairing succeeded. Hermes Link is already running in the background.",
+    "pair.autostartUnchanged": "Existing paired devices found. Boot autostart settings were left unchanged.",
     "pair.autostartFailed": "Pairing succeeded, but boot autostart could not be enabled: {message}",
     "doctor.description": "Run local diagnostics",
     "doctor.identityOk": "Runtime identity: OK",
@@ -662,7 +317,11 @@ var messages = {
     "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",
+    "autostart.alreadyEnabled": "\u5F00\u673A\u81EA\u542F\u5DF2\u542F\u7528\uFF0C\u65B9\u5F0F\uFF1A{method}\uFF0C\u6587\u4EF6\uFF1A{path}",
     "pair.description": "\u521B\u5EFA Hermes Link \u914D\u5BF9\u4F1A\u8BDD",
+    "pair.preflight": "\u6B63\u5728\u914D\u5BF9\u524D\u68C0\u67E5\u672C\u673A Hermes \u914D\u7F6E...",
+    "pair.hermesHome": "Hermes \u6570\u636E\u76EE\u5F55\uFF1A{path}",
+    "pair.apiReady": "Hermes API Server \u5DF2\u5C31\u7EEA\uFF1A127.0.0.1:{port}",
     "pair.preparing": "\u6B63\u5728\u901A\u8FC7 HermesPilot Server \u548C Relay \u521B\u5EFA\u914D\u5BF9\u4F1A\u8BDD...",
     "pair.server": "Server\uFF1A{url}",
     "pair.relay": "Relay\uFF1A{url}",
@@ -673,6 +332,7 @@ var messages = {
     "pair.expires": "\u914D\u5BF9\u4F1A\u8BDD 10 \u5206\u949F\u540E\u8FC7\u671F\u3002\u6309 Ctrl+C \u9000\u51FA\u7B49\u5F85\u3002",
     "pair.claimed": "\u914D\u5BF9\u5DF2\u6210\u529F\u3002\u6B63\u5728\u628A Hermes Link \u5207\u6362\u5230\u540E\u53F0\u8FD0\u884C...",
     "pair.claimedRunning": "\u914D\u5BF9\u5DF2\u6210\u529F\u3002Hermes Link \u5DF2\u5728\u540E\u53F0\u6301\u7EED\u8FD0\u884C\u3002",
+    "pair.autostartUnchanged": "\u68C0\u6D4B\u5230\u5DF2\u6709\u914D\u5BF9\u8BBE\u5907\uFF0C\u5F00\u673A\u81EA\u542F\u8BBE\u7F6E\u4FDD\u6301\u4E0D\u53D8\u3002",
     "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",
@@ -769,6 +429,134 @@ function parseLanguage(value) {
   return null;
 }
 
+// src/pairing/preflight.ts
+import { access, stat } from "fs/promises";
+import path2 from "path";
+async function assertPairingPreflightReady(options = {}) {
+  const profileName = normalizeProfileName(options.profileName);
+  const hermesHome = resolveHermesProfileDir(profileName);
+  const configPath = resolveHermesConfigPath(profileName);
+  const envPath = path2.join(hermesHome, ".env");
+  const failures = [];
+  if (!await isDirectory(hermesHome)) {
+    failures.push({
+      code: "hermes_home_missing",
+      zh: `\u6CA1\u6709\u627E\u5230\u5F53\u524D Hermes \u6570\u636E\u76EE\u5F55\uFF1A${hermesHome}`,
+      en: `Current Hermes home was not found: ${hermesHome}`,
+      actionZh: "\u8BF7\u5148\u8FD0\u884C `hermes setup` \u521D\u59CB\u5316 Hermes\uFF1B\u5982\u679C Hermes \u5728 Docker\u3001WSL \u6216\u53E6\u4E00\u4E2A Windows \u73AF\u5883\u4E2D\u8FD0\u884C\uFF0C\u8BF7\u5728\u542F\u52A8 Link \u524D\u8BBE\u7F6E HERMES_HOME \u6307\u5411 Link \u80FD\u8BBF\u95EE\u5230\u7684\u540C\u4E00\u4E2A\u76EE\u5F55\u3002",
+      actionEn: "Run `hermes setup` first. If Hermes runs in Docker, WSL, or another Windows environment, start Link with HERMES_HOME pointing to the same directory that Link can access."
+    });
+  }
+  if (!await isReadableFile(configPath)) {
+    failures.push({
+      code: "hermes_config_missing",
+      zh: `\u6CA1\u6709\u627E\u5230 Hermes \u914D\u7F6E\u6587\u4EF6\uFF1A${configPath}`,
+      en: `Hermes config file was not found: ${configPath}`,
+      actionZh: "\u8BF7\u5148\u8FD0\u884C `hermes setup` \u751F\u6210\u914D\u7F6E\uFF0C\u6216\u786E\u8BA4 Link \u4E0E Hermes \u4F7F\u7528\u7684\u662F\u540C\u4E00\u4E2A HERMES_HOME\u3002",
+      actionEn: "Run `hermes setup` to create the config, or make sure Link and Hermes use the same HERMES_HOME."
+    });
+  }
+  if (!await isReadableFile(envPath)) {
+    failures.push({
+      code: "hermes_env_missing",
+      zh: `\u6CA1\u6709\u627E\u5230 Hermes \u73AF\u5883\u914D\u7F6E\u6587\u4EF6\uFF1A${envPath}`,
+      en: `Hermes environment file was not found: ${envPath}`,
+      actionZh: "\u8BF7\u5148\u8FD0\u884C `hermes setup` \u521B\u5EFA `.env` \u5E76\u914D\u7F6E\u6A21\u578B/API Key\uFF1BLink \u9700\u8981\u80FD\u8BFB\u53D6\u5B83\uFF0C\u624D\u80FD\u590D\u7528 Hermes \u7684\u5B9E\u9645\u914D\u7F6E\u3002",
+      actionEn: "Run `hermes setup` to create `.env` and configure model/API keys. Link must be able to read it to reuse Hermes settings."
+    });
+  }
+  if (failures.length > 0) {
+    throwPairingPreflightError(failures);
+  }
+  const apiServerConfig = await readHermesApiServerConfig(profileName, configPath);
+  if (apiServerConfig.enabled !== true) {
+    throwPairingPreflightError([
+      {
+        code: "hermes_api_server_disabled",
+        zh: "Hermes API Server \u8FD8\u6CA1\u6709\u5F00\u542F\u3002",
+        en: "Hermes API Server is not enabled.",
+        actionZh: "\u8BF7\u8FD0\u884C `hermeslink doctor` \u8BA9 Link \u81EA\u52A8\u8865\u9F50 API Server \u914D\u7F6E\uFF0C\u6216\u5728 Hermes \u914D\u7F6E\u4E2D\u542F\u7528 platforms.api_server\u3002",
+        actionEn: "Run `hermeslink doctor` so Link can prepare the API Server config, or enable platforms.api_server in Hermes config."
+      }
+    ]);
+  }
+  try {
+    const ensureAvailable = options.ensureApiServerAvailable ?? ensureHermesApiServerAvailable;
+    const availability = await ensureAvailable({
+      paths: options.paths,
+      profileName,
+      fetchImpl: options.fetchImpl,
+      timeoutMs: 5e3,
+      autoStart: true
+    });
+    return {
+      profileName,
+      hermesHome,
+      configPath,
+      envPath,
+      apiServer: {
+        available: true,
+        started: availability.started,
+        host: availability.configResult.apiServer.host ?? null,
+        port: availability.configResult.apiServer.port ?? null
+      }
+    };
+  } catch (error) {
+    throwPairingPreflightError([
+      {
+        code: "hermes_api_server_unavailable",
+        zh: "Hermes API Server \u5F53\u524D\u4E0D\u53EF\u7528\uFF0CLink \u4E0D\u80FD\u786E\u8BA4 App \u914D\u5BF9\u540E\u53EF\u4EE5\u53D1\u9001\u6D88\u606F\u3002",
+        en: "Hermes API Server is not available, so Link cannot confirm that the App will be able to send messages after pairing.",
+        actionZh: "\u8BF7\u5148\u8FD0\u884C `hermes gateway run --replace` \u6216 `hermeslink doctor`\uFF0C\u786E\u8BA4 /health \u53EF\u4EE5\u8BBF\u95EE\u540E\u518D\u91CD\u65B0\u6267\u884C `hermeslink pair`\u3002",
+        actionEn: "Run `hermes gateway run --replace` or `hermeslink doctor` first, then retry `hermeslink pair` after /health is reachable.",
+        detail: error instanceof Error ? error.message : String(error)
+      }
+    ]);
+  }
+}
+function throwPairingPreflightError(failures) {
+  throw new LinkHttpError(
+    503,
+    failures[0]?.code ?? "pairing_preflight_failed",
+    formatPairingPreflightMessage(failures)
+  );
+}
+function formatPairingPreflightMessage(failures) {
+  const lines = [
+    "\u914D\u5BF9\u524D\u68C0\u67E5\u6CA1\u6709\u901A\u8FC7\uFF0C\u6682\u65F6\u4E0D\u4F1A\u5411 HermesPilot Server \u6216 Relay \u7533\u8BF7\u914D\u5BF9\u4E8C\u7EF4\u7801/\u914D\u5BF9\u7801\u3002",
+    "Pairing preflight failed. Link did not request a pairing QR code or pairing code from HermesPilot Server or Relay.",
+    ""
+  ];
+  failures.forEach((failure, index) => {
+    const prefix = failures.length > 1 ? `${index + 1}. ` : "";
+    lines.push(`${prefix}${failure.zh}`);
+    lines.push(`   ${failure.en}`);
+    lines.push(`   \u5904\u7406\u5EFA\u8BAE\uFF1A${failure.actionZh}`);
+    lines.push(`   Suggested fix: ${failure.actionEn}`);
+    if (failure.detail) {
+      lines.push(`   Detail: ${failure.detail}`);
+    }
+  });
+  return lines.join("\n");
+}
+async function isDirectory(filePath) {
+  return stat(filePath).then((value) => value.isDirectory()).catch(() => false);
+}
+async function isReadableFile(filePath) {
+  return access(filePath).then(() => stat(filePath)).then((value) => value.isFile()).catch(() => false);
+}
+function normalizeProfileName(profileName) {
+  const value = profileName?.trim() || "default";
+  if (!/^[a-zA-Z0-9._-]{1,64}$/u.test(value)) {
+    throw new LinkHttpError(
+      400,
+      "invalid_profile_name",
+      "invalid profile name"
+    );
+  }
+  return value;
+}
+
 // src/cli/index.ts
 var program = new Command();
 var helpLanguage = detectSystemLanguage();
@@ -841,16 +629,25 @@ program.command("daemon").option("--foreground", "run in foreground").descriptio
   await waitForShutdown(async () => {
     await service.close();
   });
+  process.exit(0);
+});
+program.command("daemon-supervisor", { hidden: true }).action(async () => {
+  process.exitCode = await runDaemonSupervisor();
 });
 program.command("pair").description(helpText("pair.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("pair.preflight"));
+  const preflight = await assertPairingPreflightReady({ paths });
+  console.log(t("pair.hermesHome", { path: preflight.hermesHome }));
+  console.log(t("pair.apiReady", { port: preflight.apiServer.port ?? "unknown" }));
   console.log(t("pair.preparing"));
   console.log(t("pair.server", { url: config.serverBaseUrl }));
   console.log(t("pair.relay", { url: config.relayBaseUrl }));
   await ensureIdentity(paths);
+  const hadActiveDevices = await hasActiveDevices(paths);
   const probeBeforePair = await probeLocalLinkService({ port: config.port });
   const prepared = await preparePairing(paths);
   await clearPairingClaim(prepared.sessionId, paths);
@@ -878,9 +675,23 @@ program.command("pair").description(helpText("pair.description")).action(async (
     await clearPairingClaim(prepared.sessionId, paths);
     console.log(t(reusedRunningService ? "pair.claimedRunning" : "pair.claimed"));
     try {
-      const autostart2 = await enableAutostart();
-      if (autostart2.supported && autostart2.enabled) {
-        console.log(t("autostart.enabled", { method: autostart2.method, path: autostart2.filePath ?? "" }));
+      if (hadActiveDevices) {
+        console.log(t("pair.autostartUnchanged"));
+      } else {
+        const currentAutostart = await getAutostartStatus();
+        if (currentAutostart.supported && currentAutostart.enabled) {
+          console.log(
+            t("autostart.alreadyEnabled", {
+              method: currentAutostart.method,
+              path: currentAutostart.filePath ?? ""
+            })
+          );
+        } else {
+          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);