@hermespilot/link 0.6.7 → 0.6.8

package/dist/{chunk-FWX7ZUP4.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;
 }
@@ -5485,7 +5504,7 @@ import os2 from "os";
 import path5 from "path";
 
 // src/constants.ts
-var LINK_VERSION = "0.6.7";
+var LINK_VERSION = "0.6.8";
 var LINK_COMMAND = "hermeslink";
 var LINK_DEFAULT_PORT = 52379;
 var LINK_RUNTIME_DIR_NAME = ".hermeslink";
@@ -9123,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);
@@ -9145,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;
     }
@@ -9207,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;
     }
@@ -9688,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;
 }
@@ -19979,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");
@@ -20185,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,
@@ -20208,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,
@@ -20260,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,
@@ -20275,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 = {
@@ -20354,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
     };
   });
@@ -20420,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) {
@@ -26263,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);
@@ -26375,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:";
@@ -26383,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;
@@ -26414,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) {
@@ -26449,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);
@@ -26486,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?.({
@@ -26495,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();
@@ -26526,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;
@@ -26543,10 +26710,8 @@ function connectRelayControl(options) {
     },
     close() {
       closedByUser = true;
-      if (retryTimer) {
-        clearTimeout(retryTimer);
-        retryTimer = null;
-      }
+      clearRetryTimer();
+      clearHeartbeatTimers();
       abortAll(abortControllers);
       socket?.terminate();
     }
@@ -26598,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") {
@@ -26723,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,
@@ -26732,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);
@@ -27151,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);
@@ -30817,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());

package/dist/cli/index.js

@@ -51,7 +51,7 @@ import {
   startLinkService,
   stopDaemonProcess,
   translate
-} from "../chunk-FWX7ZUP4.js";
+} from "../chunk-57ZJLOQA.js";
 
 // src/cli/index.ts
 import { Command } from "commander";

package/dist/http/app.js

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

package/package.json

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