@bbigbang/core 0.1.0

package/dist/services/claudeControlBroker.js

@@ -0,0 +1,154 @@
+import { randomUUID } from 'node:crypto';
+export class ClaudeControlBroker {
+    controlsPending = new Map();
+    modePending = new Map();
+    modelPending = new Map();
+    commandPending = new Map();
+    nodeRegistry;
+    timeoutMs;
+    constructor(params) {
+        this.nodeRegistry = params.nodeRegistry;
+        this.timeoutMs = params.timeoutMs ?? 15_000;
+    }
+    getControls(nodeId, target) {
+        const requestId = randomUUID();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.controlsPending.delete(requestId);
+                reject(new Error('Claude controls request timed out.'));
+            }, this.timeoutMs);
+            this.controlsPending.set(requestId, { nodeId, resolve, reject, timer });
+            const sent = this.nodeRegistry.send(nodeId, {
+                type: 'claude.controls.request',
+                requestId,
+                target,
+            });
+            if (!sent) {
+                clearTimeout(timer);
+                this.controlsPending.delete(requestId);
+                reject(new Error('Agent node is offline.'));
+            }
+        });
+    }
+    setMode(nodeId, target, modeId) {
+        const requestId = randomUUID();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.modePending.delete(requestId);
+                reject(new Error('Claude set-mode request timed out.'));
+            }, this.timeoutMs);
+            this.modePending.set(requestId, { nodeId, resolve, reject, timer });
+            const sent = this.nodeRegistry.send(nodeId, {
+                type: 'claude.set_mode.request',
+                requestId,
+                target,
+                modeId,
+            });
+            if (!sent) {
+                clearTimeout(timer);
+                this.modePending.delete(requestId);
+                reject(new Error('Agent node is offline.'));
+            }
+        });
+    }
+    setModel(nodeId, target, modelId) {
+        const requestId = randomUUID();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.modelPending.delete(requestId);
+                reject(new Error('Claude set-model request timed out.'));
+            }, this.timeoutMs);
+            this.modelPending.set(requestId, { nodeId, resolve, reject, timer });
+            const sent = this.nodeRegistry.send(nodeId, {
+                type: 'claude.set_model.request',
+                requestId,
+                target,
+                modelId,
+            });
+            if (!sent) {
+                clearTimeout(timer);
+                this.modelPending.delete(requestId);
+                reject(new Error('Agent node is offline.'));
+            }
+        });
+    }
+    executeCommand(nodeId, target, commandName, args) {
+        const requestId = randomUUID();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.commandPending.delete(requestId);
+                reject(new Error('Claude command request timed out.'));
+            }, this.timeoutMs);
+            this.commandPending.set(requestId, { nodeId, resolve, reject, timer });
+            const sent = this.nodeRegistry.send(nodeId, {
+                type: 'claude.command.request',
+                requestId,
+                target,
+                commandName,
+                args,
+            });
+            if (!sent) {
+                clearTimeout(timer);
+                this.commandPending.delete(requestId);
+                reject(new Error('Agent node is offline.'));
+            }
+        });
+    }
+    handleControlsResponse(msg) {
+        this.resolveControlsPending(this.controlsPending, msg, 'Claude controls request failed.');
+    }
+    handleSetModeResponse(msg) {
+        this.resolveControlsPending(this.modePending, msg, 'Claude set-mode request failed.');
+    }
+    handleSetModelResponse(msg) {
+        this.resolveControlsPending(this.modelPending, msg, 'Claude set-model request failed.');
+    }
+    handleCommandResponse(msg) {
+        const pending = this.commandPending.get(msg.requestId);
+        if (!pending)
+            return;
+        this.commandPending.delete(msg.requestId);
+        clearTimeout(pending.timer);
+        if (msg.error || !msg.controls || !msg.result) {
+            pending.reject(new Error(msg.error ?? 'Claude command request failed.'));
+            return;
+        }
+        pending.resolve({
+            controls: msg.controls,
+            result: msg.result,
+        });
+    }
+    rejectPendingForNode(nodeId) {
+        this.rejectControlsMap(this.controlsPending, nodeId);
+        this.rejectControlsMap(this.modePending, nodeId);
+        this.rejectControlsMap(this.modelPending, nodeId);
+        for (const [requestId, pending] of this.commandPending.entries()) {
+            if (pending.nodeId !== nodeId)
+                continue;
+            clearTimeout(pending.timer);
+            pending.reject(new Error(`Agent node disconnected: ${nodeId}`));
+            this.commandPending.delete(requestId);
+        }
+    }
+    resolveControlsPending(pendingMap, msg, fallback) {
+        const pending = pendingMap.get(msg.requestId);
+        if (!pending)
+            return;
+        pendingMap.delete(msg.requestId);
+        clearTimeout(pending.timer);
+        if (msg.error || !msg.controls) {
+            pending.reject(new Error(msg.error ?? fallback));
+            return;
+        }
+        pending.resolve(msg.controls);
+    }
+    rejectControlsMap(pendingMap, nodeId) {
+        for (const [requestId, pending] of pendingMap.entries()) {
+            if (pending.nodeId !== nodeId)
+                continue;
+            clearTimeout(pending.timer);
+            pending.reject(new Error(`Agent node disconnected: ${nodeId}`));
+            pendingMap.delete(requestId);
+        }
+    }
+}

