byterover-cli 0.4.0 → 1.0.0

package/dist/infra/cipher/process/process-service.js

@@ -3,6 +3,7 @@ import { randomBytes } from 'node:crypto';
 import { isAbsolute, relative, resolve } from 'node:path';
 import { ProcessError } from '../../../core/domain/cipher/errors/process-error.js';
 import { CommandValidator } from './command-validator.js';
+import { normalizePath } from './path-utils.js';
 /**
  * Default timeout for foreground commands (milliseconds).
  */
@@ -97,6 +98,8 @@ export class ProcessService {
         }
         // Resolve working directory
         const cwd = this.resolveSafeCwd(options.cwd);
+        // Validate path arguments in the command
+        this.validatePathArguments(normalizedCommand, cwd);
         // Merge environment variables
         const env = {};
         for (const [key, value] of Object.entries({
@@ -168,6 +171,8 @@ export class ProcessService {
     /**
      * Terminate a background process.
      *
+     * Uses process tree killing to ensure all child processes are terminated.
+     *
      * @param processId - Unique process identifier
      */
     async killProcess(processId) {
@@ -180,14 +185,8 @@ export class ProcessService {
             return;
         }
         try {
-            // Send SIGTERM
-            bgProcess.child.kill('SIGTERM');
-            // Wait 5 seconds, then escalate to SIGKILL
-            setTimeout(() => {
-                if (bgProcess.child.exitCode === null) {
-                    bgProcess.child.kill('SIGKILL');
-                }
-            }, 5000);
+            // Kill the entire process tree
+            await this.killProcessTree(bgProcess.child, bgProcess.child.pid);
         }
         catch (error) {
             throw ProcessError.killFailed(processId, error instanceof Error ? error.message : String(error));
@@ -320,12 +319,17 @@ export class ProcessService {
             truncated: false,
         };
         // Spawn process
+        // Use detached: true on Unix to create a process group for tree killing
         const child = spawn(command, {
             cwd: options.cwd,
-            detached: false, // Process dies with parent
+            detached: process.platform !== 'win32',
             env: options.env,
             shell: true,
         });
+        // Prevent child from keeping parent alive on Unix
+        if (process.platform !== 'win32') {
+            child.unref();
+        }
         const startedAt = new Date();
         // Create background process entry
         const bgProcess = {
@@ -389,13 +393,10 @@ export class ProcessService {
         // Set timeout handler
         const killTimer = setTimeout(() => {
             if (bgProcess.status === 'running') {
-                child.kill('SIGTERM');
-                // Escalate to SIGKILL after 5 seconds
-                setTimeout(() => {
-                    if (bgProcess.status === 'running') {
-                        child.kill('SIGKILL');
-                    }
-                }, 5000);
+                // Use process tree killing for timeout
+                this.killProcessTree(child, child.pid).catch(() => {
+                    // Ignore errors during timeout kill - process may already be dead
+                });
             }
         }, options.timeout);
         // Clear timeout when process completes
@@ -411,6 +412,50 @@ export class ProcessService {
             startedAt,
         };
     }
+    /**
+     * Kill a process and all its children (process tree).
+     *
+     * On Unix, uses process groups (-pid) to kill all descendants.
+     * On Windows, uses taskkill with /t flag for tree kill.
+     * Falls back to direct kill if process group kill fails.
+     *
+     * @param child - Child process to kill
+     * @param pid - Process ID (optional, extracted from child if not provided)
+     * @returns Promise that resolves when kill attempt completes
+     */
+    async killProcessTree(child, pid) {
+        const targetPid = pid ?? child.pid;
+        if (!targetPid)
+            return;
+        if (process.platform === 'win32') {
+            // Use taskkill with /t flag for tree kill on Windows
+            return new Promise((resolve) => {
+                const killer = spawn('taskkill', ['/pid', String(targetPid), '/f', '/t'], { stdio: 'ignore' });
+                killer.once('exit', () => resolve());
+                killer.once('error', () => resolve());
+            });
+        }
+        // Unix: kill process group using negative PID
+        try {
+            process.kill(-targetPid, 'SIGTERM');
+            await this.sleep(5000);
+            try {
+                process.kill(-targetPid, 'SIGKILL');
+            }
+            catch {
+                // Process already dead, ignore
+            }
+        }
+        catch {
+            // Fallback to direct kill if process group kill fails
+            // (e.g., process wasn't started with detached: true)
+            child.kill('SIGTERM');
+            await this.sleep(5000);
+            if (child.exitCode === null) {
+                child.kill('SIGKILL');
+            }
+        }
+    }
     /**
      * Resolve and validate working directory.
      *
@@ -426,8 +471,10 @@ export class ProcessService {
         if (!cwd) {
             return baseDir;
         }
+        // Normalize for Git Bash on Windows
+        const normalizedCwd = normalizePath(cwd);
         // Resolve to absolute path
-        const candidatePath = isAbsolute(cwd) ? resolve(cwd) : resolve(baseDir, cwd);
+        const candidatePath = isAbsolute(normalizedCwd) ? resolve(normalizedCwd) : resolve(baseDir, normalizedCwd);
         // Check if path is within base directory
         const relativePath = relative(baseDir, candidatePath);
         const isOutsideBase = relativePath.startsWith('..') || isAbsolute(relativePath);
@@ -436,4 +483,38 @@ export class ProcessService {
         }
         return candidatePath;
     }
+    /**
+     * Sleep for specified milliseconds.
+     *
+     * @param ms - Milliseconds to sleep
+     * @returns Promise that resolves after the delay
+     */
+    sleep(ms) {
+        return new Promise((resolve) => {
+            setTimeout(resolve, ms);
+        });
+    }
+    /**
+     * Validate file path arguments in a command.
+     *
+     * Extracts path arguments from path-sensitive commands and validates
+     * that they are within the configured base directory.
+     *
+     * @param command - Command string to validate
+     * @param baseDir - Base directory for confinement
+     * @throws ProcessError if any path argument is outside the base directory
+     */
+    validatePathArguments(command, baseDir) {
+        const paths = this.commandValidator.extractPathArguments(command);
+        for (const pathArg of paths) {
+            // Resolve to absolute path
+            const resolved = isAbsolute(pathArg) ? resolve(pathArg) : resolve(baseDir, pathArg);
+            // Check if path is within base directory
+            const relativePath = relative(baseDir, resolved);
+            const isOutsideBase = relativePath.startsWith('..') || isAbsolute(relativePath);
+            if (isOutsideBase) {
+                throw ProcessError.invalidWorkingDirectory(pathArg, `Path argument "${pathArg}" references location outside ${baseDir}`);
+            }
+        }
+    }
 }

package/dist/infra/cipher/session/chat-session.d.ts

@@ -3,11 +3,10 @@ import type { CipherAgentServices, SessionServices } from '../../../core/interfa
 import type { IChatSession } from '../../../core/interfaces/cipher/i-chat-session.js';
 import type { ExecutionContext } from '../../../core/interfaces/cipher/i-cipher-agent.js';
 import type { ILLMService } from '../../../core/interfaces/cipher/i-llm-service.js';
+import type { FileData, ImageData } from '../llm/context/context-manager.js';
 import { SessionEventBus } from '../events/event-emitter.js';
 /**
  * Chat session implementation.
- *
- * Following Dexto's pattern: ChatSession owns session-specific services
  * (LLM, EventBus) and receives shared services (ToolManager, SystemPromptManager).
  *
  * The LLM service handles:
@@ -25,8 +24,11 @@ export declare class ChatSession implements IChatSession {
     readonly eventBus: SessionEventBus;
     readonly id: string;
     private currentController?;
+    private currentTaskId?;
     private readonly forwarders;
+    private isExecuting;
     private readonly llmService;
+    private readonly messageQueue;
     private readonly sharedServices;
     /**
      * Creates a new chat session
@@ -41,7 +43,14 @@ export declare class ChatSession implements IChatSession {
      */
     cancel(): void;
     /**
-     * Dispose of the session and clean up resources.
+     * Cleanup session resources but preserve history for later restoration.
+     * Call this when ending a session temporarily (e.g., user navigates away).
+     * History remains in ContextManager for persistence; event listeners stay for potential reactivation.
+     */
+    cleanup(): void;
+    /**
+     * Dispose of the session completely - remove all event listeners.
+     * Call this when permanently destroying a session.
      * Removes event listeners to prevent memory leaks.
      */
     dispose(): void;
@@ -65,16 +74,56 @@ export declare class ChatSession implements IChatSession {
     /**
      * Send a message and get a response.
      * Delegates to the LLM service which handles the agentic loop.
+     * Processes any queued messages first if present.
+     *
+     * @param input - User message
+     * @param options - Execution options
+     * @param options.executionContext - Optional execution context
+     * @param options.taskId - Optional task ID for concurrent task isolation
      */
     run(input: string, options?: {
         executionContext?: ExecutionContext;
-        mode?: 'autonomous' | 'default' | 'query';
+        taskId?: string;
     }): Promise<string>;
     /**
-     * Setup automatic event forwarding from SessionEventBus to AgentEventBus.
-     * All session events are forwarded with sessionId added to the payload.
+     * Send a message, queuing if the session is busy executing.
+     * If the session is idle, executes immediately via run().
+     * If the session is busy, queues the message and returns the queue position.
      *
-     * Following Dexto's pattern: event forwarding is built into the session.
+     * @param input - User message content
+     * @param options - Optional execution options and attachments
+     * @param options.executionContext - Optional execution context for the LLM
+     * @param options.fileData - Optional file attachment
+     * @param options.imageData - Optional image attachment
+     * @returns Response string if executed, or queue info if queued
+     */
+    sendMessage(input: string, options?: {
+        executionContext?: ExecutionContext;
+        fileData?: FileData;
+        imageData?: ImageData;
+    }): Promise<string | {
+        position: number;
+        queued: true;
+    }>;
+    /**
+     * Stream execution with real-time event emission.
+     * Unlike run(), this does not return a response directly - events are yielded via the agent's stream().
+     * Emits run:complete event when finished.
+     *
+     * @param input - User message
+     * @param options - Execution options with optional signal for cancellation
+     * @param options.executionContext - Optional execution context for the LLM
+     * @param options.signal - Optional AbortSignal for cancellation
+     * @param options.taskId - Optional task ID for concurrent task isolation
+     */
+    streamRun(input: string, options?: {
+        executionContext?: ExecutionContext;
+        signal?: AbortSignal;
+        taskId?: string;
+    }): Promise<void>;
+    /**
+     * Setup automatic event forwarding from SessionEventBus to AgentEventBus.
+     * All session events are forwarded with sessionId and taskId added to the payload.
      */
     private setupEventForwarding;
 }

package/dist/infra/cipher/session/chat-session.js

@@ -1,4 +1,6 @@
 import { LLMError, SessionCancelledError } from '../../../core/domain/cipher/errors/session-error.js';
+import { MessageQueueService } from './message-queue.js';
+import { sessionStatusManager } from './session-status.js';
 // List of all session events that should be forwarded to agent bus
 const SESSION_EVENT_NAMES = [
     'llmservice:thinking',
@@ -6,13 +8,18 @@ const SESSION_EVENT_NAMES = [
     'llmservice:response',
     'llmservice:toolCall',
     'llmservice:toolResult',
+    'llmservice:doomLoopDetected',
     'llmservice:error',
     'llmservice:unsupportedInput',
+    'message:queued',
+    'message:dequeued',
+    'run:complete',
+    'session:statusChanged',
+    'step:started',
+    'step:finished',
 ];
 /**
  * Chat session implementation.
- *
- * Following Dexto's pattern: ChatSession owns session-specific services
  * (LLM, EventBus) and receives shared services (ToolManager, SystemPromptManager).
  *
  * The LLM service handles:
@@ -30,8 +37,11 @@ export class ChatSession {
     eventBus;
     id;
     currentController;
+    currentTaskId;
     forwarders = new Map();
+    isExecuting = false;
     llmService;
+    messageQueue;
     sharedServices;
     /**
      * Creates a new chat session
@@ -45,6 +55,7 @@ export class ChatSession {
         this.sharedServices = sharedServices;
         this.eventBus = sessionServices.sessionEventBus;
         this.llmService = sessionServices.llmService;
+        this.messageQueue = new MessageQueueService(sessionServices.sessionEventBus);
         // Setup event forwarding from session bus to agent bus
         this.setupEventForwarding();
     }
@@ -57,15 +68,34 @@ export class ChatSession {
         }
     }
     /**
-     * Dispose of the session and clean up resources.
+     * Cleanup session resources but preserve history for later restoration.
+     * Call this when ending a session temporarily (e.g., user navigates away).
+     * History remains in ContextManager for persistence; event listeners stay for potential reactivation.
+     */
+    cleanup() {
+        // Cancel any in-flight operation
+        if (this.currentController) {
+            this.currentController.abort();
+            this.currentController = undefined;
+        }
+        // Note: History remains in LLMService's ContextManager for persistence
+        // Event listeners remain for potential reactivation
+    }
+    /**
+     * Dispose of the session completely - remove all event listeners.
+     * Call this when permanently destroying a session.
      * Removes event listeners to prevent memory leaks.
      */
     dispose() {
+        // First cleanup any in-flight operations
+        this.cleanup();
         // Remove all event forwarders
         for (const [eventName, forwarder] of this.forwarders.entries()) {
             this.eventBus.off(eventName, forwarder);
         }
         this.forwarders.clear();
+        // Clean up session status
+        sessionStatusManager.remove(this.id);
     }
     /**
      * Get the conversation history.
@@ -116,22 +146,40 @@ export class ChatSession {
     /**
      * Send a message and get a response.
      * Delegates to the LLM service which handles the agentic loop.
+     * Processes any queued messages first if present.
+     *
+     * @param input - User message
+     * @param options - Execution options
+     * @param options.executionContext - Optional execution context
+     * @param options.taskId - Optional task ID for concurrent task isolation
      */
     async run(input, options) {
         // Create abort controller for cancellation
         this.currentController = new AbortController();
+        this.isExecuting = true;
+        // Store taskId for event forwarding
+        this.currentTaskId = options?.taskId;
+        // Update session status to busy
+        sessionStatusManager.setBusy(this.id, this.eventBus);
+        // Store reference to controller for use in catch/finally blocks
+        // This prevents race conditions where currentController might be undefined
+        const controller = this.currentController;
         try {
+            // Process any queued messages first, coalescing with current input
+            const queued = this.messageQueue.dequeueAll();
+            const finalInput = queued ? `${queued.content}\n\nAlso: ${input}` : input;
             // Delegate to service - it handles everything
-            const response = await this.llmService.completeTask(input, this.id, {
+            // Pass taskId for billing tracking
+            const response = await this.llmService.completeTask(finalInput, {
                 executionContext: options?.executionContext,
-                mode: options?.mode,
-                signal: this.currentController.signal,
+                signal: controller.signal,
+                taskId: options?.taskId,
             });
             return response;
         }
         catch (error) {
-            // Check if cancelled
-            if (this.currentController.signal.aborted) {
+            // Check if cancelled - use stored controller reference to avoid undefined access
+            if (controller.signal.aborted) {
                 throw new SessionCancelledError(this.id);
             }
             // Wrap other errors - pass message as-is since it's already formatted
@@ -139,20 +187,122 @@ export class ChatSession {
             throw new LLMError(errorMessage, this.id);
         }
         finally {
+            this.isExecuting = false;
             this.currentController = undefined;
+            this.currentTaskId = undefined;
+            // Update session status back to idle
+            sessionStatusManager.setIdle(this.id, this.eventBus);
         }
     }
     /**
-     * Setup automatic event forwarding from SessionEventBus to AgentEventBus.
-     * All session events are forwarded with sessionId added to the payload.
+     * Send a message, queuing if the session is busy executing.
+     * If the session is idle, executes immediately via run().
+     * If the session is busy, queues the message and returns the queue position.
+     *
+     * @param input - User message content
+     * @param options - Optional execution options and attachments
+     * @param options.executionContext - Optional execution context for the LLM
+     * @param options.fileData - Optional file attachment
+     * @param options.imageData - Optional image attachment
+     * @returns Response string if executed, or queue info if queued
+     */
+    async sendMessage(input, options) {
+        if (this.isExecuting) {
+            // Queue the message for later processing
+            const position = this.messageQueue.enqueue({
+                content: input,
+                fileData: options?.fileData,
+                imageData: options?.imageData,
+            });
+            return { position, queued: true };
+        }
+        // Execute immediately
+        return this.run(input, { executionContext: options?.executionContext });
+    }
+    /**
+     * Stream execution with real-time event emission.
+     * Unlike run(), this does not return a response directly - events are yielded via the agent's stream().
+     * Emits run:complete event when finished.
      *
-     * Following Dexto's pattern: event forwarding is built into the session.
+     * @param input - User message
+     * @param options - Execution options with optional signal for cancellation
+     * @param options.executionContext - Optional execution context for the LLM
+     * @param options.signal - Optional AbortSignal for cancellation
+     * @param options.taskId - Optional task ID for concurrent task isolation
+     */
+    async streamRun(input, options) {
+        const startTime = Date.now();
+        let finishReason = 'stop';
+        let error;
+        // Create abort controller for cancellation
+        this.currentController = new AbortController();
+        this.isExecuting = true;
+        // Store taskId for event forwarding
+        this.currentTaskId = options?.taskId;
+        // Update session status to busy
+        sessionStatusManager.setBusy(this.id, this.eventBus);
+        // Store reference to controller for use in catch/finally blocks
+        // This prevents race conditions where currentController might be undefined
+        const controller = this.currentController;
+        // Link external signal if provided (use {once: true} to prevent listener accumulation)
+        if (options?.signal) {
+            options.signal.addEventListener('abort', () => controller?.abort(), { once: true });
+        }
+        try {
+            // Process any queued messages first, coalescing with current input
+            const queued = this.messageQueue.dequeueAll();
+            const finalInput = queued ? `${queued.content}\n\nAlso: ${input}` : input;
+            // Delegate to service - it handles everything and emits events
+            // Pass taskId for billing tracking
+            await this.llmService.completeTask(finalInput, {
+                executionContext: options?.executionContext,
+                signal: controller.signal,
+                taskId: options?.taskId,
+            });
+        }
+        catch (error_) {
+            // Check if cancelled - use stored controller reference to avoid undefined access
+            if (controller.signal.aborted) {
+                finishReason = 'cancelled';
+            }
+            else {
+                finishReason = 'error';
+                error = error_ instanceof Error ? error_ : new Error(String(error_));
+            }
+        }
+        finally {
+            this.isExecuting = false;
+            this.currentController = undefined;
+            // Save taskId before clearing for run:complete event
+            const completedTaskId = this.currentTaskId;
+            this.currentTaskId = undefined;
+            // Update session status back to idle
+            sessionStatusManager.setIdle(this.id, this.eventBus);
+            // Emit run:complete event with taskId for billing tracking
+            const durationMs = Date.now() - startTime;
+            this.eventBus.emit('run:complete', {
+                durationMs,
+                error,
+                finishReason,
+                stepCount: 0, // Can be enhanced later to track actual step count
+                ...(completedTaskId && { taskId: completedTaskId }),
+            });
+        }
+    }
+    /**
+     * Setup automatic event forwarding from SessionEventBus to AgentEventBus.
+     * All session events are forwarded with sessionId and taskId added to the payload.
      */
     setupEventForwarding() {
         for (const eventName of SESSION_EVENT_NAMES) {
             const forwarder = (payload) => {
-                // Add sessionId to payload
-                const payloadWithSession = payload && typeof payload === 'object' ? { ...payload, sessionId: this.id } : { sessionId: this.id };
+                // Add sessionId and taskId to payload
+                const basePayload = payload && typeof payload === 'object' ? payload : {};
+                const payloadWithSession = {
+                    ...basePayload,
+                    sessionId: this.id,
+                    ...(this.currentTaskId && { taskId: this.currentTaskId }),
+                };
                 // Forward to agent bus - eventName is properly typed from SESSION_EVENT_NAMES
                 this.sharedServices.agentEventBus.emit(eventName, payloadWithSession);
             };

package/dist/infra/cipher/session/index.d.ts

@@ -4,3 +4,4 @@ export type { IChatSession } from '../../../core/interfaces/cipher/i-chat-sessio
 export type { ILLMService } from '../../../core/interfaces/cipher/i-llm-service.js';
 export { ChatSession } from './chat-session.js';
 export { SessionManager } from './session-manager.js';
+export { SessionStatusManager, sessionStatusManager } from './session-status.js';

package/dist/infra/cipher/session/index.js

@@ -3,3 +3,5 @@ export { LLMError, MaxIterationsExceededError, SessionCancelledError, SessionErr
 export { ChatSession } from './chat-session.js';
 // Session manager
 export { SessionManager } from './session-manager.js';
+// Session status
+export { SessionStatusManager, sessionStatusManager } from './session-status.js';

package/dist/infra/cipher/session/message-queue.d.ts

@@ -0,0 +1,65 @@
+import type { SessionEventBus } from '../events/event-emitter.js';
+import type { FileData, ImageData } from '../llm/context/context-manager.js';
+/**
+ * A message that has been queued for later processing.
+ */
+export interface QueuedMessage {
+    /** Message text content */
+    content: string;
+    /** Optional file attachment */
+    fileData?: FileData;
+    /** Unique identifier for this queued message */
+    id: string;
+    /** Optional image attachment */
+    imageData?: ImageData;
+    /** Timestamp when the message was queued */
+    queuedAt: number;
+}
+/**
+ * Service for buffering user messages when a session is busy executing.
+ *
+ * When the LLM is processing a request, new messages from the user are
+ * queued and coalesced into a single input when the session becomes available.
+ *
+ * This improves UX by allowing users to add context while waiting for responses.
+ */
+export declare class MessageQueueService {
+    private readonly eventBus?;
+    private readonly queue;
+    /**
+     * Creates a new message queue service.
+     *
+     * @param eventBus - Optional session event bus for queue events
+     */
+    constructor(eventBus?: SessionEventBus);
+    /**
+     * Clear all queued messages without processing.
+     */
+    clear(): void;
+    /**
+     * Dequeue all messages and coalesce into single input.
+     * Messages are combined intelligently based on count.
+     *
+     * @returns Coalesced content with images/files, or null if queue is empty
+     */
+    dequeueAll(): null | {
+        content: string;
+        files: FileData[];
+        images: ImageData[];
+    };
+    /**
+     * Queue a message for later processing.
+     *
+     * @param message - Message to queue (without id and queuedAt)
+     * @returns Queue position (1-based)
+     */
+    enqueue(message: Omit<QueuedMessage, 'id' | 'queuedAt'>): number;
+    /**
+     * Check if there are pending messages in the queue.
+     */
+    hasPending(): boolean;
+    /**
+     * Get the number of pending messages.
+     */
+    pendingCount(): number;
+}