@sumicom/quicksave 0.5.2 → 0.6.1

package/dist/ai/claudeCodeService.js

@@ -1,764 +0,0 @@
-import { EventEmitter } from 'events';
-import { createReadStream } from 'fs';
-import { readdir, stat } from 'fs/promises';
-import { createInterface } from 'readline';
-import { join } from 'path';
-import { homedir } from 'os';
-import { unstable_v2_createSession, unstable_v2_resumeSession, listSessions, getSessionMessages, } from '@anthropic-ai/claude-agent-sdk';
-const TOOL_RESULT_TRUNCATE_LENGTH = 500;
-const DEFAULT_MODEL = 'claude-sonnet-4-6';
-/** Tools auto-approved at each permission level (no user prompt).
- *  Read/Glob/Grep are always auto-approved at SDK level (allowedTools).
- *  Tools NOT listed here go through canUseTool → permission prompt.
- *
- *  Risk tiers:
- *  - Safe:     Edit, Write, NotebookEdit, TodoWrite, Agent, EnterWorktree, ExitWorktree
- *  - Network:  WebFetch, WebSearch
- *  - Execute:  Bash
- *  - Code/Control: Skill, ToolSearch, Config
- *  - Schedule: CronCreate, CronDelete (arbitrary scheduled execution)
- *  - Remote:   RemoteTrigger (triggers remote agents)
- *  - Workflow:  EnterPlanMode, ExitPlanMode (ExitPlanMode has its own interactive UI)
- */
-const AUTO_APPROVE = {
-    bypassPermissions: new Set([
-        // Safe
-        'Edit', 'Write', 'NotebookEdit', 'TodoWrite', 'Agent', 'EnterWorktree', 'ExitWorktree',
-        // Network
-        'WebFetch', 'WebSearch',
-        // Execute
-        'Bash',
-        // Code/Control
-        'Skill', 'ToolSearch', 'Config',
-        // Schedule + Remote
-        'CronCreate', 'CronDelete', 'CronList', 'RemoteTrigger',
-        // Workflow
-        'EnterPlanMode', 'ExitPlanMode',
-        // Background tasks
-        'TaskOutput', 'TaskStop',
-    ]),
-    acceptEdits: new Set(['Edit', 'Write', 'NotebookEdit', 'TodoWrite', 'Agent', 'EnterWorktree', 'ExitWorktree']),
-    default: new Set(['TodoWrite', 'EnterWorktree', 'ExitWorktree', 'Agent']),
-    plan: new Set(),
-};
-/** Extract readable text from tool_result content (which may be a string or array of blocks). */
-function extractToolResultText(content) {
-    if (typeof content === 'string')
-        return content;
-    if (Array.isArray(content)) {
-        return content
-            .filter((b) => b.type === 'text')
-            .map((b) => b.text || '')
-            .join('\n');
-    }
-    return JSON.stringify(content);
-}
-// ─── Direct JSONL reader ──────────────────────────────────────────────────────
-// getSessionMessages() from the SDK follows the parentUuid chain, which stops
-// at each compact_boundary. Reading the file directly lets us surface all
-// messages across every compaction epoch in a single flat list.
-//
-// Set to false to fall back to the SDK reader (only shows current epoch).
-const READ_THROUGH_COMPACT_BOUNDARY = false;
-function projectDirName(cwd) {
-    // Mirrors SDK logic: replace non-alphanumeric chars with '-'.
-    // Paths under 200 chars use the raw replacement; longer ones get a hash
-    // suffix — but that edge case is unlikely for normal project paths.
-    return cwd.replace(/[^a-zA-Z0-9]/g, '-');
-}
-function jsonlPath(sessionId, cwd) {
-    return join(homedir(), '.claude', 'projects', projectDirName(cwd), `${sessionId}.jsonl`);
-}
-async function readAllJSONLMessages(sessionId, cwd) {
-    const filePath = jsonlPath(sessionId, cwd);
-    const entries = [];
-    await new Promise((resolve, reject) => {
-        const rl = createInterface({
-            input: createReadStream(filePath),
-            crlfDelay: Infinity,
-        });
-        rl.on('line', (line) => {
-            if (!line.trim())
-                return;
-            try {
-                const obj = JSON.parse(line);
-                const t = obj.type;
-                // Keep user/assistant turns and compact_boundary markers; skip progress/queue-op
-                if (t === 'user' || t === 'assistant' || (t === 'system' && obj.subtype === 'compact_boundary')) {
-                    entries.push(obj);
-                }
-            }
-            catch { /* malformed line — skip */ }
-        });
-        rl.on('close', resolve);
-        rl.on('error', reject);
-    });
-    return entries;
-}
-export class ClaudeCodeService extends EventEmitter {
-    sessions = new Map();
-    sessionPermissions = new Map(); // persists across active/inactive
-    pendingInputRequests = new Map();
-    requestCounter = 0;
-    preferences = {
-        model: DEFAULT_MODEL,
-    };
-    constructor() {
-        super();
-    }
-    /**
-     * Initialize preferences from the most recently used session's JSONL.
-     * Reads the last assistant message's model field.
-     */
-    async initPreferences() {
-        try {
-            const claudeDir = join(homedir(), '.claude', 'projects');
-            const projectDirs = await readdir(claudeDir);
-            let mostRecentFile = null;
-            let mostRecentMtime = 0;
-            for (const projectDir of projectDirs) {
-                const projectPath = join(claudeDir, projectDir);
-                try {
-                    const files = await readdir(projectPath);
-                    for (const file of files) {
-                        if (!file.endsWith('.jsonl'))
-                            continue;
-                        const filePath = join(projectPath, file);
-                        const fileStat = await stat(filePath);
-                        if (fileStat.mtimeMs > mostRecentMtime) {
-                            mostRecentMtime = fileStat.mtimeMs;
-                            mostRecentFile = filePath;
-                        }
-                    }
-                }
-                catch { /* skip unreadable dirs */ }
-            }
-            if (!mostRecentFile)
-                return;
-            const assistantEntries = await new Promise((resolve, reject) => {
-                const results = [];
-                const rl = createInterface({ input: createReadStream(mostRecentFile), crlfDelay: Infinity });
-                rl.on('line', (line) => {
-                    if (!line.trim())
-                        return;
-                    try {
-                        const obj = JSON.parse(line);
-                        if (obj.type === 'assistant')
-                            results.push(obj);
-                    }
-                    catch { /* malformed line */ }
-                });
-                rl.on('close', () => resolve(results));
-                rl.on('error', reject);
-            });
-            for (let i = assistantEntries.length - 1; i >= 0; i--) {
-                const model = assistantEntries[i].message?.model;
-                if (model) {
-                    this.preferences.model = model;
-                    break;
-                }
-            }
-        }
-        catch { /* use defaults */ }
-    }
-    getPreferences() {
-        return { ...this.preferences };
-    }
-    /**
-     * Update preferences. Returns the applied preferences (may differ if validation fails).
-     * Emits 'preferences-updated' if any value actually changed.
-     */
-    setPreferences(prefs) {
-        const next = { ...this.preferences };
-        let changed = false;
-        if (prefs.model !== undefined && prefs.model !== this.preferences.model) {
-            next.model = prefs.model;
-            changed = true;
-        }
-        if (changed) {
-            this.preferences = next;
-            this.emit('preferences-updated', this.preferences);
-        }
-        return { ...this.preferences };
-    }
-    /** Build and emit a session-updated event with current state. */
-    emitSessionUpdate(sessionId) {
-        const ps = this.sessions.get(sessionId);
-        const hasPendingInput = Array.from(this.pendingInputRequests.values())
-            .some((p) => p.request.sessionId === sessionId);
-        this.emit('session-updated', {
-            sessionId,
-            isActive: !!ps,
-            isStreaming: ps?.streaming ?? false,
-            hasPendingInput,
-            permissionMode: ps?.permissionLevel,
-        });
-    }
-    async listAvailableSessions(cwd) {
-        const sessions = await listSessions({ dir: cwd, limit: 50 });
-        // Enrich with live state + detect pending from JSONL
-        const pendingSessionIds = new Set(Array.from(this.pendingInputRequests.values()).map((p) => p.request.sessionId));
-        // Check JSONL for sessions not in memory (cold pending detection)
-        const enriched = await Promise.all(sessions.map(async (s) => {
-            const isActive = this.sessions.has(s.sessionId);
-            const isStreaming = this.sessions.get(s.sessionId)?.streaming ?? false;
-            let hasPendingInput = pendingSessionIds.has(s.sessionId);
-            // If not already known as pending from memory, check JSONL tail
-            if (!hasPendingInput) {
-                hasPendingInput = await this.detectPendingFromJSONL(s.sessionId, cwd);
-            }
-            return {
-                sessionId: s.sessionId,
-                summary: s.summary,
-                lastModified: s.lastModified,
-                createdAt: s.createdAt,
-                cwd: s.cwd,
-                gitBranch: s.gitBranch,
-                isActive,
-                isStreaming,
-                hasPendingInput,
-                permissionMode: this.sessions.get(s.sessionId)?.permissionLevel ?? this.sessionPermissions.get(s.sessionId),
-            };
-        }));
-        // Sort: pending first, then active, then by lastModified
-        enriched.sort((a, b) => {
-            if (a.hasPendingInput !== b.hasPendingInput)
-                return a.hasPendingInput ? -1 : 1;
-            if (a.isActive !== b.isActive)
-                return a.isActive ? -1 : 1;
-            return b.lastModified - a.lastModified;
-        });
-        return enriched;
-    }
-    /**
-     * Check if a session's last message in the SDK JSONL is an unanswered tool_use.
-     * Reads only the last few messages to keep it fast.
-     */
-    async detectPendingFromJSONL(sessionId, cwd) {
-        try {
-            const allMessages = READ_THROUGH_COMPACT_BOUNDARY
-                ? await readAllJSONLMessages(sessionId, cwd)
-                : await getSessionMessages(sessionId, { dir: cwd });
-            if (allMessages.length === 0)
-                return false;
-            const last = allMessages[allMessages.length - 1];
-            // Last message is assistant with a tool_use block and no following user/tool_result
-            if (last.type !== 'assistant')
-                return false;
-            const content = last.message?.content;
-            if (!Array.isArray(content))
-                return false;
-            return content.some((block) => block.type === 'tool_use');
-        }
-        catch {
-            return false;
-        }
-    }
-    async getMessages(sessionId, cwd, offset = 0, limit = 50) {
-        const allMessages = READ_THROUGH_COMPACT_BOUNDARY
-            ? await readAllJSONLMessages(sessionId, cwd)
-            : await getSessionMessages(sessionId, { dir: cwd });
-        const total = allMessages.length;
-        const tailStart = Math.max(0, total - offset - limit);
-        const tailEnd = Math.max(0, total - offset);
-        const sliced = allMessages.slice(tailStart, tailEnd);
-        const messages = sliced.flatMap((msg, i) => {
-            // compact_boundary system entries — render as a divider
-            if (msg.type === 'system' && msg.subtype === 'compact_boundary') {
-                return [{
-                        index: tailStart + i,
-                        role: 'system',
-                        content: 'Context compacted',
-                    }];
-            }
-            const role = msg.type;
-            const rawMessage = msg.message;
-            const expanded = [];
-            if (rawMessage?.content) {
-                if (typeof rawMessage.content === 'string') {
-                    expanded.push({ index: tailStart + i, role, content: rawMessage.content });
-                }
-                else if (Array.isArray(rawMessage.content)) {
-                    const textParts = [];
-                    for (const block of rawMessage.content) {
-                        if (block.type === 'text') {
-                            textParts.push(block.text);
-                        }
-                        else if (block.type === 'tool_use') {
-                            expanded.push({
-                                index: tailStart + i,
-                                role,
-                                content: '',
-                                toolName: block.name,
-                                toolInput: JSON.stringify(block.input),
-                                toolUseId: block.id,
-                            });
-                        }
-                        else if (block.type === 'tool_result') {
-                            const resultStr = extractToolResultText(block.content);
-                            const truncated = resultStr.length > TOOL_RESULT_TRUNCATE_LENGTH;
-                            expanded.push({
-                                index: tailStart + i,
-                                role,
-                                content: '',
-                                toolResult: truncated
-                                    ? resultStr.slice(0, TOOL_RESULT_TRUNCATE_LENGTH) + ' [truncated]'
-                                    : resultStr,
-                                toolResultForId: block.tool_use_id,
-                                truncated,
-                            });
-                        }
-                    }
-                    if (textParts.length > 0) {
-                        expanded.unshift({ index: tailStart + i, role, content: textParts.join('\n') });
-                    }
-                }
-            }
-            if (expanded.length === 0) {
-                expanded.push({ index: tailStart + i, role, content: '' });
-            }
-            return expanded;
-        });
-        return {
-            messages,
-            total,
-            hasMore: tailStart > 0,
-        };
-    }
-    /**
-     * Create a V2 session with the given cwd.
-     * V2 SDKSessionOptions doesn't expose `cwd`, so we temporarily change
-     * process.cwd() around the synchronous createSession() call.
-     */
-    createSessionWithCwd(cwd, sessionId, opts) {
-        const originalCwd = process.cwd();
-        try {
-            process.chdir(cwd);
-            // allowedTools = SDK auto-approve list (bypasses canUseTool entirely).
-            // Only list tools that should NEVER prompt at ANY permission level.
-            // Everything else goes through permissionMode → canUseTool for dynamic control.
-            const sessionOpts = {
-                model: opts.model ?? DEFAULT_MODEL,
-                allowedTools: opts.allowedTools ?? ['Read', 'Glob', 'Grep'],
-                permissionMode: 'default',
-                settingSources: ['user', 'project', 'local'],
-                canUseTool: async (toolName, input, options) => {
-                    const resolvedSessionId = sessionId ?? 'unknown';
-                    // Check runtime permission level — auto-approve if tool is in the allow set
-                    const ps = resolvedSessionId !== 'unknown' ? this.sessions.get(resolvedSessionId) : undefined;
-                    const level = ps?.permissionLevel ?? 'acceptEdits';
-                    if (AUTO_APPROVE[level].has(toolName)) {
-                        return { behavior: 'allow', updatedInput: input };
-                    }
-                    const requestId = `perm-${++this.requestCounter}`;
-                    // AskUserQuestion: forward as question type with options
-                    const isQuestion = toolName === 'AskUserQuestion';
-                    const questions = isQuestion ? input.questions : undefined;
-                    // Forward request to PWA
-                    const request = {
-                        sessionId: resolvedSessionId,
-                        requestId,
-                        inputType: isQuestion ? 'question' : 'permission',
-                        title: isQuestion
-                            ? questions?.[0]?.question ?? 'Question from Claude'
-                            : (options.title ?? `Allow ${toolName}?`),
-                        message: isQuestion
-                            ? undefined
-                            : (options.description ?? JSON.stringify(input).slice(0, 500)),
-                        toolName,
-                        toolInput: input,
-                        // Include structured options for question type
-                        ...(isQuestion && questions ? {
-                            options: questions.flatMap((q) => (q.options ?? []).map((opt) => ({
-                                key: opt.label,
-                                label: opt.label,
-                                description: opt.description,
-                            }))),
-                        } : {}),
-                    };
-                    this.emit('user-input-request', request);
-                    this.emitSessionUpdate(resolvedSessionId);
-                    // Wait for explicit user response (no timeout — user must act)
-                    const response = await this.waitForUserInput(requestId, request, options.signal);
-                    if (response.action === 'deny') {
-                        return { behavior: 'deny', message: 'User denied permission' };
-                    }
-                    // For AskUserQuestion, inject user's answer into the tool input
-                    if (isQuestion && response.response) {
-                        const answers = {};
-                        if (questions?.[0]?.question) {
-                            answers[questions[0].question] = response.response;
-                        }
-                        return {
-                            behavior: 'allow',
-                            updatedInput: { ...input, answers },
-                        };
-                    }
-                    return { behavior: 'allow', updatedInput: input };
-                },
-            };
-            if (opts.resumeSessionId) {
-                return unstable_v2_resumeSession(opts.resumeSessionId, sessionOpts);
-            }
-            return unstable_v2_createSession(sessionOpts);
-        }
-        finally {
-            process.chdir(originalCwd);
-        }
-    }
-    waitForUserInput(requestId, request, signal) {
-        return new Promise((resolve) => {
-            this.pendingInputRequests.set(requestId, { resolve, request });
-            // Only auto-resolve if the SDK itself aborts (e.g. session closed)
-            signal?.addEventListener('abort', () => {
-                this.pendingInputRequests.delete(requestId);
-                resolve({ sessionId: '', requestId, action: 'allow' });
-            }, { once: true });
-        });
-    }
-    /**
-     * Called by message handler when PWA sends a user input response.
-     */
-    resolveUserInput(response) {
-        const pending = this.pendingInputRequests.get(response.requestId);
-        if (!pending)
-            return false;
-        this.pendingInputRequests.delete(response.requestId);
-        pending.resolve(response);
-        this.emit('user-input-resolved', { requestId: response.requestId, sessionId: pending.request.sessionId });
-        this.emitSessionUpdate(pending.request.sessionId);
-        return true;
-    }
-    /**
-     * Get all pending user input requests (for re-sending to a reconnected client).
-     */
-    getPendingInputRequests() {
-        return Array.from(this.pendingInputRequests.values()).map((p) => p.request);
-    }
-    async startSession(opts) {
-        const validModes = ['default', 'acceptEdits', 'bypassPermissions', 'plan'];
-        const level = validModes.includes(opts.permissionMode)
-            ? opts.permissionMode : 'acceptEdits';
-        const session = this.createSessionWithCwd(opts.cwd, null, {
-            allowedTools: opts.allowedTools,
-            model: opts.model,
-            permissionMode: opts.permissionMode,
-        });
-        const prompt = opts.systemPrompt
-            ? `[System context: ${opts.systemPrompt}]\n\n${opts.prompt}`
-            : opts.prompt;
-        await session.send(prompt);
-        this.emit('stream', {
-            sessionId: '', streamId: opts.streamId,
-            eventType: 'user_message',
-            content: opts.prompt,
-        });
-        const sessionId = await new Promise((resolve) => {
-            this.consumeStream(session, opts.streamId, (id) => {
-                this.sessions.set(id, {
-                    session,
-                    sessionId: id,
-                    cwd: opts.cwd,
-                    streaming: true,
-                    cancelStreaming: null,
-                    permissionLevel: level,
-                });
-                this.sessionPermissions.set(id, level);
-                this.emitSessionUpdate(id);
-                resolve(id);
-            });
-        });
-        return sessionId;
-    }
-    async resumeSession(opts) {
-        const existing = this.sessions.get(opts.sessionId);
-        if (existing) {
-            console.log(`[v2] hot resume session=${opts.sessionId}`);
-            existing.streaming = true;
-            this.emitSessionUpdate(opts.sessionId);
-            this.emit('stream', {
-                sessionId: opts.sessionId, streamId: opts.streamId,
-                eventType: 'user_message',
-                content: opts.prompt,
-            });
-            await existing.session.send(opts.prompt);
-            this.consumeStream(existing.session, opts.streamId, () => {
-                // Session ID already captured
-            });
-            return opts.sessionId;
-        }
-        console.log(`[v2] cold resume session=${opts.sessionId}`);
-        const session = this.createSessionWithCwd(opts.cwd, opts.sessionId, {
-            resumeSessionId: opts.sessionId,
-        });
-        this.emit('stream', {
-            sessionId: opts.sessionId, streamId: opts.streamId,
-            eventType: 'user_message',
-            content: opts.prompt,
-        });
-        await session.send(opts.prompt);
-        const actualSessionId = await new Promise((resolve) => {
-            this.consumeStream(session, opts.streamId, (id) => {
-                if (id !== opts.sessionId) {
-                    this.emit('stream', {
-                        sessionId: id, streamId: opts.streamId,
-                        eventType: 'system',
-                        content: `Warning: SDK created new session ${id} instead of resuming ${opts.sessionId}`,
-                    });
-                }
-                const restoredLevel = this.sessionPermissions.get(opts.sessionId) ?? 'acceptEdits';
-                this.sessions.set(id, {
-                    session,
-                    sessionId: id,
-                    cwd: opts.cwd,
-                    streaming: true,
-                    cancelStreaming: null,
-                    permissionLevel: restoredLevel,
-                });
-                this.sessionPermissions.set(id, restoredLevel);
-                this.emitSessionUpdate(id);
-                resolve(id);
-            });
-        });
-        return actualSessionId;
-    }
-    cancelSession(sessionId) {
-        const ps = this.sessions.get(sessionId);
-        if (!ps)
-            return false;
-        // Stop streaming but keep the session process alive
-        if (ps.cancelStreaming) {
-            ps.cancelStreaming();
-        }
-        ps.streaming = false;
-        return true;
-    }
-    setPermissionLevel(sessionId, level) {
-        const ps = this.sessions.get(sessionId);
-        if (ps) {
-            ps.permissionLevel = level;
-        }
-        // Persist across active/inactive lifecycle
-        this.sessionPermissions.set(sessionId, level);
-        // Always broadcast so all clients sync, even for inactive sessions
-        this.emit('session-updated', {
-            sessionId,
-            isActive: !!ps,
-            isStreaming: ps?.streaming ?? false,
-            hasPendingInput: ps ? Array.from(this.pendingInputRequests.values()).some((p) => p.request.sessionId === sessionId) : false,
-            permissionMode: level,
-        });
-        return true;
-    }
-    getPermissionLevel(sessionId) {
-        return this.sessions.get(sessionId)?.permissionLevel ?? 'acceptEdits';
-    }
-    getActiveSessions() {
-        const pendingSessionIds = new Set(Array.from(this.pendingInputRequests.values()).map((p) => p.request.sessionId));
-        return Array.from(this.sessions.entries()).map(([id, ps]) => ({
-            sessionId: id,
-            cwd: ps.cwd,
-            isStreaming: ps.streaming,
-            hasPendingInput: pendingSessionIds.has(id),
-            permissionMode: ps.permissionLevel,
-        }));
-    }
-    closeSession(sessionId) {
-        const ps = this.sessions.get(sessionId);
-        if (!ps)
-            return false;
-        // Stop streaming if active
-        if (ps.cancelStreaming) {
-            ps.cancelStreaming();
-        }
-        // Terminate the subprocess
-        ps.session.close();
-        this.sessions.delete(sessionId);
-        this.emitSessionUpdate(sessionId);
-        return true;
-    }
-    isStreaming(sessionId) {
-        return this.sessions.get(sessionId)?.streaming ?? false;
-    }
-    isOpen(sessionId) {
-        return this.sessions.has(sessionId);
-    }
-    getActiveSessionCount() {
-        return this.sessions.size;
-    }
-    cleanup() {
-        // Force-resolve any pending inputs on daemon shutdown
-        for (const [requestId, pending] of this.pendingInputRequests) {
-            pending.resolve({ sessionId: '', requestId, action: 'allow' });
-        }
-        this.pendingInputRequests.clear();
-        for (const [, ps] of this.sessions) {
-            try {
-                ps.session.close();
-            }
-            catch {
-                // Ignore errors during cleanup
-            }
-        }
-        this.sessions.clear();
-    }
-    async consumeStream(session, streamId, onSessionId) {
-        let textBuffer = '';
-        let bufferTimer = null;
-        let capturedSessionId = null;
-        let cancelled = false;
-        const emitStream = (event) => {
-            this.emit('stream', { ...event, sessionId: capturedSessionId ?? '', streamId });
-        };
-        const flushText = () => {
-            if (textBuffer) {
-                emitStream({ eventType: 'assistant_text', content: textBuffer });
-                textBuffer = '';
-            }
-            if (bufferTimer) {
-                clearTimeout(bufferTimer);
-                bufferTimer = null;
-            }
-        };
-        const markStreamingDone = () => {
-            if (capturedSessionId) {
-                const ps = this.sessions.get(capturedSessionId);
-                if (ps) {
-                    ps.streaming = false;
-                    ps.cancelStreaming = null;
-                }
-                this.emitSessionUpdate(capturedSessionId);
-            }
-        };
-        const bufferText = (text) => {
-            textBuffer += text;
-            if (!bufferTimer) {
-                bufferTimer = setTimeout(flushText, 150);
-            }
-            if (textBuffer.length > 2048) {
-                flushText();
-            }
-        };
-        // Wire up cancel function for this streaming turn
-        const setCancelFn = () => {
-            if (capturedSessionId) {
-                const ps = this.sessions.get(capturedSessionId);
-                if (ps) {
-                    ps.cancelStreaming = () => { cancelled = true; };
-                }
-            }
-        };
-        try {
-            for await (const message of session.stream()) {
-                if (cancelled)
-                    break;
-                // Capture session ID from init message
-                if (message.type === 'system' && message.subtype === 'init') {
-                    capturedSessionId = message.session_id;
-                    console.log(`[stream] init session=${message.session_id}`);
-                    onSessionId(message.session_id);
-                    setCancelFn();
-                    continue;
-                }
-                // Session state changed — 'idle' means turn is over
-                if (message.type === 'system' && message.subtype === 'session_state_changed') {
-                    const state = message.state;
-                    if (state === 'idle') {
-                        flushText();
-                        console.log(`[stream] session_state_changed=idle session=${capturedSessionId}`);
-                        // Don't call onEnd here — the result message will follow
-                    }
-                    continue;
-                }
-                // Streaming partial events
-                if (message.type === 'stream_event') {
-                    const event = message.event;
-                    if (event?.type === 'content_block_delta') {
-                        const delta = event.delta;
-                        if (delta?.type === 'text_delta' && delta.text) {
-                            bufferText(delta.text);
-                        }
-                    }
-                    continue;
-                }
-                // Complete assistant messages
-                if (message.type === 'assistant') {
-                    flushText();
-                    const betaMessage = message.message;
-                    if (betaMessage?.content) {
-                        for (const block of betaMessage.content) {
-                            if (block.type === 'text' && block.text) {
-                                emitStream({
-                                    eventType: 'assistant_text',
-                                    content: block.text,
-                                });
-                            }
-                            else if (block.type === 'tool_use') {
-                                const toolInput = JSON.stringify(block.input);
-                                emitStream({
-                                    eventType: 'tool_use',
-                                    content: '',
-                                    toolName: block.name,
-                                    toolInput,
-                                    toolUseId: block.id,
-                                });
-                            }
-                        }
-                    }
-                    continue;
-                }
-                // User messages contain tool results
-                if (message.type === 'user') {
-                    const userMsg = message.message;
-                    if (userMsg?.content && Array.isArray(userMsg.content)) {
-                        for (const block of userMsg.content) {
-                            if (block.type === 'tool_result') {
-                                const resultContent = extractToolResultText(block.content);
-                                const truncated = resultContent.length > TOOL_RESULT_TRUNCATE_LENGTH
-                                    ? resultContent.slice(0, TOOL_RESULT_TRUNCATE_LENGTH) + ' [truncated]'
-                                    : resultContent;
-                                emitStream({
-                                    eventType: 'tool_result',
-                                    content: truncated,
-                                    toolResultForId: block.tool_use_id,
-                                });
-                            }
-                        }
-                    }
-                    continue;
-                }
-                // Final result — turn is complete but session stays alive
-                if (message.type === 'result') {
-                    flushText();
-                    const result = message;
-                    console.log(`[stream] result session=${capturedSessionId} subtype=${result.subtype} cost=$${result.total_cost_usd?.toFixed(4) ?? '?'}`);
-                    markStreamingDone();
-                    this.emit('stream:end', {
-                        sessionId: capturedSessionId ?? '', streamId,
-                        success: result.subtype === 'success',
-                        error: result.subtype !== 'success'
-                            ? (result.errors?.join('; ') || `Session ended: ${result.subtype}`)
-                            : undefined,
-                        totalCostUsd: result.total_cost_usd,
-                        tokenUsage: result.usage
-                            ? { input: result.usage.input_tokens, output: result.usage.output_tokens }
-                            : undefined,
-                    });
-                    return;
-                }
-            }
-            flushText();
-            console.log(`[stream] ended without result session=${capturedSessionId} (cancel or unexpected)`);
-            markStreamingDone();
-            this.emit('stream:end', { sessionId: capturedSessionId ?? '', streamId, success: true });
-        }
-        catch (error) {
-            flushText();
-            console.error(`[stream] error session=${capturedSessionId}:`, error);
-            markStreamingDone();
-            const msg = error instanceof Error ? error.message : 'Unknown error';
-            this.emit('stream:end', { sessionId: capturedSessionId ?? '', streamId, success: false, error: msg });
-        }
-    }
-}
-//# sourceMappingURL=claudeCodeService.js.map