profclaw 0.0.1-beta.1

package/dist/chat/execution/process-pool.js

@@ -0,0 +1,290 @@
+/**
+ * Process Pool Manager
+ *
+ * Limits concurrent tool executions to prevent resource exhaustion.
+ * Queues excess requests and tracks resource usage.
+ */
+import { EventEmitter } from 'events';
+import { logger } from '../../utils/logger.js';
+// Constants (configurable via environment variables)
+// Pool limits for I/O-bound chat tool executions
+// Override via POOL_MAX_CONCURRENT, POOL_MAX_QUEUE_SIZE, POOL_TIMEOUT_MS, POOL_QUEUE_TIMEOUT_MS
+const DEFAULT_MAX_CONCURRENT = parseInt(process.env.POOL_MAX_CONCURRENT || '50', 10);
+const DEFAULT_MAX_QUEUE_SIZE = parseInt(process.env.POOL_MAX_QUEUE_SIZE || '200', 10);
+const DEFAULT_TIMEOUT_MS = parseInt(process.env.POOL_TIMEOUT_MS || '300000', 10); // 5 minutes
+const QUEUE_TIMEOUT_MS = parseInt(process.env.POOL_QUEUE_TIMEOUT_MS || '30000', 10); // 30 seconds
+// Process Pool
+export class ProcessPool extends EventEmitter {
+    config;
+    active = new Map();
+    queue = [];
+    metrics;
+    constructor(config) {
+        super();
+        this.config = {
+            maxConcurrent: config?.maxConcurrent ?? DEFAULT_MAX_CONCURRENT,
+            maxQueueSize: config?.maxQueueSize ?? DEFAULT_MAX_QUEUE_SIZE,
+            defaultTimeout: config?.defaultTimeout ?? DEFAULT_TIMEOUT_MS,
+            maxMemoryMB: config?.maxMemoryMB,
+            enableMetrics: config?.enableMetrics ?? true,
+        };
+        this.metrics = {
+            activeCount: 0,
+            queuedCount: 0,
+            totalExecuted: 0,
+            totalFailed: 0,
+            totalTimeout: 0,
+            totalRejected: 0,
+            avgDurationMs: 0,
+            peakConcurrent: 0,
+        };
+    }
+    /**
+     * Submit an execution to the pool
+     */
+    async submit(id, toolName, conversationId, execute, options) {
+        // Check if we can execute immediately
+        if (this.active.size < this.config.maxConcurrent) {
+            return this.executeNow(id, toolName, conversationId, execute, options);
+        }
+        // Check queue capacity
+        if (this.queue.length >= this.config.maxQueueSize) {
+            this.metrics.totalRejected++;
+            throw new PoolFullError(`Pool queue full (${this.queue.length}/${this.config.maxQueueSize}). Try again later.`);
+        }
+        // Queue the execution
+        return this.queueExecution(id, toolName, conversationId, execute, options);
+    }
+    /**
+     * Cancel a queued or active execution
+     */
+    cancel(id) {
+        // Check queue first
+        const queueIndex = this.queue.findIndex(q => q.id === id);
+        if (queueIndex !== -1) {
+            const queued = this.queue[queueIndex];
+            if (queued.timeoutId)
+                clearTimeout(queued.timeoutId);
+            this.queue.splice(queueIndex, 1);
+            this.metrics.queuedCount = this.queue.length;
+            queued.reject(new Error('Execution cancelled'));
+            return true;
+        }
+        // Check active - can't cancel active without process handle
+        const active = this.active.get(id);
+        if (active) {
+            logger.warn(`[Pool] Cannot cancel active execution ${id} (no process handle)`, { component: 'ProcessPool' });
+            return false;
+        }
+        return false;
+    }
+    /**
+     * Get pool status
+     */
+    getStatus() {
+        return {
+            active: Array.from(this.active.values()),
+            queuedCount: this.queue.length,
+            metrics: { ...this.metrics },
+            config: { ...this.config },
+        };
+    }
+    /**
+     * Get metrics
+     */
+    getMetrics() {
+        return {
+            ...this.metrics,
+            activeCount: this.active.size,
+            queuedCount: this.queue.length,
+        };
+    }
+    /**
+     * Update configuration
+     */
+    updateConfig(updates) {
+        this.config = { ...this.config, ...updates };
+        logger.info('[Pool] Config updated', { component: 'ProcessPool', config: this.config });
+        // Process queue if capacity increased
+        this.processQueue();
+    }
+    /**
+     * Check if pool has capacity
+     */
+    hasCapacity() {
+        return this.active.size < this.config.maxConcurrent;
+    }
+    /**
+     * Get current load percentage
+     */
+    getLoad() {
+        return (this.active.size / this.config.maxConcurrent) * 100;
+    }
+    /**
+     * Clear the queue (reject all pending)
+     */
+    clearQueue() {
+        const count = this.queue.length;
+        for (const queued of this.queue) {
+            if (queued.timeoutId)
+                clearTimeout(queued.timeoutId);
+            queued.reject(new Error('Queue cleared'));
+        }
+        this.queue = [];
+        this.metrics.queuedCount = 0;
+        return count;
+    }
+    // Private Methods
+    async executeNow(id, toolName, conversationId, execute, options) {
+        const startTime = Date.now();
+        // Track active execution
+        const activeExec = {
+            id,
+            toolName,
+            conversationId,
+            userId: options?.userId,
+            startedAt: startTime,
+        };
+        this.active.set(id, activeExec);
+        this.metrics.activeCount = this.active.size;
+        // Update peak
+        if (this.active.size > this.metrics.peakConcurrent) {
+            this.metrics.peakConcurrent = this.active.size;
+        }
+        this.emit('execution:start', activeExec);
+        try {
+            // Execute with timeout
+            const timeout = options?.timeout ?? this.config.defaultTimeout;
+            const result = await this.withTimeout(execute(), timeout, id);
+            // Update metrics
+            const duration = Date.now() - startTime;
+            this.updateDurationMetric(duration);
+            this.metrics.totalExecuted++;
+            this.emit('execution:complete', { id, duration, success: true });
+            return result;
+        }
+        catch (error) {
+            if (error instanceof TimeoutError) {
+                this.metrics.totalTimeout++;
+            }
+            else {
+                this.metrics.totalFailed++;
+            }
+            this.emit('execution:complete', { id, success: false, error });
+            throw error;
+        }
+        finally {
+            this.active.delete(id);
+            this.metrics.activeCount = this.active.size;
+            // Process next in queue
+            this.processQueue();
+        }
+    }
+    queueExecution(id, toolName, conversationId, execute, options) {
+        return new Promise((resolve, reject) => {
+            const queued = {
+                id,
+                toolName,
+                conversationId,
+                userId: options?.userId,
+                priority: options?.priority ?? 0,
+                queuedAt: Date.now(),
+                execute: execute,
+                resolve: resolve,
+                reject,
+            };
+            // Set queue timeout
+            queued.timeoutId = setTimeout(() => {
+                const index = this.queue.findIndex(q => q.id === id);
+                if (index !== -1) {
+                    this.queue.splice(index, 1);
+                    this.metrics.queuedCount = this.queue.length;
+                    this.metrics.totalTimeout++;
+                    reject(new QueueTimeoutError(`Execution ${id} timed out waiting in queue`));
+                }
+            }, QUEUE_TIMEOUT_MS);
+            // Insert by priority (higher priority = earlier in queue)
+            const insertIndex = this.queue.findIndex(q => q.priority < queued.priority);
+            if (insertIndex === -1) {
+                this.queue.push(queued);
+            }
+            else {
+                this.queue.splice(insertIndex, 0, queued);
+            }
+            this.metrics.queuedCount = this.queue.length;
+            logger.debug(`[Pool] Queued execution ${id} (queue size: ${this.queue.length})`, { component: 'ProcessPool' });
+            this.emit('execution:queued', { id, position: this.queue.length });
+        });
+    }
+    processQueue() {
+        while (this.active.size < this.config.maxConcurrent && this.queue.length > 0) {
+            const queued = this.queue.shift();
+            if (queued.timeoutId)
+                clearTimeout(queued.timeoutId);
+            this.metrics.queuedCount = this.queue.length;
+            // Execute and resolve/reject the promise
+            this.executeNow(queued.id, queued.toolName, queued.conversationId, queued.execute, { userId: queued.userId, priority: queued.priority })
+                .then(queued.resolve)
+                .catch(queued.reject);
+        }
+    }
+    async withTimeout(promise, timeoutMs, id) {
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                reject(new TimeoutError(`Execution ${id} timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+            promise
+                .then(result => {
+                clearTimeout(timeoutId);
+                resolve(result);
+            })
+                .catch(error => {
+                clearTimeout(timeoutId);
+                reject(error);
+            });
+        });
+    }
+    updateDurationMetric(duration) {
+        const total = this.metrics.totalExecuted;
+        if (total === 0) {
+            this.metrics.avgDurationMs = duration;
+        }
+        else {
+            // Running average
+            this.metrics.avgDurationMs =
+                (this.metrics.avgDurationMs * total + duration) / (total + 1);
+        }
+    }
+}
+// Error Classes
+export class PoolFullError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'PoolFullError';
+    }
+}
+export class TimeoutError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'TimeoutError';
+    }
+}
+export class QueueTimeoutError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'QueueTimeoutError';
+    }
+}
+// Singleton
+let processPool = null;
+export function getProcessPool() {
+    if (!processPool) {
+        processPool = new ProcessPool();
+    }
+    return processPool;
+}
+export function initProcessPool(config) {
+    processPool = new ProcessPool(config);
+    return processPool;
+}
+//# sourceMappingURL=process-pool.js.map

package/dist/chat/execution/pty.d.ts

@@ -0,0 +1,92 @@
+/**
+ * PTY (Pseudo-Terminal) Support
+ *
+ * Provides interactive terminal support for commands that require TTY.
+ * Uses node-pty for cross-platform PTY handling.
+ *
+ * Use cases:
+ * - Interactive installers (npm init, create-react-app)
+ * - Text editors (vim, nano)
+ * - Pagers (less, more)
+ * - Password prompts
+ * - SSH sessions
+ */
+import { EventEmitter } from 'events';
+export interface PTYSession {
+    id: string;
+    pid: number;
+    command: string;
+    cols: number;
+    rows: number;
+    status: 'running' | 'exited';
+    exitCode?: number;
+    output: string;
+    createdAt: Date;
+    exitedAt?: Date;
+}
+export interface PTYOptions {
+    cols?: number;
+    rows?: number;
+    cwd?: string;
+    env?: Record<string, string>;
+    timeout?: number;
+    maxOutputChars?: number;
+}
+export interface PTYResult {
+    success: boolean;
+    exitCode: number;
+    output: string;
+    durationMs: number;
+    truncated: boolean;
+    secretsRedacted: boolean;
+}
+export declare class PTYManager extends EventEmitter {
+    private sessions;
+    private sessionCounter;
+    /**
+     * Spawn a new PTY session
+     */
+    spawn(command: string, args?: string[], options?: PTYOptions): PTYSession;
+    /**
+     * Execute a command and wait for completion
+     */
+    execute(command: string, args?: string[], options?: PTYOptions): Promise<PTYResult>;
+    /**
+     * Write input to PTY
+     */
+    write(sessionId: string, data: string): boolean;
+    /**
+     * Resize PTY dimensions
+     */
+    resize(sessionId: string, cols: number, rows: number): boolean;
+    /**
+     * Kill a PTY session
+     */
+    kill(sessionId: string, signal?: string): boolean;
+    /**
+     * Get session info
+     */
+    getSession(sessionId: string): PTYSession | null;
+    /**
+     * Get all active sessions
+     */
+    getActiveSessions(): PTYSession[];
+    /**
+     * Subscribe to session output
+     */
+    subscribe(sessionId: string, listener: (data: string) => void): () => void;
+    /**
+     * Clean up completed session
+     */
+    cleanup(sessionId: string): void;
+    /**
+     * Clean up all sessions
+     */
+    cleanupAll(): void;
+}
+export declare function getPTYManager(): PTYManager;
+/**
+ * Check if a command likely requires PTY
+ */
+export declare function commandNeedsPTY(command: string): boolean;
+//# sourceMappingURL=pty.d.ts.map

package/dist/chat/execution/pty.js

@@ -0,0 +1,285 @@
+/**
+ * PTY (Pseudo-Terminal) Support
+ *
+ * Provides interactive terminal support for commands that require TTY.
+ * Uses node-pty for cross-platform PTY handling.
+ *
+ * Use cases:
+ * - Interactive installers (npm init, create-react-app)
+ * - Text editors (vim, nano)
+ * - Pagers (less, more)
+ * - Password prompts
+ * - SSH sessions
+ */
+import * as pty from 'node-pty';
+import { EventEmitter } from 'events';
+import { logger } from '../../utils/logger.js';
+import { redactSecrets, isSecretsDetectionEnabled } from './secrets.js';
+// =============================================================================
+// Constants
+// =============================================================================
+const DEFAULT_COLS = 80;
+const DEFAULT_ROWS = 24;
+const DEFAULT_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+const DEFAULT_MAX_OUTPUT = 200_000;
+// =============================================================================
+// PTY Manager
+// =============================================================================
+export class PTYManager extends EventEmitter {
+    sessions = new Map();
+    sessionCounter = 0;
+    /**
+     * Spawn a new PTY session
+     */
+    spawn(command, args = [], options = {}) {
+        const id = `pty_${Date.now()}_${++this.sessionCounter}`;
+        const cols = options.cols ?? DEFAULT_COLS;
+        const rows = options.rows ?? DEFAULT_ROWS;
+        // Determine shell
+        const shell = process.platform === 'win32'
+            ? process.env.ComSpec || 'cmd.exe'
+            : process.env.SHELL || '/bin/bash';
+        // Build args
+        const shellArgs = process.platform === 'win32'
+            ? ['/c', command, ...args]
+            : ['-c', `${command} ${args.join(' ')}`];
+        logger.debug(`[PTY] Spawning: ${command}`, { id, cols, rows });
+        // Spawn PTY
+        const ptyProcess = pty.spawn(shell, shellArgs, {
+            name: 'xterm-256color',
+            cols,
+            rows,
+            cwd: options.cwd ?? process.cwd(),
+            env: {
+                ...process.env,
+                ...options.env,
+                TERM: 'xterm-256color',
+                COLORTERM: 'truecolor',
+            },
+        });
+        const session = {
+            id,
+            pid: ptyProcess.pid,
+            command,
+            cols,
+            rows,
+            status: 'running',
+            output: '',
+            createdAt: new Date(),
+        };
+        const entry = {
+            pty: ptyProcess,
+            session,
+            outputBuffer: '',
+            listeners: new Set(),
+        };
+        this.sessions.set(id, entry);
+        // Handle data
+        ptyProcess.onData((data) => {
+            entry.outputBuffer += data;
+            session.output = entry.outputBuffer;
+            // Truncate if needed
+            const maxChars = options.maxOutputChars ?? DEFAULT_MAX_OUTPUT;
+            if (entry.outputBuffer.length > maxChars) {
+                entry.outputBuffer = `[...truncated...]\n${entry.outputBuffer.slice(-maxChars)}`;
+                session.output = entry.outputBuffer;
+            }
+            // Notify listeners
+            for (const listener of entry.listeners) {
+                listener(data);
+            }
+            this.emit('data', id, data);
+        });
+        // Handle exit
+        ptyProcess.onExit(({ exitCode }) => {
+            session.status = 'exited';
+            session.exitCode = exitCode;
+            session.exitedAt = new Date();
+            logger.debug(`[PTY] Exited: ${id}`, { exitCode });
+            this.emit('exit', id, exitCode);
+        });
+        return session;
+    }
+    /**
+     * Execute a command and wait for completion
+     */
+    async execute(command, args = [], options = {}) {
+        const startTime = Date.now();
+        const timeout = options.timeout ?? DEFAULT_TIMEOUT_MS;
+        const maxOutput = options.maxOutputChars ?? DEFAULT_MAX_OUTPUT;
+        const session = this.spawn(command, args, options);
+        const entry = this.sessions.get(session.id);
+        if (!entry) {
+            throw new Error('Failed to create PTY session');
+        }
+        return new Promise((resolve) => {
+            let timedOut = false;
+            // Timeout handler
+            const timeoutId = setTimeout(() => {
+                timedOut = true;
+                this.kill(session.id);
+            }, timeout);
+            // Wait for exit
+            const exitHandler = (id, exitCode) => {
+                if (id !== session.id)
+                    return;
+                clearTimeout(timeoutId);
+                this.off('exit', exitHandler);
+                const durationMs = Date.now() - startTime;
+                let output = entry.outputBuffer;
+                let secretsRedacted = false;
+                // Redact secrets if enabled
+                if (isSecretsDetectionEnabled()) {
+                    output = redactSecrets(output);
+                    secretsRedacted = output !== entry.outputBuffer;
+                }
+                // Clean up session after a delay
+                setTimeout(() => this.cleanup(session.id), 5000);
+                resolve({
+                    success: !timedOut && exitCode === 0,
+                    exitCode: timedOut ? -1 : exitCode,
+                    output: output.trim() || '(no output)',
+                    durationMs,
+                    truncated: entry.outputBuffer.length >= maxOutput,
+                    secretsRedacted,
+                });
+            };
+            this.on('exit', exitHandler);
+        });
+    }
+    /**
+     * Write input to PTY
+     */
+    write(sessionId, data) {
+        const entry = this.sessions.get(sessionId);
+        if (!entry || entry.session.status !== 'running') {
+            return false;
+        }
+        entry.pty.write(data);
+        return true;
+    }
+    /**
+     * Resize PTY dimensions
+     */
+    resize(sessionId, cols, rows) {
+        const entry = this.sessions.get(sessionId);
+        if (!entry || entry.session.status !== 'running') {
+            return false;
+        }
+        entry.pty.resize(cols, rows);
+        entry.session.cols = cols;
+        entry.session.rows = rows;
+        return true;
+    }
+    /**
+     * Kill a PTY session
+     */
+    kill(sessionId, signal = 'SIGTERM') {
+        const entry = this.sessions.get(sessionId);
+        if (!entry || entry.session.status !== 'running') {
+            return false;
+        }
+        try {
+            entry.pty.kill(signal);
+            return true;
+        }
+        catch (error) {
+            logger.warn(`[PTY] Failed to kill session ${sessionId}`, { error });
+            return false;
+        }
+    }
+    /**
+     * Get session info
+     */
+    getSession(sessionId) {
+        return this.sessions.get(sessionId)?.session ?? null;
+    }
+    /**
+     * Get all active sessions
+     */
+    getActiveSessions() {
+        return Array.from(this.sessions.values())
+            .filter((e) => e.session.status === 'running')
+            .map((e) => e.session);
+    }
+    /**
+     * Subscribe to session output
+     */
+    subscribe(sessionId, listener) {
+        const entry = this.sessions.get(sessionId);
+        if (!entry) {
+            return () => { };
+        }
+        entry.listeners.add(listener);
+        return () => entry.listeners.delete(listener);
+    }
+    /**
+     * Clean up completed session
+     */
+    cleanup(sessionId) {
+        const entry = this.sessions.get(sessionId);
+        if (entry) {
+            if (entry.session.status === 'running') {
+                this.kill(sessionId);
+            }
+            entry.listeners.clear();
+            this.sessions.delete(sessionId);
+            logger.debug(`[PTY] Cleaned up session: ${sessionId}`);
+        }
+    }
+    /**
+     * Clean up all sessions
+     */
+    cleanupAll() {
+        for (const sessionId of this.sessions.keys()) {
+            this.cleanup(sessionId);
+        }
+    }
+}
+// =============================================================================
+// Singleton Instance
+// =============================================================================
+let _ptyManager = null;
+export function getPTYManager() {
+    if (!_ptyManager) {
+        _ptyManager = new PTYManager();
+    }
+    return _ptyManager;
+}
+// =============================================================================
+// Helper: Check if command needs PTY
+// =============================================================================
+const PTY_REQUIRED_COMMANDS = new Set([
+    'vim', 'vi', 'nvim', 'nano', 'emacs',
+    'less', 'more', 'man',
+    'top', 'htop', 'btop',
+    'ssh', 'telnet',
+    'ftp', 'sftp',
+    'mysql', 'psql', 'mongo', 'redis-cli',
+    'python', 'python3', 'node', 'irb', 'rails',
+    'bash', 'zsh', 'sh', 'fish',
+]);
+const PTY_HINT_PATTERNS = [
+    /npm\s+init/i,
+    /yarn\s+init/i,
+    /npx\s+create-/i,
+    /\bpassword\b/i,
+    /\bsudo\b/,
+    /--interactive/i,
+    /-i\b/,
+];
+/**
+ * Check if a command likely requires PTY
+ */
+export function commandNeedsPTY(command) {
+    // Extract base command
+    const parts = command.trim().split(/\s+/);
+    const baseCmd = parts[0]?.split('/').pop() ?? '';
+    // Check known PTY-required commands
+    if (PTY_REQUIRED_COMMANDS.has(baseCmd)) {
+        return true;
+    }
+    // Check hint patterns
+    return PTY_HINT_PATTERNS.some((p) => p.test(command));
+}
+//# sourceMappingURL=pty.js.map