@hermespilot/link 0.4.1 → 0.4.3

package/README.md

@@ -44,6 +44,8 @@ If Hermes Agent is configured through `~/.hermes/.env`, Link follows the same `A
 
 CLI output follows the current system language when it is Chinese or English. You can override it for a single command with `HERMESLINK_LANG=zh-CN` or `HERMESLINK_LANG=en`.
 
+Set `HERMESLINK_LOG_LEVEL=warn` to suppress `debug` and `info` logs in published builds; `warn` is the default. You can also persist it with `hermeslink config set log-level warn`.
+
 ## Runtime data
 
 Hermes Link keeps its local identity and runtime state under:

package/dist/{chunk-476X63MC.js → chunk-MFRSQUSE.js}

@@ -1102,6 +1102,20 @@ function readProfileAvatarType(row) {
 import { mkdir as mkdir3, readdir as readdir3, readFile as readFile3, stat as stat2 } from "fs/promises";
 import path4 from "path";
 
+// src/core/errors.ts
+var LinkHttpError = class extends Error {
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+  }
+  status;
+  code;
+};
+function isLinkHttpError(error) {
+  return error instanceof LinkHttpError;
+}
+
 // src/storage/atomic-json.ts
 import { readFile } from "fs/promises";
 
@@ -3824,6 +3838,7 @@ async function decorateHermesLinkCronJob(paths, profileName, job) {
 async function syncHermesLinkCronDeliveries(paths, runtime, logger) {
   const registry = await readRegistry(paths);
   let touched = false;
+  const staleBindings = [];
   for (const binding of registry.bindings) {
     const delivered = new Set(binding.deliveredOutputPaths ?? []);
     const outputs = await listCronOutputFiles(
@@ -3848,6 +3863,13 @@ async function syncHermesLinkCronDeliveries(paths, runtime, logger) {
         delivered.add(output.path);
         touched = true;
       } catch (error) {
+        if (isConversationMissingError(error)) {
+          staleBindings.push({
+            profileName: binding.profileName,
+            jobId: binding.jobId
+          });
+          break;
+        }
         void logger.warn("cron_link_delivery_failed", {
           profile: binding.profileName,
           job_id: binding.jobId,
@@ -3858,6 +3880,14 @@ async function syncHermesLinkCronDeliveries(paths, runtime, logger) {
     }
     binding.deliveredOutputPaths = [...delivered];
   }
+  if (staleBindings.length > 0) {
+    registry.bindings = registry.bindings.filter(
+      (binding) => !staleBindings.some(
+        (staleBinding) => staleBinding.profileName === binding.profileName && staleBinding.jobId === binding.jobId
+      )
+    );
+    touched = true;
+  }
   if (touched) {
     await writeRegistry(paths, registry);
   }
@@ -3945,6 +3975,9 @@ function readString3(record, ...keys) {
 function isNodeError4(error, code) {
   return error instanceof Error && error.code === code;
 }
+function isConversationMissingError(error) {
+  return isLinkHttpError(error) && error.status === 404 && error.code === "conversation_not_found";
+}
 
 // src/hermes/gateway.ts
 import { execFile as execFile2, spawn } from "child_process";
@@ -3953,20 +3986,6 @@ import path7 from "path";
 import { setTimeout as delay } from "timers/promises";
 import { promisify as promisify2 } from "util";
 
-// src/core/errors.ts
-var LinkHttpError = class extends Error {
-  constructor(status, code, message) {
-    super(message);
-    this.status = status;
-    this.code = code;
-  }
-  status;
-  code;
-};
-function isLinkHttpError(error) {
-  return error instanceof LinkHttpError;
-}
-
 // src/runtime/logger.ts
 import { appendFile, mkdir as mkdir4, open as open2, readFile as readFile4, rename as rename2, rm as rm2, stat as stat3 } from "fs/promises";
 import os3 from "os";
@@ -3977,7 +3996,7 @@ import os2 from "os";
 import path5 from "path";
 
 // src/constants.ts
-var LINK_VERSION = "0.4.1";
+var LINK_VERSION = "0.4.3";
 var LINK_COMMAND = "hermeslink";
 var LINK_DEFAULT_PORT = 52379;
 var LINK_RUNTIME_DIR_NAME = ".hermeslink";
@@ -4012,11 +4031,18 @@ var MAX_READ_LIMIT = 1e3;
 var DEFAULT_MAX_BYTES_PER_FILE = 512 * 1024;
 var GATEWAY_LOG_FILE = "hermes-gateway.log";
 var DAEMON_LOG_FILE = "daemon.log";
+var LOG_LEVEL_PRIORITY = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40
+};
 var FileLogger = class {
   filePath;
   paths;
   maxFileBytes;
   maxFiles;
+  minLevel;
   now;
   queue = Promise.resolve();
   constructor(options = {}) {
@@ -4024,6 +4050,7 @@ var FileLogger = class {
     this.filePath = getLinkLogFile(this.paths, options.fileName);
     this.maxFileBytes = Math.max(256, Math.floor(options.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES));
     this.maxFiles = Math.max(0, Math.floor(options.maxFiles ?? DEFAULT_MAX_FILES));
+    this.minLevel = options.minLevel ?? "warn";
     this.now = options.now ?? (() => /* @__PURE__ */ new Date());
   }
   debug(message, fields) {
@@ -4039,6 +4066,9 @@ var FileLogger = class {
     return this.write("error", message, fields);
   }
   write(level, message, fields) {
+    if (LOG_LEVEL_PRIORITY[level] < LOG_LEVEL_PRIORITY[this.minLevel]) {
+      return Promise.resolve();
+    }
     const entry = {
       ts: this.now().toISOString(),
       level,
@@ -4464,8 +4494,11 @@ var MIN_API_SERVER_VERSION = "0.4.0";
 var PROFILE_NAME_PATTERN = /^[a-zA-Z0-9._-]{1,64}$/u;
 var DASHBOARD_STATUS_URL = "http://127.0.0.1:9119/api/status";
 var DASHBOARD_STATUS_TIMEOUT_MS = 1500;
+var DEFAULT_VERSION_CACHE_TTL_MS = 6e4;
 var MAX_VERSION_LOG_OUTPUT_LENGTH = 1200;
 var gatewayStartInFlightByProfile = /* @__PURE__ */ new Map();
+var hermesVersionCache = /* @__PURE__ */ new Map();
+var hermesVersionInFlight = /* @__PURE__ */ new Map();
 async function ensureHermesApiServerAvailable(options = {}) {
   const profileName = normalizeProfileName(options.profileName);
   await assertProfileExists(profileName);
@@ -4582,41 +4615,38 @@ async function reloadHermesGateway(options = {}) {
   return ensureHermesApiServerAvailable({ ...options, forceRestart: true });
 }
 async function readHermesVersion(options = {}) {
+  const hermesBin = resolveHermesBin();
+  const cacheTtlMs = Math.max(
+    0,
+    Math.floor(options.cacheTtlMs ?? DEFAULT_VERSION_CACHE_TTL_MS)
+  );
+  if (!options.forceRefresh && cacheTtlMs > 0) {
+    const cached = hermesVersionCache.get(hermesBin);
+    if (cached && cached.expiresAt > Date.now()) {
+      return cached.value;
+    }
+    hermesVersionCache.delete(hermesBin);
+  }
+  const inFlight = hermesVersionInFlight.get(hermesBin);
+  if (inFlight) {
+    return await inFlight;
+  }
+  const probe = probeHermesVersion(hermesBin, options);
+  hermesVersionInFlight.set(hermesBin, probe);
   try {
-    const { stdout } = await execHermesVersion(options.logger);
-    const raw = stdout.trim();
-    const version = parseHermesVersion(raw);
-    return buildHermesVersionInfo(raw, version);
-  } catch (cliError) {
-    const dashboardStatusUrl = options.dashboardStatusUrl ?? DASHBOARD_STATUS_URL;
-    void options.logger?.warn("hermes_version_dashboard_fallback_requested", {
-      dashboard_status_url: dashboardStatusUrl,
-      reason: cliError instanceof Error ? cliError.message : String(cliError)
-    });
-    try {
-      const fallback = await readHermesDashboardVersion({
-        fetchImpl: options.fetchImpl,
-        statusUrl: dashboardStatusUrl,
-        timeoutMs: options.dashboardTimeoutMs
-      });
-      void options.logger?.info("hermes_version_dashboard_fallback_succeeded", {
-        dashboard_status_url: dashboardStatusUrl,
-        hermes_version: fallback.version
-      });
-      return fallback;
-    } catch (dashboardError) {
-      void options.logger?.warn("hermes_version_dashboard_fallback_failed", {
-        dashboard_status_url: dashboardStatusUrl,
-        error: dashboardError instanceof Error ? dashboardError.message : String(dashboardError)
+    const version = await probe;
+    if (cacheTtlMs > 0) {
+      hermesVersionCache.set(hermesBin, {
+        value: version,
+        expiresAt: Date.now() + cacheTtlMs
       });
-      throw new Error(
-        `Hermes version detection failed. CLI: ${cliError instanceof Error ? cliError.message : String(cliError)}; dashboard fallback: ${dashboardError instanceof Error ? dashboardError.message : String(dashboardError)}`
-      );
     }
+    return version;
+  } finally {
+    hermesVersionInFlight.delete(hermesBin);
   }
 }
-async function execHermesVersion(logger) {
-  const hermesBin = resolveHermesBin();
+async function execHermesVersion(hermesBin, logger) {
   const failures = [];
   for (const args of [["version"], ["--version"]]) {
     try {
@@ -4626,11 +4656,18 @@ async function execHermesVersion(logger) {
       });
     } catch (error) {
       const failure = describeVersionCommandFailure(hermesBin, args, error);
-      failures.push(failure.summary);
-      void logger?.warn("hermes_version_cli_command_failed", failure.fields);
+      failures.push(failure);
+      void logger?.debug("hermes_version_cli_command_attempt_failed", failure.fields);
     }
   }
-  throw new Error(failures.join("; "));
+  const summary = failures.map((failure) => failure.summary).join("; ");
+  void logger?.warn("hermes_version_cli_command_failed", {
+    hermes_bin: hermesBin,
+    failure_count: failures.length,
+    error: summary,
+    attempts: failures.map((failure) => failure.fields)
+  });
+  throw new Error(summary);
 }
 function assertHermesRunsApiSupported(version, status) {
   if (status !== 404) {
@@ -5051,27 +5088,85 @@ async function readHermesDashboardVersion(options = {}) {
     clearTimeout(timer);
   }
 }
+async function probeHermesVersion(hermesBin, options) {
+  try {
+    const { stdout } = await execHermesVersion(hermesBin, options.logger);
+    const raw = stdout.trim();
+    const version = parseHermesVersion(raw);
+    return buildHermesVersionInfo(raw, version);
+  } catch (cliError) {
+    const dashboardStatusUrl = options.dashboardStatusUrl ?? DASHBOARD_STATUS_URL;
+    void options.logger?.warn("hermes_version_dashboard_fallback_requested", {
+      dashboard_status_url: dashboardStatusUrl,
+      reason: cliError instanceof Error ? cliError.message : String(cliError)
+    });
+    try {
+      const fallback = await readHermesDashboardVersion({
+        fetchImpl: options.fetchImpl,
+        statusUrl: dashboardStatusUrl,
+        timeoutMs: options.dashboardTimeoutMs
+      });
+      void options.logger?.info("hermes_version_dashboard_fallback_succeeded", {
+        dashboard_status_url: dashboardStatusUrl,
+        hermes_version: fallback.version
+      });
+      return fallback;
+    } catch (dashboardError) {
+      void options.logger?.warn("hermes_version_dashboard_fallback_failed", {
+        dashboard_status_url: dashboardStatusUrl,
+        error: dashboardError instanceof Error ? dashboardError.message : String(dashboardError)
+      });
+      throw new Error(
+        `Hermes version detection failed. CLI: ${cliError instanceof Error ? cliError.message : String(cliError)}; dashboard fallback: ${dashboardError instanceof Error ? dashboardError.message : String(dashboardError)}`
+      );
+    }
+  }
+}
 function describeVersionCommandFailure(hermesBin, args, error) {
   const message = error instanceof Error ? error.message : String(error);
-  const output = truncateVersionLogOutput(readExecErrorOutput2(error));
+  const details = readExecErrorDetails(error, message);
   return {
     summary: `${hermesBin} ${args.join(" ")} failed: ${message}`,
     fields: {
       hermes_bin: hermesBin,
       command: args.join(" "),
+      cwd: process.cwd(),
       error: message,
-      ...output ? { output } : {}
+      ...details
     }
   };
 }
-function readExecErrorOutput2(error) {
+function readExecErrorDetails(error, message) {
   if (typeof error !== "object" || error === null) {
-    return "";
+    return message.includes("timed out") ? { timed_out: true } : {};
   }
+  const details = {};
   const stdout = "stdout" in error && error.stdout != null ? String(error.stdout) : "";
   const stderr = "stderr" in error && error.stderr != null ? String(error.stderr) : "";
-  return `${stdout}
-${stderr}`.trim();
+  if ("code" in error) {
+    const code = error.code;
+    if (typeof code === "number") {
+      details.exit_code = code;
+    } else if (typeof code === "string" && code.trim()) {
+      details.error_code = code;
+    }
+  }
+  if ("signal" in error && typeof error.signal === "string") {
+    details.signal = error.signal;
+  }
+  if ("killed" in error && typeof error.killed === "boolean") {
+    details.killed = error.killed;
+  }
+  if (message.includes("timed out")) {
+    details.timed_out = true;
+  }
+  if (stdout.trim()) {
+    details.stdout = truncateVersionLogOutput(stdout.trim());
+  }
+  if (stderr.trim()) {
+    details.stderr = truncateVersionLogOutput(stderr.trim());
+  }
+  return details;
 }
 function truncateVersionLogOutput(value) {
   return value.length > MAX_VERSION_LOG_OUTPUT_LENGTH ? `${value.slice(0, MAX_VERSION_LOG_OUTPUT_LENGTH)}...` : value;
@@ -7244,22 +7339,31 @@ var defaultLinkConfig = {
   relayBaseUrl: "https://hermes-relay.clawpilot.me",
   appConnectTokenIssuer: "https://hermes-server.clawpilot.me",
   appConnectTokenAudience: "hermes-link",
-  language: "auto"
+  language: "auto",
+  logLevel: "warn"
 };
 async function loadConfig(paths = resolveRuntimePaths()) {
   const existing = await readJsonFile(paths.configFile);
   const language = normalizeConfiguredLanguage(existing?.language);
   const lanHost = normalizeLanHost(existing?.lanHost);
+  const logLevel = normalizeLogLevel(
+    existing?.logLevel ?? process.env.HERMESLINK_LOG_LEVEL
+  );
   return {
     ...defaultLinkConfig,
     ...existing ?? {},
     language,
-    lanHost
+    lanHost,
+    logLevel
   };
 }
 async function saveConfig(patch, paths = resolveRuntimePaths()) {
   const current = await loadConfig(paths);
-  const next = { ...current, ...patch };
+  const next = {
+    ...current,
+    ...patch,
+    logLevel: patch.logLevel === void 0 ? current.logLevel : normalizeLogLevel(patch.logLevel)
+  };
   await writeJsonFile(paths.configFile, next);
   return next;
 }
@@ -7269,6 +7373,18 @@ function normalizeConfiguredLanguage(language) {
   }
   return defaultLinkConfig.language;
 }
+function normalizeLogLevel(level) {
+  if (level === "debug" || level === "info" || level === "warn" || level === "error") {
+    return level;
+  }
+  return defaultLinkConfig.logLevel;
+}
+function parseLogLevel(value) {
+  if (value === "debug" || value === "info" || value === "warn" || value === "error") {
+    return value;
+  }
+  return null;
+}
 function normalizeLanHost(value) {
   if (value === null || value === void 0) {
     return null;
@@ -8037,13 +8153,23 @@ var ConversationOrchestrationCoordinator = class {
     return this.appendCommandResultLocked(input);
   }
   startRunWorkerAndDrain(conversationId, runId, input) {
-    void this.deps.runLifecycle.startRunWorker(conversationId, runId, input).catch(
-      (error) => this.deps.runLifecycle.failRun(
-        conversationId,
-        runId,
-        error instanceof Error ? error.message : String(error)
-      )
-    ).finally(() => {
+    void this.deps.runLifecycle.startRunWorker(conversationId, runId, input).catch(async (error) => {
+      if (isConversationNotFoundError(error)) {
+        return;
+      }
+      try {
+        await this.deps.runLifecycle.failRun(
+          conversationId,
+          runId,
+          error instanceof Error ? error.message : String(error)
+        );
+      } catch (failError) {
+        if (isConversationNotFoundError(failError)) {
+          return;
+        }
+        throw failError;
+      }
+    }).finally(() => {
       void this.startNextQueuedRun(conversationId);
     });
   }
@@ -8575,6 +8701,9 @@ var ConversationOrchestrationCoordinator = class {
 ${attachmentLines.join("\n")}`;
   }
 };
