@kaitranntt/ccs 6.7.0-dev.5 → 6.7.1-dev.1

package/dist/delegation/headless-executor.js

@@ -1,5 +1,9 @@
 #!/usr/bin/env node
 "use strict";
+/**
+ * Headless executor for Claude CLI delegation
+ * Spawns claude with -p flag for single-turn execution
+ */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -32,9 +36,10 @@ const fs = __importStar(require("fs"));
 const session_manager_1 = require("./session-manager");
 const settings_parser_1 = require("./settings-parser");
 const ui_1 = require("../utils/ui");
+const stream_parser_1 = require("./executor/stream-parser");
+const result_aggregator_1 = require("./executor/result-aggregator");
 /**
  * Headless executor for Claude CLI delegation
- * Spawns claude with -p flag for single-turn execution
  */
 class HeadlessExecutor {
     /**
@@ -63,21 +68,17 @@ class HeadlessExecutor {
             throw new Error(`Settings file not found: ${settingsPath}\nProfile "${profile}" may not be configured.`);
         }
         // Smart slash command detection and preservation
-        // Detects if prompt contains slash command and restructures for proper execution
         const processedPrompt = this._processSlashCommand(enhancedPrompt);
         // Prepare arguments
         const args = ['-p', processedPrompt, '--settings', settingsPath];
         // Always use stream-json for real-time progress visibility
-        // Note: --verbose is required when using --print with stream-json
         args.push('--output-format', 'stream-json', '--verbose');
         // Add permission mode
         if (permissionMode && permissionMode !== 'default') {
             if (permissionMode === 'bypassPermissions') {
                 args.push('--dangerously-skip-permissions');
-                // Warn about dangerous mode
                 if (process.env.CCS_DEBUG) {
                     console.warn((0, ui_1.warn)('WARNING: Using --dangerously-skip-permissions mode'));
-                    console.warn((0, ui_1.warn)('This bypasses ALL permission checks. Use only in trusted environments.'));
                 }
             }
             else {
@@ -90,17 +91,12 @@ class HeadlessExecutor {
             if (lastSession) {
                 args.push('--resume', lastSession.sessionId);
                 if (process.env.CCS_DEBUG) {
-                    const cost = lastSession.totalCost !== undefined && lastSession.totalCost !== null
-                        ? lastSession.totalCost.toFixed(4)
-                        : '0.0000';
-                    console.error((0, ui_1.info)(`Resuming session: ${lastSession.sessionId} (${lastSession.turns} turns, $${cost})`));
+                    const cost = lastSession.totalCost?.toFixed(4) || '0.0000';
+                    console.error((0, ui_1.info)(`Resuming session: ${lastSession.sessionId} ($${cost})`));
                 }
             }
             else if (sessionId) {
                 args.push('--resume', sessionId);
-                if (process.env.CCS_DEBUG) {
-                    console.error((0, ui_1.info)(`Resuming specific session: ${sessionId}`));
-                }
             }
             else {
                 console.warn((0, ui_1.warn)('No previous session found, starting new session'));
@@ -108,37 +104,43 @@ class HeadlessExecutor {
         }
         else if (sessionId) {
             args.push('--resume', sessionId);
-            if (process.env.CCS_DEBUG) {
-                console.error((0, ui_1.info)(`Resuming specific session: ${sessionId}`));
-            }
         }
         // Add tool restrictions from settings
         const toolRestrictions = settings_parser_1.SettingsParser.parseToolRestrictions(cwd);
         if (toolRestrictions.allowedTools.length > 0) {
-            args.push('--allowedTools');
-            toolRestrictions.allowedTools.forEach((tool) => args.push(tool));
+            args.push('--allowedTools', ...toolRestrictions.allowedTools);
         }
         if (toolRestrictions.disallowedTools.length > 0) {
-            args.push('--disallowedTools');
-            toolRestrictions.disallowedTools.forEach((tool) => args.push(tool));
+            args.push('--disallowedTools', ...toolRestrictions.disallowedTools);
         }
-        // Note: No max-turns limit - using time-based limits instead (default 10min timeout)
-        // Passthrough extra args (from Claude CLI flags like --agent, --system-prompt-file, etc.)
+        // Passthrough extra args
         if (extraArgs.length > 0) {
             args.push(...extraArgs);
         }
-        // Debug log args
         if (process.env.CCS_DEBUG) {
             console.error((0, ui_1.info)(`Claude CLI args: ${args.join(' ')}`));
         }
         // Initialize UI before spawning
         await ui_1.ui.init();
         // Execute with spawn
+        return this._spawnAndExecute(claudeCli, args, {
+            cwd,
+            profile,
+            timeout,
+            resumeSession,
+            sessionId,
+            sessionMgr,
+        });
+    }
+    /**
+     * Spawn Claude CLI and handle execution
+     */
+    static _spawnAndExecute(claudeCli, args, ctx) {
+        const { cwd, profile, timeout, resumeSession, sessionId, sessionMgr } = ctx;
         return new Promise((resolve, reject) => {
             const startTime = Date.now();
-            // Show progress unless explicitly disabled with CCS_QUIET
             const showProgress = !process.env.CCS_QUIET;
-            // Show initial progress message
+            const streamBuffer = new stream_parser_1.StreamBuffer();
             if (showProgress) {
                 const modelName = profile === 'glm' ? 'GLM-4.6' : profile === 'kimi' ? 'Kimi' : profile.toUpperCase();
                 console.error(ui_1.ui.info(`Delegating to ${modelName}...`));
@@ -151,416 +153,207 @@ class HeadlessExecutor {
             let stdout = '';
             let stderr = '';
             let progressInterval;
-            const messages = []; // Accumulate stream-json messages
-            let partialLine = ''; // Buffer for incomplete JSON lines
-            // Handle parent process termination (Ctrl+C or Esc in Claude)
-            // When main Claude session is killed, cleanup spawned child process
+            const messages = [];
+            let timedOut = false;
+            // Setup signal handlers for cleanup
             const cleanupHandler = () => {
                 if (!proc.killed) {
-                    if (process.env.CCS_DEBUG) {
-                        console.error((0, ui_1.warn)('Parent process terminating, killing delegated session...'));
-                    }
                     proc.kill('SIGTERM');
-                    // Force kill if not dead after 2s
                     setTimeout(() => {
-                        if (!proc.killed) {
+                        if (!proc.killed)
                             proc.kill('SIGKILL');
-                        }
                     }, 2000);
                 }
             };
-            // Register signal handlers for parent process termination
             process.once('SIGINT', cleanupHandler);
             process.once('SIGTERM', cleanupHandler);
-            // Cleanup signal handlers when child process exits
             const removeSignalHandlers = () => {
                 process.removeListener('SIGINT', cleanupHandler);
                 process.removeListener('SIGTERM', cleanupHandler);
             };
             proc.on('close', removeSignalHandlers);
             proc.on('error', removeSignalHandlers);
-            // Progress indicator (show elapsed time every 5 seconds)
+            // Progress indicator
             if (showProgress) {
                 progressInterval = setInterval(() => {
                     const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
                     process.stderr.write(`${ui_1.ui.info(`Still running... ${elapsed}s elapsed`)}\r`);
                 }, 5000);
             }
-            // Capture stdout (stream-json format - jsonl)
+            // Capture stdout (stream-json format)
             proc.stdout?.on('data', (data) => {
                 const dataStr = data.toString();
                 stdout += dataStr;
-                // Parse stream-json messages (jsonl format - one JSON per line)
-                const chunk = partialLine + dataStr;
-                const lines = chunk.split('\n');
-                partialLine = lines.pop() || ''; // Save incomplete line for next chunk
-                for (const line of lines) {
-                    if (!line.trim())
-                        continue;
-                    try {
-                        const msg = JSON.parse(line);
-                        messages.push(msg);
-                        // Show real-time tool use with verbose details
-                        if (showProgress && msg.type === 'assistant') {
-                            const toolUses = msg.message?.content?.filter((c) => c.type === 'tool_use') || [];
-                            for (const tool of toolUses) {
-                                process.stderr.write('\r\x1b[K'); // Clear line
-                                // Show verbose tool use with description/input if available
-                                const toolInput = tool.input || {};
-                                let verboseMsg = `[Tool] ${tool.name}`;
-                                // Add context based on tool type (all Claude Code tools)
-                                switch (tool.name) {
-                                    case 'Bash':
-                                        if (toolInput.command) {
-                                            // Truncate long commands
-                                            const command = toolInput.command;
-                                            const cmd = command.length > 80 ? command.substring(0, 77) + '...' : command;
-                                            verboseMsg += `: ${cmd}`;
-                                        }
-                                        break;
-                                    case 'Edit':
-                                    case 'Write':
-                                    case 'Read':
-                                        if (toolInput.file_path) {
-                                            verboseMsg += `: ${toolInput.file_path}`;
-                                        }
-                                        break;
-                                    case 'NotebookEdit':
-                                    case 'NotebookRead':
-                                        if (toolInput.notebook_path) {
-                                            verboseMsg += `: ${toolInput.notebook_path}`;
-                                        }
-                                        break;
-                                    case 'Grep':
-                                        if (toolInput.pattern) {
-                                            verboseMsg += `: searching for "${toolInput.pattern}"`;
-                                            if (toolInput.path) {
-                                                verboseMsg += ` in ${toolInput.path}`;
-                                            }
-                                        }
-                                        break;
-                                    case 'Glob':
-                                        if (toolInput.pattern) {
-                                            verboseMsg += `: ${toolInput.pattern}`;
-                                        }
-                                        break;
-                                    case 'SlashCommand':
-                                        if (toolInput.command) {
-                                            verboseMsg += `: ${toolInput.command}`;
-                                        }
-                                        break;
-                                    case 'Task':
-                                        if (toolInput.description) {
-                                            verboseMsg += `: ${toolInput.description}`;
-                                        }
-                                        else if (toolInput.prompt) {
-                                            const promptText = toolInput.prompt;
-                                            const prompt = promptText.length > 60 ? promptText.substring(0, 57) + '...' : promptText;
-                                            verboseMsg += `: ${prompt}`;
-                                        }
-                                        break;
-                                    case 'TodoWrite':
-                                        if (toolInput.todos && Array.isArray(toolInput.todos)) {
-                                            // Show in_progress task instead of just count
-                                            const inProgressTask = toolInput.todos.find((t) => t.status === 'in_progress');
-                                            if (inProgressTask && inProgressTask.activeForm) {
-                                                verboseMsg += `: ${inProgressTask.activeForm}`;
-                                            }
-                                            else {
-                                                // Fallback to count if no in_progress task
-                                                verboseMsg += `: ${toolInput.todos.length} task(s)`;
-                                            }
-                                        }
-                                        break;
-                                    case 'WebFetch':
-                                        if (toolInput.url) {
-                                            verboseMsg += `: ${toolInput.url}`;
-                                        }
-                                        break;
-                                    case 'WebSearch':
-                                        if (toolInput.query) {
-                                            verboseMsg += `: "${toolInput.query}"`;
-                                        }
-                                        break;
-                                    default:
-                                        // For unknown tools, show first meaningful parameter
-                                        if (Object.keys(toolInput).length > 0) {
-                                            const firstKey = Object.keys(toolInput)[0];
-                                            const firstValue = toolInput[firstKey];
-                                            if (typeof firstValue === 'string' && firstValue.length < 60) {
-                                                verboseMsg += `: ${firstValue}`;
-                                            }
-                                        }
-                                }
-                                process.stderr.write(`${verboseMsg}\n`);
-                            }
-                        }
-                    }
-                    catch (parseError) {
-                        // Skip malformed JSON lines (shouldn't happen with stream-json)
-                        if (process.env.CCS_DEBUG) {
-                            console.error((0, ui_1.warn)(`Failed to parse stream-json line: ${parseError.message}`));
+                const parsedMessages = streamBuffer.parseChunk(dataStr);
+                for (const msg of parsedMessages) {
+                    messages.push(msg);
+                    // Show real-time tool use
+                    if (showProgress && msg.type === 'assistant') {
+                        const toolUses = msg.message?.content?.filter((c) => c.type === 'tool_use') || [];
+                        for (const tool of toolUses) {
+                            process.stderr.write('\r\x1b[K');
+                            const toolInput = tool.input || {};
+                            const verboseMsg = (0, stream_parser_1.formatToolVerbose)(tool.name || 'Unknown', toolInput);
+                            process.stderr.write(`${verboseMsg}\n`);
                         }
                     }
                 }
             });
-            // Stream stderr in real-time (progress messages from Claude CLI)
+            // Stream stderr in real-time
             proc.stderr?.on('data', (data) => {
                 const stderrText = data.toString();
                 stderr += stderrText;
-                // Show stderr in real-time if in TTY
                 if (showProgress) {
-                    // Clear progress line before showing stderr
-                    if (progressInterval) {
-                        process.stderr.write('\r\x1b[K'); // Clear line
-                    }
+                    if (progressInterval)
+                        process.stderr.write('\r\x1b[K');
                     process.stderr.write(stderrText);
                 }
             });
             // Handle completion
             proc.on('close', (exitCode) => {
                 const duration = Date.now() - startTime;
-                // Clear progress indicator
                 if (progressInterval) {
                     clearInterval(progressInterval);
-                    process.stderr.write('\r\x1b[K'); // Clear line
+                    process.stderr.write('\r\x1b[K');
                 }
-                // Show completion message
                 if (showProgress) {
                     const durationSec = (duration / 1000).toFixed(1);
-                    if (timedOut) {
-                        console.error(ui_1.ui.warn(`Execution timed out after ${durationSec}s`));
-                    }
-                    else {
-                        console.error(ui_1.ui.info(`Execution completed in ${durationSec}s`));
-                    }
-                    console.error(''); // Blank line before formatted output
+                    console.error(timedOut
+                        ? ui_1.ui.warn(`Timed out after ${durationSec}s`)
+                        : ui_1.ui.info(`Completed in ${durationSec}s`));
+                    console.error('');
                 }
-                const result = {
+                const result = (0, result_aggregator_1.buildExecutionResult)({
                     exitCode: exitCode || 0,
                     stdout,
                     stderr,
                     cwd,
                     profile,
                     duration,
-                    timedOut: false,
-                    success: exitCode === 0 && !timedOut,
-                    messages, // Include all stream-json messages
-                };
-                // Extract metadata from final 'result' message in stream-json
-                const resultMessage = messages.find((m) => m.type === 'result');
-                if (resultMessage) {
-                    // Add parsed fields from result message
-                    result.sessionId = resultMessage.session_id || undefined;
-                    result.totalCost = resultMessage.total_cost_usd || 0;
-                    result.numTurns = resultMessage.num_turns || 0;
-                    result.isError = resultMessage.is_error || false;
-                    result.type = resultMessage.type || null;
-                    result.subtype = resultMessage.subtype || undefined;
-                    result.durationApi = resultMessage.duration_api_ms || 0;
-                    result.permissionDenials = resultMessage.permission_denials || [];
-                    result.errors = resultMessage.errors || [];
-                    // Extract content from result message
-                    result.content = resultMessage.result || '';
-                }
-                else {
-                    // Fallback: no result message found (shouldn't happen)
-                    result.content = stdout;
-                    if (process.env.CCS_DEBUG) {
-                        console.error((0, ui_1.warn)('No result message found in stream-json output'));
-                    }
-                }
-                // Store or update session if we have session ID (even on timeout, for :continue support)
+                    timedOut,
+                    messages,
+                });
+                // Store session
                 if (result.sessionId) {
                     if (resumeSession || sessionId) {
-                        // Update existing session
-                        sessionMgr.updateSession(profile, result.sessionId, {
-                            totalCost: result.totalCost,
-                        });
+                        sessionMgr.updateSession(profile, result.sessionId, { totalCost: result.totalCost });
                     }
                     else {
-                        // Store new session
                         sessionMgr.storeSession(profile, {
                             sessionId: result.sessionId,
                             totalCost: result.totalCost,
-                            cwd: result.cwd,
+                            cwd,
                         });
                     }
-                    // Cleanup expired sessions periodically
-                    if (Math.random() < 0.1) {
-                        // 10% chance
+                    if (Math.random() < 0.1)
                         sessionMgr.cleanupExpired();
-                    }
                 }
                 resolve(result);
             });
             // Handle errors
             proc.on('error', (error) => {
-                if (progressInterval) {
+                if (progressInterval)
                     clearInterval(progressInterval);
-                }
                 reject(new Error(`Failed to execute Claude CLI: ${error.message}`));
             });
-            // Handle timeout with graceful SIGTERM then forceful SIGKILL
-            let timedOut = false;
+            // Handle timeout
             if (timeout > 0) {
                 const timeoutHandle = setTimeout(() => {
                     if (!proc.killed) {
                         timedOut = true;
                         if (progressInterval) {
                             clearInterval(progressInterval);
-                            process.stderr.write('\r\x1b[K'); // Clear line
+                            process.stderr.write('\r\x1b[K');
                         }
-                        if (process.env.CCS_DEBUG) {
-                            console.error((0, ui_1.warn)(`Timeout reached after ${timeout}ms, sending SIGTERM for graceful shutdown...`));
-                        }
-                        // Send SIGTERM for graceful shutdown
                         proc.kill('SIGTERM');
-                        // If process doesn't terminate within 10s, force kill
                         setTimeout(() => {
-                            if (!proc.killed) {
-                                if (process.env.CCS_DEBUG) {
-                                    console.error((0, ui_1.warn)('Process did not terminate gracefully, sending SIGKILL...'));
-                                }
+                            if (!proc.killed)
                                 proc.kill('SIGKILL');
-                            }
-                        }, 10000); // Give 10s for graceful shutdown instead of 5s
+                        }, 10000);
                     }
                 }, timeout);
-                // Clear timeout on successful completion
                 proc.on('close', () => clearTimeout(timeoutHandle));
             }
         });
     }
-    /**
-     * Validate permission mode
-     * @param mode - Permission mode
-     * @throws {Error} If mode is invalid
-     * @private
-     */
+    /** Validate permission mode */
     static _validatePermissionMode(mode) {
         const VALID_MODES = ['default', 'plan', 'acceptEdits', 'bypassPermissions'];
         if (!VALID_MODES.includes(mode)) {
             throw new Error(`Invalid permission mode: "${mode}". Valid modes: ${VALID_MODES.join(', ')}`);
         }
     }
-    /**
-     * Detect Claude CLI executable
-     * @returns Path to claude CLI or null if not found
-     * @private
-     */
+    /** Detect Claude CLI executable */
     static _detectClaudeCli() {
-        // Check environment variable override
-        if (process.env.CCS_CLAUDE_PATH) {
+        if (process.env.CCS_CLAUDE_PATH)
             return process.env.CCS_CLAUDE_PATH;
-        }
-        // Try to find in PATH
         const { execSync } = require('child_process');
         try {
-            const result = execSync('command -v claude', { encoding: 'utf8' });
-            return result.trim();
+            return execSync('command -v claude', { encoding: 'utf8' }).trim();
         }
-        catch (_error) {
+        catch {
             return null;
         }
     }
-    /**
-     * Execute with retry logic
-     * @param profile - Profile name
-     * @param enhancedPrompt - Enhanced prompt
-     * @param options - Execution options
-     * @returns execution result
-     */
+    /** Execute with retry logic */
     static async executeWithRetry(profile, enhancedPrompt, options = {}) {
         const { maxRetries = 2, ...execOptions } = options;
         let lastError;
         for (let attempt = 0; attempt <= maxRetries; attempt++) {
             try {
                 const result = await this.execute(profile, enhancedPrompt, execOptions);
-                // If successful, return immediately
-                if (result.success) {
+                if (result.success)
                     return result;
-                }
-                // If not last attempt, retry
                 if (attempt < maxRetries) {
                     console.error((0, ui_1.warn)(`Attempt ${attempt + 1} failed, retrying...`));
-                    await this._sleep(1000 * (attempt + 1)); // Exponential backoff
+                    await this._sleep(1000 * (attempt + 1));
                     continue;
                 }
-                // Last attempt failed, return result anyway
                 return result;
             }
             catch (error) {
                 lastError = error;
                 if (attempt < maxRetries) {
-                    console.error((0, ui_1.warn)(`Attempt ${attempt + 1} errored: ${error.message}, retrying...`));
+                    console.error((0, ui_1.warn)(`Attempt ${attempt + 1} errored, retrying...`));
                     await this._sleep(1000 * (attempt + 1));
                 }
             }
         }
-        // All retries exhausted
         throw lastError || new Error('Execution failed after all retry attempts');
     }
-    /**
-     * Sleep utility for retry backoff
-     * @param ms - Milliseconds to sleep
-     * @returns Promise<void>
-     * @private
-     */
+    /** Sleep utility for retry backoff */
     static _sleep(ms) {
         return new Promise((resolve) => setTimeout(resolve, ms));
     }
-    /**
-     * Process prompt to detect and preserve slash commands
-     * Implements smart enhancement: preserves slash command at start, allows context in rest
-     * @param prompt - Original prompt (may contain slash command)
-     * @returns Processed prompt with slash command preserved
-     * @private
-     */
+    /** Process prompt to detect and preserve slash commands */
     static _processSlashCommand(prompt) {
         const trimmed = prompt.trim();
-        // Case 1: Already starts with slash command - keep as-is
-        if (trimmed.match(/^\/[\w:-]+(\s|$)/)) {
+        // Case 1: Already starts with slash command
+        if (trimmed.match(/^\/[\w:-]+(\s|$)/))
             return prompt;
-        }
         // Case 2: Find slash command embedded in text
-        // Look for /command that's NOT part of a file path
-        // File paths: /home/user, /path/to/file (have / before or after)
-        // Commands: /cook, /plan (standalone, preceded by space/colon/start)
-        // Strategy: Find LAST occurrence that looks like a command, not a path
         const embeddedSlash = trimmed.match(/(?:^|[^\w/])(\/[\w:-]+)(\s+[\s\S]*)?$/);
         if (embeddedSlash) {
-            const command = embeddedSlash[1]; // e.g., "/cook"
-            const args = (embeddedSlash[2] || '').trim(); // Everything after command
-            // Calculate where the command starts (excluding preceding char if any)
+            const command = embeddedSlash[1];
+            const args = (embeddedSlash[2] || '').trim();
             const matchIndex = embeddedSlash.index || 0;
             const matchStart = matchIndex + (embeddedSlash[0][0] === '/' ? 0 : 1);
             const beforeCommand = trimmed.substring(0, matchStart).trim();
-            // Restructure: command first, context after
-            if (beforeCommand && args) {
+            if (beforeCommand && args)
                 return `${command} ${args}\n\nContext: ${beforeCommand}`;
-            }
-            else if (beforeCommand) {
+            if (beforeCommand)
                 return `${command}\n\nContext: ${beforeCommand}`;
-            }
             return args ? `${command} ${args}` : command;
         }
-        // No slash command detected, return as-is
         return prompt;
     }
-    /**
-     * Test if profile is executable (quick health check)
-     * @param profile - Profile name
-     * @returns True if profile can execute
-     */
+    /** Test if profile is executable */
     static async testProfile(profile) {
         try {
-            const result = await this.execute(profile, 'Say "test successful"', {
-                timeout: 10000,
-            });
+            const result = await this.execute(profile, 'Say "test successful"', { timeout: 10000 });
             return result.success;
         }
-        catch (_error) {
+        catch {
             return false;
         }
     }