@adhdev/daemon-standalone 0.8.94 → 0.8.96

package/dist/index.js

@@ -35477,6 +35477,125 @@ ${cleanBody}`;
         return { sessions: [], hasMore: false };
       }
     }
+    function normalizeCanonicalHermesMessageContent(content) {
+      if (typeof content === "string") return content.trim();
+      if (content == null) return "";
+      try {
+        return JSON.stringify(content).trim();
+      } catch {
+        return String(content).trim();
+      }
+    }
+    function extractCanonicalHermesMessageTimestamp(message, fallbackTs) {
+      const numericTimestamp = Number(message.receivedAt || message.timestamp || message.ts || 0);
+      if (Number.isFinite(numericTimestamp) && numericTimestamp > 0) return numericTimestamp;
+      const stringTimestamp = typeof message.ts === "string" ? Date.parse(message.ts) : typeof message.timestamp === "string" ? Date.parse(message.timestamp) : NaN;
+      if (Number.isFinite(stringTimestamp) && stringTimestamp > 0) return stringTimestamp;
+      return fallbackTs;
+    }
+    function readExistingHermesSessionStartRecord(historySessionId) {
+      try {
+        const dir = path7.join(HISTORY_DIR, "hermes-cli");
+        if (!fs32.existsSync(dir)) return null;
+        const files = listHistoryFiles(dir, historySessionId).sort();
+        for (const file2 of files) {
+          const lines = fs32.readFileSync(path7.join(dir, file2), "utf-8").split("\n").filter(Boolean);
+          for (const line of lines) {
+            try {
+              const parsed = JSON.parse(line);
+              if (parsed.historySessionId !== historySessionId) continue;
+              if (parsed.kind === "session_start" && parsed.role === "system") {
+                return parsed;
+              }
+            } catch {
+            }
+          }
+        }
+        return null;
+      } catch {
+        return null;
+      }
+    }
+    function rebuildHermesSavedHistoryFromCanonicalSession(historySessionId) {
+      const normalizedSessionId = normalizeSavedHistorySessionId("hermes-cli", historySessionId);
+      if (!normalizedSessionId) return false;
+      try {
+        const sessionFilePath = path7.join(os52.homedir(), ".hermes", "sessions", `session_${normalizedSessionId}.json`);
+        if (!fs32.existsSync(sessionFilePath)) return false;
+        const raw = JSON.parse(fs32.readFileSync(sessionFilePath, "utf-8"));
+        const canonicalMessages = Array.isArray(raw.messages) ? raw.messages : [];
+        const dir = path7.join(HISTORY_DIR, "hermes-cli");
+        fs32.mkdirSync(dir, { recursive: true });
+        const existingSessionStart = readExistingHermesSessionStartRecord(normalizedSessionId);
+        const records = [];
+        if (existingSessionStart) {
+          records.push({
+            ...existingSessionStart,
+            historySessionId: normalizedSessionId
+          });
+        }
+        let fallbackTs = Date.parse(raw.session_start || raw.last_updated || "") || Date.now();
+        for (const message of canonicalMessages) {
+          const role = String(message.role || "").trim();
+          const content = normalizeCanonicalHermesMessageContent(message.content);
+          if (!content) continue;
+          const receivedAt = extractCanonicalHermesMessageTimestamp(message, fallbackTs);
+          fallbackTs = receivedAt + 1;
+          if (role === "user") {
+            records.push({
+              ts: new Date(receivedAt).toISOString(),
+              receivedAt,
+              role: "user",
+              content,
+              kind: "standard",
+              agent: "hermes-cli",
+              historySessionId: normalizedSessionId
+            });
+            continue;
+          }
+          if (role === "assistant") {
+            records.push({
+              ts: new Date(receivedAt).toISOString(),
+              receivedAt,
+              role: "assistant",
+              content,
+              kind: "standard",
+              agent: "hermes-cli",
+              historySessionId: normalizedSessionId
+            });
+            continue;
+          }
+          if (role === "tool") {
+            records.push({
+              ts: new Date(receivedAt).toISOString(),
+              receivedAt,
+              role: "assistant",
+              content,
+              kind: "tool",
+              senderName: "Tool",
+              agent: "hermes-cli",
+              historySessionId: normalizedSessionId
+            });
+          }
+        }
+        if (records.length === 0) return false;
+        const prefix = `${normalizedSessionId.replace(/[^a-zA-Z0-9_-]/g, "_")}_`;
+        for (const file2 of fs32.readdirSync(dir)) {
+          if (file2.startsWith(prefix) && file2.endsWith(".jsonl")) {
+            fs32.unlinkSync(path7.join(dir, file2));
+          }
+        }
+        const targetDate = new Date(records[records.length - 1].receivedAt || Date.now()).toISOString().slice(0, 10);
+        const filePath = path7.join(dir, `${prefix}${targetDate}.jsonl`);
+        fs32.writeFileSync(filePath, `${records.map((record2) => JSON.stringify(record2)).join("\n")}
+`, "utf-8");
+        invalidatePersistedSavedHistoryIndex("hermes-cli", dir);
+        savedHistorySessionCache.delete("hermes-cli");
+        return true;
+      } catch {
+        return false;
+      }
+    }
     function isControlValue(value) {
       return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
     }
@@ -40323,6 +40442,7 @@ ${effect.notification.body || ""}`.trim();
       historyWriter;
       runtimeMessages = [];
       lastPersistedHistoryMessages = [];
