@adhdev/daemon-core 0.8.97 → 0.8.99

package/dist/config/chat-history.d.ts

@@ -103,4 +103,5 @@ export declare function listSavedHistorySessions(agentType: string, options?: {
     hasMore: boolean;
 };
 export declare function rebuildHermesSavedHistoryFromCanonicalSession(historySessionId: string): boolean;
+export declare function rebuildClaudeSavedHistoryFromNativeProject(historySessionId: string, workspace?: string): boolean;
 export {};

package/dist/index.js

@@ -1789,8 +1789,8 @@ function resolveCliSpawnPlan(options) {
     isWin,
     useShell,
     ptyOptions: {
-      cols: 80,
-      rows: 24,
+      cols: import_session_host_core2.DEFAULT_SESSION_HOST_COLS,
+      rows: import_session_host_core2.DEFAULT_SESSION_HOST_ROWS,
       cwd: workingDir,
       env: buildCliSpawnEnv(process.env, spawnConfig.env)
     }
@@ -1841,12 +1841,13 @@ function respondToCliTerminalQueries(options) {
   }
   return "";
 }
-var os9, path10;
+var os9, path10, import_session_host_core2;
 var init_provider_cli_runtime = __esm({
   "src/cli-adapters/provider-cli-runtime.ts"() {
     "use strict";
     os9 = __toESM(require("os"));
     path10 = __toESM(require("path"));
+    import_session_host_core2 = require("@adhdev/session-host-core");
     init_provider_cli_shared();
   }
 });
@@ -4581,6 +4582,7 @@ init_config();
 
 // src/providers/provider-session-id.ts
 var HERMES_SESSION_ID_RE = /^\d{8}_\d{6}_[a-z0-9]+$/i;
+var CLAUDE_SESSION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 function normalizeProviderSessionId(providerType, providerSessionId) {
   const normalizedProviderType = typeof providerType === "string" ? providerType.trim() : "";
   const normalizedId = typeof providerSessionId === "string" ? providerSessionId.trim() : "";
@@ -4590,6 +4592,9 @@ function normalizeProviderSessionId(providerType, providerSessionId) {
   if (normalizedProviderType === "hermes-cli" && !HERMES_SESSION_ID_RE.test(normalizedId)) {
     return "";
   }
+  if (normalizedProviderType === "claude-cli" && !CLAUDE_SESSION_ID_RE.test(normalizedId)) {
+    return "";
+  }
   return normalizedId;
 }
 function isLegacyVolatileSessionReadKey(key) {
@@ -7711,9 +7716,16 @@ function extractCanonicalHermesMessageTimestamp(message, fallbackTs) {
   if (Number.isFinite(stringTimestamp) && stringTimestamp > 0) return stringTimestamp;
   return fallbackTs;
 }
-function readExistingHermesSessionStartRecord(historySessionId) {
+function extractTimestampValue(value) {
+  const numericTimestamp = Number(value || 0);
+  if (Number.isFinite(numericTimestamp) && numericTimestamp > 0) return numericTimestamp;
+  const stringTimestamp = typeof value === "string" ? Date.parse(value) : NaN;
+  if (Number.isFinite(stringTimestamp) && stringTimestamp > 0) return stringTimestamp;
+  return 0;
+}
+function readExistingSessionStartRecord(agentType, historySessionId) {
   try {
-    const dir = path7.join(HISTORY_DIR, "hermes-cli");
+    const dir = path7.join(HISTORY_DIR, agentType);
     if (!fs3.existsSync(dir)) return null;
     const files = listHistoryFiles(dir, historySessionId).sort();
     for (const file of files) {
@@ -7734,6 +7746,28 @@ function readExistingHermesSessionStartRecord(historySessionId) {
     return null;
   }
 }
+function rewriteCanonicalSavedHistory(agentType, historySessionId, records) {
+  if (records.length === 0) return false;
+  try {
+    const dir = path7.join(HISTORY_DIR, agentType);
+    fs3.mkdirSync(dir, { recursive: true });
+    const prefix = `${historySessionId.replace(/[^a-zA-Z0-9_-]/g, "_")}_`;
+    for (const file of fs3.readdirSync(dir)) {
+      if (file.startsWith(prefix) && file.endsWith(".jsonl")) {
+        fs3.unlinkSync(path7.join(dir, file));
+      }
+    }
+    const targetDate = new Date(records[records.length - 1].receivedAt || Date.now()).toISOString().slice(0, 10);
+    const filePath = path7.join(dir, `${prefix}${targetDate}.jsonl`);
+    fs3.writeFileSync(filePath, `${records.map((record) => JSON.stringify(record)).join("\n")}
+`, "utf-8");
+    invalidatePersistedSavedHistoryIndex(agentType, dir);
+    savedHistorySessionCache.delete(agentType.replace(/[^a-zA-Z0-9_-]/g, "_"));
+    return true;
+  } catch {
+    return false;
+  }
+}
 function rebuildHermesSavedHistoryFromCanonicalSession(historySessionId) {
   const normalizedSessionId = normalizeSavedHistorySessionId("hermes-cli", historySessionId);
   if (!normalizedSessionId) return false;
@@ -7744,7 +7778,7 @@ function rebuildHermesSavedHistoryFromCanonicalSession(historySessionId) {
     const canonicalMessages = Array.isArray(raw.messages) ? raw.messages : [];
     const dir = path7.join(HISTORY_DIR, "hermes-cli");
     fs3.mkdirSync(dir, { recursive: true });
-    const existingSessionStart = readExistingHermesSessionStartRecord(normalizedSessionId);
+    const existingSessionStart = readExistingSessionStartRecord("hermes-cli", normalizedSessionId);
     const records = [];
     if (existingSessionStart) {
       records.push({
@@ -7796,20 +7830,167 @@ function rebuildHermesSavedHistoryFromCanonicalSession(historySessionId) {
         });
       }
     }
-    if (records.length === 0) return false;
-    const prefix = `${normalizedSessionId.replace(/[^a-zA-Z0-9_-]/g, "_")}_`;
-    for (const file of fs3.readdirSync(dir)) {
-      if (file.startsWith(prefix) && file.endsWith(".jsonl")) {
-        fs3.unlinkSync(path7.join(dir, file));
+    return rewriteCanonicalSavedHistory("hermes-cli", normalizedSessionId, records);
+  } catch {
+    return false;
+  }
+}
+function resolveClaudeProjectTranscriptPath(historySessionId, workspace) {
+  const claudeProjectsDir = path7.join(os5.homedir(), ".claude", "projects");
+  if (!fs3.existsSync(claudeProjectsDir)) return null;
+  const normalizedWorkspace = typeof workspace === "string" ? workspace.trim() : "";
+  if (normalizedWorkspace) {
+    const directPath = path7.join(claudeProjectsDir, normalizedWorkspace.replace(/[\\/]/g, "-"), `${historySessionId}.jsonl`);
+    if (fs3.existsSync(directPath)) return directPath;
+  }
+  const stack = [claudeProjectsDir];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current) continue;
+    for (const entry of fs3.readdirSync(current, { withFileTypes: true })) {
+      const entryPath = path7.join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(entryPath);
+        continue;
+      }
+      if (entry.isFile() && entry.name === `${historySessionId}.jsonl`) {
+        return entryPath;
       }
     }
-    const targetDate = new Date(records[records.length - 1].receivedAt || Date.now()).toISOString().slice(0, 10);
-    const filePath = path7.join(dir, `${prefix}${targetDate}.jsonl`);
-    fs3.writeFileSync(filePath, `${records.map((record) => JSON.stringify(record)).join("\n")}
-`, "utf-8");
-    invalidatePersistedSavedHistoryIndex("hermes-cli", dir);
-    savedHistorySessionCache.delete("hermes-cli");
-    return true;
+  }
+  return null;
+}
+function extractClaudeAssistantContentParts(content) {
+  if (typeof content === "string") {
+    const trimmed = content.trim();
+    return trimmed ? [{ content: trimmed, kind: "standard", role: "assistant" }] : [];
+  }
+  if (!Array.isArray(content)) return [];
+  const parts = [];
+  for (const block of content) {
+    if (!block || typeof block !== "object") continue;
+    const record = block;
+    const type = String(record.type || "").trim();
+    if (type === "text") {
+      const text = String(record.text || "").trim();
+      if (text) parts.push({ content: text, kind: "standard", role: "assistant" });
+      continue;
+    }
+    if (type === "tool_use") {
+      const name = String(record.name || "").trim() || "Tool";
+      const input = record.input && typeof record.input === "object" ? record.input : null;
+      const command = input ? String(input.command || "").trim() : "";
+      const summary = command ? `${name}: ${command}` : name;
+      if (summary) parts.push({ content: summary, kind: "tool", senderName: "Tool", role: "assistant" });
+    }
+  }
+  return parts;
+}
+function extractClaudeUserContentParts(content) {
+  if (typeof content === "string") {
+    const trimmed = content.trim();
+    return trimmed ? [{ role: "user", content: trimmed, kind: "standard" }] : [];
+  }
+  if (!Array.isArray(content)) return [];
+  const parts = [];
+  for (const block of content) {
+    if (!block || typeof block !== "object") continue;
+    const record = block;
+    const type = String(record.type || "").trim();
+    if (type === "text") {
+      const text = String(record.text || "").trim();
+      if (text) parts.push({ role: "user", content: text, kind: "standard" });
+      continue;
+    }
+    if (type === "tool_result") {
+      const rawContent = record.content;
+      const text = typeof rawContent === "string" ? rawContent.trim() : Array.isArray(rawContent) ? rawContent.map((entry) => {
+        if (typeof entry === "string") return entry.trim();
+        if (!entry || typeof entry !== "object") return "";
+        const nested = entry;
+        if (typeof nested.text === "string") return nested.text.trim();
+        if (typeof nested.content === "string") return nested.content.trim();
+        return "";
+      }).filter(Boolean).join("\n") : "";
+      if (text) parts.push({ role: "assistant", content: text, kind: "tool", senderName: "Tool" });
+    }
+  }
+  return parts;
+}
+function rebuildClaudeSavedHistoryFromNativeProject(historySessionId, workspace) {
+  const normalizedSessionId = normalizeSavedHistorySessionId("claude-cli", historySessionId);
+  if (!normalizedSessionId) return false;
+  try {
+    const transcriptPath = resolveClaudeProjectTranscriptPath(normalizedSessionId, workspace);
+    if (!transcriptPath) return false;
+    const lines = fs3.readFileSync(transcriptPath, "utf-8").split("\n").filter(Boolean);
+    const records = [];
+    const existingSessionStart = readExistingSessionStartRecord("claude-cli", normalizedSessionId);
+    if (existingSessionStart) {
+      records.push({
+        ...existingSessionStart,
+        historySessionId: normalizedSessionId
+      });
+    }
+    let fallbackTs = Date.now();
+    for (const line of lines) {
+      let parsed = null;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        parsed = null;
+      }
+      if (!parsed) continue;
+      const parsedSessionId = String(parsed.sessionId || "").trim();
+      if (parsedSessionId && parsedSessionId !== normalizedSessionId) continue;
+      const receivedAt = extractTimestampValue(parsed.timestamp) || fallbackTs;
+      fallbackTs = receivedAt + 1;
+      const parsedWorkspace = String(parsed.cwd || workspace || "").trim();
+      if (records.length === 0 && parsedWorkspace) {
+        records.push({
+          ts: new Date(receivedAt).toISOString(),
+          receivedAt,
+          role: "system",
+          kind: "session_start",
+          content: parsedWorkspace,
+          agent: "claude-cli",
+          historySessionId: normalizedSessionId,
+          workspace: parsedWorkspace
+        });
+      }
+      const type = String(parsed.type || "").trim();
+      const message = parsed.message && typeof parsed.message === "object" ? parsed.message : null;
+      if (type === "user" && message) {
+        for (const part of extractClaudeUserContentParts(message.content)) {
+          records.push({
+            ts: new Date(receivedAt).toISOString(),
+            receivedAt,
+            role: part.role,
+            content: part.content,
+            kind: part.kind,
+            senderName: part.senderName,
+            agent: "claude-cli",
+            historySessionId: normalizedSessionId
+          });
+        }
+        continue;
+      }
+      if (type === "assistant" && message) {
+        for (const part of extractClaudeAssistantContentParts(message.content)) {
+          records.push({
+            ts: new Date(receivedAt).toISOString(),
+            receivedAt,
+            role: "assistant",
+            content: part.content,
+            kind: part.kind,
+            senderName: part.senderName,
+            agent: "claude-cli",
+            historySessionId: normalizedSessionId
+          });
+        }
+      }
+    }
+    return rewriteCanonicalSavedHistory("claude-cli", normalizedSessionId, records);
   } catch {
     return false;
   }
@@ -12868,7 +13049,7 @@ var CliProviderInstance = class {
       parsedMessages = historyMessageCount > 0 ? parsedMessages.slice(-historyMessageCount) : [];
     }
     const mergedMessages = this.mergeConversationMessages(parsedMessages);
-    const canonicalHermesBackedHistory = this.syncCanonicalHermesSavedHistoryIfNeeded();
+    const canonicalBackedHistory = this.syncCanonicalSavedHistoryIfNeeded();
     const dirName = this.workingDir.split("/").filter(Boolean).pop() || "session";
     if (parsedMessages.length > 0) {
       const shouldSkipReplayPersist = this.suppressIdleHistoryReplay && adapterStatus.status === "idle" && parsedStatus?.status === "idle";
@@ -12886,7 +13067,7 @@ var CliProviderInstance = class {
         senderName: typeof message.senderName === "string" ? message.senderName : void 0,
         receivedAt: typeof message.receivedAt === "number" ? message.receivedAt : message.timestamp
       }));
-      if (!canonicalHermesBackedHistory && !shouldSkipReplayPersist && normalizedMessagesToSave.length > 0) {
+      if (!canonicalBackedHistory && !shouldSkipReplayPersist && normalizedMessagesToSave.length > 0) {
         const incrementalMessages = buildIncrementalHistoryAppendMessages(this.lastPersistedHistoryMessages, normalizedMessagesToSave);
         this.historyWriter.appendNewMessages(
           this.type,
@@ -12896,7 +13077,7 @@ var CliProviderInstance = class {
           this.providerSessionId
         );
       }
-      if (!canonicalHermesBackedHistory) {
+      if (!canonicalBackedHistory) {
         this.lastPersistedHistoryMessages = normalizedMessagesToSave;
       }
     }
@@ -13373,32 +13554,52 @@ ${effect.notification.body || ""}`.trim();
     });
     LOG.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 (!fs5.existsSync(canonicalPath)) return false;
-      const stat = fs5.statSync(canonicalPath);
-      if (stat.mtimeMs <= this.lastCanonicalHermesSyncMtimeMs) return true;
-      const rebuilt = rebuildHermesSavedHistoryFromCanonicalSession(this.providerSessionId);
-      if (!rebuilt) return false;
-      this.lastCanonicalHermesSyncMtimeMs = stat.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;
+  syncCanonicalSavedHistoryIfNeeded() {
+    if (!this.providerSessionId) return false;
+    if (this.type === "hermes-cli") {
+      try {
+        const canonicalPath = path11.join(os11.homedir(), ".hermes", "sessions", `session_${this.providerSessionId}.json`);
+        if (!fs5.existsSync(canonicalPath)) return false;
+        const stat = fs5.statSync(canonicalPath);
+        if (stat.mtimeMs <= this.lastCanonicalHermesSyncMtimeMs) return true;
+        const rebuilt = rebuildHermesSavedHistoryFromCanonicalSession(this.providerSessionId);
+        if (!rebuilt) return false;
+        this.lastCanonicalHermesSyncMtimeMs = stat.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;
+      }
     }
+    if (this.type === "claude-cli") {
+      try {
+        const rebuilt = rebuildClaudeSavedHistoryFromNativeProject(this.providerSessionId, this.workingDir);
+        if (!rebuilt) return false;
+        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;
+      }
+    }
+    return false;
   }
   restorePersistedHistoryFromCurrentSession() {
     if (!this.providerSessionId) return;
-    this.syncCanonicalHermesSavedHistoryIfNeeded();
+    this.syncCanonicalSavedHistoryIfNeeded();
     this.historyWriter.compactHistorySession(this.type, this.providerSessionId);
     const restoredHistory = readChatHistory(this.type, 0, Number.MAX_SAFE_INTEGER, this.providerSessionId);
     this.historyWriter.seedSessionHistory(
@@ -25494,7 +25695,7 @@ init_provider_cli_adapter();
 init_pty_transport();
 
 // src/cli-adapters/session-host-transport.ts
-var import_session_host_core2 = require("@adhdev/session-host-core");
+var import_session_host_core3 = require("@adhdev/session-host-core");
 init_logger();
 function shouldResumeAttachedSession(record) {
   if (!record) return false;
@@ -25506,7 +25707,7 @@ function shouldResumeAttachedSession(record) {
 var SessionHostRuntimeTransport = class {
   constructor(options) {
     this.options = options;
-    this.client = new import_session_host_core2.SessionHostClient({
+    this.client = new import_session_host_core3.SessionHostClient({
       endpoint: options.endpoint,
       appName: options.appName
     });
@@ -25912,11 +26113,11 @@ function resolveSessionHostAppName(options = {}) {
 }
 
 // src/session-host/runtime-support.ts
-var import_session_host_core3 = require("@adhdev/session-host-core");
+var import_session_host_core4 = require("@adhdev/session-host-core");
 var STARTUP_TIMEOUT_MS = DEFAULT_SESSION_HOST_READY_TIMEOUT_MS;
 var STARTUP_POLL_MS = 200;
 async function canConnect(endpoint) {
-  const client = new import_session_host_core3.SessionHostClient({ endpoint });
+  const client = new import_session_host_core4.SessionHostClient({ endpoint });
   try {
     await client.connect();
     await client.close();
@@ -25934,14 +26135,14 @@ async function waitForReady(endpoint, timeoutMs = STARTUP_TIMEOUT_MS) {
   throw new Error(`Session host did not become ready within ${timeoutMs}ms`);
 }
 async function ensureSessionHostReady(options) {
-  const endpoint = (0, import_session_host_core3.getDefaultSessionHostEndpoint)(options.appName || "adhdev");
+  const endpoint = (0, import_session_host_core4.getDefaultSessionHostEndpoint)(options.appName || "adhdev");
   if (await canConnect(endpoint)) return endpoint;
   options.spawnHost();
   await waitForReady(endpoint, options.timeoutMs);
   return endpoint;
 }
 async function listHostedCliRuntimes(endpoint) {
-  const client = new import_session_host_core3.SessionHostClient({ endpoint });
+  const client = new import_session_host_core4.SessionHostClient({ endpoint });
   try {
     const response = await client.request({
       type: "list_sessions",