@hermespilot/link 0.4.3 → 0.4.5

package/dist/{chunk-MFRSQUSE.js → chunk-UANE2YHT.js}

@@ -3602,17 +3602,6 @@ function isEnvValueConfigured(value) {
 }
 async function readHermesApiServerEnvOverrides(profileName) {
   const values = await readHermesEnvFile(profileName);
-  for (const key of [
-    "API_SERVER_ENABLED",
-    "API_SERVER_HOST",
-    "API_SERVER_PORT",
-    "API_SERVER_KEY"
-  ]) {
-    const value = process.env[key];
-    if (typeof value === "string" && value.trim()) {
-      values[key] = value;
-    }
-  }
   const port = Number.parseInt(values.API_SERVER_PORT ?? "", 10);
   return {
     enabled: parseEnvBoolean(values.API_SERVER_ENABLED),
@@ -3996,7 +3985,7 @@ import os2 from "os";
 import path5 from "path";
 
 // src/constants.ts
-var LINK_VERSION = "0.4.3";
+var LINK_VERSION = "0.4.5";
 var LINK_COMMAND = "hermeslink";
 var LINK_DEFAULT_PORT = 52379;
 var LINK_RUNTIME_DIR_NAME = ".hermeslink";
@@ -4496,6 +4485,7 @@ 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 HERMES_GATEWAY_ENV_BLOCKLIST_PREFIXES = ["API_SERVER_"];
 var gatewayStartInFlightByProfile = /* @__PURE__ */ new Map();
 var hermesVersionCache = /* @__PURE__ */ new Map();
 var hermesVersionInFlight = /* @__PURE__ */ new Map();
@@ -4720,7 +4710,7 @@ async function startHermesGateway(paths, profileName, logger) {
   try {
     const child = spawn(resolveHermesBin(), gatewayRunArgs(profileName), {
       detached: true,
-      env: process.env,
+      env: buildHermesGatewayChildEnv(),
       stdio: ["ignore", "pipe", "pipe"],
       windowsHide: true
     });
@@ -4786,6 +4776,7 @@ async function restartHermesGatewayServiceIfAvailable(options) {
   }
   try {
     await execFileAsync2(resolveHermesBin(), ["gateway", "restart"], {
+      env: buildHermesGatewayChildEnv(),
       timeout: options.timeoutMs ?? DEFAULT_START_TIMEOUT_MS,
       windowsHide: true
     });
@@ -4840,6 +4831,17 @@ function gatewayRunArgs(profileName) {
 function formatHermesGatewayRunCommand(profileName) {
   return `${resolveHermesBin()} ${gatewayRunArgs(profileName).join(" ")}`;
 }
+function buildHermesGatewayChildEnv() {
+  const env = { ...process.env };
+  for (const key of Object.keys(env)) {
+    if (HERMES_GATEWAY_ENV_BLOCKLIST_PREFIXES.some(
+      (prefix) => key.startsWith(prefix)
+    )) {
+      delete env[key];
+    }
+  }
+  return env;
+}
 async function fileExists(filePath) {
   return access(filePath).then(() => true).catch(() => false);
 }
@@ -4875,6 +4877,10 @@ async function readHermesApiServerHealth(config, fetcher = fetch) {
     }
     const issue = describeDetailedHealthIssue(record);
     const terminal = isTerminalDetailedHealth(record);
+    const authIssue = issue ? null : await probeHermesApiServerAuth(resolvedConfig, fetcher);
+    if (authIssue) {
+      return authIssue;
+    }
     return {
       healthy: !issue,
       terminal,
@@ -4911,20 +4917,9 @@ async function readHermesApiServerHealth(config, fetcher = fetch) {
       };
     }
     if (resolvedConfig.key) {
-      const authProbe = await fetchWithTimeout(
-        `http://127.0.0.1:${resolvedConfig.port}/v1/models`,
-        {
-          method: "GET",
-          headers: authHeaders(resolvedConfig)
-        },
-        fetcher
-      );
-      if (authProbe?.status === 401) {
-        return {
-          healthy: false,
-          authInvalid: true,
-          issue: "Hermes API Server \u8FD4\u56DE 401\uFF0C\u5F53\u524D\u7AEF\u53E3\u53EF\u80FD\u5C5E\u4E8E\u53E6\u4E00\u4E2A Profile\uFF0C\u6216 API Server key \u5DF2\u53D8\u66F4\u3002"
-        };
+      const authIssue = await probeHermesApiServerAuth(resolvedConfig, fetcher);
+      if (authIssue) {
+        return authIssue;
       }
     }
     return { healthy: true };
@@ -4941,6 +4936,39 @@ async function readHermesApiServerHealth(config, fetcher = fetch) {
     issue: describePortHealthFailure(resolvedConfig.port)
   };
 }
+async function probeHermesApiServerAuth(config, fetcher) {
+  if (!config.key) {
+    return null;
+  }
+  const response = await fetchWithTimeout(
+    `http://127.0.0.1:${config.port}/v1/models`,
+    {
+      method: "GET",
+      headers: authHeaders(config)
+    },
+    fetcher
+  );
+  if (!response) {
+    return {
+      healthy: false,
+      issue: "Hermes API Server \u9274\u6743\u63A2\u6D4B\u65E0\u54CD\u5E94\uFF1A/v1/models \u6CA1\u6709\u5728\u8D85\u65F6\u65F6\u95F4\u5185\u8FD4\u56DE\u3002"
+    };
+  }
+  if (response?.status === 401) {
+    return {
+      healthy: false,
+      authInvalid: true,
+      issue: "Hermes API Server \u8FD4\u56DE 401\uFF0C\u5F53\u524D\u7AEF\u53E3\u53EF\u80FD\u5C5E\u4E8E\u53E6\u4E00\u4E2A Profile\uFF0C\u6216 API Server key \u5DF2\u53D8\u66F4\u3002"
+    };
+  }
+  if (response && !response.ok) {
+    return {
+      healthy: false,
+      issue: `Hermes API Server \u9274\u6743\u63A2\u6D4B\u5931\u8D25\uFF1A/v1/models \u8FD4\u56DE HTTP ${response.status}\u3002`
+    };
+  }
+  return null;
+}
 function fetchWithTimeout(input, init, fetcher) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), HEALTH_TIMEOUT_MS);
@@ -8979,24 +9007,15 @@ var ConversationQueryCoordinator = class {
   async listConversationPage(options = {}) {
     const limit = normalizeConversationListPageLimit(options.limit);
     const cursor = decodeConversationListCursor(options.cursor);
-    const indexedPage = await listConversationStatsPage(this.deps.paths, {
+    return this.listIndexedConversationPage({
       limit,
-      cursor
-    });
-    if (indexedPage.records.length === 0) {
-      return this.listConversationPageFromStore({ limit, cursor });
-    }
-    const summaries = await this.summarizeIndexedConversations(
-      indexedPage.records
-    );
-    return {
-      conversations: summaries,
-      page: {
+      cursor,
+      fallback: () => this.listConversationPageFromStore({ limit, cursor }),
+      listPage: (pageCursor) => listConversationStatsPage(this.deps.paths, {
         limit,
-        has_more: indexedPage.hasMore,
-        next_cursor: indexedPage.hasMore && indexedPage.records.length > 0 ? encodeConversationListCursor(indexedPage.records.at(-1)) : null
-      }
-    };
+        cursor: pageCursor
+      })
+    });
   }
   async searchConversationPage(options = {}) {
     const query = normalizeConversationSearchQuery(options.query);
@@ -9005,20 +9024,72 @@ var ConversationQueryCoordinator = class {
     }
     const limit = normalizeConversationListPageLimit(options.limit);
     const cursor = decodeConversationListCursor(options.cursor);
-    const indexedPage = await searchConversationStatsPage(this.deps.paths, {
+    return this.listIndexedConversationPage({
       limit,
       cursor,
-      query
+      listPage: (pageCursor) => searchConversationStatsPage(this.deps.paths, {
+        limit,
+        cursor: pageCursor,
+        query
+      })
     });
-    const summaries = await this.summarizeIndexedConversations(
-      indexedPage.records
-    );
+  }
+  async listIndexedConversationPage(input) {
+    const collected = [];
+    const seenConversationIds = /* @__PURE__ */ new Set();
+    let scanCursor = input.cursor;
+    let usedIndex = false;
+    while (collected.length <= input.limit) {
+      const indexedPage = await input.listPage(scanCursor);
+      if (indexedPage.records.length === 0) {
+        if (!usedIndex && input.fallback) {
+          return input.fallback();
+        }
+        return this.buildConversationListPage({
+          limit: input.limit,
+          conversations: collected,
+          hasMore: false
+        });
+      }
+      usedIndex = true;
+      const summaries = await this.summarizeIndexedConversations(
+        indexedPage.records
+      );
+      for (const summary of summaries) {
+        if (!seenConversationIds.add(summary.id)) {
+          continue;
+        }
+        collected.push(summary);
+        if (collected.length > input.limit) {
+          break;
+        }
+      }
+      if (collected.length > input.limit) {
+        break;
+      }
+      if (!indexedPage.hasMore) {
+        return this.buildConversationListPage({
+          limit: input.limit,
+          conversations: collected,
+          hasMore: false
+        });
+      }
+      scanCursor = conversationListCursorFromRecord(indexedPage.records.at(-1));
+    }
+    return this.buildConversationListPage({
+      limit: input.limit,
+      conversations: collected,
+      hasMore: true
+    });
+  }
+  buildConversationListPage(input) {
+    const conversations = input.conversations.slice(0, input.limit);
     return {
-      conversations: summaries,
+      conversations,
       page: {
-        limit,
-        has_more: indexedPage.hasMore,
-        next_cursor: indexedPage.hasMore && indexedPage.records.length > 0 ? encodeConversationListCursor(indexedPage.records.at(-1)) : null
+        limit: input.limit,
+        has_more: input.hasMore,
+        next_cursor: input.hasMore && conversations.length > 0 ? encodeConversationListCursorFromSummary(conversations.at(-1)) : null
       }
     };
   }
@@ -9177,6 +9248,12 @@ function encodeConversationListCursor(record) {
     "utf8"
   ).toString("base64url");
 }
+function conversationListCursorFromRecord(record) {
+  return {
+    updatedAt: record.updatedAt,
+    conversationId: record.conversationId
+  };
+}
 function encodeConversationListCursorFromSummary(summary) {
   return encodeConversationListCursor({
     conversationId: summary.id,
@@ -15305,6 +15382,24 @@ function readHeader(ctx, name) {
   const value = ctx.get(name).trim();
   return value ? value : null;
 }
+function readUploadFilenameHeader(ctx) {
+  const encoded = readHeader(ctx, "x-filename-base64") ?? readHeader(ctx, "x-filename-b64");
+  if (encoded) {
+    const decoded = decodeBase64Utf8Header(encoded);
+    if (decoded) {
+      return decoded;
+    }
+  }
+  return readHeader(ctx, "x-filename");
+}
+function decodeBase64Utf8Header(value) {
+  const trimmed = value.trim();
+  if (!trimmed || !/^[A-Za-z0-9+/]+={0,2}$/u.test(trimmed)) {
+    return null;
+  }
+  const decoded = Buffer.from(trimmed, "base64").toString("utf8").trim();
+  return decoded || null;
+}
 var CONVERSATION_HISTORY_REPLAY_FIELDS = [
   "tool_call_id",
   "tool_calls",
@@ -15797,7 +15892,7 @@ function registerConversationRoutes(router, options) {
     }
     const blob = await conversations.writeBlob(ctx.params.conversationId, {
       bytes,
-      filename: readHeader(ctx, "x-filename") ?? void 0,
+      filename: readUploadFilenameHeader(ctx) ?? void 0,
       mime: ctx.get("content-type") || void 0
     });
     ctx.status = 201;
@@ -20641,6 +20736,8 @@ import { mkdir as mkdir12, rm as rm9, writeFile as writeFile3 } from "fs/promise
 
 // src/relay/control-client.ts
 import WebSocket from "ws";
+var RELAY_SSE_BATCH_FLUSH_INTERVAL_MS = 50;
+var RELAY_SSE_BATCH_FLUSH_BYTES = 2 * 1024;
 function connectRelayControl(options) {
   const wsUrl = new URL(`${options.relayBaseUrl.replace(/\/+$/u, "")}/api/v1/relay/link/connect`);
   wsUrl.protocol = wsUrl.protocol === "https:" ? "wss:" : "ws:";
@@ -20776,6 +20873,7 @@ async function handleFrame(socket, raw, localPort, abortControllers) {
   }
   const abortController = new AbortController();
   abortControllers.set(frame.id, abortController);
+  let sseBatcher = null;
   try {
     const response = await fetch(`http://127.0.0.1:${localPort}${frame.path}`, {
       method: frame.method,
@@ -20787,26 +20885,92 @@ async function handleFrame(socket, raw, localPort, abortControllers) {
     const contentType = response.headers.get("content-type") ?? "";
     if (response.body && contentType.includes("text/event-stream")) {
       socket.send(JSON.stringify({ type: "http.stream.start", id: frame.id, status: response.status, headers }));
+      sseBatcher = createRelayStreamChunkBatcher(socket, frame.id);
       const reader = response.body.getReader();
       while (true) {
         const next = await reader.read();
         if (next.done) {
           break;
         }
-        socket.send(JSON.stringify({ type: "http.stream.chunk", id: frame.id, bodyBase64: Buffer.from(next.value).toString("base64") }));
+        sseBatcher.push(next.value);
       }
+      sseBatcher.flush();
       socket.send(JSON.stringify({ type: "http.stream.end", id: frame.id }));
       return;
     }
     const body = Buffer.from(await response.arrayBuffer()).toString("base64");
     socket.send(JSON.stringify({ type: "http.response", id: frame.id, status: response.status, headers, bodyBase64: body }));
   } catch (error) {
+    if (abortController.signal.aborted || isAbortError2(error)) {
+      return;
+    }
+    sseBatcher?.flush();
     const message = error instanceof Error ? error.message : "Relay request failed";
     socket.send(JSON.stringify({ type: "http.error", id: frame.id, status: 502, message }));
   } finally {
+    sseBatcher?.dispose();
     abortControllers.delete(frame.id);
   }
 }
+function isAbortError2(error) {
+  return typeof error === "object" && error !== null && "name" in error && error.name === "AbortError";
+}
+function createRelayStreamChunkBatcher(socket, id) {
+  let chunks = [];
+  let totalBytes = 0;
+  let flushTimer = null;
+  const clearFlushTimer = () => {
+    if (flushTimer == null) {
+      return;
+    }
+    clearTimeout(flushTimer);
+    flushTimer = null;
+  };
+  const flush = () => {
+    clearFlushTimer();
+    if (totalBytes <= 0) {
+      return;
+    }
+    const bodyBase64 = Buffer.concat(chunks, totalBytes).toString("base64");
+    chunks = [];
+    totalBytes = 0;
+    if (socket.readyState !== WebSocket.OPEN) {
+      return;
+    }
+    socket.send(JSON.stringify({ type: "http.stream.chunk", id, bodyBase64 }));
+  };
+  const scheduleFlush = () => {
+    if (flushTimer != null) {
+      return;
+    }
+    flushTimer = setTimeout(() => {
+      flushTimer = null;
+      flush();
+    }, RELAY_SSE_BATCH_FLUSH_INTERVAL_MS);
+    flushTimer.unref?.();
+  };
+  return {
+    push(chunk) {
+      if (chunk.byteLength <= 0) {
+        return;
+      }
+      const buffer = Buffer.from(chunk);
+      chunks.push(buffer);
+      totalBytes += buffer.byteLength;
+      if (totalBytes >= RELAY_SSE_BATCH_FLUSH_BYTES) {
+        flush();
+        return;
+      }
+      scheduleFlush();
+    },
+    flush,
+    dispose() {
+      clearFlushTimer();
+      chunks = [];
+      totalBytes = 0;
+    }
+  };
+}
 
 // src/runtime/system-info.ts
 import { execFileSync } from "child_process";
@@ -20827,8 +20991,8 @@ function readLinkSystemInfo() {
 function buildDefaultDisplayName(input) {
   const hostname = normalizeText(input.hostname);
   const osLabel = normalizeText(input.osLabel);
-  if (hostname && osLabel && hostname.toLowerCase() !== osLabel.toLowerCase()) {
-    return truncateText(`${hostname} - ${osLabel}`, 128);
+  if (hostname) {
+    return truncateText(hostname, 128);
   }
   return truncateText(hostname ?? osLabel ?? `Hermes Link ${input.platform}`, 128);
 }
@@ -21126,6 +21290,10 @@ function unique(values) {
 
 // src/link/network-report-state.ts
 var DEFAULT_AUTO_DAILY_LIMIT = 20;
+async function readNetworkReportState(paths) {
+  const state = await readLinkState(paths);
+  return normalizeNetworkReportState(state.networkReport);
+}
 async function markNetworkStatusReported(paths, snapshotInput, reportedAt = /* @__PURE__ */ new Date()) {
   const snapshot = normalizeNetworkSnapshot(snapshotInput);
   await updateNetworkReportState(paths, (current) => ({
@@ -21175,6 +21343,20 @@ async function reserveAutomaticNetworkReport(paths, snapshotInput, options = {})
   });
   return reservation;
 }
+async function mergeLastReportedPublicRoutes(paths, snapshotInput) {
+  const state = await readNetworkReportState(paths);
+  return {
+    ...snapshotInput,
+    publicIpv4s: uniqueStrings([
+      ...snapshotInput.publicIpv4s,
+      ...state.lastReportedPublicIpv4s
+    ]).slice(0, 2),
+    publicIpv6s: uniqueStrings([
+      ...snapshotInput.publicIpv6s,
+      ...state.lastReportedPublicIpv6s
+    ]).slice(0, 2)
+  };
+}
 async function updateNetworkReportState(paths, update) {
   const state = await readLinkState(paths);
   const next = {
@@ -21263,6 +21445,9 @@ function sameStringList(left, right) {
   }
   return left.every((value, index) => value === right[index]);
 }
+function uniqueStrings(values) {
+  return [...new Set(values)];
+}
 function formatUtcDay(date) {
   return date.toISOString().slice(0, 10);
 }
@@ -21274,7 +21459,7 @@ async function reportLinkStatusToServer(options = {}) {
   if (!identity?.link_id) {
     return null;
   }
-  const routes = options.routes ?? await discoverRouteCandidates({
+  const discoveredRoutes = options.routes ?? await discoverRouteCandidates({
     port: config.port,
     relayBaseUrl: config.relayBaseUrl,
     linkId: identity.link_id,
@@ -21284,6 +21469,7 @@ async function reportLinkStatusToServer(options = {}) {
     configuredLanHost: config.lanHost,
     fetchImpl: options.fetchImpl
   });
+  const routes = await mergeLastReportedPublicRoutes(paths, discoveredRoutes);
   const systemInfo = readLinkSystemInfo();
   const payload = {
     type: "hermes_link_status_report",
@@ -21375,12 +21561,16 @@ function startLanIpMonitor(options) {
       running = false;
     }
   };
-  current = check({ forceReport: true, publishToRelay: true });
+  current = check({ forceReport: true, publishToRelay: true, observePublicRoute: true });
   const timer = setInterval(() => {
-    current = check();
+    current = check({ observePublicRoute: false });
   }, options.intervalMs ?? DEFAULT_INTERVAL_MS);
   timer.unref?.();
   return {
+    async refreshPublicRoutes() {
+      current = check({ forceReport: true, publishToRelay: true, observePublicRoute: true });
+      await current;
+    },
     async close() {
       closed = true;
       clearInterval(timer);
@@ -21396,16 +21586,17 @@ async function checkLanIpChange(options, context = {}) {
   if (!identity?.link_id) {
     return;
   }
-  const routes = await discoverRouteCandidates({
+  const discoveredRoutes = await discoverRouteCandidates({
     port: config.port,
     relayBaseUrl: config.relayBaseUrl,
     linkId: identity.link_id,
     installId: identity.install_id,
     publicKeyPem: identity.public_key_pem,
-    observePublicRoute: true,
+    observePublicRoute: context.observePublicRoute === true,
     configuredLanHost: config.lanHost,
     fetchImpl: options.fetchImpl
   });
+  const routes = await mergeLastReportedPublicRoutes(options.paths, discoveredRoutes);
   if (context.publishToRelay) {
     options.onNetworkRoutes?.(routes);
   }
@@ -21515,6 +21706,7 @@ function startHermesSessionSyncScheduler(options) {
 
 // src/daemon/service.ts
 var DEFAULT_RELAY_READY_TIMEOUT_MS = 2e3;
+var RELAY_RECONNECT_PUBLIC_ROUTE_REFRESH_MIN_INTERVAL_MS = 15 * 6e4;
 async function startLinkService(options = {}) {
   const paths = options.paths ?? resolveRuntimePaths();
   const [identity, config] = await Promise.all([loadIdentity(paths), loadConfig(paths)]);
@@ -21585,6 +21777,9 @@ async function startLinkService(options = {}) {
     logger
   });
   let relay = null;
+  let lanIpMonitor = null;
+  let hasSeenRelayConnected = false;
+  let lastRelayReconnectPublicRouteRefreshAt = 0;
   if (identity?.link_id) {
     let resolveRelayReady = null;
     const relayReady = new Promise((resolve) => {
@@ -21600,6 +21795,12 @@ async function startLinkService(options = {}) {
       onStatus: (status) => {
         void logger.info("relay_status", status);
         if (status.state === "connected") {
+          const now = Date.now();
+          if (hasSeenRelayConnected && lanIpMonitor && now - lastRelayReconnectPublicRouteRefreshAt >= RELAY_RECONNECT_PUBLIC_ROUTE_REFRESH_MIN_INTERVAL_MS) {
+            lastRelayReconnectPublicRouteRefreshAt = now;
+            void lanIpMonitor.refreshPublicRoutes();
+          }
+          hasSeenRelayConnected = true;
           resolveRelayReady?.(true);
           resolveRelayReady = null;
         } else if (status.state === "failed") {
@@ -21618,7 +21819,7 @@ async function startLinkService(options = {}) {
   } else {
     void logger.info("relay_skipped", { reason: "link_not_paired" });
   }
-  const lanIpMonitor = startLanIpMonitor({
+  lanIpMonitor = startLanIpMonitor({
     paths,
     logger,
     intervalMs: options.lanIpMonitorIntervalMs,
@@ -21638,7 +21839,7 @@ async function startLinkService(options = {}) {
       await Promise.all([
         scheduler.close(),
         hermesSessionSyncScheduler.close(),
-        lanIpMonitor.close(),
+        lanIpMonitor?.close(),
         hermesSessionSync.catch(() => void 0)
       ]);
       await logger.info("service_stopped");

package/dist/cli/index.js

@@ -36,7 +36,7 @@ import {
   startDaemonProcess,
   startLinkService,
   stopDaemonProcess
-} from "../chunk-MFRSQUSE.js";
+} from "../chunk-UANE2YHT.js";
 
 // src/cli/index.ts
 import { Command } from "commander";

package/dist/http/app.js

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

package/package.json

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