@hermespilot/link 0.6.6 → 0.6.8

package/dist/{chunk-4OXUJNO6.js → chunk-57ZJLOQA.js}

@@ -1359,6 +1359,7 @@ function isNodeError(error, code) {
 }
 
 // src/storage/atomic-json.ts
+var jsonUpdateQueues = /* @__PURE__ */ new Map();
 async function readJsonFile(filePath) {
   try {
     const raw = await readFile(filePath, "utf8");
@@ -1375,6 +1376,24 @@ async function writeJsonFile(filePath, value, mode = 384) {
 `;
   await atomicWriteFilePreservingMetadata(filePath, payload, { mode });
 }
+async function updateJsonFile(filePath, update, mode = 384) {
+  const previous = jsonUpdateQueues.get(filePath) ?? Promise.resolve();
+  let next;
+  const operation = previous.catch(() => void 0).then(async () => {
+    const current = await readJsonFile(filePath);
+    next = await update(current);
+    await writeJsonFile(filePath, next, mode);
+  });
+  const queued = operation.catch(() => void 0);
+  jsonUpdateQueues.set(filePath, queued);
+  void queued.finally(() => {
+    if (jsonUpdateQueues.get(filePath) === queued) {
+      jsonUpdateQueues.delete(filePath);
+    }
+  });
+  await operation;
+  return next;
+}
 function isNodeError2(error, code) {
   return typeof error === "object" && error !== null && "code" in error && error.code === code;
 }
@@ -1465,6 +1484,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 +1542,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 +1572,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 +1698,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 +1756,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 +1786,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 +1935,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 +2857,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 +3184,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 +3194,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 +4968,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 +5504,7 @@ import os2 from "os";
 import path5 from "path";
 
 // src/constants.ts
-var LINK_VERSION = "0.6.6";
+var LINK_VERSION = "0.6.8";
 var LINK_COMMAND = "hermeslink";
 var LINK_DEFAULT_PORT = 52379;
 var LINK_RUNTIME_DIR_NAME = ".hermeslink";
@@ -9056,6 +9142,7 @@ var ConversationMaintenanceCoordinator = class {
   clearPlans;
   archivePlans;
   async prepareClearAllConversationPlan(targetStatus = "active") {
+    assertArchivedClearPlanTarget(targetStatus);
     const targets = [];
     for (const conversationId of await this.deps.store.listConversationIds()) {
       const manifest = await this.deps.store.readManifest(conversationId).catch(() => null);
@@ -9078,6 +9165,7 @@ var ConversationMaintenanceCoordinator = class {
   }
   async executeClearAllConversationPlan(planId) {
     let plan = await this.clearPlans.read(planId);
+    assertArchivedClearPlanTarget(plan.target_status ?? "active");
     if (plan.status === "completed") {
       return plan;
     }
@@ -9140,6 +9228,7 @@ var ConversationMaintenanceCoordinator = class {
   }
   async startClearAllConversationPlan(planId) {
     const plan = await this.clearPlans.read(planId);
+    assertArchivedClearPlanTarget(plan.target_status ?? "active");
     if (plan.status === "completed" || plan.status === "executing") {
       return plan;
     }
@@ -9621,6 +9710,16 @@ var ConversationMaintenanceCoordinator = class {
     return plan;
   }
 };
+function assertArchivedClearPlanTarget(targetStatus) {
+  if (targetStatus === "archived") {
+    return;
+  }
+  throw new LinkHttpError(
+    409,
+    "active_conversation_clear_plan_disabled",
+    "Bulk deletion of active conversations is disabled. Archive active conversations first, or delete explicitly selected conversations."
+  );
+}
 function isVoiceAttachmentInput(attachment) {
   return attachment.kind === "voice" || attachment.type === "voice" || attachment.is_voice_note === true || attachment.isVoiceNote === true;
 }
@@ -18816,8 +18915,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;
@@ -19529,6 +19635,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;
 }
@@ -19875,7 +20011,7 @@ function isExpectedClientDisconnectError(error) {
 
 // src/http/routes/conversations.ts
 function registerConversationRoutes(router, options) {
-  const { paths, conversations } = options;
+  const { paths, logger, conversations } = options;
   router.get("/api/v1/conversations", async (ctx) => {
     await authenticateRequest(ctx, paths);
     ctx.set("cache-control", "no-store");
@@ -20081,12 +20217,20 @@ function registerConversationRoutes(router, options) {
     ctx.body = { ok: true };
   });
   router.post("/api/v1/conversations/clear-plans", async (ctx) => {
-    await authenticateRequest(ctx, paths);
+    const auth = await authenticateRequest(ctx, paths);
     const body = await readJsonBody(ctx.req);
     const targetStatus = readConversationClearPlanTargetStatus(body);
     const plan = await conversations.prepareClearAllConversationPlan(
       targetStatus
     );
+    void logger.warn(
+      "conversation_clear_plan_prepared",
+      conversationMutationAuditFields(ctx, auth, {
+        plan_id: plan.id,
+        target_status: plan.target_status,
+        total_count: plan.total_count
+      })
+    );
     ctx.status = 201;
     ctx.body = {
       ok: true,
@@ -20104,10 +20248,19 @@ function registerConversationRoutes(router, options) {
   router.post(
     "/api/v1/conversations/clear-plans/:planId/execute",
     async (ctx) => {
-      await authenticateRequest(ctx, paths);
+      const auth = await authenticateRequest(ctx, paths);
       const plan = await conversations.startClearAllConversationPlan(
         ctx.params.planId
       );
+      void logger.warn(
+        "conversation_clear_plan_execute_requested",
+        conversationMutationAuditFields(ctx, auth, {
+          plan_id: plan.id,
+          target_status: plan.target_status,
+          total_count: plan.total_count,
+          status: plan.status
+        })
+      );
       ctx.status = plan.status === "completed" ? 200 : 202;
       ctx.body = {
         ok: true,
@@ -20156,7 +20309,7 @@ function registerConversationRoutes(router, options) {
     }
   );
   router.delete("/api/v1/conversations", async (ctx) => {
-    await authenticateRequest(ctx, paths);
+    const auth = await authenticateRequest(ctx, paths);
     const body = await readJsonBody(ctx.req);
     const conversationIds = readStringArray(
       body,
@@ -20171,6 +20324,14 @@ function registerConversationRoutes(router, options) {
       );
     }
     const deleted = await conversations.deleteConversations(conversationIds);
+    void logger.warn(
+      "conversation_bulk_delete_requested",
+      conversationMutationAuditFields(ctx, auth, {
+        requested_count: conversationIds.length,
+        deleted_count: deleted.deleted_count,
+        failed_count: deleted.failed_count
+      })
+    );
     const ok = deleted.failed_count === 0;
     ctx.status = ok ? 200 : 409;
     ctx.body = {
@@ -20209,7 +20370,8 @@ function registerConversationRoutes(router, options) {
         ...await conversations.resolveApproval({
           conversationId: ctx.params.conversationId,
           approvalId: ctx.params.approvalId,
-          decision: scope
+          decision: scope,
+          language: readPreferredLanguage(ctx)
         })
       };
     }
@@ -20223,7 +20385,8 @@ function registerConversationRoutes(router, options) {
         ...await conversations.resolveApproval({
           conversationId: ctx.params.conversationId,
           approvalId: ctx.params.approvalId,
-          decision: "deny"
+          decision: "deny",
+          language: readPreferredLanguage(ctx)
         })
       };
     }
@@ -20248,10 +20411,21 @@ function registerConversationRoutes(router, options) {
     }
   );
   router.delete("/api/v1/conversations/:conversationId", async (ctx) => {
-    await authenticateRequest(ctx, paths);
+    const auth = await authenticateRequest(ctx, paths);
+    const result = await conversations.deleteConversation(
+      ctx.params.conversationId
+    );
+    void logger.warn(
+      "conversation_delete_requested",
+      conversationMutationAuditFields(ctx, auth, {
+        conversation_id: result.conversation_id,
+        hermes_deleted: result.hermes_deleted,
+        hermes_session_count: result.hermes_session_ids?.length ?? 0
+      })
+    );
     ctx.body = {
       ok: true,
-      ...await conversations.deleteConversation(ctx.params.conversationId),
+      ...result,
       blob_gc_completed: true
     };
   });
@@ -20314,6 +20488,21 @@ function readConversationClearPlanTargetStatus(body) {
     "Conversation clear plan target status is invalid"
   );
 }
+function conversationMutationAuditFields(ctx, auth, fields) {
+  return {
+    method: ctx.method,
+    path: ctx.path,
+    auth_kind: auth.kind,
+    device_id: auth.device?.id ?? null,
+    device_label: auth.device?.label ?? null,
+    device_platform: auth.device?.platform ?? null,
+    device_model: auth.device?.model ?? null,
+    account_id: auth.accountId ?? null,
+    app_instance_id: auth.appInstanceId ?? null,
+    user_agent: ctx.get("user-agent") || null,
+    ...fields
+  };
+}
 function readNonNegativeIntegerHeader(value) {
   const raw = Array.isArray(value) ? value[0] : value;
   if (!raw) {
@@ -20448,7 +20637,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) => {
@@ -20473,6 +20664,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);
@@ -20596,6 +20817,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"], {
@@ -20747,6 +20981,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, "\\$&");
 }
@@ -21473,7 +21710,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)
@@ -21486,10 +21727,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
@@ -21502,11 +21750,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);
 }
 
@@ -21619,7 +21867,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) {
@@ -21673,6 +21921,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);
 }
@@ -25153,6 +25420,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");
@@ -25252,6 +25529,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");
@@ -26055,12 +26346,10 @@ function computeRelayBackoffMs(attempt, options = {}) {
   return exponential + Math.floor(exponential * ratio);
 }
 async function updateRelayReconnectState(paths, update) {
-  const state = await readLinkState(paths);
-  const next = {
+  await updateJsonFile(paths.stateFile, (state) => ({
     ...state,
-    relayReconnect: update(normalizeRelayReconnectState(state.relayReconnect))
-  };
-  await writeJsonFile(paths.stateFile, next);
+    relayReconnect: update(normalizeRelayReconnectState(state?.relayReconnect))
+  }));
 }
 async function readLinkState(paths) {
   const state = await readJsonFile(paths.stateFile);
@@ -26167,6 +26456,9 @@ function readInteger4(value) {
 }
 
 // src/relay/control-client.ts
+var DEFAULT_RELAY_HANDSHAKE_TIMEOUT_MS = 2e4;
+var DEFAULT_RELAY_PING_INTERVAL_MS = 3 * 6e4;
+var DEFAULT_RELAY_PONG_TIMEOUT_MS = 3e4;
 function connectRelayControl(options) {
   const wsUrl = new URL(`${options.relayBaseUrl.replace(/\/+$/u, "")}/api/v1/relay/link/connect`);
   wsUrl.protocol = wsUrl.protocol === "https:" ? "wss:" : "ws:";
@@ -26175,10 +26467,15 @@ function connectRelayControl(options) {
   const maxReconnectAttempts = options.maxReconnectAttempts ?? Number.POSITIVE_INFINITY;
   const backoffBaseMs = options.backoffBaseMs ?? DEFAULT_RELAY_RECONNECT_BASE_MS;
   const backoffMaxMs = options.backoffMaxMs ?? DEFAULT_RELAY_RECONNECT_MAX_MS;
+  const handshakeTimeoutMs = positiveInteger2(options.handshakeTimeoutMs, DEFAULT_RELAY_HANDSHAKE_TIMEOUT_MS);
+  const pingIntervalMs = positiveInteger2(options.pingIntervalMs, DEFAULT_RELAY_PING_INTERVAL_MS);
+  const pongTimeoutMs = positiveInteger2(options.pongTimeoutMs, DEFAULT_RELAY_PONG_TIMEOUT_MS);
   let reconnectAttempts = 0;
   let closedByUser = false;
   let socket = null;
   let retryTimer = null;
+  let pingTimer = null;
+  let pongTimer = null;
   let abortControllers = /* @__PURE__ */ new Map();
   let fatalRelayRejection = null;
   let relayRetryAfterMs = null;
@@ -26206,15 +26503,19 @@ function connectRelayControl(options) {
     });
   };
   const connect = () => {
+    clearRetryTimer();
+    clearHeartbeatTimers();
     options.onStatus?.({ state: "connecting", attempt: reconnectAttempts });
     fatalRelayRejection = null;
     relayRetryAfterMs = null;
     let closeHandled = false;
+    let localCloseReason;
     const handleConnectionClosed = (reason) => {
       if (closeHandled) {
         return;
       }
       closeHandled = true;
+      clearHeartbeatTimers();
       abortAll(abortControllers);
       abortControllers = /* @__PURE__ */ new Map();
       if (fatalRelayRejection) {
@@ -26241,30 +26542,48 @@ function connectRelayControl(options) {
         scheduleTimer(backoffMaxMs, "retrying", `Relay reconnect scheduling failed: ${message}`);
       });
     };
-    socket = new WebSocket(wsUrl, {
+    const currentSocket = new WebSocket(wsUrl, {
+      handshakeTimeout: handshakeTimeoutMs,
       headers: {
         "x-hermes-link-version": LINK_VERSION
       }
     });
-    socket.on("open", () => {
+    socket = currentSocket;
+    currentSocket.on("open", () => {
+      if (socket !== currentSocket) {
+        return;
+      }
       reconnectAttempts = 0;
       void clearRelayReconnectState(paths).catch(() => void 0);
       options.onStatus?.({ state: "connected", attempt: reconnectAttempts });
-      const currentSocket = socket;
-      if (currentSocket && latestNetworkRoutes) {
+      startHeartbeat(currentSocket, (message) => {
+        localCloseReason = message;
+        options.onStatus?.({ state: "disconnected", attempt: reconnectAttempts, message });
+        currentSocket.terminate();
+      });
+      if (latestNetworkRoutes) {
         sendNetworkRoutes(currentSocket, options.linkId, latestNetworkRoutes);
       }
     });
-    socket.on("message", (raw) => {
-      if (!socket || typeof raw !== "string" && !Buffer.isBuffer(raw)) {
+    currentSocket.on("pong", () => {
+      if (socket !== currentSocket) {
         return;
       }
-      void handleFrame(socket, String(raw), options.localPort, abortControllers, streamBatchPolicy).catch((error) => {
+      clearPongTimer();
+    });
+    currentSocket.on("message", (raw) => {
+      if (socket !== currentSocket || typeof raw !== "string" && !Buffer.isBuffer(raw)) {
+        return;
+      }
+      void handleFrame(currentSocket, String(raw), options.localPort, abortControllers, streamBatchPolicy).catch((error) => {
         const message = error instanceof Error ? error.message : "Relay request failed";
-        socket?.send(JSON.stringify({ type: "http.error", id: "unknown", status: 502, message }));
+        currentSocket.send(JSON.stringify({ type: "http.error", id: "unknown", status: 502, message }));
       });
     });
-    socket.on("unexpected-response", (request, response) => {
+    currentSocket.on("unexpected-response", (request, response) => {
+      if (socket !== currentSocket) {
+        return;
+      }
       const statusCode = response.statusCode ?? 0;
       fatalRelayRejection = resolveFatalRelayRejectionFromStatus(statusCode);
       relayRetryAfterMs = readRetryAfterMs(response);
@@ -26278,7 +26597,10 @@ function connectRelayControl(options) {
       handleConnectionClosed(message);
       request.destroy();
     });
-    socket.on("error", (error) => {
+    currentSocket.on("error", (error) => {
+      if (socket !== currentSocket) {
+        return;
+      }
       const message = error instanceof Error ? error.message : "Relay websocket error";
       fatalRelayRejection = resolveFatalRelayRejection(message);
       options.onStatus?.({
@@ -26287,8 +26609,12 @@ function connectRelayControl(options) {
         message: fatalRelayRejection ?? message
       });
     });
-    socket.on("close", () => {
-      handleConnectionClosed();
+    currentSocket.on("close", (code, reason) => {
+      if (socket !== currentSocket) {
+        return;
+      }
+      socket = null;
+      handleConnectionClosed(localCloseReason ?? formatCloseReason(code, reason));
     });
   };
   startConnect();
@@ -26318,10 +26644,59 @@ function connectRelayControl(options) {
     return await readRelayCooldownDelayMs(paths).catch(() => 0);
   }
   function scheduleTimer(delay4, state, message) {
+    clearRetryTimer();
     options.onStatus?.({ state, attempt: reconnectAttempts, message });
     retryTimer = setTimeout(connect, delay4);
     retryTimer.unref?.();
   }
+  function clearRetryTimer() {
+    if (retryTimer == null) {
+      return;
+    }
+    clearTimeout(retryTimer);
+    retryTimer = null;
+  }
+  function startHeartbeat(currentSocket, onTimeout) {
+    clearHeartbeatTimers();
+    pingTimer = setInterval(() => {
+      if (socket !== currentSocket || currentSocket.readyState !== WebSocket.OPEN) {
+        clearHeartbeatTimers();
+        return;
+      }
+      if (pongTimer != null) {
+        return;
+      }
+      try {
+        currentSocket.ping();
+      } catch {
+        onTimeout("Relay websocket ping failed");
+        return;
+      }
+      pongTimer = setTimeout(() => {
+        if (socket !== currentSocket || currentSocket.readyState !== WebSocket.OPEN) {
+          clearPongTimer();
+          return;
+        }
+        onTimeout(`Relay websocket pong timed out after ${pongTimeoutMs}ms`);
+      }, pongTimeoutMs);
+      pongTimer.unref?.();
+    }, pingIntervalMs);
+    pingTimer.unref?.();
+  }
+  function clearHeartbeatTimers() {
+    if (pingTimer != null) {
+      clearInterval(pingTimer);
+      pingTimer = null;
+    }
+    clearPongTimer();
+  }
+  function clearPongTimer() {
+    if (pongTimer == null) {
+      return;
+    }
+    clearTimeout(pongTimer);
+    pongTimer = null;
+  }
   return {
     publishNetworkRoutes(routes) {
       latestNetworkRoutes = routes;
@@ -26335,10 +26710,8 @@ function connectRelayControl(options) {
     },
     close() {
       closedByUser = true;
-      if (retryTimer) {
-        clearTimeout(retryTimer);
-        retryTimer = null;
-      }
+      clearRetryTimer();
+      clearHeartbeatTimers();
       abortAll(abortControllers);
       socket?.terminate();
     }
@@ -26390,6 +26763,16 @@ function readRetryAfterMs(response) {
   }
   return Math.max(0, dateMs - Date.now());
 }
+function formatCloseReason(code, reason) {
+  const text = reason.toString("utf8").trim();
+  if (code === 1e3 && !text) {
+    return void 0;
+  }
+  return text ? `Relay websocket closed (${code}): ${text}` : `Relay websocket closed (${code})`;
+}
+function positiveInteger2(value, fallback) {
+  return Number.isFinite(value) ? Math.max(1, Math.floor(value)) : fallback;
+}
 async function handleFrame(socket, raw, localPort, abortControllers, streamBatchPolicy) {
   const frame = JSON.parse(raw);
   if (frame.type === "relay.config.update") {
@@ -26515,8 +26898,7 @@ async function readRelayStatusSnapshot(paths) {
   return normalizeRelayStatusSnapshot(state.relayStatus);
 }
 async function writeRelayStatusSnapshot(paths, status, now = /* @__PURE__ */ new Date()) {
-  const current = await readLinkState2(paths);
-  await writeJsonFile(paths.stateFile, {
+  await updateLinkState(paths, (current) => ({
     ...current,
     relayStatus: {
       state: status.state,
@@ -26524,7 +26906,10 @@ async function writeRelayStatusSnapshot(paths, status, now = /* @__PURE__ */ new
       message: normalizeMessage(status.message),
       updatedAt: now.toISOString()
     }
-  });
+  }));
+}
+async function updateLinkState(paths, update) {
+  await updateJsonFile(paths.stateFile, (state) => update(state && typeof state === "object" ? state : {}));
 }
 async function readLinkState2(paths) {
   const state = await readJsonFile(paths.stateFile);
@@ -26943,12 +27328,10 @@ async function mergeLastReportedPublicRoutes(paths, snapshotInput) {
   };
 }
 async function updateNetworkReportState(paths, update) {
-  const state = await readLinkState3(paths);
-  const next = {
+  await updateJsonFile(paths.stateFile, (state) => ({
     ...state,
-    networkReport: update(normalizeNetworkReportState(state.networkReport))
-  };
-  await writeJsonFile(paths.stateFile, next);
+    networkReport: update(normalizeNetworkReportState(state?.networkReport))
+  }));
 }
 async function readLinkState3(paths) {
   const state = await readJsonFile(paths.stateFile);
@@ -27413,6 +27796,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) => {
@@ -27432,6 +27824,7 @@ async function startLinkService(options = {}) {
         logger,
         source: "pairing_claimed"
       });
+      triggerProfilePreparation("pairing_claimed");
       triggerHermesSessionSync();
       void loadRelayStreamBatchPolicy("pairing_claimed");
       await options.onPairingClaimed?.();
@@ -27492,6 +27885,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,
@@ -27576,6 +27972,7 @@ async function startLinkService(options = {}) {
         scheduler.close(),
         hermesSessionSyncScheduler.close(),
         lanIpMonitor?.close(),
+        profilePreparation.catch(() => void 0),
         hermesSessionSync.catch(() => void 0)
       ]);
       await logger.info("service_stopped");
@@ -27601,6 +27998,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`;
 }
@@ -30569,7 +30992,7 @@ async function createApp(options = {}) {
     conversations,
     syncCronDeliveries
   });
-  registerConversationRoutes(router, { paths, conversations });
+  registerConversationRoutes(router, { paths, logger, conversations });
   registerRunRoutes(router, { paths, logger, conversations });
   registerProfileRoutes(router, { paths, logger, conversations });
   app.use(router.routes());
@@ -30585,6 +31008,7 @@ export {
   resolveLanguage,
   translate,
   localizeErrorMessage,
+  DEFAULT_HERMES_API_SERVER_PORT,
   resolveHermesProfileDir,
   resolveHermesConfigPath,
   ensureHermesApiServerConfig,
@@ -30599,6 +31023,7 @@ export {
   HermesApiServerUnavailableError,
   ensureHermesApiServerAvailable,
   readHermesVersion,
+  readHermesApiServerHealth,
   defaultLinkConfig,
   loadConfig,
   saveConfig,
@@ -30609,6 +31034,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-4OXUJNO6.js";
+} from "../chunk-57ZJLOQA.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

@@ -381,6 +381,8 @@ declare class FileLogger {
     private rotateIfNeeded;
 }
 
+type SupportedLanguage = 'zh-CN' | 'en';
+
 interface HermesSessionSyncResult {
     scanned_profiles: number;
     scanned_sessions: number;
@@ -510,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-4OXUJNO6.js";
+} from "../chunk-57ZJLOQA.js";
 export {
   createApp
 };

package/package.json

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