@exreve/exk 1.0.61 → 1.0.63

package/dist/cli/claudeBackend.js

@@ -0,0 +1,535 @@
+/**
+ * Claude Agent SDK Backend
+ *
+ * Implements AgentBackend using @anthropic-ai/claude-agent-sdk.
+ * This is the original backend — all Claude SDK-specific code lives here
+ * so the queue manager (agentSession.ts) stays SDK-agnostic.
+ */
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { existsSync, mkdirSync } from 'fs';
+import { execSync, spawn } from 'child_process';
+import path from 'path';
+import os from 'os';
+import { createRequire } from 'module';
+import { createModuleMcpServer } from './moduleMcpServer.js';
+// ============ Claude Executable Resolution ============
+function resolveSdkCliPath() {
+    try {
+        const req = typeof globalThis.require === 'function'
+            ? globalThis.require
+            : createRequire(import.meta.url);
+        const pkgPath = req.resolve('@anthropic-ai/claude-agent-sdk/package.json');
+        const cliPath = path.join(path.dirname(pkgPath), 'cli.js');
+        return existsSync(cliPath) ? cliPath : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const CACHED_CLAUDE_PATH = (() => {
+    const envPath = process.env.TTC_CLAUDE_PATH;
+    if (envPath)
+        return envPath;
+    const sdkPath = resolveSdkCliPath();
+    if (sdkPath)
+        return sdkPath;
+    const localPath = path.join(os.homedir(), '.local', 'bin', 'claude');
+    if (existsSync(localPath))
+        return localPath;
+    return undefined;
+})();
+// ============ Tool Name Detection ============
+// (Moved from agentSession.ts — these are Claude SDK–specific heuristics)
+function extractToolName(toolResult) {
+    if (!toolResult || typeof toolResult !== 'object')
+        return 'unknown';
+    const r = toolResult;
+    if (r.file && typeof r.file === 'object'
+        && ['text', 'image', 'notebook', 'pdf', 'parts', 'file_unchanged'].includes(r.type)) {
+        return 'Read';
+    }
+    if (r.filePath && r.oldString !== undefined && r.newString !== undefined
+        && Array.isArray(r.structuredPatch)) {
+        return 'Edit';
+    }
+    if (r.filePath && (r.type === 'create' || r.type === 'update')
+        && r.content !== undefined) {
+        return 'Write';
+    }
+    if (typeof r.numFiles === 'number' && Array.isArray(r.filenames)
+        && r.mode !== undefined) {
+        return 'Grep';
+    }
+    if (typeof r.numFiles === 'number' && Array.isArray(r.filenames)
+        && typeof r.durationMs === 'number' && r.truncated !== undefined) {
+        return 'Glob';
+    }
+    if (Array.isArray(r.oldTodos) && Array.isArray(r.newTodos)) {
+        return 'TodoWrite';
+    }
+    if (r.stdout !== undefined || r.stderr !== undefined) {
+        return 'Bash';
+    }
+    if (typeof r.query === 'string' && Array.isArray(r.results)) {
+        return 'WebSearch';
+    }
+    if (typeof r.url === 'string' && typeof r.result === 'string'
+        && typeof r.code === 'number') {
+        return 'WebFetch';
+    }
+    if (r.content && typeof r.content === 'string' && r.type === 'text') {
+        try {
+            const parsed = JSON.parse(r.content);
+            if (parsed._type === 'send_file')
+                return 'send_file';
+        }
+        catch { /* not JSON */ }
+        return 'unknown';
+    }
+    if (r.agentId && Array.isArray(r.content) && r.status) {
+        return 'Task';
+    }
+    return 'unknown';
+}
+function lookupToolNameFromHistory(messages, toolUseId) {
+    if (!toolUseId)
+        return null;
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (msg.role !== 'assistant')
+            continue;
+        let content = typeof msg.content === 'string' ? null : msg.content;
+        if (content && !Array.isArray(content) && Array.isArray(content.content)) {
+            content = content.content;
+        }
+        if (!Array.isArray(content))
+            continue;
+        const toolUse = content.find((c) => c.type === 'tool_use' && c.id === toolUseId);
+        if (toolUse?.name)
+            return toolUse.name;
+    }
+    return null;
+}
+// ============ Claude Backend Class ============
+export class ClaudeBackend {
+    id = 'claude';
+    /** Tracked child processes for force-kill on emergency stop */
+    childProcesses = new Set();
+    processGroupId;
+    /**
+     * Kill all tracked child processes.
+     * Called by the queue manager during emergency stop.
+     */
+    killProcesses() {
+        const isWin = process.platform === 'win32';
+        for (const child of this.childProcesses) {
+            if (!child.killed) {
+                try {
+                    if (isWin && child.pid) {
+                        spawn('taskkill', ['/pid', child.pid.toString(), '/f', '/t'], {
+                            stdio: 'ignore',
+                            windowsHide: true,
+                        });
+                    }
+                    else {
+                        child.kill('SIGTERM');
+                    }
+                }
+                catch { /* already dead */ }
+            }
+        }
+        // Force kill after a brief grace period (sync — caller should handle timing)
+        for (const child of this.childProcesses) {
+            if (!child.killed) {
+                try {
+                    if (!isWin && child.pid) {
+                        child.kill('SIGKILL');
+                    }
+                }
+                catch { /* already dead */ }
+            }
+        }
+        this.childProcesses.clear();
+        if (!isWin && this.processGroupId) {
+            try {
+                process.kill(-this.processGroupId, 'SIGKILL');
+            }
+            catch { /* already dead */ }
+            this.processGroupId = undefined;
+        }
+    }
+    /**
+     * Get the Claude executable path (for diagnostics).
+     */
+    getClaudePath() {
+        return CACHED_CLAUDE_PATH;
+    }
+    async *executePrompt(prompt, config) {
+        const { cwd, apiKey, model, env, settings, signal, attachmentDir, routingSessionId, routingPromptId, resumeSessionId } = config;
+        // Build MCP server for this query
+        const mcpServer = createModuleMcpServer({
+            attachmentDir,
+            sessionId: routingSessionId,
+            promptId: routingPromptId,
+        });
+        const pathToClaudeCodeExecutable = CACHED_CLAUDE_PATH;
+        // Build query options
+        const queryOptions = {
+            signal,
+            cwd,
+            apiKey,
+            model,
+            tools: { type: 'preset', preset: 'claude_code' },
+            disallowedTools: ['AskUserQuestion', 'analyze_image'],
+            settingSources: ['project'],
+            permissionMode: 'bypassPermissions',
+            allowDangerouslySkipPermissions: true,
+            mcpServers: { 'claude-voice-modules': mcpServer },
+            ...(pathToClaudeCodeExecutable ? { pathToClaudeCodeExecutable } : {}),
+            spawnClaudeCodeProcess: (spawnOptions) => {
+                return this.spawnProcess(spawnOptions, signal);
+            },
+            env: env || {},
+            hooks: {
+                PostToolUse: [{
+                        hooks: [() => ({ continue: true })]
+                    }],
+                Notification: [{
+                        hooks: [(_notification) => {
+                                // Notifications are handled as progress events via the stream
+                            }]
+                    }],
+            }
+        };
+        // Create query stream — optionally resume session
+        const queryStream = query({
+            prompt,
+            options: {
+                ...queryOptions,
+                ...(settings ? { settings } : {}),
+                ...(resumeSessionId ? { resume: resumeSessionId } : {}),
+            }
+        });
+        // Message history for tool name lookup (local to this execution)
+        const localMessages = [];
+        const toolNameMap = new Map();
+        for await (const message of queryStream) {
+            // Check abort
+            if (signal?.aborted)
+                break;
+            // ── System init ──
+            if (message.type === 'system' && message.subtype === 'init') {
+                const systemMsg = message;
+                if (systemMsg.session_id) {
+                    yield { type: 'init', sessionId: systemMsg.session_id };
+                }
+                // Also emit as system event
+                yield {
+                    type: 'system',
+                    raw: systemMsg,
+                    subtype: systemMsg.subtype,
+                };
+                continue;
+            }
+            // ── Assistant message ──
+            if (message.type === 'assistant') {
+                const msg = message;
+                // Capture session ID
+                if (msg.session_id) {
+                    // Will be used by queue manager for session tracking
+                }
+                // Store for tool name lookup
+                localMessages.push({ role: 'assistant', content: msg.message });
+                // Populate toolNameMap
+                const toolUses = [];
+                if (Array.isArray(msg.message?.content)) {
+                    for (const block of msg.message.content) {
+                        if (block.type === 'tool_use' && block.id && block.name) {
+                            toolNameMap.set(block.id, block.name);
+                            toolUses.push({ id: block.id, name: block.name });
+                        }
+                    }
+                }
+                // Detect context window limit error
+                const isContextWindowError = msg.error === 'max_output_tokens' && ((typeof msg.message === 'string' && msg.message.includes('context window limit')) ||
+                    (Array.isArray(msg.message?.content) && msg.message.content.some((c) => typeof c?.text === 'string' && c.text.includes('context window limit'))));
+                yield {
+                    type: 'assistant_message',
+                    raw: msg.message,
+                    sdkSessionId: msg.session_id,
+                    error: msg.error,
+                    toolUses,
+                    isContextWindowError,
+                };
+                continue;
+            }
+            // ── Result ──
+            if (message.type === 'result') {
+                const msg = message;
+                let usage;
+                if (msg.usage) {
+                    const u = msg.usage;
+                    const inputTokens = u.input_tokens || u.inputTokens || 0;
+                    const outputTokens = u.output_tokens || u.outputTokens || 0;
+                    usage = {
+                        inputTokens,
+                        outputTokens,
+                        totalCostUsd: msg.total_cost_usd || 0,
+                        durationMs: msg.duration_ms,
+                        numTurns: msg.num_turns,
+                    };
+                }
+                yield {
+                    type: 'result',
+                    raw: msg,
+                    isError: !!msg.is_error,
+                    usage,
+                };
+                continue;
+            }
+            // ── User message (tool results) ──
+            if (message.type === 'user') {
+                const msg = message;
+                let toolResult = null;
+                let toolUseId = null;
+                // Extract tool_use_id from message.content
+                if (Array.isArray(msg.message?.content)) {
+                    const contentBlocks = msg.message.content;
+                    const toolResultBlock = contentBlocks.find((c) => c.type === 'tool_result');
+                    if (toolResultBlock?.tool_use_id) {
+                        toolUseId = toolResultBlock.tool_use_id;
+                    }
+                }
+                // Fallback: parent_tool_use_id
+                if (!toolUseId && msg.parent_tool_use_id) {
+                    toolUseId = msg.parent_tool_use_id;
+                }
+                // Extract tool result data
+                if (msg.tool_use_result) {
+                    const raw = msg.tool_use_result;
+                    if (Array.isArray(raw)) {
+                        const textParts = raw
+                            .filter((c) => c.type === 'text')
+                            .map((c) => c.text);
+                        const rawContent = textParts.join('\n');
+                        try {
+                            toolResult = JSON.parse(rawContent);
+                        }
+                        catch {
+                            toolResult = { content: rawContent, type: 'text' };
+                        }
+                    }
+                    else if (typeof raw === 'object' && raw !== null) {
+                        toolResult = raw;
+                    }
+                    else if (typeof raw === 'string') {
+                        try {
+                            toolResult = JSON.parse(raw);
+                        }
+                        catch {
+                            toolResult = { content: raw, type: 'text' };
+                        }
+                    }
+                }
+                // Fallback to parsing message.content
+                if (!toolResult && Array.isArray(msg.message?.content)) {
+                    const contentBlocks = msg.message.content;
+                    const toolResultBlock = contentBlocks.find((c) => c.type === 'tool_result');
+                    if (toolResultBlock) {
+                        if (typeof toolResultBlock.content === 'string') {
+                            try {
+                                toolResult = JSON.parse(toolResultBlock.content);
+                            }
+                            catch {
+                                toolResult = { content: toolResultBlock.content, type: 'text' };
+                            }
+                        }
+                        else if (Array.isArray(toolResultBlock.content)) {
+                            const textParts = toolResultBlock.content
+                                .filter((c) => c.type === 'text')
+                                .map((c) => c.text);
+                            const rawContent = textParts.join('\n');
+                            try {
+                                toolResult = JSON.parse(rawContent);
+                            }
+                            catch {
+                                toolResult = { content: rawContent, type: 'text' };
+                            }
+                        }
+                        else {
+                            toolResult = toolResultBlock;
+                        }
+                    }
+                }
+                if (toolResult) {
+                    // Resolve tool name: map lookup → history scan → heuristic
+                    const mappedName = toolUseId ? toolNameMap.get(toolUseId) ?? null : null;
+                    const historyName = mappedName || lookupToolNameFromHistory(localMessages, toolUseId);
+                    const detectedName = historyName || extractToolName(toolResult);
+                    yield {
+                        type: 'tool_result',
+                        result: toolResult,
+                        toolName: detectedName,
+                        toolUseId,
+                        parentToolUseId: msg.parent_tool_use_id,
+                        isSynthetic: msg.isSynthetic,
+                    };
+                }
+                else {
+                    // No tool result — emit as raw user message (rare)
+                    yield {
+                        type: 'tool_result',
+                        result: msg.message,
+                        toolName: null,
+                        toolUseId: null,
+                        parentToolUseId: msg.parent_tool_use_id,
+                        isSynthetic: msg.isSynthetic,
+                    };
+                }
+                continue;
+            }
+            // ── System (non-init) ──
+            if (message.type === 'system') {
+                const sysMsg = message;
+                yield {
+                    type: 'system',
+                    raw: sysMsg,
+                    subtype: sysMsg.subtype,
+                };
+                continue;
+            }
+            // ── Tool progress ──
+            if (message.type === 'tool_progress') {
+                const msg = message;
+                yield {
+                    type: 'tool_progress',
+                    raw: msg,
+                    toolName: msg.tool_name,
+                    toolUseId: msg.tool_use_id,
+                    elapsedTimeSeconds: msg.elapsed_time_seconds,
+                    parentToolUseId: msg.parent_tool_use_id,
+                };
+                continue;
+            }
+            // ── Stream event ──
+            if (message.type === 'stream_event') {
+                yield {
+                    type: 'stream_event',
+                    raw: message.event || message,
+                    parentToolUseId: message.parent_tool_use_id,
+                };
+                continue;
+            }
+            // ── Tool use summary ──
+            if (message.type === 'tool_use_summary') {
+                // Treat as system event for simplicity
+                const msg = message;
+                yield {
+                    type: 'system',
+                    raw: msg,
+                    subtype: 'tool_use_summary',
+                };
+                continue;
+            }
+            // ── Rate limit ──
+            if (message.type === 'rate_limit_event') {
+                yield {
+                    type: 'rate_limit',
+                    raw: message,
+                };
+                continue;
+            }
+            // ── Prompt suggestion ──
+            if (message.type === 'prompt_suggestion') {
+                const msg = message;
+                yield {
+                    type: 'prompt_suggestion',
+                    suggestion: msg.suggestion || '',
+                    raw: msg,
+                };
+                continue;
+            }
+            // ── Auth status ──
+            if (message.type === 'auth_status') {
+                yield {
+                    type: 'system',
+                    raw: message,
+                    subtype: 'auth_status',
+                };
+                continue;
+            }
+            // ── Keepalive — ignore ──
+            if (message.type === 'keep_alive') {
+                continue;
+            }
+            // ── Unknown — emit as system event ──
+            yield {
+                type: 'system',
+                raw: message,
+                subtype: 'unknown',
+            };
+        }
+    }
+    /**
+     * Spawn a Claude Code child process with proper environment.
+     */
+    spawnProcess(spawnOptions, signal) {
+        const { command, args, cwd, env } = spawnOptions;
+        console.log(`[ClaudeBackend] Spawn ANTHROPIC_BASE_URL:`, env?.ANTHROPIC_BASE_URL || '(not set)');
+        console.log(`[ClaudeBackend] Spawn ANTHROPIC_API_KEY:`, env?.ANTHROPIC_API_KEY ? '(set)' : '(not set)');
+        const hasPathSep = command.includes(path.sep) || command.includes('/') || command.includes('\\');
+        if (hasPathSep && !existsSync(command)) {
+            throw new Error(`Executable not found at ${command}. Set path with: ttc config --claude-path "<path>" (or TTC_CLAUDE_PATH)`);
+        }
+        if (cwd && !existsSync(cwd)) {
+            try {
+                mkdirSync(cwd, { recursive: true });
+            }
+            catch { /* ignore */ }
+        }
+        const isWin = process.platform === 'win32';
+        const defaultPath = isWin
+            ? (process.env.Path || process.env.PATH || '')
+            : '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin';
+        const spawnEnv = {
+            ...env,
+            IS_SANDBOX: '1',
+            PATH: env.PATH || process.env.PATH || defaultPath,
+            ...(isWin
+                ? {
+                    USERPROFILE: env.USERPROFILE || process.env.USERPROFILE || os.homedir(),
+                    USERNAME: env.USERNAME || process.env.USERNAME || 'user',
+                    HOME: env.USERPROFILE || process.env.USERPROFILE || os.homedir(),
+                }
+                : { HOME: env.HOME || process.env.HOME || os.homedir(), USER: env.USER || process.env.USER || 'user' }),
+        };
+        // Resolve 'node' if needed
+        let effectiveCommand = command;
+        if (command === 'node' && !hasPathSep) {
+            try {
+                const nodePath = execSync('which node', { encoding: 'utf-8', env: spawnEnv }).trim();
+                if (nodePath)
+                    effectiveCommand = nodePath;
+            }
+            catch { /* fall through */ }
+        }
+        const child = spawn(effectiveCommand, args, {
+            cwd: cwd || process.cwd(),
+            stdio: ['pipe', 'pipe', env.DEBUG_CLAUDE_AGENT_SDK ? 'pipe' : 'ignore'],
+            signal,
+            env: spawnEnv,
+            windowsHide: true,
+            detached: !isWin,
+        });
+        // Track for cleanup
+        this.childProcesses.add(child);
+        if (!isWin && child.pid) {
+            this.processGroupId = child.pid;
+        }
+        child.on('exit', () => { this.childProcesses.delete(child); });
+        child.on('error', () => { this.childProcesses.delete(child); });
+        return child;
+    }
+}
+/** Singleton instance */
+export const claudeBackend = new ClaudeBackend();