+      lastCanonicalHermesSyncMtimeMs = 0;
       instanceId;
       suppressIdleHistoryReplay = false;
       errorMessage = void 0;
@@ -40355,34 +40475,7 @@ ${effect.notification.body || ""}`.trim();
         await this.enforceFreshSessionLaunchIfNeeded();
         this.maybeAppendRuntimeRecoveryMessage(this.adapter.getRuntimeMetadata());
         if (this.providerSessionId) {
-          this.historyWriter.compactHistorySession(this.type, this.providerSessionId);
-          const restoredHistory = readChatHistory(this.type, 0, 200, this.providerSessionId);
-          this.historyWriter.seedSessionHistory(
-            this.type,
-            restoredHistory.messages,
-            this.providerSessionId,
-            this.instanceId
-          );
-          this.lastPersistedHistoryMessages = restoredHistory.messages.map((message) => ({
-            role: message.role,
-            content: message.content,
-            kind: message.kind,
-            senderName: message.senderName,
-            receivedAt: message.receivedAt
-          }));
-          this.suppressIdleHistoryReplay = restoredHistory.messages.length > 0;
-          if (restoredHistory.messages.length > 0) {
-            this.adapter.seedCommittedMessages(
-              restoredHistory.messages.map((message) => ({
-                role: message.role,
-                content: message.content,
-                timestamp: message.receivedAt,
-                receivedAt: message.receivedAt,
-                kind: message.kind,
-                senderName: message.senderName
-              }))
-            );
-          }
+          this.restorePersistedHistoryFromCurrentSession();
         }
         if (this.providerSessionId && this.launchMode === "resume") {
           const resumedAt = Date.now();
@@ -40491,6 +40584,7 @@ ${effect.notification.body || ""}`.trim();
           parsedMessages = historyMessageCount > 0 ? parsedMessages.slice(-historyMessageCount) : [];
         }
         const mergedMessages = this.mergeConversationMessages(parsedMessages);
+        const canonicalHermesBackedHistory = this.syncCanonicalHermesSavedHistoryIfNeeded();
         const dirName = this.workingDir.split("/").filter(Boolean).pop() || "session";
         if (parsedMessages.length > 0) {
           const shouldSkipReplayPersist = this.suppressIdleHistoryReplay && adapterStatus.status === "idle" && parsedStatus?.status === "idle";
@@ -40508,7 +40602,7 @@ ${effect.notification.body || ""}`.trim();
             senderName: typeof message.senderName === "string" ? message.senderName : void 0,
             receivedAt: typeof message.receivedAt === "number" ? message.receivedAt : message.timestamp
           }));
-          if (!shouldSkipReplayPersist && normalizedMessagesToSave.length > 0) {
+          if (!canonicalHermesBackedHistory && !shouldSkipReplayPersist && normalizedMessagesToSave.length > 0) {
             const incrementalMessages = buildIncrementalHistoryAppendMessages(this.lastPersistedHistoryMessages, normalizedMessagesToSave);
             this.historyWriter.appendNewMessages(
               this.type,
@@ -40518,7 +40612,9 @@ ${effect.notification.body || ""}`.trim();
               this.providerSessionId
             );
           }
