@hermespilot/link 0.1.8 → 0.2.0

package/dist/cli/index.js

@@ -1,21 +1,31 @@
 #!/usr/bin/env node
 import {
+  ConversationService,
   LINK_COMMAND,
   LINK_VERSION,
+  LinkHttpError,
   clearPairingClaim,
   createApp,
   createFileLogger,
+  createRotatingTextLogWriter,
   ensureHermesApiServerAvailable,
   ensureHermesApiServerConfig,
   ensureIdentity,
+  getDaemonLogFile,
   getIdentityStatus,
   getLinkLogFile,
+  hasActiveDevices,
   loadConfig,
   loadIdentity,
+  migrateLinkDatabase,
   preparePairing,
+  readHermesApiServerConfig,
   readPairingClaim,
-  resolveRuntimePaths
-} from "../chunk-L2NM2XMX.js";
+  resolveHermesConfigPath,
+  resolveHermesProfileDir,
+  resolveRuntimePaths,
+  syncHermesLinkCronDeliveries
+} from "../chunk-TMCXOV6J.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
@@ -30,7 +40,7 @@ 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 { mkdir as mkdir2, readFile, rm as rm2 } from "fs/promises";
 import path from "path";
 
 // src/daemon/service.ts
@@ -51,8 +61,10 @@ function connectRelayControl(options) {
   let socket = null;
   let retryTimer = null;
   let abortControllers = /* @__PURE__ */ new Map();
+  let fatalRelayRejection = null;
   const connect = () => {
     options.onStatus?.({ state: "connecting", attempt: reconnectAttempts });
+    fatalRelayRejection = null;
     socket = new WebSocket(wsUrl, {
       headers: {
         "x-hermes-link-version": LINK_VERSION
@@ -73,11 +85,24 @@ function connectRelayControl(options) {
     });
     socket.on("error", (error) => {
       const message = error instanceof Error ? error.message : "Relay websocket error";
-      options.onStatus?.({ state: "disconnected", attempt: reconnectAttempts, message });
+      fatalRelayRejection = resolveFatalRelayRejection(message);
+      options.onStatus?.({
+        state: "disconnected",
+        attempt: reconnectAttempts,
+        message: fatalRelayRejection ?? message
+      });
     });
     socket.on("close", () => {
       abortAll(abortControllers);
       abortControllers = /* @__PURE__ */ new Map();
+      if (fatalRelayRejection) {
+        options.onStatus?.({
+          state: "failed",
+          attempt: reconnectAttempts,
+          message: fatalRelayRejection
+        });
+        return;
+      }
       if (closedByUser) {
         options.onStatus?.({ state: "disconnected", attempt: reconnectAttempts });
         return;
@@ -99,12 +124,19 @@ function connectRelayControl(options) {
       closedByUser = true;
       if (retryTimer) {
         clearTimeout(retryTimer);
+        retryTimer = null;
       }
       abortAll(abortControllers);
-      socket?.close();
+      socket?.terminate();
     }
   };
 }
+function resolveFatalRelayRejection(message) {
+  if (!/Unexpected server response:\s*(400|401|403|426)\b/u.test(message)) {
+    return null;
+  }
+  return "Relay refused the Hermes Link connection. Check Link version and pairing state before retrying.";
+}
 function abortAll(abortControllers) {
   for (const controller of abortControllers.values()) {
     controller.abort();
@@ -160,6 +192,39 @@ async function handleFrame(socket, raw, localPort, abortControllers) {
   }
 }
 
+// src/daemon/scheduler.ts
+function startCronDeliveryScheduler(options) {
+  let running = false;
+  const syncCronDeliveries = async () => {
+    if (running) {
+      return;
+    }
+    running = true;
+    try {
+      await syncHermesLinkCronDeliveries(
+        options.paths,
+        options.conversations,
+        options.logger
+      );
+    } catch (error) {
+      void options.logger.warn("cron_link_delivery_sync_failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    } finally {
+      running = false;
+    }
+  };
+  const timer = setInterval(() => {
+    void syncCronDeliveries();
+  }, options.intervalMs ?? 3e4);
+  timer.unref?.();
+  return {
+    close() {
+      clearInterval(timer);
+    }
+  };
+}
+
 // src/daemon/service.ts
 async function startLinkService(options = {}) {
   const paths = options.paths ?? resolveRuntimePaths();
@@ -169,7 +234,22 @@ async function startLinkService(options = {}) {
     port: config.port,
     mode: identity?.link_id ? "paired" : "local-only"
   });
-  const app = await createApp({ paths, logger, onPairingClaimed: options.onPairingClaimed });
+  const migration = await migrateLinkDatabase(paths);
+  if (migration.appliedVersions.length > 0) {
+    await logger.info("database_migrated", {
+      database_file: migration.databaseFile,
+      applied_versions: migration.appliedVersions,
+      current_version: migration.currentVersion
+    });
+  }
+  const conversations = new ConversationService(paths, logger);
+  await conversations.rebuildStatisticsIndex();
+  const app = await createApp({
+    paths,
+    logger,
+    conversations,
+    onPairingClaimed: options.onPairingClaimed
+  });
   const server = createServer(app.callback());
   try {
     await listenServer(server, config.port);
@@ -188,6 +268,11 @@ async function startLinkService(options = {}) {
     port: config.port,
     link_id: identity?.link_id ?? null
   });
+  const scheduler = startCronDeliveryScheduler({
+    paths,
+    conversations,
+    logger
+  });
   let relay = null;
   if (identity?.link_id) {
     relay = connectRelayControl({
@@ -209,6 +294,7 @@ async function startLinkService(options = {}) {
   }
   return {
     async close() {
+      scheduler.close();
       relay?.close();
       await closeServer(server);
       await logger.info("service_stopped");
@@ -229,13 +315,38 @@ async function writePidFile(paths) {
 }
 async function closeServer(server) {
   await new Promise((resolve, reject) => {
-    server.close((error) => {
+    let settled = false;
+    let forceCloseTimer;
+    let timeoutTimer;
+    const settle = (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(forceCloseTimer);
+      clearTimeout(timeoutTimer);
       if (error) {
         reject(error);
         return;
       }
       resolve();
+    };
+    forceCloseTimer = setTimeout(() => {
+      server.closeIdleConnections?.();
+      server.closeAllConnections?.();
+    }, 250);
+    timeoutTimer = setTimeout(() => {
+      server.closeAllConnections?.();
+      settle();
+    }, 5e3);
+    server.close((error) => {
+      if (error) {
+        settle(error);
+        return;
+      }
+      settle();
     });
+    server.closeIdleConnections?.();
   });
 }
 async function listenServer(server, port) {
@@ -260,30 +371,79 @@ async function listenServer(server, port) {
 
 // src/daemon/process.ts
 async function startDaemonProcess(paths = resolveRuntimePaths()) {
-  const status = await getDaemonStatus(paths);
+  const config = await loadConfig(paths);
+  let status = await getDaemonStatus(paths);
   if (status.running) {
-    return status;
+    const probe = await probeLocalLinkService({ port: config.port, timeoutMs: 500 });
+    if (probe.reachable) {
+      return status;
+    }
+    await stopDaemonProcess(paths);
+    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"], {
+  const child = spawn(process.execPath, [scriptPath, "daemon-supervisor"], {
     detached: true,
-    stdio: ["ignore", log.fd, log.fd],
+    stdio: "ignore",
     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) {
+    if (next.running && (await probeLocalLinkService({ port: config.port, timeoutMs: 500 })).reachable) {
       return next;
     }
   }
   return await getDaemonStatus(paths);
 }
+async function runDaemonSupervisor(paths = resolveRuntimePaths()) {
+  await mkdir2(paths.logsDir, { recursive: true, mode: 448 });
+  const log = createRotatingTextLogWriter({
+    paths,
+    fileName: path.basename(daemonLogFile(paths))
+  });
+  const scriptPath = currentCliScriptPath();
+  const child = spawn(process.execPath, [scriptPath, "daemon", "--foreground"], {
+    stdio: ["ignore", "pipe", "pipe"],
+    env: process.env
+  });
+  const write = (chunk) => {
+    void log.write(chunk);
+  };
+  write(`[${(/* @__PURE__ */ new Date()).toISOString()}] daemon supervisor started
+`);
+  child.stdout?.on("data", write);
+  child.stderr?.on("data", write);
+  const forwardStop = () => {
+    if (child.pid && isProcessAlive(child.pid)) {
+      child.kill("SIGTERM");
+    }
+  };
+  process.once("SIGINT", forwardStop);
+  process.once("SIGTERM", forwardStop);
+  const result = await new Promise((resolve, reject) => {
+    child.once("error", reject);
+    child.once("exit", (code, signal) => resolve({ code, signal }));
+  }).catch((error) => {
+    write(`[${(/* @__PURE__ */ new Date()).toISOString()}] daemon supervisor failed: ${error instanceof Error ? error.message : String(error)}
+`);
+    return { code: 1, signal: null };
+  });
+  process.off("SIGINT", forwardStop);
+  process.off("SIGTERM", forwardStop);
+  write(
+    `[${(/* @__PURE__ */ new Date()).toISOString()}] daemon supervisor stopped code=${result.code ?? "null"} signal=${result.signal ?? "null"}
+`
+  );
+  await log.flush();
+  return result.code ?? (result.signal ? 0 : 1);
+}
 async function probeLocalLinkService(options) {
   const unreachable = {
     reachable: false,
@@ -332,7 +492,19 @@ async function stopDaemonProcess(paths = resolveRuntimePaths()) {
       break;
     }
   }
-  if (!isProcessAlive(status.pid)) {
+  if (isProcessAlive(status.pid)) {
+    try {
+      process.kill(status.pid, "SIGKILL");
+    } catch {
+    }
+    for (let index = 0; index < 10; index += 1) {
+      await wait(250);
+      if (!isProcessAlive(status.pid)) {
+        break;
+      }
+    }
+  }
+  if (!isProcessAlive(status.pid) || !await pidBackedServiceIsReachable(paths)) {
     await rm2(pidFilePath(paths), { force: true }).catch(() => void 0);
   }
   return await getDaemonStatus(paths);
@@ -357,7 +529,7 @@ async function getDaemonStatus(paths = resolveRuntimePaths()) {
   };
 }
 function daemonLogFile(paths = resolveRuntimePaths()) {
-  return path.join(paths.logsDir, "daemon.log");
+  return getDaemonLogFile(paths);
 }
 function currentCliScriptPath() {
   return process.argv[1];
@@ -378,6 +550,13 @@ function isProcessAlive(pid) {
     return false;
   }
 }
+async function pidBackedServiceIsReachable(paths) {
+  const config = await loadConfig(paths).catch(() => null);
+  if (!config) {
+    return false;
+  }
+  return (await probeLocalLinkService({ port: config.port, timeoutMs: 500 })).reachable;
+}
 function wait(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -483,17 +662,12 @@ 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>
 `
@@ -510,7 +684,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]
@@ -526,7 +700,7 @@ function xdgAutostartDefinition() {
     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
 `
@@ -539,7 +713,7 @@ function windowsStartupDefinition() {
     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 +772,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 +787,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 +841,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 +856,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 +953,134 @@ function parseLanguage(value) {
   return null;
 }
 
+// src/pairing/preflight.ts
+import { access, stat } from "fs/promises";
+import path3 from "path";
+async function assertPairingPreflightReady(options = {}) {
+  const profileName = normalizeProfileName(options.profileName);
+  const hermesHome = resolveHermesProfileDir(profileName);
+  const configPath = resolveHermesConfigPath(profileName);
+  const envPath = path3.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 +1153,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 +1199,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);