+function isConversationNotFoundError(error) {
+  return error instanceof LinkHttpError && error.code === "conversation_not_found";
+}
 
 // src/conversations/agent-events.ts
 import { createHash as createHash3 } from "crypto";
@@ -11483,16 +11612,32 @@ async function callHermesApi(path26, init, options) {
   try {
     response = await request();
   } catch (error) {
-    logHermesApiError(options.logger, method, path26, startedAt, error);
+    logHermesApiError(
+      options.logger,
+      method,
+      path26,
+      options.profileName,
+      startedAt,
+      error
+    );
     throw error;
   }
   if (response.status !== 401) {
-    logHermesApiResponse(options.logger, method, path26, startedAt, response);
+    logHermesApiResponse(
+      options.logger,
+      method,
+      path26,
+      options.profileName,
+      startedAt,
+      response
+    );
     return response;
   }
   void options.logger?.warn("hermes_api_request_retrying_after_401", {
     method,
     path: path26,
+    profile: options.profileName ?? "default",
+    port: config.port ?? null,
     duration_ms: Date.now() - startedAt
   });
   const refreshedAvailability = await ensureHermesApiServerAvailable({
@@ -11505,10 +11650,24 @@ async function callHermesApi(path26, init, options) {
   try {
     response = await request();
   } catch (error) {
-    logHermesApiError(options.logger, method, path26, startedAt, error);
+    logHermesApiError(
+      options.logger,
+      method,
+      path26,
+      options.profileName,
+      startedAt,
+      error
+    );
     throw error;
   }
-  logHermesApiResponse(options.logger, method, path26, startedAt, response);
+  logHermesApiResponse(
+    options.logger,
+    method,
+    path26,
+    options.profileName,
+    startedAt,
+    response
+  );
   return response;
 }
 async function fetchHermesApi(fetcher, config, path26, init, options) {
@@ -11526,8 +11685,11 @@ async function fetchHermesApi(fetcher, config, path26, init, options) {
       throw error;
     }
     void options.logger?.warn("hermes_api_server_connect_failed", {
+      method: String(init.method ?? "GET").toUpperCase(),
       path: path26,
+      profile: options.profileName ?? "default",
       port: config.port ?? null,
+      url: `http://127.0.0.1:${config.port}${path26}`,
       error: error instanceof Error ? error.message : String(error)
     });
     throw new LinkHttpError(
@@ -11537,10 +11699,11 @@ async function fetchHermesApi(fetcher, config, path26, init, options) {
     );
   });
 }
-function logHermesApiResponse(logger, method, path26, startedAt, response) {
+function logHermesApiResponse(logger, method, path26, profileName, startedAt, response) {
   const fields = {
     method,
     path: path26,
+    profile: profileName ?? "default",
     status: response.status,
     duration_ms: Date.now() - startedAt
   };
@@ -11560,10 +11723,11 @@ async function logHermesApiFailureResponse(logger, fields, response) {
     ...upstreamError ? { upstream_error: upstreamError } : {}
   });
 }
-function logHermesApiError(logger, method, path26, startedAt, error) {
+function logHermesApiError(logger, method, path26, profileName, startedAt, error) {
   void logger?.warn("hermes_api_request_failed", {
     method,
     path: path26,
+    profile: profileName ?? "default",
     duration_ms: Date.now() - startedAt,
     ...error instanceof LinkHttpError ? { status: error.status, code: error.code } : {},
     error: error instanceof Error ? error.message : String(error)
@@ -15748,6 +15912,7 @@ function createHttpErrorMiddleware(logger) {
         {
           method: ctx.method,
           path: ctx.path,
+          query: ctx.querystring || null,
           status,
           code,
           error: error instanceof Error ? error.message : String(error)
@@ -20254,6 +20419,9 @@ function subscribeHermesUpdateStatus(listener) {
   return () => updateEvents.off("status", listener);
 }
 async function readRemoteRelease(options, now) {
+  const context = await readHermesReleaseCheckContext(options.paths).catch(
+    () => null
+  );
   const cached = await readReleaseCache(options.paths);
   const cacheFresh = cached ? now().getTime() - Date.parse(cached.fetched_at) < RELEASE_CACHE_TTL_MS : false;
   if (!options.refreshRemote || cacheFresh) {
@@ -20267,6 +20435,8 @@ async function readRemoteRelease(options, now) {
     const snapshot = normalizeServerReleaseSnapshot(await response.json());
     if (snapshot.issue) {
       void options.logger?.warn("hermes_release_server_cache_issue", {
+        server_base_url: context?.serverBaseUrl ?? null,
+        release_check_url: context?.releaseCheckUrl ?? null,
         error: snapshot.issue
       });
     }
@@ -20296,6 +20466,10 @@ async function readRemoteRelease(options, now) {
   } catch (error) {
     const issue = error instanceof Error ? error.message : String(error);
     void options.logger?.warn("hermes_release_server_check_failed", {
+      server_base_url: context?.serverBaseUrl ?? null,
+      release_check_url: context?.releaseCheckUrl ?? null,
+      cached: cached !== null,
+      cache_fresh: cacheFresh,
       error: issue
     });
     return cached ? { remote: fromCache(cached), state: "cached", issue } : { remote: null, state: "unavailable", issue };
@@ -20419,6 +20593,14 @@ async function fetchLatestReleaseFromServer(options, fetcher) {
     clearTimeout(timer);
   }
 }
+async function readHermesReleaseCheckContext(paths) {
+  const config = await loadConfig(paths);
+  const url = new URL(SERVER_HERMES_RELEASES_LATEST_PATH, config.serverBaseUrl);
+  return {
+    serverBaseUrl: config.serverBaseUrl,
+    releaseCheckUrl: url.toString()
+  };
+}
 function isProcessAlive2(pid) {
   if (!pid || pid <= 0) {
     return false;
@@ -21239,11 +21421,7 @@ async function checkLanIpChange(options, context = {}) {
       public_ipv6s: routes.publicIpv6s,
       reason: reservation.reason
     };
-    if (reservation.reason === "daily_limit_reached") {
-      void options.logger.warn("lan_ip_report_skipped", logFields);
-    } else {
-      void options.logger.debug("lan_ip_report_skipped", logFields);
-    }
+    void options.logger.debug("lan_ip_report_skipped", logFields);
     return;
   }
   try {
@@ -21286,6 +21464,7 @@ function startCronDeliveryScheduler(options) {
       );
     } catch (error) {
       void options.logger.warn("cron_link_delivery_sync_failed", {
+        source: "daemon_scheduler",
         error: error instanceof Error ? error.message : String(error)
       });
     } finally {
@@ -21315,6 +21494,7 @@ function startHermesSessionSyncScheduler(options) {
       await options.conversations.syncHermesSessions();
     } catch (error) {
       void options.logger.warn("hermes_session_sync_failed", {
+        source: "daemon_scheduler",
         error: error instanceof Error ? error.message : String(error)
       });
     } finally {
@@ -21337,8 +21517,8 @@ function startHermesSessionSyncScheduler(options) {
 var DEFAULT_RELAY_READY_TIMEOUT_MS = 2e3;
 async function startLinkService(options = {}) {
   const paths = options.paths ?? resolveRuntimePaths();
-  const logger = createFileLogger({ paths });
   const [identity, config] = await Promise.all([loadIdentity(paths), loadConfig(paths)]);
+  const logger = createFileLogger({ paths, minLevel: config.logLevel });
   await logger.info("service_starting", {
     port: config.port,
     mode: identity?.link_id ? "paired" : "local-only"
@@ -21357,6 +21537,7 @@ async function startLinkService(options = {}) {
   const triggerHermesSessionSync = () => {
     hermesSessionSync = Promise.resolve().then(() => conversations.syncHermesSessions()).then(() => void 0).catch((error) => {
       void logger.warn("hermes_session_sync_failed", {
+        source: "service_startup",
         error: error instanceof Error ? error.message : String(error)
       });
     });
@@ -21376,13 +21557,18 @@ async function startLinkService(options = {}) {
   } catch (error) {
     await logger.error("service_start_failed", {
       port: config.port,
+      link_id: identity?.link_id ?? null,
       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.error("service_error", {
+      port: config.port,
+      link_id: identity?.link_id ?? null,
+      error: error.message
+    });
   });
   void logger.info("service_started", {
     port: config.port,
@@ -21998,6 +22184,9 @@ async function writeFailedStartState(options, error, targetVersion = null) {
   return readLinkUpdateStatus(options.paths);
 }
 async function readRemoteLinkPolicy(options) {
+  const context = await readLinkReleaseCheckContext(options.paths).catch(
+    () => null
+  );
   try {
     const response = await fetchCurrentLinkReleaseFromServer(
       options,
@@ -22022,6 +22211,8 @@ async function readRemoteLinkPolicy(options) {
   } catch (error) {
     const issue = error instanceof Error ? error.message : String(error);
     void options.logger?.warn("link_release_server_check_failed", {
+      server_base_url: context?.serverBaseUrl ?? null,
+      release_check_url: context?.releaseCheckUrl ?? null,
       error: issue
     });
     return { remote: null, state: "unavailable", issue };
@@ -22080,6 +22271,16 @@ async function fetchCurrentLinkReleaseFromServer(options, fetcher) {
     clearTimeout(timer);
   }
 }
+async function readLinkReleaseCheckContext(paths) {
+  const config = await loadConfig(paths);
+  const url = new URL(SERVER_LINK_CURRENT_RELEASE_PATH, config.serverBaseUrl);
+  url.searchParams.set("channel", "stable");
+  url.searchParams.set("lang", "en");
+  return {
+    serverBaseUrl: config.serverBaseUrl,
+    releaseCheckUrl: url.toString()
+  };
+}
 function computeLinkUpdateState(localVersion, remote) {
   if (!remote?.current_version) {
     return "unknown";
@@ -22879,7 +23080,7 @@ function registerSystemRoutes(router, options) {
       })),
       readDeviceSummary(paths),
       listHermesProfiles(paths).catch(() => []),
-      readHermesUpdateCheck({ paths, logger, refreshRemote: true }).catch(
+      readHermesUpdateCheck({ paths, logger }).catch(
         (error) => ({
           ok: true,
           local: {
@@ -23744,7 +23945,8 @@ function assertLoopbackRequest(request) {
 // src/http/app.ts
 async function createApp(options = {}) {
   const paths = options.paths ?? resolveRuntimePaths();
-  const logger = options.logger ?? createFileLogger({ paths });
+  const config = await loadConfig(paths).catch(() => null);
+  const logger = options.logger ?? createFileLogger({ paths, minLevel: config?.logLevel ?? "warn" });
   const conversations = options.conversations ?? new ConversationService(paths, logger);
   let cronDeliverySyncRunning = false;
   const syncCronDeliveries = async () => {
@@ -23756,6 +23958,7 @@ async function createApp(options = {}) {
       await syncHermesLinkCronDeliveries(paths, conversations, logger);
     } catch (error) {
       void logger.warn("cron_link_delivery_sync_failed", {
+        source: "http_app_bootstrap",
         error: error instanceof Error ? error.message : String(error)
       });
     } finally {
@@ -23794,18 +23997,20 @@ async function createApp(options = {}) {
 export {
   LINK_VERSION,
   LINK_COMMAND,
+  LinkHttpError,
   resolveHermesProfileDir,
   resolveHermesConfigPath,
   readHermesApiServerConfig,
   ensureHermesApiServerConfig,
-  LinkHttpError,
   resolveRuntimePaths,
   createFileLogger,
   getLinkLogFile,
   ensureHermesApiServerAvailable,
   readHermesVersion,
+  defaultLinkConfig,
   loadConfig,
   saveConfig,
+  parseLogLevel,
   normalizeLanHost,
   ConversationService,
   loadIdentity,

package/dist/cli/index.d.ts

@@ -2,5 +2,6 @@
 import { R as RuntimePaths } from '../paths-CmAiZsna.js';
 
 declare function waitForPairingOrShutdown(sessionId: string, expiresAt: string, paths: RuntimePaths): Promise<'claimed' | 'expired' | 'shutdown'>;
+declare function isCliEntrypoint(entry?: string, moduleUrl?: string): boolean;
 
-export { waitForPairingOrShutdown };
+export { isCliEntrypoint, waitForPairingOrShutdown };

package/dist/cli/index.js

@@ -9,6 +9,7 @@ import {
   createFileLogger,
   currentCliScriptPath,
   daemonLogFile,
+  defaultLinkConfig,
   detectRuntimeEnvironment,
   ensureHermesApiServerAvailable,
   ensureHermesApiServerConfig,
@@ -20,6 +21,7 @@ import {
   loadConfig,
   loadIdentity,
   normalizeLanHost,
+  parseLogLevel,
   preparePairing,
   probeLocalLinkService,
   readHermesApiServerConfig,
@@ -34,12 +36,14 @@ import {
   startDaemonProcess,
   startLinkService,
   stopDaemonProcess
-} from "../chunk-476X63MC.js";
+} from "../chunk-MFRSQUSE.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
+import { realpathSync } from "fs";
 import path3 from "path";
 import { createInterface } from "readline/promises";
+import { pathToFileURL } from "url";
 import qrcode from "qrcode-terminal";
 
 // src/autostart/autostart.ts
@@ -257,6 +261,9 @@ var messages = {
     "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.logLevelInvalid": "log-level must be one of: debug, info, warn, error.",
+    "config.logLevelSet": "Configured log level: {value}",
+    "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",
@@ -352,6 +359,9 @@ var messages = {
     "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.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.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",
@@ -736,16 +746,28 @@ configCommand.command("set").argument("<key>").argument("<value>").description(h
   const language = resolveLanguage(current.language);
   const t = translate.bind(null, language);
   const normalizedKey = key.trim().toLowerCase();
-  if (normalizedKey !== "lan-host") {
-    throw new Error(t("config.unknownKey", { key }));
+  if (normalizedKey === "lan-host") {
+    const lanHost = normalizeLanHost(value);
+    if (!lanHost) {
+      throw new Error(t("config.lanHostInvalid"));
+    }
+    const next = await saveConfig({ lanHost }, paths);
+    console.log(t("config.lanHostSet", { value: next.lanHost ?? lanHost }));
+    await reportConfigNetworkUpdate(paths, t);
+    return;
   }
-  const lanHost = normalizeLanHost(value);
-  if (!lanHost) {
-    throw new Error(t("config.lanHostInvalid"));
+  if (normalizedKey === "log-level") {
+    const logLevel = parseLogLevel(value.trim().toLowerCase());
+    if (!logLevel) {
+      throw new Error(t("config.logLevelInvalid"));
+    }
+    const next = await saveConfig({ logLevel }, paths);
+    console.log(t("config.logLevelSet", { value: next.logLevel }));
+    return;
+  }
+  {
+    throw new Error(t("config.unknownKey", { key }));
   }
-  const next = await saveConfig({ lanHost }, paths);
-  console.log(t("config.lanHostSet", { value: next.lanHost ?? lanHost }));
-  await reportConfigNetworkUpdate(paths, t);
 });
 configCommand.command("unset").argument("<key>").description(helpText("config.unset.description")).action(async (key) => {
   const paths = resolveRuntimePaths();
@@ -753,12 +775,22 @@ configCommand.command("unset").argument("<key>").description(helpText("config.un
   const language = resolveLanguage(current.language);
   const t = translate.bind(null, language);
   const normalizedKey = key.trim().toLowerCase();
-  if (normalizedKey !== "lan-host") {
+  if (normalizedKey === "lan-host") {
+    await saveConfig({ lanHost: null }, paths);
+    console.log(t("config.lanHostUnset"));
+    await reportConfigNetworkUpdate(paths, t);
+    return;
+  }
+  if (normalizedKey === "log-level") {
+    await saveConfig({ logLevel: defaultLinkConfig.logLevel }, paths);
+    console.log(
+      t("config.logLevelUnset", { value: defaultLinkConfig.logLevel })
+    );
+    return;
+  }
+  {
     throw new Error(t("config.unknownKey", { key }));
   }
-  await saveConfig({ lanHost: null }, paths);
-  console.log(t("config.lanHostUnset"));
-  await reportConfigNetworkUpdate(paths, t);
 });
 program.command("start").description(helpText("start.description")).action(async () => {
   const [config, status] = await Promise.all([loadConfig(), getDaemonStatus()]);
@@ -1031,7 +1063,7 @@ async function deliverStagedFilesFromCli(stagingDir, paths, config) {
       throw error;
     }
   }
-  const logger = createFileLogger({ paths });
+  const logger = createFileLogger({ paths, minLevel: config.logLevel });
   try {
     const conversations = new ConversationService(paths, logger);
     return await conversations.deliverStagedFiles(stagingDir);
@@ -1156,10 +1188,17 @@ function printPostPairingNetworkNotice(environment, config, t) {
   console.log(t("pair.relayOnlyLanHostHint"));
   console.log(t("pair.relayOnlySafetyHint"));
 }
-function isCliEntrypoint() {
-  const entry = process.argv[1];
-  return Boolean(entry && import.meta.url === new URL(`file://${path3.resolve(entry)}`).href);
+function isCliEntrypoint(entry = process.argv[1], moduleUrl = import.meta.url) {
+  if (!entry) {
+    return false;
+  }
+  try {
+    return moduleUrl === pathToFileURL(realpathSync(path3.resolve(entry))).href;
+  } catch {
+    return moduleUrl === pathToFileURL(path3.resolve(entry)).href;
+  }
 }
 export {
+  isCliEntrypoint,
   waitForPairingOrShutdown
 };

package/dist/http/app.d.ts

@@ -310,6 +310,7 @@ interface FileLoggerOptions {
     fileName?: string;
     maxFileBytes?: number;
     maxFiles?: number;
+    minLevel?: LogLevel;
     now?: () => Date;
 }
 declare class FileLogger {
@@ -317,6 +318,7 @@ declare class FileLogger {
     private readonly paths;
     private readonly maxFileBytes;
     private readonly maxFiles;
+    private readonly minLevel;
     private readonly now;
     private queue;
     constructor(options?: FileLoggerOptions);

package/dist/http/app.js

@@ -1,6 +1,6 @@
 import {
   createApp
-} from "../chunk-476X63MC.js";
+} from "../chunk-MFRSQUSE.js";
 export {
   createApp
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hermespilot/link",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "private": false,
   "description": "Hermes Link companion service and CLI for connecting hermes-agent through HermesPilot",
   "license": "MIT",