package/dist/services/claudeTranscriptBroker.js

@@ -0,0 +1,100 @@
+import { randomUUID } from 'node:crypto';
+export class ClaudeTranscriptBroker {
+    pending = new Map();
+    nodeRegistry;
+    timeoutMs;
+    constructor(params) {
+        this.nodeRegistry = params.nodeRegistry;
+        this.timeoutMs = params.timeoutMs ?? 15_000;
+    }
+    listFiles(nodeId, workspaceRoot, maxFiles = 1000) {
+        const requestId = randomUUID();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(requestId);
+                reject(new Error('Claude transcript request timed out.'));
+            }, this.timeoutMs);
+            this.pending.set(requestId, { nodeId, kind: 'list', resolve, reject, timer });
+            const sent = this.nodeRegistry.send(nodeId, {
+                type: 'claude.transcript.list.request',
+                requestId,
+                workspaceRoot,
+                maxFiles,
+            });
+            if (!sent) {
+                clearTimeout(timer);
+                this.pending.delete(requestId);
+                reject(new Error('Agent node is offline.'));
+            }
+        });
+    }
+    readFile(nodeId, workspaceRoot, transcriptPath) {
+        const requestId = randomUUID();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(requestId);
+                reject(new Error('Claude transcript request timed out.'));
+            }, this.timeoutMs);
+            this.pending.set(requestId, { nodeId, kind: 'read', resolve, reject, timer });
+            const sent = this.nodeRegistry.send(nodeId, {
+                type: 'claude.transcript.read.request',
+                requestId,
+                workspaceRoot,
+                path: transcriptPath,
+            });
+            if (!sent) {
+                clearTimeout(timer);
+                this.pending.delete(requestId);
+                reject(new Error('Agent node is offline.'));
+            }
+        });
+    }
+    handleListResponse(msg) {
+        const pending = this.pending.get(msg.requestId);
+        if (!pending || pending.kind !== 'list')
+            return;
+        this.pending.delete(msg.requestId);
+        clearTimeout(pending.timer);
+        if (msg.error || !msg.rootPath || !msg.files) {
+            pending.reject(new Error(formatErrorMessage(msg.errorCode, msg.error)));
+            return;
+        }
+        pending.resolve({
+            rootPath: msg.rootPath,
+            files: msg.files,
+            truncated: Boolean(msg.truncated),
+        });
+    }
+    handleReadResponse(msg) {
+        const pending = this.pending.get(msg.requestId);
+        if (!pending || pending.kind !== 'read')
+            return;
+        this.pending.delete(msg.requestId);
+        clearTimeout(pending.timer);
+        if (msg.error || !msg.rootPath || msg.content === undefined || msg.size === undefined) {
+            pending.reject(new Error(formatErrorMessage(msg.errorCode, msg.error)));
+            return;
+        }
+        pending.resolve({
+            rootPath: msg.rootPath,
+            path: msg.path,
+            content: msg.content,
+            size: msg.size,
+            modifiedAt: msg.modifiedAt ?? null,
+        });
+    }
+    rejectPendingForNode(nodeId) {
+        for (const [requestId, pending] of this.pending.entries()) {
+            if (pending.nodeId !== nodeId)
+                continue;
+            clearTimeout(pending.timer);
+            pending.reject(new Error(`Agent node disconnected: ${nodeId}`));
+            this.pending.delete(requestId);
+        }
+    }
+}
+function formatErrorMessage(errorCode, error) {
+    if (errorCode)
+        return `${errorCode}:${error ?? 'claude transcript request failed'}`;
+    return error ?? 'claude transcript request failed';
+}

