@hermespilot/link 0.6.5 → 0.6.7

package/dist/{chunk-IJOWAEQ4.js → chunk-FWX7ZUP4.js}

@@ -1465,6 +1465,9 @@ var messages = {
     "config.notice.autoFilled": "Hermes API Server was auto-filled with {fields}; existing port/host/key were not overwritten.",
     "config.notice.repairDefault": "Hermes API Server kept the default port and rotated the key to repair an old Gateway or a key mismatch that caused 401.",
     "config.notice.repairProfile": "Hermes API Server was reassigned a local port and had its key rotated to repair an old Gateway or a key mismatch that caused 401.",
+    "config.yaml.invalid": "Hermes Profile config is not valid YAML, so Link cannot write settings yet. Fix {path}, then try again.{details}{more}",
+    "config.yaml.details": " YAML error: {errors}",
+    "config.yaml.more": " and {count} more error(s).",
     "daemon.description": "Run Hermes Link in the foreground",
     "daemon.foreground": "Hermes Link foreground daemon is running. Press Ctrl+C to stop.",
     "logs.description": "Show or follow Hermes Link logs",
@@ -1520,6 +1523,7 @@ var messages = {
     "pair.autostartFailed": "Pairing succeeded, but boot autostart could not be enabled: {message}",
     "doctor.description": "Run local diagnostics",
     "doctor.installOnly": "only check npm global command and PATH setup",
+    "doctor.noProfiles": "skip Hermes Profile diagnostics",
     "doctor.installHeader": "Install/PATH diagnostics:",
     "doctor.installNpmPrefix": "npm global prefix: {value}",
     "doctor.installGlobalBin": "npm global bin directory: {value}",
@@ -1549,6 +1553,13 @@ var messages = {
     "doctor.apiReady": "Hermes API Server: ready",
     "doctor.apiStarted": "Hermes API Server: started and ready",
     "doctor.apiUnavailable": "Hermes API Server: unavailable. {message}",
+    "doctor.profilesHeader": "Hermes Profiles:",
+    "doctor.profilesNone": "- no profiles found",
+    "doctor.profileLine": "- {profile}: {endpoint}; {state}",
+    "doctor.profileReady": "ready",
+    "doctor.profileNotRunning": "not running ({message})",
+    "doctor.profilePreparedState": "prepared config; {state}",
+    "doctor.profilePrepareFailed": "prepare failed ({message})",
     "doctor.apiUnavailable.summary": "Hermes API Server: unavailable",
     "doctor.apiUnavailable.profile": "Profile: {profile}; port: {port}",
     "doctor.apiUnavailable.diagnosisDivider": "----- API Server diagnosis -----",
@@ -1668,6 +1679,9 @@ var messages = {
     "config.notice.autoFilled": "\u5DF2\u4E3A Hermes API Server \u81EA\u52A8\u8865\u5145 {fields}\uFF1B\u672A\u8986\u76D6\u5DF2\u6709 port/host/key\u3002",
     "config.notice.repairDefault": "\u5DF2\u4E3A Hermes API Server \u4FDD\u6301\u9ED8\u8BA4\u7AEF\u53E3\u5E76\u8F6E\u6362 key\uFF0C\u7528\u4E8E\u4FEE\u590D\u65E7 Gateway \u6216 key \u4E0D\u4E00\u81F4\u5BFC\u81F4\u7684 401\u3002",
     "config.notice.repairProfile": "\u5DF2\u4E3A Hermes API Server \u91CD\u65B0\u5206\u914D\u672C\u673A\u7AEF\u53E3\u5E76\u8F6E\u6362 key\uFF0C\u7528\u4E8E\u4FEE\u590D\u65E7 Gateway \u6216 key \u4E0D\u4E00\u81F4\u5BFC\u81F4\u7684 401\u3002",
+    "config.yaml.invalid": "Hermes Profile \u914D\u7F6E\u6587\u4EF6\u4E0D\u662F\u6709\u6548\u7684 YAML\uFF0C\u6682\u65F6\u65E0\u6CD5\u5199\u5165\u914D\u7F6E\u3002\u8BF7\u5148\u4FEE\u590D {path} \u540E\u91CD\u8BD5\u3002{details}{more}",
+    "config.yaml.details": " YAML \u9519\u8BEF\uFF1A{errors}",
+    "config.yaml.more": " \u7B49 {count} \u5904\u9519\u8BEF\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\u6216\u8DDF\u8E2A Hermes Link \u65E5\u5FD7",
@@ -1723,6 +1737,7 @@ var messages = {
     "pair.autostartFailed": "\u914D\u5BF9\u5DF2\u6210\u529F\uFF0C\u4F46\u542F\u7528\u5F00\u673A\u81EA\u542F\u5931\u8D25\uFF1A{message}",
     "doctor.description": "\u8FD0\u884C\u672C\u673A\u8BCA\u65AD",
     "doctor.installOnly": "\u53EA\u68C0\u67E5 npm \u5168\u5C40\u547D\u4EE4\u548C PATH \u8BBE\u7F6E",
+    "doctor.noProfiles": "\u8DF3\u8FC7 Hermes Profile \u8BCA\u65AD",
     "doctor.installHeader": "\u5B89\u88C5 / PATH \u8BCA\u65AD\uFF1A",
     "doctor.installNpmPrefix": "npm \u5168\u5C40 prefix\uFF1A{value}",
     "doctor.installGlobalBin": "npm \u5168\u5C40 bin \u76EE\u5F55\uFF1A{value}",
@@ -1752,6 +1767,13 @@ var messages = {
     "doctor.apiReady": "Hermes API Server\uFF1A\u5DF2\u5C31\u7EEA",
     "doctor.apiStarted": "Hermes API Server\uFF1A\u5DF2\u81EA\u52A8\u542F\u52A8\u5E76\u5C31\u7EEA",
     "doctor.apiUnavailable": "Hermes API Server\uFF1A\u4E0D\u53EF\u7528\u3002{message}",
+    "doctor.profilesHeader": "Hermes Profiles\uFF1A",
+    "doctor.profilesNone": "- \u6CA1\u6709\u627E\u5230 Profile",
+    "doctor.profileLine": "- {profile}\uFF1A{endpoint}\uFF1B{state}",
+    "doctor.profileReady": "\u5DF2\u5C31\u7EEA",
+    "doctor.profileNotRunning": "\u5C1A\u672A\u8FD0\u884C\uFF08{message}\uFF09",
+    "doctor.profilePreparedState": "\u5DF2\u81EA\u52A8\u51C6\u5907\u914D\u7F6E\uFF1B{state}",
+    "doctor.profilePrepareFailed": "\u51C6\u5907\u5931\u8D25\uFF08{message}\uFF09",
     "doctor.apiUnavailable.summary": "Hermes API Server\uFF1A\u4E0D\u53EF\u7528",
     "doctor.apiUnavailable.profile": "Profile\uFF1A{profile}\uFF1B\u7AEF\u53E3\uFF1A{port}",
     "doctor.apiUnavailable.diagnosisDivider": "----- API Server \u8BCA\u65AD -----",
@@ -1894,6 +1916,17 @@ var MODEL_CONFIG_RESTART_HINT = "\u6A21\u578B\u914D\u7F6E\u5DF2\u4FDD\u5B58\u300
 var MODEL_DEFAULTS_APPLIED_HINT = "\u9ED8\u8BA4\u6A21\u578B\u8BBE\u7F6E\u5DF2\u4FDD\u5B58\u3002\u65B0\u7684 Run \u4F1A\u76F4\u63A5\u8BFB\u53D6\u6700\u65B0\u914D\u7F6E\uFF0C\u65E0\u9700\u91CD\u8F7D Hermes Gateway\u3002";
 var PROFILE_PERMISSIONS_RESTART_HINT = "\u6743\u9650\u914D\u7F6E\u5DF2\u4FDD\u5B58\u3002\u540E\u7EED\u4EE5\u8BE5 Profile \u53D1\u8D77\u7684\u65B0 Run \u4F1A\u8BFB\u53D6\u6700\u65B0\u914D\u7F6E\uFF1B\u5982\u679C\u8BE5 Profile \u7684 Gateway \u5DF2\u7ECF\u5728\u8FD0\u884C\uFF0C\u9700\u8981\u91CD\u8F7D\u5BF9\u5E94 Gateway\u3002";
 var PROFILE_TOOL_CONFIG_RESTART_HINT = "\u5DE5\u5177\u540E\u7AEF\u914D\u7F6E\u5DF2\u4FDD\u5B58\u3002\u540E\u7EED\u4EE5\u8BE5 Profile \u53D1\u8D77\u7684\u65B0 Run \u4F1A\u8BFB\u53D6\u6700\u65B0\u914D\u7F6E\uFF1B\u5982\u679C\u8BE5 Profile \u7684 Gateway \u5DF2\u7ECF\u5728\u8FD0\u884C\uFF0C\u9700\u8981\u91CD\u8F7D\u5BF9\u5E94 Gateway\u3002";
+var HermesConfigYamlError = class extends Error {
+  constructor(configPath, errors, language) {
+    super(buildHermesConfigYamlErrorMessage(configPath, errors, language));
+    this.configPath = configPath;
+    this.errors = errors;
+    this.name = "HermesConfigYamlError";
+  }
+  configPath;
+  errors;
+  code = "hermes_config_yaml_invalid";
+};
 var REASONING_EFFORTS = [
   "none",
   "minimal",
@@ -2805,12 +2838,12 @@ async function saveHermesProfilePermissions(profileName, input, configPath = res
     restartHint: PROFILE_PERMISSIONS_RESTART_HINT
   };
 }
-async function addHermesCommandAllowlistEntry(profileName, entry, configPath = resolveHermesConfigPath(profileName)) {
+async function addHermesCommandAllowlistEntry(profileName, entry, configPath = resolveHermesConfigPath(profileName), language) {
   const normalizedEntry = entry.trim();
   if (!normalizedEntry) {
     throw new Error("command_allowlist entry must be non-empty");
   }
-  const { document, config, existingRaw } = await readHermesConfigDocument(configPath);
+  const { document, config, existingRaw } = await readHermesConfigDocument(configPath, language);
   const current = readStringList(config.command_allowlist);
   if (current.includes(normalizedEntry)) {
     return {
@@ -3132,7 +3165,7 @@ async function repairHermesApiServerConfigUnlocked(profileName = "default", conf
     notice: buildRepairNotice(language, profileName)
   };
 }
-async function readHermesConfigDocument(configPath) {
+async function readHermesConfigDocument(configPath, language) {
   const existingRaw = await readFile2(configPath, "utf8").catch(
     (error) => {
       if (isNodeError3(error, "ENOENT")) {
@@ -3142,12 +3175,34 @@ async function readHermesConfigDocument(configPath) {
     }
   );
   const document = existingRaw ? YAML.parseDocument(existingRaw) : new YAML.Document({});
+  assertValidHermesConfigDocument(configPath, document, language);
   return {
     document,
     config: toRecord(document.toJSON()),
     existingRaw
   };
 }
+function assertValidHermesConfigDocument(configPath, document, language) {
+  const errors = document.errors.map((error) => error.message.trim()).filter((message) => message.length > 0);
+  if (errors.length > 0) {
+    throw new HermesConfigYamlError(configPath, errors, language);
+  }
+}
+function buildHermesConfigYamlErrorMessage(configPath, errors, language) {
+  const firstErrors = errors.slice(0, 3);
+  const resolvedLanguage = language ?? "zh-CN";
+  const details = firstErrors.length > 0 ? translate(resolvedLanguage, "config.yaml.details", {
+    errors: firstErrors.join("; ")
+  }) : "";
+  const more = errors.length > firstErrors.length ? translate(resolvedLanguage, "config.yaml.more", {
+    count: errors.length - firstErrors.length
+  }) : "";
+  return translate(resolvedLanguage, "config.yaml.invalid", {
+    path: configPath,
+    details,
+    more
+  });
+}
 async function writeHermesConfigDocument(input) {
   const backupPath = input.existingRaw ? `${input.configPath}.bak.${Date.now()}` : null;
   if (backupPath) {
@@ -4894,12 +4949,24 @@ async function addConfiguredApiServerPort(ports, profileName, excludedProfileNam
     throw error;
   });
   if (!raw.trim()) {
+    const envPort2 = readApiServerPort(
+      (await readHermesApiServerEnvOverrides(profileName)).port
+    );
+    if (envPort2 !== null) {
+      ports.add(envPort2);
+    }
     return;
   }
   const config = toRecord(YAML.parse(raw));
   const apiServer = toRecord(toRecord(config.platforms).api_server);
-  const port = readApiServerConfig(apiServer).port;
-  if (typeof port === "number" && Number.isFinite(port)) {
+  const envPort = readApiServerPort(
+    (await readHermesApiServerEnvOverrides(profileName)).port
+  );
+  const configPort = readApiServerPort(readApiServerConfig(apiServer).port);
+  for (const port of [envPort, configPort]) {
+    if (port === null) {
+      continue;
+    }
     ports.add(port);
   }
 }
@@ -5418,7 +5485,7 @@ import os2 from "os";
 import path5 from "path";
 
 // src/constants.ts
-var LINK_VERSION = "0.6.5";
+var LINK_VERSION = "0.6.7";
 var LINK_COMMAND = "hermeslink";
 var LINK_DEFAULT_PORT = 52379;
 var LINK_RUNTIME_DIR_NAME = ".hermeslink";
@@ -8273,6 +8340,37 @@ function hasRunningRuns(snapshot) {
 function hasQueuedRuns(snapshot) {
   return snapshot.runs.some((run) => run.status === "queued");
 }
+function buildConversationEventStreamState(snapshot) {
+  const pendingApprovalRunIds = /* @__PURE__ */ new Set();
+  let hasPendingApproval = false;
+  for (const message of snapshot.messages) {
+    if (!message.approvals?.some((approval) => approval.status === "pending")) {
+      continue;
+    }
+    hasPendingApproval = true;
+    if (message.run_id) {
+      pendingApprovalRunIds.add(message.run_id);
+    }
+  }
+  const summaries = snapshot.runs.map(
+    (run) => toEventStreamRunSummary(run, pendingApprovalRunIds.has(run.id))
+  );
+  const activeRuns = summaries.filter((run) => isRealtimeRunStatus(run.status));
+  const unknownRuns = summaries.filter((run) => run.status === "unknown");
+  const requiresUserAction = hasPendingApproval || summaries.some((run) => run.requires_user_action);
+  const hasQueuedRun = activeRuns.some((run) => run.status === "queued");
+  const hasRunningRun = activeRuns.some((run) => run.status === "running");
+  const hasUnknownRun = unknownRuns.length > 0;
+  const reason = requiresUserAction ? "requires_user_action" : hasQueuedRun ? "queued_run" : hasRunningRun ? "active_run" : hasUnknownRun ? "unknown" : "terminal";
+  return {
+    should_subscribe: !requiresUserAction && activeRuns.length > 0,
+    reason,
+    has_active_runs: activeRuns.length > 0 || hasUnknownRun,
+    requires_user_action: requiresUserAction,
+    active_runs: activeRuns,
+    latest_runs: summaries.slice().sort((left, right) => right.updated_at.localeCompare(left.updated_at)).slice(0, 5)
+  };
+}
 function isRetryableUserMessage(message) {
   return message.role === "user" && message.raw?.format !== "hermes-link-slash-command" && (messageText(message).length > 0 || message.parts.some((part) => Boolean(part.blob)));
 }
@@ -8325,6 +8423,18 @@ function previewText(message) {
 function messageText(message) {
   return message.parts.filter((part) => part.type === "text" && part.text).map((part) => part.text).join("").trim();
 }
+function toEventStreamRunSummary(run, requiresUserAction) {
+  return {
+    id: run.id,
+    status: run.status,
+    assistant_message_id: run.assistant_message_id,
+    requires_user_action: requiresUserAction,
+    updated_at: run.completed_at ?? run.started_at
+  };
+}
+function isRealtimeRunStatus(status) {
+  return status === "queued" || status === "running";
+}
 
 // src/conversations/slash-commands.ts
 import { randomUUID as randomUUID4 } from "crypto";
@@ -11538,7 +11648,8 @@ var ConversationQueryCoordinator = class {
         has_more_after: endIndex < total,
         oldest_message_id: messages2[0]?.id ?? null,
         newest_message_id: messages2.at(-1)?.id ?? null
-      }
+      },
+      event_stream: buildConversationEventStreamState(snapshot)
     };
   }
   async listEvents(conversationId, after = 0) {
@@ -18772,8 +18883,15 @@ var ConversationService = class {
         );
         const result = await addHermesCommandAllowlistEntry(
           profileName,
-          patternKey
-        );
+          patternKey,
+          void 0,
+          input.language
+        ).catch((error) => {
+          if (error instanceof HermesConfigYamlError) {
+            throw new LinkHttpError(409, error.code, error.message);
+          }
+          throw error;
+        });
         commandAllowlistUpdated = result.changed;
         configPath = result.configPath;
         requiresGatewayReload = result.requiresGatewayReload;
@@ -19485,6 +19603,36 @@ function readString16(body, key) {
   const value = body[key];
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
+function readPreferredLanguage(ctx) {
+  const candidates = [
+    ctx.get("x-hermespilot-language"),
+    ctx.get("x-app-language"),
+    ctx.get("accept-language")
+  ];
+  for (const candidate of candidates) {
+    for (const part of candidate.split(",")) {
+      const normalized = part.split(";")[0]?.trim();
+      if (!normalized) {
+        continue;
+      }
+      const language = readSupportedLanguage(normalized);
+      if (language) {
+        return language;
+      }
+    }
+  }
+  return resolveLanguage();
+}
+function readSupportedLanguage(value) {
+  const normalized = value.trim().replace("_", "-").toLowerCase();
+  if (normalized.startsWith("zh")) {
+    return "zh-CN";
+  }
+  if (normalized.startsWith("en")) {
+    return "en";
+  }
+  return null;
+}
 function readOptionalProfileName(body) {
   return readString16(body, "profile") ?? readString16(body, "profile_name") ?? readString16(body, "profileName") ?? void 0;
 }
@@ -20165,7 +20313,8 @@ function registerConversationRoutes(router, options) {
         ...await conversations.resolveApproval({
           conversationId: ctx.params.conversationId,
           approvalId: ctx.params.approvalId,
-          decision: scope
+          decision: scope,
+          language: readPreferredLanguage(ctx)
         })
       };
     }
@@ -20179,7 +20328,8 @@ function registerConversationRoutes(router, options) {
         ...await conversations.resolveApproval({
           conversationId: ctx.params.conversationId,
           approvalId: ctx.params.approvalId,
-          decision: "deny"
+          decision: "deny",
+          language: readPreferredLanguage(ctx)
         })
       };
     }
@@ -20404,7 +20554,9 @@ var PROFILE_DELETE_VERIFY_INTERVAL_MS = 150;
 var execFileAsync4 = promisify4(execFile4);
 async function listHermesProfiles(paths = resolveRuntimePaths()) {
   const profiles = /* @__PURE__ */ new Map();
-  profiles.set(DEFAULT_PROFILE, await profileInfo(DEFAULT_PROFILE, paths));
+  if (await hasDefaultProfileConfigSource()) {
+    profiles.set(DEFAULT_PROFILE, await profileInfo(DEFAULT_PROFILE, paths));
+  }
   const profilesDir = resolveHermesProfilesDir();
   const entries = await readdir9(profilesDir, { withFileTypes: true }).catch(
     (error) => {
@@ -20429,6 +20581,36 @@ async function listHermesProfiles(paths = resolveRuntimePaths()) {
     return left.name.localeCompare(right.name);
   });
 }
+async function prepareHermesProfilesForUse(paths = resolveRuntimePaths()) {
+  const profiles = await listHermesProfiles(paths);
+  const prepared = [];
+  for (const profile of profiles) {
+    try {
+      const result = await ensureHermesApiServerKey(
+        profile.name,
+        profile.configPath
+      );
+      prepared.push({
+        profile,
+        apiServer: result.apiServer,
+        changed: result.changed,
+        backupPath: result.backupPath,
+        notice: result.notice,
+        error: null
+      });
+    } catch (error) {
+      prepared.push({
+        profile,
+        apiServer: null,
+        changed: false,
+        backupPath: null,
+        notice: null,
+        error: errorMessage(error)
+      });
+    }
+  }
+  return prepared;
+}
 async function getHermesProfileStatus(name, paths = resolveRuntimePaths()) {
   assertProfileName(name);
   const profile = await profileInfo(name, paths);
@@ -20552,6 +20734,19 @@ async function pathExists(targetPath) {
     throw error;
   });
 }
+async function hasDefaultProfileConfigSource() {
+  const profilePath = resolveHermesProfileDir(DEFAULT_PROFILE);
+  const profileStat = await stat13(profilePath).catch((error) => {
+    if (isNodeError15(error, "ENOENT")) {
+      return null;
+    }
+    throw error;
+  });
+  if (!profileStat?.isDirectory()) {
+    return false;
+  }
+  return await pathExists(resolveHermesConfigPath(DEFAULT_PROFILE)) || await pathExists(path20.join(profilePath, ".env"));
+}
 async function deleteHermesProfileWithCli(name) {
   try {
     await execFileAsync4(resolveHermesBin(), ["profile", "delete", name, "--yes"], {
@@ -20703,6 +20898,9 @@ function readExecErrorOutput2(error) {
 function isNodeError15(error, code) {
   return typeof error === "object" && error !== null && "code" in error && error.code === code;
 }
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
 function escapeRegExp2(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -21429,7 +21627,11 @@ function registerProfileCatalogRoutes(router, options) {
   });
 }
 async function readProfileCatalogItem(profile) {
-  const [capabilities, permissions, modelConfigs] = await Promise.all([
+  const [apiServer, capabilities, permissions, modelConfigs] = await Promise.all([
+    readCatalogField(
+      "apiServer",
+      () => readHermesApiServerConfig(profile.name, profile.configPath)
+    ),
     readCatalogField(
       "capabilities",
       () => readHermesProfileCapabilities(profile.name)
@@ -21442,10 +21644,17 @@ async function readProfileCatalogItem(profile) {
   ]);
   return {
     profile,
+    apiServer: apiServer.value ? {
+      host: apiServer.value.host ?? null,
+      port: apiServer.value.port ?? null,
+      configured: Boolean(apiServer.value.key),
+      changed: false
+    } : null,
     capabilities: capabilities.value,
     permissions: permissions.value,
     modelConfigs: modelConfigs.value,
     errors: [
+      ...apiServer.errors,
       ...capabilities.errors,
       ...permissions.errors,
       ...modelConfigs.errors
@@ -21458,11 +21667,11 @@ async function readCatalogField(field, load) {
   } catch (error) {
     return {
       value: null,
-      errors: [{ field, message: errorMessage(error) }]
+      errors: [{ field, message: errorMessage2(error) }]
     };
   }
 }
-function errorMessage(error) {
+function errorMessage2(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
@@ -21575,7 +21784,7 @@ async function ensureHermesLinkSkillInstalledForProfiles(options = {}) {
   const skillChanged = await writeHermesLinkSkill(skillPath);
   const profiles = await listHermesProfiles(paths);
   const results = [];
-  for (const profile of profiles) {
+  for (const profile of withDefaultProfilePlaceholder(profiles)) {
     try {
       results.push(await ensureProfileUsesExternalSkillDir(profile, externalDir));
     } catch (error) {
@@ -21629,6 +21838,25 @@ async function ensureHermesLinkSkillInstalledBestEffort(options = {}) {
     });
   }
 }
+function withDefaultProfilePlaceholder(profiles) {
+  if (profiles.some((profile) => profile.name === "default")) {
+    return profiles;
+  }
+  return [
+    {
+      uid: "default",
+      name: "default",
+      active: false,
+      path: resolveHermesProfileDir("default"),
+      configPath: resolveHermesConfigPath("default"),
+      displayName: null,
+      description: null,
+      avatarType: "default",
+      avatarUrl: null
+    },
+    ...profiles
+  ];
+}
 function resolveHermesLinkSkillExternalDir(paths = resolveRuntimePaths()) {
   return path21.join(paths.homeDir, HERMES_LINK_SKILL_ROOT_DIR);
 }
@@ -25109,6 +25337,16 @@ function registerProfileRoutes(router, options) {
       profiles: await listHermesProfiles(paths)
     };
   });
+  router.post("/api/v1/profiles/prepare", async (ctx) => {
+    await authenticateRequest(ctx, paths);
+    ctx.set("cache-control", "no-store");
+    ctx.body = {
+      ok: true,
+      profiles: (await prepareHermesProfilesForUse(paths)).map(
+        formatProfilePreparation
+      )
+    };
+  });
   router.get("/api/v1/profile-creation/status", async (ctx) => {
     await authenticateRequest(ctx, paths);
     ctx.set("cache-control", "no-store");
@@ -25208,6 +25446,20 @@ function registerProfileRoutes(router, options) {
     ctx.status = 204;
   });
 }
+function formatProfilePreparation(item) {
+  return {
+    profile: item.profile,
+    apiServer: item.apiServer ? {
+      host: item.apiServer.host ?? null,
+      port: item.apiServer.port ?? null,
+      configured: Boolean(item.apiServer.key),
+      changed: item.changed
+    } : null,
+    changed: item.changed,
+    notice: item.notice,
+    error: item.error
+  };
+}
 function readProfileName(body) {
   if (typeof body.name !== "string") {
     throw new Error("invalid profile name");
@@ -27369,6 +27621,15 @@ async function startLinkService(options = {}) {
     });
     return streamBatchPolicy;
   };
+  let profilePreparation = Promise.resolve();
+  const triggerProfilePreparation = (source) => {
+    profilePreparation = profilePreparation.catch(() => void 0).then(() => prepareHermesProfilesForUse(paths)).then((profiles) => logProfilePreparationResult(logger, source, profiles)).catch((error) => {
+      void logger.warn("profile_preparation_failed", {
+        source,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    });
+  };
   let hermesSessionSync = Promise.resolve();
   const triggerHermesSessionSync = () => {
     hermesSessionSync = Promise.resolve().then(() => conversations.syncHermesSessions()).then(() => void 0).catch((error) => {
@@ -27388,6 +27649,7 @@ async function startLinkService(options = {}) {
         logger,
         source: "pairing_claimed"
       });
+      triggerProfilePreparation("pairing_claimed");
       triggerHermesSessionSync();
       void loadRelayStreamBatchPolicy("pairing_claimed");
       await options.onPairingClaimed?.();
@@ -27448,6 +27710,9 @@ async function startLinkService(options = {}) {
     port: config.port,
     link_id: identity?.link_id ?? null
   });
+  if (identity?.link_id) {
+    triggerProfilePreparation("service_startup");
+  }
   triggerHermesSessionSync();
   const scheduler = startCronDeliveryScheduler({
     paths,
@@ -27532,6 +27797,7 @@ async function startLinkService(options = {}) {
         scheduler.close(),
         hermesSessionSyncScheduler.close(),
         lanIpMonitor?.close(),
+        profilePreparation.catch(() => void 0),
         hermesSessionSync.catch(() => void 0)
       ]);
       await logger.info("service_stopped");
@@ -27557,6 +27823,32 @@ function waitForRelayReadyTimeout(timeoutMs) {
     timer.unref?.();
   });
 }
+async function logProfilePreparationResult(logger, source, profiles) {
+  const changed = profiles.filter((profile) => profile.changed);
+  const failed = profiles.filter((profile) => profile.error);
+  const summary = {
+    source,
+    total: profiles.length,
+    prepared: profiles.length - failed.length,
+    changed: changed.length,
+    failed: failed.length,
+    changed_profiles: changed.map((profile) => profile.profile.name)
+  };
+  if (changed.length > 0 || failed.length > 0) {
+    await logger.warn("profiles_prepared", summary);
+  } else {
+    await logger.info("profiles_prepared", summary);
+  }
+  if (failed.length > 0) {
+    await logger.warn("profile_preparation_partial_failure", {
+      source,
+      failed_profiles: failed.map((profile) => ({
+        profile: profile.profile.name,
+        error: profile.error
+      }))
+    });
+  }
+}
 function pidFilePath(paths = resolveRuntimePaths()) {
   return `${paths.runDir}/hermeslink.pid`;
 }
@@ -30541,6 +30833,7 @@ export {
   resolveLanguage,
   translate,
   localizeErrorMessage,
+  DEFAULT_HERMES_API_SERVER_PORT,
   resolveHermesProfileDir,
   resolveHermesConfigPath,
   ensureHermesApiServerConfig,
@@ -30555,6 +30848,7 @@ export {
   HermesApiServerUnavailableError,
   ensureHermesApiServerAvailable,
   readHermesVersion,
+  readHermesApiServerHealth,
   defaultLinkConfig,
   loadConfig,
   saveConfig,
@@ -30565,6 +30859,7 @@ export {
   getIdentityStatus,
   ConversationService,
   hasActiveDevices,
+  prepareHermesProfilesForUse,
   ensureHermesLinkSkillInstalledBestEffort,
   detectRuntimeEnvironment,
   preparePairing,

package/dist/cli/index.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import {
   ConversationService,
+  DEFAULT_HERMES_API_SERVER_PORT,
   HermesApiServerUnavailableError,
   LINK_COMMAND,
   LINK_VERSION,
@@ -29,8 +30,10 @@ import {
   localizeErrorMessage,
   normalizeLanHost,
   parseLogLevel,
+  prepareHermesProfilesForUse,
   preparePairing,
   probeLocalLinkService,
+  readHermesApiServerHealth,
   readHermesVersion,
   readPairingClaim,
   readRecentGatewayLogEntries,
@@ -48,7 +51,7 @@ import {
   startLinkService,
   stopDaemonProcess,
   translate
-} from "../chunk-IJOWAEQ4.js";
+} from "../chunk-FWX7ZUP4.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
@@ -1158,7 +1161,7 @@ logsCommand.command("flush").description(helpText("logs.flush.description")).opt
     })
   );
 });
-program.command("doctor").option("--install", helpText("doctor.installOnly")).description(helpText("doctor.description")).action(async (options) => {
+program.command("doctor").option("--install", helpText("doctor.installOnly")).option("--no-profiles", helpText("doctor.noProfiles")).description(helpText("doctor.description")).action(async (options) => {
   const installInfo = readInstallPathInfo();
   const installLanguage = await loadCliLanguage().catch(() => detectSystemLanguage());
   const installT = translate.bind(null, installLanguage);
@@ -1200,6 +1203,9 @@ program.command("doctor").option("--install", helpText("doctor.installOnly")).de
   } catch (error) {
     console.log(formatHermesApiServerUnavailable(error, language));
   }
+  if (options.profiles !== false) {
+    await printProfileDiagnostics(t);
+  }
 });
 if (isCliEntrypoint()) {
   program.parseAsync(process.argv).catch(async (error) => {
@@ -1212,6 +1218,45 @@ async function loadCliLanguage() {
   const config = await loadConfig();
   return resolveLanguage(config.language);
 }
+async function printProfileDiagnostics(t) {
+  console.log(t("doctor.profilesHeader"));
+  const profiles = await prepareHermesProfilesForUse();
+  if (profiles.length === 0) {
+    console.log(t("doctor.profilesNone"));
+    return;
+  }
+  for (const profile of profiles) {
+    console.log(await formatProfileDiagnosticLine(profile, t));
+  }
+}
+async function formatProfileDiagnosticLine(profile, t) {
+  if (profile.error || !profile.apiServer) {
+    return t("doctor.profileLine", {
+      profile: profile.profile.name,
+      endpoint: t("status.unknown"),
+      state: t("doctor.profilePrepareFailed", {
+        message: profile.error ?? t("status.unknown")
+      })
+    });
+  }
+  const host = profile.apiServer.host ?? "127.0.0.1";
+  const port = profile.apiServer.port ?? DEFAULT_HERMES_API_SERVER_PORT;
+  const health = await readHermesApiServerHealth(profile.apiServer).catch(
+    (error) => ({
+      healthy: false,
+      issue: error instanceof Error ? error.message : String(error)
+    })
+  );
+  const baseState = health.healthy ? t("doctor.profileReady") : t("doctor.profileNotRunning", {
+    message: health.issue ?? t("status.unknown")
+  });
+  const state = profile.changed ? t("doctor.profilePreparedState", { state: baseState }) : baseState;
+  return t("doctor.profileLine", {
+    profile: profile.profile.name,
+    endpoint: `${host}:${port}`,
+    state
+  });
+}
 function buildRelayStatusPayload(input) {
   if (!input.paired) {
     return emptyRelayStatus(input.relayConfigured, "not_paired");

package/dist/http/app.d.ts

@@ -62,6 +62,22 @@ interface ConversationMessagesPageInfo {
     oldest_message_id: string | null;
     newest_message_id: string | null;
 }
+type ConversationEventStreamReason = 'terminal' | 'active_run' | 'queued_run' | 'recovering' | 'requires_user_action' | 'unknown';
+interface ConversationEventStreamRunSummary {
+    id: string;
+    status: LinkRun['status'];
+    assistant_message_id: string;
+    requires_user_action: boolean;
+    updated_at: string;
+}
+interface ConversationEventStreamState {
+    should_subscribe: boolean;
+    reason: ConversationEventStreamReason;
+    has_active_runs: boolean;
+    requires_user_action: boolean;
+    active_runs: ConversationEventStreamRunSummary[];
+    latest_runs: ConversationEventStreamRunSummary[];
+}
 interface LinkMessagePart {
     type: 'text' | 'image' | 'file' | 'audio' | 'video' | 'unsupported';
     text?: string;
@@ -365,6 +381,8 @@ declare class FileLogger {
     private rotateIfNeeded;
 }
 
+type SupportedLanguage = 'zh-CN' | 'en';
+
 interface HermesSessionSyncResult {
     scanned_profiles: number;
     scanned_sessions: number;
@@ -455,6 +473,7 @@ declare class ConversationService {
         last_event_seq: number;
         runtime: ConversationRuntimeMetadata;
         page: ConversationMessagesPageInfo;
+        event_stream: ConversationEventStreamState;
     }>;
     setConversationModel(conversationId: string, modelId: string): Promise<{
         conversation_id: string;
@@ -493,6 +512,7 @@ declare class ConversationService {
         conversationId: string;
         approvalId: string;
         decision: LinkApprovalDecision;
+        language?: SupportedLanguage;
     }): Promise<{
         conversation_id: string;
         message_id: string;

package/dist/http/app.js

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

package/package.json

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