-          this.lastPersistedHistoryMessages = normalizedMessagesToSave;
+          if (!canonicalHermesBackedHistory) {
+            this.lastPersistedHistoryMessages = normalizedMessagesToSave;
+          }
         }
         this.applyProviderResponse(parsedStatus, { phase: "immediate" });
         const surface = resolveProviderStateSurface({
@@ -40975,6 +41071,7 @@ ${effect.notification.body || ""}`.trim();
         this.providerSessionId = nextSessionId;
         this.historyWriter.promoteHistorySession(this.type, previousHistorySessionId, nextSessionId);
         this.historyWriter.writeSessionStart(this.type, nextSessionId, this.workingDir, this.instanceId);
+        this.restorePersistedHistoryFromCurrentSession();
         this.adapter.updateRuntimeMeta({ providerSessionId: nextSessionId });
         this.onProviderSessionResolved?.({
           instanceId: this.instanceId,
@@ -40986,6 +41083,61 @@ ${effect.notification.body || ""}`.trim();
         });
         LOG2.info("CLI", `[${this.type}] discovered provider session id: ${nextSessionId}`);
       }
+      syncCanonicalHermesSavedHistoryIfNeeded() {
+        if (this.type !== "hermes-cli" || !this.providerSessionId) return false;
+        try {
+          const canonicalPath = path11.join(os11.homedir(), ".hermes", "sessions", `session_${this.providerSessionId}.json`);
+          if (!fs52.existsSync(canonicalPath)) return false;
+          const stat4 = fs52.statSync(canonicalPath);
+          if (stat4.mtimeMs <= this.lastCanonicalHermesSyncMtimeMs) return true;
+          const rebuilt = rebuildHermesSavedHistoryFromCanonicalSession(this.providerSessionId);
+          if (!rebuilt) return false;
+          this.lastCanonicalHermesSyncMtimeMs = stat4.mtimeMs;
+          const restoredHistory = readChatHistory(this.type, 0, Number.MAX_SAFE_INTEGER, this.providerSessionId);
+          this.lastPersistedHistoryMessages = restoredHistory.messages.map((message) => ({
+            role: message.role,
+            content: message.content,
+            kind: message.kind,
+            senderName: message.senderName,
+            receivedAt: message.receivedAt
+          }));
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      restorePersistedHistoryFromCurrentSession() {
+        if (!this.providerSessionId) return;
+        this.syncCanonicalHermesSavedHistoryIfNeeded();
+        this.historyWriter.compactHistorySession(this.type, this.providerSessionId);
+        const restoredHistory = readChatHistory(this.type, 0, Number.MAX_SAFE_INTEGER, this.providerSessionId);
+        this.historyWriter.seedSessionHistory(
+          this.type,
+          restoredHistory.messages,
+          this.providerSessionId,
+          this.instanceId
+        );
+        this.lastPersistedHistoryMessages = restoredHistory.messages.map((message) => ({
+          role: message.role,
+          content: message.content,
+          kind: message.kind,
+          senderName: message.senderName,
+          receivedAt: message.receivedAt
+        }));
+        this.suppressIdleHistoryReplay = restoredHistory.messages.length > 0;
+        if (restoredHistory.messages.length > 0) {
+          this.adapter.seedCommittedMessages(
+            restoredHistory.messages.map((message) => ({
+              role: message.role,
+              content: message.content,
+              timestamp: message.receivedAt,
+              receivedAt: message.receivedAt,
+              kind: message.kind,
+              senderName: message.senderName
+            }))
+          );
+        }
+      }
       getProbeDirectories() {
         const dirs = /* @__PURE__ */ new Set();
         const addDir = (value) => {