@adhdev/daemon-core 0.8.98 → 0.8.100

package/src/config/chat-history.ts

@@ -1295,9 +1295,17 @@ function extractCanonicalHermesMessageTimestamp(message: Record<string, unknown>
     return fallbackTs;
 }
 
-function readExistingHermesSessionStartRecord(historySessionId: string): HistoryMessage | null {
+function extractTimestampValue(value: unknown): number {
+    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: string, historySessionId: string): HistoryMessage | null {
     try {
-        const dir = path.join(HISTORY_DIR, 'hermes-cli');
+        const dir = path.join(HISTORY_DIR, agentType);
         if (!fs.existsSync(dir)) return null;
         const files = listHistoryFiles(dir, historySessionId).sort();
         for (const file of files) {
@@ -1320,6 +1328,28 @@ function readExistingHermesSessionStartRecord(historySessionId: string): History
     }
 }
 
+function rewriteCanonicalSavedHistory(agentType: string, historySessionId: string, records: HistoryMessage[]): boolean {
+    if (records.length === 0) return false;
+    try {
+        const dir = path.join(HISTORY_DIR, agentType);
+        fs.mkdirSync(dir, { recursive: true });
+        const prefix = `${historySessionId.replace(/[^a-zA-Z0-9_-]/g, '_')}_`;
+        for (const file of fs.readdirSync(dir)) {
+            if (file.startsWith(prefix) && file.endsWith('.jsonl')) {
+                fs.unlinkSync(path.join(dir, file));
+            }
+        }
+        const targetDate = new Date(records[records.length - 1].receivedAt || Date.now()).toISOString().slice(0, 10);
+        const filePath = path.join(dir, `${prefix}${targetDate}.jsonl`);
+        fs.writeFileSync(filePath, `${records.map((record) => JSON.stringify(record)).join('\n')}\n`, 'utf-8');
+        invalidatePersistedSavedHistoryIndex(agentType, dir);
+        savedHistorySessionCache.delete(agentType.replace(/[^a-zA-Z0-9_-]/g, '_'));
+        return true;
+    } catch {
+        return false;
+    }
+}
+
 export function rebuildHermesSavedHistoryFromCanonicalSession(historySessionId: string): boolean {
     const normalizedSessionId = normalizeSavedHistorySessionId('hermes-cli', historySessionId);
     if (!normalizedSessionId) return false;
@@ -1335,7 +1365,7 @@ export function rebuildHermesSavedHistoryFromCanonicalSession(historySessionId:
         const canonicalMessages = Array.isArray(raw.messages) ? raw.messages : [];
         const dir = path.join(HISTORY_DIR, 'hermes-cli');
         fs.mkdirSync(dir, { recursive: true });
-        const existingSessionStart = readExistingHermesSessionStartRecord(normalizedSessionId);
+        const existingSessionStart = readExistingSessionStartRecord('hermes-cli', normalizedSessionId);
         const records: HistoryMessage[] = [];
         if (existingSessionStart) {
             records.push({
@@ -1392,21 +1422,184 @@ export function rebuildHermesSavedHistoryFromCanonicalSession(historySessionId:
             }
         }
 
-        if (records.length === 0) return false;
+        return rewriteCanonicalSavedHistory('hermes-cli', normalizedSessionId, records);
+    } catch {
+        return false;
+    }
+}
 
-        const prefix = `${normalizedSessionId.replace(/[^a-zA-Z0-9_-]/g, '_')}_`;
-        for (const file of fs.readdirSync(dir)) {
-            if (file.startsWith(prefix) && file.endsWith('.jsonl')) {
-                fs.unlinkSync(path.join(dir, file));
+function resolveClaudeProjectTranscriptPath(historySessionId: string, workspace?: string): string | null {
+    const claudeProjectsDir = path.join(os.homedir(), '.claude', 'projects');
+    if (!fs.existsSync(claudeProjectsDir)) return null;
+    const normalizedWorkspace = typeof workspace === 'string' ? workspace.trim() : '';
+    if (normalizedWorkspace) {
+        const directPath = path.join(claudeProjectsDir, normalizedWorkspace.replace(/[\\/]/g, '-'), `${historySessionId}.jsonl`);
+        if (fs.existsSync(directPath)) return directPath;
+    }
+    const stack = [claudeProjectsDir];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current) continue;
+        for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+            const entryPath = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(entryPath);
+                continue;
+            }
+            if (entry.isFile() && entry.name === `${historySessionId}.jsonl`) {
+                return entryPath;
             }
         }
+    }
+    return null;
+}
 
-        const targetDate = new Date(records[records.length - 1].receivedAt || Date.now()).toISOString().slice(0, 10);
-        const filePath = path.join(dir, `${prefix}${targetDate}.jsonl`);
-        fs.writeFileSync(filePath, `${records.map((record) => JSON.stringify(record)).join('\n')}\n`, 'utf-8');
-        invalidatePersistedSavedHistoryIndex('hermes-cli', dir);
-        savedHistorySessionCache.delete('hermes-cli');
-        return true;
+function extractClaudeAssistantContentParts(content: unknown): Array<{ content: string; kind: 'standard' | 'tool'; senderName?: string; role?: 'assistant' }> {
+    if (typeof content === 'string') {
+        const trimmed = content.trim();
+        return trimmed ? [{ content: trimmed, kind: 'standard', role: 'assistant' }] : [];
+    }
+    if (!Array.isArray(content)) return [];
+    const parts: Array<{ content: string; kind: 'standard' | 'tool'; senderName?: string; role?: 'assistant' }> = [];
+    for (const block of content) {
+        if (!block || typeof block !== 'object') continue;
+        const record = block as Record<string, unknown>;
+        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 as Record<string, unknown>
+                : 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: unknown): Array<{ role: 'user' | 'assistant'; content: string; kind: 'standard' | 'tool'; senderName?: string }> {
+    if (typeof content === 'string') {
+        const trimmed = content.trim();
+        return trimmed ? [{ role: 'user', content: trimmed, kind: 'standard' }] : [];
+    }
+    if (!Array.isArray(content)) return [];
+    const parts: Array<{ role: 'user' | 'assistant'; content: string; kind: 'standard' | 'tool'; senderName?: string }> = [];
+    for (const block of content) {
+        if (!block || typeof block !== 'object') continue;
+        const record = block as Record<string, unknown>;
+        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 as Record<string, unknown>;
+                            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;
+}
+
+export function rebuildClaudeSavedHistoryFromNativeProject(historySessionId: string, workspace?: string): boolean {
+    const normalizedSessionId = normalizeSavedHistorySessionId('claude-cli', historySessionId);
+    if (!normalizedSessionId) return false;
+
+    try {
+        const transcriptPath = resolveClaudeProjectTranscriptPath(normalizedSessionId, workspace);
+        if (!transcriptPath) return false;
+        const lines = fs.readFileSync(transcriptPath, 'utf-8').split('\n').filter(Boolean);
+        const records: HistoryMessage[] = [];
+        const existingSessionStart = readExistingSessionStartRecord('claude-cli', normalizedSessionId);
+        if (existingSessionStart) {
+            records.push({
+                ...existingSessionStart,
+                historySessionId: normalizedSessionId,
+            });
+        }
+        let fallbackTs = Date.now();
+        for (const line of lines) {
+            let parsed: Record<string, unknown> | null = null;
+            try {
+                parsed = JSON.parse(line) as Record<string, unknown>;
+            } 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 as Record<string, unknown>
+                : 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;
     }

package/src/providers/cli-provider-instance.ts

@@ -17,7 +17,7 @@ import { ProviderCliAdapter } from '../cli-adapters/provider-cli-adapter.js';
 import type { CliProviderModule } from '../cli-adapters/provider-cli-adapter.js';
 import type { PtyRuntimeMetadata, PtyTransportFactory } from '../cli-adapters/pty-transport.js';
 import { StatusMonitor } from './status-monitor.js';
-import { ChatHistoryWriter, readChatHistory, rebuildHermesSavedHistoryFromCanonicalSession } from '../config/chat-history.js';
+import { ChatHistoryWriter, readChatHistory, rebuildClaudeSavedHistoryFromNativeProject, rebuildHermesSavedHistoryFromCanonicalSession } from '../config/chat-history.js';
 import { LOG } from '../logging/logger.js';
 import type { ChatMessage } from '../types.js';
 import { buildPersistedProviderEffectMessage, normalizeProviderEffects } from './control-effects.js';
@@ -377,7 +377,7 @@ export class CliProviderInstance implements ProviderInstance {
                 : [];
         }
         const mergedMessages = this.mergeConversationMessages(parsedMessages);
-        const canonicalHermesBackedHistory = this.syncCanonicalHermesSavedHistoryIfNeeded();
+        const canonicalBackedHistory = this.syncCanonicalSavedHistoryIfNeeded();
 
         const dirName = this.workingDir.split('/').filter(Boolean).pop() || 'session';
 
@@ -400,7 +400,7 @@ export class CliProviderInstance implements ProviderInstance {
                 senderName: typeof message.senderName === 'string' ? message.senderName : undefined,
                 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,
@@ -410,7 +410,7 @@ export class CliProviderInstance implements ProviderInstance {
                     this.providerSessionId,
                 );
             }
-            if (!canonicalHermesBackedHistory) {
+            if (!canonicalBackedHistory) {
                 this.lastPersistedHistoryMessages = normalizedMessagesToSave;
             }
         }
@@ -807,7 +807,14 @@ export class CliProviderInstance implements ProviderInstance {
     get cliName(): string { return this.provider.name; }
 
     private shouldAutoApprove(): boolean {
-        return this.settings.autoApprove !== false;
+        if (typeof this.settings.autoApprove === 'boolean') {
+            return this.settings.autoApprove;
+        }
+        const providerDefault = this.provider.settings?.autoApprove?.default;
+        if (typeof providerDefault === 'boolean') {
+            return providerDefault;
+        }
+        return false;
     }
 
     private recordAutoApproval(modalMessage?: string, buttonLabel?: string, now = Date.now()): void {
@@ -951,33 +958,53 @@ export class CliProviderInstance implements ProviderInstance {
         LOG.info('CLI', `[${this.type}] discovered provider session id: ${nextSessionId}`);
     }
 
-    private syncCanonicalHermesSavedHistoryIfNeeded(): boolean {
-        if (this.type !== 'hermes-cli' || !this.providerSessionId) return false;
-        try {
-            const canonicalPath = path.join(os.homedir(), '.hermes', 'sessions', `session_${this.providerSessionId}.json`);
-            if (!fs.existsSync(canonicalPath)) return false;
-            const stat = fs.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;
+    private syncCanonicalSavedHistoryIfNeeded(): boolean {
+        if (!this.providerSessionId) return false;
+        if (this.type === 'hermes-cli') {
+            try {
+                const canonicalPath = path.join(os.homedir(), '.hermes', 'sessions', `session_${this.providerSessionId}.json`);
+                if (!fs.existsSync(canonicalPath)) return false;
+                const stat = fs.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;
     }
 
     private restorePersistedHistoryFromCurrentSession(): void {
         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(

package/src/providers/provider-session-id.ts

@@ -1,4 +1,5 @@
 const HERMES_SESSION_ID_RE = /^\d{8}_\d{6}_[a-z0-9]+$/i
+const 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
 
 export function normalizeProviderSessionId(providerType: string | undefined, providerSessionId: string | null | undefined): string {
   const normalizedProviderType = typeof providerType === 'string' ? providerType.trim() : ''
@@ -11,6 +12,9 @@ export function normalizeProviderSessionId(providerType: string | undefined, pro
   if (normalizedProviderType === 'hermes-cli' && !HERMES_SESSION_ID_RE.test(normalizedId)) {
     return ''
   }
+  if (normalizedProviderType === 'claude-cli' && !CLAUDE_SESSION_ID_RE.test(normalizedId)) {
+    return ''
+  }
 
   return normalizedId
 }