@hermespilot/link 0.6.0 → 0.6.1

package/dist/cli/index.js

@@ -13,9 +13,12 @@ import {
   detectRuntimeEnvironment,
   ensureHermesApiServerAvailable,
   ensureHermesApiServerConfig,
+  ensureHermesLinkSkillInstalledBestEffort,
   ensureIdentity,
   fetchRelayStreamBatchPolicy,
+  flushLogFiles,
   getDaemonStatus,
+  getGatewayLogFiles,
   getIdentityStatus,
   getLinkLogFile,
   hasActiveDevices,
@@ -28,6 +31,10 @@ import {
   readHermesApiServerConfig,
   readHermesVersion,
   readPairingClaim,
+  readRecentGatewayLogEntries,
+  readRecentLogEntries,
+  readRecentTextLogEntries,
+  readRelayStatusSnapshot,
   reportLinkStatusToServer,
   resolveHermesConfigPath,
   resolveHermesProfileDir,
@@ -37,11 +44,12 @@ import {
   startDaemonProcess,
   startLinkService,
   stopDaemonProcess
-} from "../chunk-UHYO4EJD.js";
+} from "../chunk-RBMFF32Z.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
-import { realpathSync as realpathSync2 } from "fs";
+import { realpathSync as realpathSync2, unwatchFile, watchFile } from "fs";
+import { open, readFile as readFile2, stat as stat2 } from "fs/promises";
 import path4 from "path";
 import { createInterface } from "readline/promises";
 import { pathToFileURL } from "url";
@@ -298,12 +306,41 @@ var messages = {
     "status.json": "print machine-readable status",
     "status.runtime": "Runtime: {value}",
     "status.mode": "Mode: {value}",
+    "status.daemon": "Service: {value}",
+    "status.daemon.runningReachable": "running (PID {pid}, local API reachable)",
+    "status.daemon.runningUnreachable": "running (PID {pid}, local API is not responding)",
+    "status.daemon.notRunning": "not running",
     "status.port": "Local port: {value}",
-    "status.lanHost": "Configured LAN host: {value}",
+    "status.lanHost": "LAN access address (manual override): {value}",
     "status.notSet": "not set",
+    "status.unknown": "unknown",
     "status.environmentWarning": "Network note: {message}",
     "status.linkId": "Link ID: {value}",
     "status.notPaired": "not paired",
+    "status.relay": "Relay: {value}",
+    "status.relay.notPaired": "not connected (not paired yet; Relay is disabled until pairing)",
+    "status.relay.notConfigured": "not configured",
+    "status.relay.serviceStopped": "not connected (background service is not running)",
+    "status.relay.serviceUnreachable": "unknown (background service is running but local API is not responding)",
+    "status.relay.unknown": "unknown (background service has not reported Relay state yet)",
+    "status.relay.state.connecting": "connecting",
+    "status.relay.state.connected": "connected",
+    "status.relay.state.disconnected": "disconnected",
+    "status.relay.state.retrying": "retrying",
+    "status.relay.state.cooldown": "cooling down",
+    "status.relay.state.failed": "failed",
+    "status.relay.stateWithAttempt": "{state}, attempt {attempt}",
+    "status.relay.updatedAt": "updated {time}",
+    "status.relay.withMessage": "{state} - {message}",
+    "status.relay.withUpdatedAt": "{state}; {updatedAt}",
+    "status.relay.withMessageAndUpdatedAt": "{state} - {message}; {updatedAt}",
+    "status.recentError": "Latest error: {value}",
+    "status.recentError.none": "none",
+    "status.recentError.format": "{time} [{source}] {message}",
+    "status.logSource.service": "service",
+    "status.logSource.daemon": "daemon",
+    "status.logSource.gateway": "gateway",
+    "status.timeUnknown": "time unknown",
     "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}",
@@ -323,18 +360,36 @@ var messages = {
     "config.unset.description": "Unset a configuration value",
     "config.unknownKey": "Unknown config key: {key}",
     "config.lanHostInvalid": "lan-host must be a private LAN IPv4 address, such as 192.168.1.23.",
-    "config.lanHostSet": "Configured LAN host: {value}",
-    "config.lanHostUnset": "Configured LAN host cleared.",
+    "config.lanHostSet": "LAN access address override set: {value}",
+    "config.lanHostUnset": "LAN access address override cleared.",
     "config.logLevelInvalid": "log-level must be one of: debug, info, warn, error.",
     "config.logLevelSet": "Configured log level: {value}",
+    "config.logLevelRestartRequired": "The running daemon keeps its current logger until restart. Run `hermeslink restart` to apply this write level immediately.",
     "config.logLevelUnset": "Configured log level reset to the default: {value}.",
     "config.reported": "Updated HermesPilot Server with the latest LAN address.",
     "config.reportSkippedUnpaired": "Hermes Link is not paired yet. The LAN address will be reported after pairing.",
     "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.description": "Show or follow Hermes Link logs",
+    "logs.follow": "follow log output",
+    "logs.tail": "print the last N lines before exiting or following",
+    "logs.serviceOnly": "only read the service JSONL log",
+    "logs.daemonOnly": "only read the daemon stdout/stderr log",
+    "logs.gatewayOnly": "only read Hermes Gateway logs",
+    "logs.all": "read service, daemon, and Gateway logs",
+    "logs.level": "minimum level to display: debug, info, warn, or error",
+    "logs.debugLevel": "show debug and above",
+    "logs.infoLevel": "show info and above",
+    "logs.warnLevel": "show warn and above",
+    "logs.errorLevel": "show errors only",
     "logs.servicePath": "Service log: {path}",
     "logs.daemonPath": "Daemon stdout/stderr log: {path}",
+    "logs.gatewayPath": "Gateway log: {path}",
+    "logs.followHint": "Use `hermeslink logs -f` to follow logs, or `hermeslink logs -n 100` to print recent lines.",
+    "logs.following": "Following logs. Press Ctrl+C to stop.",
+    "logs.flush.description": "Clear Hermes Link log files",
+    "logs.flush.all": "clear service, daemon, and Gateway logs",
+    "logs.flush.flushed": "Cleared {truncated} active log file(s) and removed {removed} rotated log file(s).",
     "autostart.description": "Manage boot autostart",
     "autostart.on.description": "Enable boot autostart",
     "autostart.off.description": "Disable boot autostart",
@@ -390,7 +445,7 @@ var messages = {
     "doctor.installId": "Install ID: {value}",
     "doctor.linkId": "Link ID: {value}",
     "doctor.notAssigned": "not assigned",
-    "doctor.lanHost": "Configured LAN host: {value}",
+    "doctor.lanHost": "LAN access address (manual override): {value}",
     "doctor.networkWarning": "Network note: {message}",
     "doctor.hermesCli": "Hermes CLI: {value}",
     "doctor.hermesCliUnavailable": "Hermes CLI is unavailable. Please make sure the `hermes` command can run in this system.",
@@ -415,12 +470,41 @@ var messages = {
     "status.json": "\u8F93\u51FA\u673A\u5668\u53EF\u8BFB\u7684\u72B6\u6001 JSON",
     "status.runtime": "\u8FD0\u884C\u76EE\u5F55\uFF1A{value}",
     "status.mode": "\u6A21\u5F0F\uFF1A{value}",
+    "status.daemon": "\u540E\u53F0\u670D\u52A1\uFF1A{value}",
+    "status.daemon.runningReachable": "\u8FD0\u884C\u4E2D\uFF08PID\uFF1A{pid}\uFF0C\u672C\u5730 API \u53EF\u8BBF\u95EE\uFF09",
+    "status.daemon.runningUnreachable": "\u8FD0\u884C\u4E2D\uFF08PID\uFF1A{pid}\uFF0C\u4F46\u672C\u5730 API \u6682\u4E0D\u53EF\u8BBF\u95EE\uFF09",
+    "status.daemon.notRunning": "\u672A\u8FD0\u884C",
     "status.port": "\u672C\u5730\u7AEF\u53E3\uFF1A{value}",
-    "status.lanHost": "\u5DF2\u914D\u7F6E\u5C40\u57DF\u7F51\u4E3B\u673A\uFF1A{value}",
+    "status.lanHost": "\u5C40\u57DF\u7F51\u8BBF\u95EE\u5730\u5740\uFF08\u624B\u52A8\u6307\u5B9A\uFF09\uFF1A{value}",
     "status.notSet": "\u672A\u8BBE\u7F6E",
+    "status.unknown": "\u672A\u77E5",
     "status.environmentWarning": "\u7F51\u7EDC\u63D0\u793A\uFF1A{message}",
     "status.linkId": "Link ID\uFF1A{value}",
     "status.notPaired": "\u5C1A\u672A\u914D\u5BF9",
+    "status.relay": "Relay\uFF1A{value}",
+    "status.relay.notPaired": "\u672A\u8FDE\u63A5\uFF08\u5C1A\u672A\u914D\u5BF9\uFF0CRelay \u4F1A\u4FDD\u6301\u5173\u95ED\uFF09",
+    "status.relay.notConfigured": "\u672A\u914D\u7F6E",
+    "status.relay.serviceStopped": "\u672A\u8FDE\u63A5\uFF08\u540E\u53F0\u670D\u52A1\u672A\u8FD0\u884C\uFF09",
+    "status.relay.serviceUnreachable": "\u672A\u77E5\uFF08\u540E\u53F0\u670D\u52A1\u6B63\u5728\u8FD0\u884C\uFF0C\u4F46\u672C\u5730 API \u6682\u4E0D\u53EF\u8BBF\u95EE\uFF09",
+    "status.relay.unknown": "\u672A\u77E5\uFF08\u540E\u53F0\u670D\u52A1\u8FD8\u6CA1\u6709\u4E0A\u62A5 Relay \u72B6\u6001\uFF09",
+    "status.relay.state.connecting": "\u8FDE\u63A5\u4E2D",
+    "status.relay.state.connected": "\u5DF2\u8FDE\u63A5",
+    "status.relay.state.disconnected": "\u672A\u8FDE\u63A5",
+    "status.relay.state.retrying": "\u91CD\u8BD5\u4E2D",
+    "status.relay.state.cooldown": "\u51B7\u5374\u4E2D",
+    "status.relay.state.failed": "\u8FDE\u63A5\u5931\u8D25",
+    "status.relay.stateWithAttempt": "{state}\uFF08\u7B2C {attempt} \u6B21\uFF09",
+    "status.relay.updatedAt": "\u66F4\u65B0\u4E8E {time}",
+    "status.relay.withMessage": "{state} - {message}",
+    "status.relay.withUpdatedAt": "{state}\uFF1B{updatedAt}",
+    "status.relay.withMessageAndUpdatedAt": "{state} - {message}\uFF1B{updatedAt}",
+    "status.recentError": "\u6700\u8FD1\u9519\u8BEF\uFF1A{value}",
+    "status.recentError.none": "\u65E0",
+    "status.recentError.format": "{time} [{source}] {message}",
+    "status.logSource.service": "\u670D\u52A1",
+    "status.logSource.daemon": "\u5B88\u62A4\u8FDB\u7A0B",
+    "status.logSource.gateway": "Gateway",
+    "status.timeUnknown": "\u65F6\u95F4\u672A\u77E5",
     "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}",
@@ -440,18 +524,36 @@ var messages = {
     "config.unset.description": "\u6E05\u9664\u914D\u7F6E\u9879",
     "config.unknownKey": "\u672A\u77E5\u914D\u7F6E\u9879\uFF1A{key}",
     "config.lanHostInvalid": "lan-host \u5FC5\u987B\u662F\u5C40\u57DF\u7F51 IPv4 \u5730\u5740\uFF0C\u4F8B\u5982 192.168.1.23\u3002",
-    "config.lanHostSet": "\u5DF2\u914D\u7F6E\u5C40\u57DF\u7F51\u4E3B\u673A\uFF1A{value}",
-    "config.lanHostUnset": "\u5DF2\u6E05\u9664\u5C40\u57DF\u7F51\u4E3B\u673A\u914D\u7F6E\u3002",
+    "config.lanHostSet": "\u5DF2\u8BBE\u7F6E\u5C40\u57DF\u7F51\u8BBF\u95EE\u5730\u5740\uFF08\u624B\u52A8\u6307\u5B9A\uFF09\uFF1A{value}",
+    "config.lanHostUnset": "\u5DF2\u6E05\u9664\u5C40\u57DF\u7F51\u8BBF\u95EE\u5730\u5740\u624B\u52A8\u914D\u7F6E\u3002",
     "config.logLevelInvalid": "log-level \u53EA\u80FD\u662F\u4EE5\u4E0B\u503C\u4E4B\u4E00\uFF1Adebug\u3001info\u3001warn\u3001error\u3002",
     "config.logLevelSet": "\u5DF2\u914D\u7F6E\u65E5\u5FD7\u7EA7\u522B\uFF1A{value}",
+    "config.logLevelRestartRequired": "\u6B63\u5728\u8FD0\u884C\u7684 daemon \u4F1A\u7EE7\u7EED\u4F7F\u7528\u542F\u52A8\u65F6\u7684\u65E5\u5FD7\u5199\u5165\u7EA7\u522B\u3002\u8FD0\u884C `hermeslink restart` \u53EF\u7ACB\u5373\u5E94\u7528\u65B0\u7684\u5199\u5165\u7EA7\u522B\u3002",
     "config.logLevelUnset": "\u5DF2\u5C06\u65E5\u5FD7\u7EA7\u522B\u6062\u590D\u4E3A\u9ED8\u8BA4\u503C\uFF1A{value}\u3002",
     "config.reported": "\u5DF2\u628A\u6700\u65B0\u5C40\u57DF\u7F51\u5730\u5740\u66F4\u65B0\u5230 HermesPilot Server\u3002",
     "config.reportSkippedUnpaired": "Hermes Link \u8FD8\u6CA1\u6709\u914D\u5BF9\uFF0C\u5C40\u57DF\u7F51\u5730\u5740\u4F1A\u5728\u914D\u5BF9\u540E\u4E0A\u62A5\u3002",
     "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.description": "\u663E\u793A\u6216\u8DDF\u8E2A Hermes Link \u65E5\u5FD7",
+    "logs.follow": "\u6301\u7EED\u8DDF\u8E2A\u65E5\u5FD7\u8F93\u51FA",
+    "logs.tail": "\u9000\u51FA\u6216\u6301\u7EED\u8DDF\u8E2A\u524D\u5148\u8F93\u51FA\u6700\u8FD1 N \u884C",
+    "logs.serviceOnly": "\u53EA\u8BFB\u53D6\u670D\u52A1 JSONL \u65E5\u5FD7",
+    "logs.daemonOnly": "\u53EA\u8BFB\u53D6 Daemon \u6807\u51C6\u8F93\u51FA/\u9519\u8BEF\u65E5\u5FD7",
+    "logs.gatewayOnly": "\u53EA\u8BFB\u53D6 Hermes Gateway \u65E5\u5FD7",
+    "logs.all": "\u8BFB\u53D6\u670D\u52A1\u3001Daemon \u4E0E Gateway \u65E5\u5FD7",
+    "logs.level": "\u6700\u4F4E\u663E\u793A\u7EA7\u522B\uFF1Adebug\u3001info\u3001warn \u6216 error",
+    "logs.debugLevel": "\u663E\u793A debug \u53CA\u4EE5\u4E0A\u7EA7\u522B",
+    "logs.infoLevel": "\u663E\u793A info \u53CA\u4EE5\u4E0A\u7EA7\u522B",
+    "logs.warnLevel": "\u663E\u793A warn \u53CA\u4EE5\u4E0A\u7EA7\u522B",
+    "logs.errorLevel": "\u53EA\u663E\u793A error \u7EA7\u522B",
     "logs.servicePath": "\u670D\u52A1\u65E5\u5FD7\uFF1A{path}",
     "logs.daemonPath": "Daemon \u6807\u51C6\u8F93\u51FA/\u9519\u8BEF\u65E5\u5FD7\uFF1A{path}",
+    "logs.gatewayPath": "Gateway \u65E5\u5FD7\uFF1A{path}",
+    "logs.followHint": "\u4F7F\u7528 `hermeslink logs -f` \u6301\u7EED\u8DDF\u8E2A\u65E5\u5FD7\uFF0C\u6216 `hermeslink logs -n 100` \u8F93\u51FA\u6700\u8FD1\u65E5\u5FD7\u3002",
+    "logs.following": "\u6B63\u5728\u6301\u7EED\u8DDF\u8E2A\u65E5\u5FD7\u3002\u6309 Ctrl+C \u505C\u6B62\u3002",
+    "logs.flush.description": "\u6E05\u7A7A Hermes Link \u65E5\u5FD7\u6587\u4EF6",
+    "logs.flush.all": "\u6E05\u7A7A\u670D\u52A1\u3001Daemon \u4E0E Gateway \u65E5\u5FD7",
+    "logs.flush.flushed": "\u5DF2\u6E05\u7A7A {truncated} \u4E2A\u5F53\u524D\u65E5\u5FD7\u6587\u4EF6\uFF0C\u5E76\u5220\u9664 {removed} \u4E2A\u8F6E\u8F6C\u65E5\u5FD7\u6587\u4EF6\u3002",
     "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",
@@ -507,7 +609,7 @@ var messages = {
     "doctor.installId": "Install ID\uFF1A{value}",
     "doctor.linkId": "Link ID\uFF1A{value}",
     "doctor.notAssigned": "\u5C1A\u672A\u5206\u914D",
-    "doctor.lanHost": "\u5DF2\u914D\u7F6E\u5C40\u57DF\u7F51\u4E3B\u673A\uFF1A{value}",
+    "doctor.lanHost": "\u5C40\u57DF\u7F51\u8BBF\u95EE\u5730\u5740\uFF08\u624B\u52A8\u6307\u5B9A\uFF09\uFF1A{value}",
     "doctor.networkWarning": "\u7F51\u7EDC\u63D0\u793A\uFF1A{message}",
     "doctor.hermesCli": "Hermes CLI\uFF1A{value}",
     "doctor.hermesCliUnavailable": "Hermes CLI\uFF1A\u4E0D\u53EF\u7528\u3002\u8BF7\u786E\u8BA4\u5F53\u524D\u7CFB\u7EDF\u53EF\u4EE5\u76F4\u63A5\u8FD0\u884C `hermes` \u547D\u4EE4\u3002",
@@ -942,6 +1044,23 @@ program.command("status").option("--json", helpText("status.json")).description(
   const [identity, config] = await Promise.all([loadIdentity(paths), loadConfig(paths)]);
   const language = resolveLanguage(config.language);
   const t = translate.bind(null, language);
+  const [daemonStatus, relayStatus, recentError] = await Promise.all([
+    getDaemonStatus(paths),
+    readRelayStatusSnapshot(paths).catch(() => null),
+    readMostRecentError(paths).catch(() => null)
+  ]);
+  const serviceProbe = daemonStatus.running ? await probeLocalLinkService({
+    port: config.port,
+    linkId: identity?.link_id ?? void 0,
+    timeoutMs: 500
+  }).catch(() => null) : null;
+  const relay = buildRelayStatusPayload({
+    paired: Boolean(identity?.link_id),
+    relayConfigured: Boolean(config.relayBaseUrl),
+    daemonRunning: daemonStatus.running,
+    localApiReachable: serviceProbe?.reachable ?? false,
+    relayStatus
+  });
   const payload = {
     version: LINK_VERSION,
     runtimeHome: paths.homeDir,
@@ -949,12 +1068,18 @@ program.command("status").option("--json", helpText("status.json")).description(
     mode: identity?.link_id ? "paired" : "local-only",
     port: config.port,
     lanHost: config.lanHost,
+    lanHostMeaning: config.lanHost ? "Manual LAN address override. It is only needed when the phone cannot reach the automatically discovered LAN address." : null,
+    daemon: {
+      running: daemonStatus.running,
+      pid: daemonStatus.pid,
+      localApiReachable: serviceProbe?.reachable ?? false,
+      localApiVersion: serviceProbe?.version ?? null,
+      logFile: daemonStatus.logFile
+    },
     environment: detectRuntimeEnvironment(),
     identity: identity ? getIdentityStatus(identity) : null,
-    relay: {
-      configured: Boolean(config.relayBaseUrl),
-      connected: false
-    }
+    relay,
+    recentError
   };
   if (options.json) {
     console.log(JSON.stringify(payload, null, 2));
@@ -963,12 +1088,17 @@ program.command("status").option("--json", helpText("status.json")).description(
   console.log(`Hermes Link ${payload.version}`);
   console.log(t("status.runtime", { value: payload.runtimeHome }));
   console.log(t("status.mode", { value: payload.mode }));
+  console.log(t("status.daemon", { value: formatDaemonStatus(payload.daemon, t) }));
   console.log(t("status.port", { value: payload.port }));
-  console.log(t("status.lanHost", { value: payload.lanHost ?? t("status.notSet") }));
+  if (payload.lanHost) {
+    console.log(t("status.lanHost", { value: payload.lanHost }));
+  }
   if (payload.environment.warning) {
     console.log(t("status.environmentWarning", { message: payload.environment.warning }));
   }
   console.log(t("status.linkId", { value: payload.identity?.linkId ?? t("status.notPaired") }));
+  console.log(t("status.relay", { value: formatRelayStatus(payload.relay, t, language) }));
+  console.log(t("status.recentError", { value: formatRecentError(payload.recentError, t, language) }));
 });
 var configCommand = program.command("config").description(helpText("config.description"));
 configCommand.command("set").argument("<key>").argument("<value>").description(helpText("config.set.description")).action(async (key, value) => {
@@ -994,6 +1124,10 @@ configCommand.command("set").argument("<key>").argument("<value>").description(h
     }
     const next = await saveConfig({ logLevel }, paths);
     console.log(t("config.logLevelSet", { value: next.logLevel }));
+    const status = await getDaemonStatus(paths).catch(() => null);
+    if (status?.running) {
+      console.log(t("config.logLevelRestartRequired"));
+    }
     return;
   }
   {
@@ -1024,15 +1158,24 @@ configCommand.command("unset").argument("<key>").description(helpText("config.un
   }
 });
 program.command("start").description(helpText("start.description")).action(async () => {
-  const [config, status] = await Promise.all([loadConfig(), getDaemonStatus()]);
+  const paths = resolveRuntimePaths();
+  const [config, status] = await Promise.all([loadConfig(paths), getDaemonStatus(paths)]);
   const language = resolveLanguage(config.language);
   const t = translate.bind(null, language);
   if (status.running && status.pid) {
     console.log(t("start.alreadyRunning", { pid: status.pid }));
+    await ensureHermesLinkSkillInstalledBestEffort({
+      paths,
+      source: "cli_start_already_running"
+    });
     return;
   }
-  const nextStatus = await startDaemonProcess();
+  const nextStatus = await startDaemonProcess(paths);
   console.log(t("start.backgroundStarted", { pid: nextStatus.pid ?? "unknown" }));
+  await ensureHermesLinkSkillInstalledBestEffort({
+    paths,
+    source: "cli_start"
+  });
 });
 program.command("stop").description(helpText("stop.description")).action(async () => {
   const config = await loadConfig();
@@ -1047,12 +1190,17 @@ program.command("stop").description(helpText("stop.description")).action(async (
   console.log(t("stop.stopped"));
 });
 program.command("restart").description(helpText("restart.description")).action(async () => {
-  const config = await loadConfig();
+  const paths = resolveRuntimePaths();
+  const config = await loadConfig(paths);
   const language = resolveLanguage(config.language);
   const t = translate.bind(null, language);
-  await stopDaemonProcess();
-  const status = await startDaemonProcess();
+  await stopDaemonProcess(paths);
+  const status = await startDaemonProcess(paths);
   console.log(t("start.backgroundStarted", { pid: status.pid ?? "unknown" }));
+  await ensureHermesLinkSkillInstalledBestEffort({
+    paths,
+    source: "cli_restart"
+  });
 });
 program.command("deliver").argument("<staging-dir>").description(helpText("deliver.description")).action(async (stagingDir) => {
   const paths = resolveRuntimePaths();
@@ -1125,6 +1273,7 @@ program.command("pair").description(helpText("pair.description")).action(async (
       relayBaseUrl: prepared.relayBaseUrl,
       linkId: prepared.linkId,
       localPort: config.port,
+      paths,
       initialStreamBatchPolicy: streamBatchPolicy
     });
     pairingRelayBridge.publishNetworkRoutes(prepared.routes);
@@ -1151,6 +1300,10 @@ program.command("pair").description(helpText("pair.description")).action(async (
       await clearPairingClaim(prepared.sessionId, paths);
       console.log(t(reusedRunningService ? "pair.claimedRunning" : "pair.claimed"));
       printPostPairingNetworkNotice(prepared.routes.environment, config, t);
+      await ensureHermesLinkSkillInstalledBestEffort({
+        paths,
+        source: "cli_pair_claimed"
+      });
       try {
         if (hadActiveDevices) {
           console.log(t("pair.autostartUnchanged"));
@@ -1224,13 +1377,44 @@ autostart.command("status").description(helpText("autostart.status.description")
     })
   );
 });
-program.command("logs").description(helpText("logs.description")).action(async () => {
+var logsCommand = program.command("logs").option("-f, --follow", helpText("logs.follow")).option("-n, --tail <lines>", helpText("logs.tail")).option("--service", helpText("logs.serviceOnly")).option("--daemon", helpText("logs.daemonOnly")).option("--gateway", helpText("logs.gatewayOnly")).option("--all", helpText("logs.all")).option("--level <level>", helpText("logs.level")).option("--debug", helpText("logs.debugLevel")).option("-i, --info", helpText("logs.infoLevel")).option("-w, --warn", helpText("logs.warnLevel")).option("-e, --error", helpText("logs.errorLevel")).description(helpText("logs.description")).action(async (options) => {
   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) }));
+  const sources = resolveLogSources(paths, options);
+  const tailLines = parseLogTailLines(options.tail, options.follow ? 80 : null);
+  const displayLevel = parseLogDisplayLevel(options, config.logLevel);
+  if (!options.follow && tailLines === null) {
+    console.log(t("logs.servicePath", { path: getLinkLogFile(paths) }));
+    console.log(t("logs.daemonPath", { path: daemonLogFile(paths) }));
+    for (const filePath of getGatewayLogFiles(paths)) {
+      console.log(t("logs.gatewayPath", { path: filePath }));
+    }
+    console.log(t("logs.followHint"));
+    return;
+  }
+  await printRecentLogLines(sources, tailLines ?? 80, displayLevel);
+  if (options.follow) {
+    console.log(t("logs.following"));
+    await followLogSources(sources, displayLevel);
+  }
+});
+logsCommand.command("flush").description(helpText("logs.flush.description")).option("--service", helpText("logs.serviceOnly")).option("--daemon", helpText("logs.daemonOnly")).option("--gateway", helpText("logs.gatewayOnly")).option("--all", helpText("logs.flush.all")).action(async (options) => {
+  const paths = resolveRuntimePaths();
+  const config = await loadConfig(paths);
+  const language = resolveLanguage(config.language);
+  const t = translate.bind(null, language);
+  const sources = resolveLogSources(paths, options);
+  const result = await flushLogFiles({
+    filePaths: sources.map((source) => source.filePath)
+  });
+  console.log(
+    t("logs.flush.flushed", {
+      truncated: result.truncated.length,
+      removed: result.removed.length
+    })
+  );
 });
 program.command("doctor").option("--install", helpText("doctor.installOnly")).description(helpText("doctor.description")).action(async (options) => {
   const installInfo = readInstallPathInfo();
@@ -1285,6 +1469,193 @@ async function loadCliLanguage() {
   const config = await loadConfig();
   return resolveLanguage(config.language);
 }
+function buildRelayStatusPayload(input) {
+  if (!input.paired) {
+    return emptyRelayStatus(input.relayConfigured, "not_paired");
+  }
+  if (!input.relayConfigured) {
+    return emptyRelayStatus(false, "not_configured");
+  }
+  if (!input.daemonRunning) {
+    return emptyRelayStatus(true, "service_stopped");
+  }
+  if (!input.localApiReachable) {
+    return emptyRelayStatus(true, "service_unreachable");
+  }
+  if (!input.relayStatus) {
+    return emptyRelayStatus(true, "unknown");
+  }
+  return {
+    configured: true,
+    connected: input.relayStatus.state === "connected",
+    state: input.relayStatus.state,
+    attempt: input.relayStatus.attempt,
+    message: input.relayStatus.message,
+    updatedAt: input.relayStatus.updatedAt
+  };
+}
+function emptyRelayStatus(configured, state) {
+  return {
+    configured,
+    connected: false,
+    state,
+    attempt: null,
+    message: null,
+    updatedAt: null
+  };
+}
+function formatDaemonStatus(daemon, t) {
+  if (!daemon.running) {
+    return t("status.daemon.notRunning");
+  }
+  const pid = daemon.pid ?? t("status.unknown");
+  return t(
+    daemon.localApiReachable ? "status.daemon.runningReachable" : "status.daemon.runningUnreachable",
+    { pid }
+  );
+}
+function formatRelayStatus(relay, t, language) {
+  if (relay.state === "not_paired") {
+    return t("status.relay.notPaired");
+  }
+  if (relay.state === "not_configured") {
+    return t("status.relay.notConfigured");
+  }
+  if (relay.state === "service_stopped") {
+    return t("status.relay.serviceStopped");
+  }
+  if (relay.state === "service_unreachable") {
+    return t("status.relay.serviceUnreachable");
+  }
+  if (relay.state === "unknown") {
+    return t("status.relay.unknown");
+  }
+  let state = formatRelayState(relay.state, t);
+  if (relay.attempt !== null && relay.attempt > 0 && relay.state !== "connected") {
+    state = t("status.relay.stateWithAttempt", {
+      state,
+      attempt: relay.attempt
+    });
+  }
+  const updatedAt = relay.updatedAt ? t("status.relay.updatedAt", {
+    time: formatTimestamp(relay.updatedAt, language)
+  }) : null;
+  if (relay.message && updatedAt) {
+    return t("status.relay.withMessageAndUpdatedAt", {
+      state,
+      message: relay.message,
+      updatedAt
+    });
+  }
+  if (relay.message) {
+    return t("status.relay.withMessage", {
+      state,
+      message: relay.message
+    });
+  }
+  if (updatedAt) {
+    return t("status.relay.withUpdatedAt", {
+      state,
+      updatedAt
+    });
+  }
+  return state;
+}
+function formatRelayState(state, t) {
+  switch (state) {
+    case "connecting":
+      return t("status.relay.state.connecting");
+    case "connected":
+      return t("status.relay.state.connected");
+    case "disconnected":
+      return t("status.relay.state.disconnected");
+    case "retrying":
+      return t("status.relay.state.retrying");
+    case "cooldown":
+      return t("status.relay.state.cooldown");
+    case "failed":
+      return t("status.relay.state.failed");
+  }
+}
+async function readMostRecentError(paths) {
+  const [service, daemon, gateway] = await Promise.all([
+    readRecentLogEntries({ paths, limit: 120 }).catch(() => []),
+    readRecentTextLogEntries({
+      paths,
+      filePaths: [daemonLogFile(paths)],
+      limit: 120
+    }).catch(() => []),
+    readRecentGatewayLogEntries({ paths, limit: 120 }).catch(() => [])
+  ]);
+  const errors = [
+    ...service.map((entry) => toStatusRecentError("service", entry)),
+    ...daemon.map((entry) => toStatusRecentError("daemon", entry)),
+    ...gateway.map((entry) => toStatusRecentError("gateway", entry))
+  ].filter((item) => item !== null);
+  errors.sort((left, right) => readTimestampMs(right.ts) - readTimestampMs(left.ts));
+  return errors[0] ?? null;
+}
+function toStatusRecentError(source, entry) {
+  if (!isActionableStatusError(source, entry)) {
+    return null;
+  }
+  const errorDetail = typeof entry.fields?.error === "string" ? entry.fields.error : null;
+  const message = errorDetail && errorDetail !== entry.message ? `${entry.message}: ${errorDetail}` : entry.message;
+  return {
+    source,
+    ts: entry.ts,
+    message
+  };
+}
+function isActionableStatusError(source, entry) {
+  if (source === "service") {
+    return entry.level === "error";
+  }
+  if (entry.level !== "error") {
+    return false;
+  }
+  return /(^|[\s[])(error|fatal)([\]\s:]|$)|\b(traceback|exception|failed|failure|unhandledRejection|uncaughtException)\b/iu.test(
+    entry.message
+  );
+}
+function formatRecentError(error, t, language) {
+  if (!error) {
+    return t("status.recentError.none");
+  }
+  return t("status.recentError.format", {
+    time: error.ts ? formatTimestamp(error.ts, language) : t("status.timeUnknown"),
+    source: formatLogSourceLabel(error.source, t),
+    message: error.message
+  });
+}
+function formatLogSourceLabel(source, t) {
+  switch (source) {
+    case "service":
+      return t("status.logSource.service");
+    case "daemon":
+      return t("status.logSource.daemon");
+    case "gateway":
+      return t("status.logSource.gateway");
+  }
+}
+function formatTimestamp(value, language) {
+  const timestamp = Date.parse(value);
+  if (!Number.isFinite(timestamp)) {
+    return value;
+  }
+  return new Intl.DateTimeFormat(language === "zh-CN" ? "zh-CN" : "en-US", {
+    dateStyle: "short",
+    timeStyle: "medium",
+    hour12: false
+  }).format(new Date(timestamp));
+}
+function readTimestampMs(value) {
+  if (!value) {
+    return 0;
+  }
+  const timestamp = Date.parse(value);
+  return Number.isFinite(timestamp) ? timestamp : 0;
+}
 function formatHermesVersion(version) {
   return version.version ?? version.raw;
 }
@@ -1335,6 +1706,225 @@ function printInstallDiagnostics(info, t, verbose) {
   }
   console.log(t("doctor.installNpxFallback"));
 }
+function resolveLogSources(paths, options) {
+  const hasExplicitSelection = Boolean(
+    options.service || options.daemon || options.gateway || options.all
+  );
+  const includeService = options.all || options.service || !hasExplicitSelection;
+  const includeDaemon = options.all || options.daemon || !hasExplicitSelection;
+  const includeGateway = options.all || options.gateway;
+  const sources = [];
+  if (includeService) {
+    sources.push({ label: "service", filePath: getLinkLogFile(paths), kind: "jsonl" });
+  }
+  if (includeDaemon) {
+    sources.push({ label: "daemon", filePath: daemonLogFile(paths), kind: "text" });
+  }
+  if (includeGateway) {
+    for (const filePath of getGatewayLogFiles(paths)) {
+      sources.push({ label: "gateway", filePath, kind: "text" });
+    }
+  }
+  return sources;
+}
+function parseLogDisplayLevel(options, fallback) {
+  const flagLevels = [];
+  if (options.debug) {
+    flagLevels.push("debug");
+  }
+  if (options.info) {
+    flagLevels.push("info");
+  }
+  if (options.warn) {
+    flagLevels.push("warn");
+  }
+  if (options.error) {
+    flagLevels.push("error");
+  }
+  if (flagLevels.length > 1) {
+    throw new Error("Choose only one log level filter");
+  }
+  if (options.level !== void 0 && flagLevels.length > 0) {
+    throw new Error("Use either --level or a level shortcut, not both");
+  }
+  if (flagLevels.length === 1) {
+    return flagLevels[0];
+  }
+  if (options.level === void 0) {
+    return fallback;
+  }
+  const level = parseLogLevel(options.level.trim().toLowerCase());
+  if (!level) {
+    throw new Error("--level must be one of: debug, info, warn, error");
+  }
+  return level;
+}
+function parseLogTailLines(raw, defaultValue) {
+  if (raw === void 0) {
+    return defaultValue;
+  }
+  const value = Number.parseInt(raw, 10);
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error("--tail must be a non-negative integer");
+  }
+  return Math.min(value, 2e3);
+}
+async function printRecentLogLines(sources, limit, minLevel) {
+  for (const source of sources) {
+    const lines = await readLastLogLines(source.filePath, limit);
+    for (const line of lines) {
+      printLogLine(source, line, minLevel);
+    }
+  }
+}
+async function readLastLogLines(filePath, limit) {
+  if (limit <= 0) {
+    return [];
+  }
+  const raw = await readFile2(filePath, "utf8").catch(() => null);
+  if (!raw) {
+    return [];
+  }
+  return raw.split(/\r?\n/u).filter(Boolean).slice(-limit);
+}
+async function followLogSources(sources, minLevel) {
+  const followers = await Promise.all(
+    sources.map((source) => createLogFollower(source, minLevel))
+  );
+  await new Promise((resolve) => {
+    const stop = () => {
+      for (const follower of followers) {
+        follower.close();
+      }
+      process.off("SIGINT", stop);
+      process.off("SIGTERM", stop);
+      resolve();
+    };
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+  });
+}
+async function createLogFollower(source, minLevel) {
+  let offset = await readFileSize(source.filePath);
+  let pending = "";
+  let closed = false;
+  const poll = async () => {
+    if (closed) {
+      return;
+    }
+    const size = await readFileSize(source.filePath);
+    if (size === null) {
+      offset = 0;
+      pending = "";
+      return;
+    }
+    if (offset === null || size < offset) {
+      offset = 0;
+      pending = "";
+    }
+    if (size <= offset) {
+      return;
+    }
+    const chunk = await readFileRange(source.filePath, offset, size);
+    offset = size;
+    const parts = `${pending}${chunk}`.split(/\r?\n/u);
+    pending = parts.pop() ?? "";
+    for (const line of parts) {
+      if (line) {
+        printLogLine(source, line, minLevel);
+      }
+    }
+  };
+  watchFile(source.filePath, { interval: 1e3 }, () => {
+    void poll().catch(() => void 0);
+  });
+  return {
+    close() {
+      closed = true;
+      unwatchFile(source.filePath);
+      if (pending) {
+        printLogLine(source, pending, minLevel);
+        pending = "";
+      }
+    }
+  };
+}
+async function readFileSize(filePath) {
+  const info = await stat2(filePath).catch(() => null);
+  return info?.isFile() ? info.size : null;
+}
+async function readFileRange(filePath, start, end) {
+  const length = Math.max(0, end - start);
+  if (length === 0) {
+    return "";
+  }
+  const handle = await open(filePath, "r");
+  try {
+    const buffer = Buffer.alloc(length);
+    const result = await handle.read(buffer, 0, length, start);
+    return buffer.subarray(0, result.bytesRead).toString("utf8");
+  } finally {
+    await handle.close();
+  }
+}
+function printLogLine(source, line, minLevel) {
+  if (!logLineMatchesLevel(source, line, minLevel)) {
+    return;
+  }
+  console.log(`[${source.label}] ${formatLogLine(source, line)}`);
+}
+function logLineMatchesLevel(source, line, minLevel) {
+  return LOG_LEVEL_PRIORITY[readLogLineLevel(source, line)] >= LOG_LEVEL_PRIORITY[minLevel];
+}
+function readLogLineLevel(source, line) {
+  if (source.kind === "jsonl") {
+    try {
+      const entry = JSON.parse(line);
+      if (isLogLevel(entry.level)) {
+        return entry.level;
+      }
+    } catch {
+      return "info";
+    }
+  }
+  return inferTextLogLevel(line);
+}
+function formatLogLine(source, line) {
+  if (source.kind !== "jsonl") {
+    return line;
+  }
+  try {
+    const entry = JSON.parse(line);
+    const ts = typeof entry.ts === "string" ? entry.ts : "";
+    const level = typeof entry.level === "string" ? entry.level.toUpperCase() : "INFO";
+    const message = typeof entry.message === "string" ? entry.message : line;
+    const fields = entry.fields && typeof entry.fields === "object" ? ` ${JSON.stringify(entry.fields)}` : "";
+    return `${ts} ${level} ${message}${fields}`.trim();
+  } catch {
+    return line;
+  }
+}
+var LOG_LEVEL_PRIORITY = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40
+};
+function isLogLevel(value) {
+  return value === "debug" || value === "info" || value === "warn" || value === "error";
+}
+function inferTextLogLevel(line) {
+  if (/\b(error|fatal|traceback|failed|failure)\b/iu.test(line)) {
+    return "error";
+  }
+  if (/\b(warn|warning)\b/iu.test(line)) {
+    return "warn";
+  }
+  if (/\b(debug|trace)\b/iu.test(line)) {
+    return "debug";
+  }
+  return "info";
+}
 function pairingPreflightProgressKey(stage) {
   switch (stage) {
     case "hermes_files":