package/dist/services/claudeTranscriptService.js

@@ -0,0 +1,359 @@
+import { log } from '@bbigbang/runtime-acp';
+import { attachPlatformInputsToTurns, getRolloutSortTime, listPlatformInputsForConversation, parseReplyTarget, parseTriggerTarget, } from './codexTranscriptService.js';
+const MAX_INLINE_TRANSCRIPT_BYTES = 2 * 1024 * 1024;
+const HEURISTIC_TRANSCRIPT_LOOKBACK_MS = 24 * 60 * 60 * 1000;
+const MAX_SESSION_MATCH_TRANSCRIPT_FILES = 8;
+const MAX_HEURISTIC_TRANSCRIPT_FILES = 6;
+export class ClaudeTranscriptService {
+    rolloutCache = new Map();
+    db;
+    broker;
+    getConversationById;
+    getAgentById;
+    getAcpSessionIdByConversationId;
+    constructor(params) {
+        this.db = params.db;
+        this.broker = params.broker;
+        this.getConversationById = params.getConversationById;
+        this.getAgentById = params.getAgentById;
+        this.getAcpSessionIdByConversationId = params.getAcpSessionIdByConversationId ?? (() => null);
+    }
+    async getConversationDebug(conversationId) {
+        const conversation = this.getConversationById(conversationId);
+        if (!conversation)
+            throw new Error('Conversation not found.');
+        if (conversation.agentType !== 'claude_acp' && conversation.agentType !== 'claude_sdk') {
+            throw new Error('Claude debug is only supported for Claude conversations.');
+        }
+        if (!conversation.nodeId)
+            throw new Error('Conversation is not assigned to a remote node.');
+        if (!conversation.workspacePath)
+            throw new Error('Conversation has no workspace path.');
+        const replyTarget = (conversation.replyTarget ?? '').trim();
+        if (!replyTarget)
+            throw new Error('Conversation has no reply target.');
+        const acpSessionId = this.getAcpSessionIdByConversationId(conversationId)?.trim() || undefined;
+        const heuristicTranscriptCutoff = Date.now() - HEURISTIC_TRANSCRIPT_LOOKBACK_MS;
+        const listing = await this.broker.listFiles(conversation.nodeId, conversation.workspacePath).catch((error) => {
+            log.warn('[claude-debug] failed to list transcripts', {
+                conversationId,
+                nodeId: conversation.nodeId,
+                workspacePath: conversation.workspacePath,
+                error: String(error?.message ?? error),
+            });
+            return {
+                rootPath: '',
+                files: [],
+                truncated: false,
+            };
+        });
+        const exactSessionRollouts = [];
+        const heuristicRollouts = [];
+        const workspaceCandidates = listing.files.filter((file) => {
+            if (!acpSessionId && file.modifiedAt < heuristicTranscriptCutoff)
+                return false;
+            if (file.size > MAX_INLINE_TRANSCRIPT_BYTES)
+                return false;
+            if (file.cwd && file.cwd.trim() !== conversation.workspacePath)
+                return false;
+            return true;
+        });
+        const filesToScan = acpSessionId
+            ? selectTranscriptCandidatesForSession(workspaceCandidates, acpSessionId, heuristicTranscriptCutoff)
+            : workspaceCandidates.slice(0, MAX_HEURISTIC_TRANSCRIPT_FILES);
+        for (const file of filesToScan) {
+            const loaded = await this.loadParsedRollout(conversation.nodeId, conversation.workspacePath, file);
+            if (loaded.timedOut)
+                break;
+            const parsed = loaded.rollout;
+            if (!parsed)
+                continue;
+            const sessionCwd = parsed.cwd?.trim();
+            if (!sessionCwd || sessionCwd !== conversation.workspacePath)
+                continue;
+            const exactSessionMatch = acpSessionId != null
+                && (parsed.sessionId === acpSessionId || file.path.includes(acpSessionId));
+            let matchedTurns = parsed.turns.filter((turn) => (turn.replyTarget ?? '').trim() === replyTarget);
+            if (matchedTurns.length === 0 && exactSessionMatch) {
+                matchedTurns = parsed.turns.filter((turn) => !(turn.replyTarget ?? '').trim());
+                if (matchedTurns.length === 0) {
+                    matchedTurns = parsed.turns;
+                }
+            }
+            if (matchedTurns.length === 0)
+                continue;
+            const matchedRollout = {
+                ...parsed,
+                turns: matchedTurns,
+            };
+            if (exactSessionMatch) {
+                exactSessionRollouts.push(matchedRollout);
+            }
+            else {
+                heuristicRollouts.push(matchedRollout);
+            }
+        }
+        const sessionMatchMissed = Boolean(acpSessionId) && exactSessionRollouts.length === 0;
+        const usingExactSession = Boolean(acpSessionId) && exactSessionRollouts.length > 0;
+        const rollouts = usingExactSession ? exactSessionRollouts : heuristicRollouts;
+        rollouts.sort((a, b) => {
+            const aTime = getRolloutSortTime(a);
+            const bTime = getRolloutSortTime(b);
+            return usingExactSession ? aTime - bTime : bTime - aTime;
+        });
+        const platformInputs = listPlatformInputsForConversation(this.db, {
+            conversation,
+            getAgentById: this.getAgentById,
+            includePlatformTrace: false,
+            newestFirst: !usingExactSession,
+        });
+        const unmatchedPlatformInputs = attachPlatformInputsToTurns(rollouts, platformInputs);
+        return {
+            provider: 'claude',
+            conversationId: conversation.id,
+            agentType: conversation.agentType,
+            workspacePath: conversation.workspacePath,
+            replyTarget,
+            acpSessionId,
+            matchMode: usingExactSession ? 'acp_session_id' : 'heuristic',
+            sessionMatchMissed,
+            truncated: listing.truncated,
+            rollouts,
+            unmatchedPlatformInputs,
+            notificationDeliveries: [],
+        };
+    }
+    async loadParsedRollout(nodeId, workspacePath, file) {
+        const cacheKey = `${nodeId}:${workspacePath}:${file.path}:${file.modifiedAt}:${file.size}`;
+        const cached = this.rolloutCache.get(cacheKey);
+        if (cached) {
+            this.rolloutCache.delete(cacheKey);
+            this.rolloutCache.set(cacheKey, cached);
+            return { rollout: cached, timedOut: false };
+        }
+        let result;
+        try {
+            result = await this.broker.readFile(nodeId, workspacePath, file.path);
+        }
+        catch (error) {
+            const message = String(error?.message ?? error);
+            log.warn('[claude-debug] failed to read transcript', {
+                nodeId,
+                workspacePath,
+                path: file.path,
+                error: message,
+            });
+            return { rollout: null, timedOut: isTranscriptTimeoutError(message) };
+        }
+        const parsed = parseClaudeRollout(result.content, {
+            path: file.path,
+            modifiedAt: file.modifiedAt,
+            size: file.size,
+        });
+        setCachedRollout(this.rolloutCache, cacheKey, parsed);
+        return { rollout: parsed, timedOut: false };
+    }
+}
+function parseClaudeRollout(content, meta) {
+    const lines = content.split(/\r?\n/).filter((line) => line.trim().length > 0);
+    let sessionId;
+    let cwd;
+    const turns = [];
+    let currentTurn = null;
+    const functionCallById = new Map();
+    const pushCurrentTurn = () => {
+        if (!currentTurn)
+            return;
+        turns.push(currentTurn);
+        currentTurn = null;
+        functionCallById.clear();
+    };
+    for (const line of lines) {
+        let parsedLine;
+        try {
+            parsedLine = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const lineType = stringValue(parsedLine.type);
+        const timestamp = stringValue(parsedLine.timestamp) ?? new Date(meta.modifiedAt).toISOString();
+        sessionId = sessionId ?? stringValue(parsedLine.sessionId);
+        cwd = cwd ?? stringValue(parsedLine.cwd);
+        if (lineType === 'user') {
+            const message = objectValue(parsedLine.message);
+            const role = stringValue(message?.role);
+            const textBlocks = extractClaudeTextBlocks(message?.content);
+            const toolResults = extractClaudeToolResults(message?.content);
+            if (role === 'user' && textBlocks.length > 0) {
+                pushCurrentTurn();
+                const combined = textBlocks.join('\n\n');
+                currentTurn = {
+                    turnId: stringValue(parsedLine.uuid) ?? `turn-${turns.length + 1}`,
+                    timestamp,
+                    cwd: stringValue(parsedLine.cwd) ?? cwd,
+                    replyTarget: parseReplyTarget(combined),
+                    triggerTarget: parseTriggerTarget(combined),
+                    inputBlocks: textBlocks,
+                    combinedUserMessage: combined,
+                    functionCalls: [],
+                    assistantOutputs: [],
+                    reasoningSummaries: [],
+                    hasEncryptedReasoning: false,
+                };
+            }
+            else if (currentTurn && toolResults.length > 0) {
+                const toolUseId = stringValueArray(message?.content, 'tool_use_id')[0];
+                const outputText = toolResults.join('\n\n');
+                if (toolUseId) {
+                    const existing = functionCallById.get(toolUseId);
+                    if (existing) {
+                        existing.output = outputText;
+                        existing.outputTimestamp = timestamp;
+                    }
+                }
+            }
+            continue;
+        }
+        if (lineType === 'assistant') {
+            if (!currentTurn)
+                continue;
+            const message = objectValue(parsedLine.message);
+            const assistantTexts = extractClaudeTextBlocks(message?.content);
+            for (const text of assistantTexts) {
+                currentTurn.assistantOutputs.push({
+                    text,
+                    phase: stringValue(message?.stop_reason) ?? undefined,
+                    timestamp,
+                });
+            }
+            const toolUses = extractClaudeToolUses(message?.content);
+            for (const toolUse of toolUses) {
+                const call = {
+                    callId: toolUse.id,
+                    name: toolUse.name,
+                    arguments: toolUse.input,
+                    timestamp,
+                };
+                functionCallById.set(call.callId, call);
+                currentTurn.functionCalls.push(call);
+            }
+            const usage = objectValue(message?.usage);
+            if (usage) {
+                currentTurn.tokenUsage = parseClaudeTokenUsage(usage);
+            }
+        }
+    }
+    pushCurrentTurn();
+    return {
+        path: meta.path,
+        modifiedAt: meta.modifiedAt,
+        size: meta.size,
+        sessionId,
+        cwd,
+        preludeDeveloperMessages: [],
+        preludeUserMessages: [],
+        turns,
+    };
+}
+function extractClaudeTextBlocks(content) {
+    const blocks = Array.isArray(content) ? content : [];
+    return blocks.flatMap((block) => {
+        const typed = objectValue(block);
+        if (!typed)
+            return [];
+        if (stringValue(typed.type) !== 'text')
+            return [];
+        const text = stringValue(typed.text);
+        return text ? [text] : [];
+    });
+}
+function extractClaudeToolResults(content) {
+    const blocks = Array.isArray(content) ? content : [];
+    return blocks.flatMap((block) => {
+        const typed = objectValue(block);
+        if (!typed)
+            return [];
+        if (stringValue(typed.type) !== 'tool_result')
+            return [];
+        return extractClaudeTextBlocks(typed.content);
+    });
+}
+function selectTranscriptCandidatesForSession(files, acpSessionId, heuristicCutoffMs) {
+    const exactCandidates = files.filter((file) => file.sessionId === acpSessionId);
+    if (exactCandidates.length > 0)
+        return exactCandidates.slice(0, MAX_SESSION_MATCH_TRANSCRIPT_FILES);
+    const hintedCandidates = files.filter((file) => file.path.includes(acpSessionId));
+    if (hintedCandidates.length > 0)
+        return hintedCandidates.slice(0, MAX_SESSION_MATCH_TRANSCRIPT_FILES);
+    const heuristicCandidates = files.filter((file) => file.modifiedAt >= heuristicCutoffMs);
+    if (heuristicCandidates.length > 0)
+        return heuristicCandidates.slice(0, MAX_HEURISTIC_TRANSCRIPT_FILES);
+    return files.slice(0, MAX_HEURISTIC_TRANSCRIPT_FILES);
+}
+function setCachedRollout(cache, key, rollout, maxEntries = 64) {
+    cache.set(key, rollout);
+    while (cache.size > maxEntries) {
+        const oldestKey = cache.keys().next().value;
+        if (!oldestKey)
+            break;
+        cache.delete(oldestKey);
+    }
+}
+function extractClaudeToolUses(content) {
+    const blocks = Array.isArray(content) ? content : [];
+    return blocks.flatMap((block) => {
+        const typed = objectValue(block);
+        if (!typed)
+            return [];
+        if (stringValue(typed.type) !== 'tool_use')
+            return [];
+        const id = stringValue(typed.id);
+        const name = stringValue(typed.name);
+        if (!id || !name)
+            return [];
+        return [{
+                id,
+                name,
+                input: JSON.stringify(typed.input ?? {}, null, 2),
+            }];
+    });
+}
+function parseClaudeTokenUsage(usage) {
+    const inputTokens = numberValue(usage.input_tokens) ?? numberValue(usage.prompt_tokens);
+    const cachedInputTokens = numberValue(usage.cache_read_input_tokens) ?? numberValue(usage.cached_tokens);
+    return {
+        currentInputTokens: inputTokens,
+        inputTokens,
+        cachedInputTokens,
+        currentCachedInputTokens: cachedInputTokens,
+        outputTokens: numberValue(usage.output_tokens),
+        totalTokens: addNumbers(inputTokens, numberValue(usage.output_tokens)),
+        modelContextWindow: 256000,
+    };
+}
+function objectValue(value) {
+    return value && typeof value === 'object' ? value : null;
+}
+function stringValue(value) {
+    return typeof value === 'string' && value.trim() ? value : undefined;
+}
+function numberValue(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function addNumbers(a, b) {
+    if (a == null && b == null)
+        return undefined;
+    return (a ?? 0) + (b ?? 0);
+}
+function stringValueArray(content, key) {
+    const blocks = Array.isArray(content) ? content : [];
+    return blocks.flatMap((block) => {
+        const typed = objectValue(block);
+        const value = stringValue(typed?.[key]);
+        return value ? [value] : [];
+    });
+}
+function isTranscriptTimeoutError(message) {
+    return message.toLowerCase().includes('timed out');
+}