profclaw 2.0.0 → 2.3.0

package/dist/chat/execution/tools/exec.js

@@ -14,17 +14,44 @@ const ExecParamsSchema = z.object({
     env: z.record(z.string()).optional().describe('Environment variables'),
     timeout: z.number().optional().describe('Timeout in seconds (default: 300)'),
     background: z.boolean().optional().describe('Run in background immediately'),
+    pty: z.boolean().optional().describe('Enable PTY mode for interactive terminal commands'),
 });
 // Constants
 const DEFAULT_TIMEOUT_SEC = 300;
 const MAX_OUTPUT_CHARS = 200_000;
 const YIELD_MS = 10_000; // Background after 10s if not finished
+// PTY spawn helper - dynamically imported to allow graceful fallback
+async function spawnWithPty(command, options) {
+    // Dynamic import allows graceful fallback if native module fails to load
+    const pty = await import('node-pty');
+    const ptyProc = pty.spawn(options.shell, ['-c', command], {
+        name: 'xterm-256color',
+        cols: options.cols ?? 220,
+        rows: options.rows ?? 50,
+        cwd: options.cwd,
+        env: options.env,
+        encoding: 'utf8',
+    });
+    return {
+        pid: ptyProc.pid,
+        onData: (cb) => {
+            ptyProc.onData(cb);
+        },
+        onExit: (cb) => {
+            ptyProc.onExit(cb);
+        },
+        kill: (signal) => {
+            ptyProc.kill(signal);
+        },
+    };
+}
 // Tool Definition
 export const execTool = {
     name: 'exec',
     description: `Execute shell commands. Commands run in a shell with access to standard Unix tools.
 Use for: running scripts, git operations, package management, file manipulation.
-The command output is captured and returned. Long-running commands can be backgrounded.`,
+The command output is captured and returned. Long-running commands can be backgrounded.
+Use pty: true for interactive commands that require a terminal (e.g. npm, yarn, interactive CLIs).`,
     category: 'execution',
     securityLevel: 'moderate',
     allowedHosts: ['sandbox', 'gateway', 'local'],
@@ -33,11 +60,13 @@ The command output is captured and returned. Long-running commands can be backgr
         { description: 'List files', params: { command: 'ls -la' } },
         { description: 'Git status', params: { command: 'git status' } },
         { description: 'Run npm install', params: { command: 'npm install' } },
+        { description: 'Interactive CLI via PTY', params: { command: 'npm run build', pty: true } },
     ],
     async execute(context, params) {
         const { sessionManager, signal, onProgress } = context;
         const workdir = params.workdir ?? context.workdir;
         const timeoutSec = params.timeout ?? DEFAULT_TIMEOUT_SEC;
+        const usePty = params.pty ?? false;
         // Create session for tracking
         const session = sessionManager.create({
             toolCallId: context.toolCallId,
@@ -53,171 +82,281 @@ The command output is captured and returned. Long-running commands can be backgr
             backgrounded: params.background ?? false,
             notifyOnExit: true,
         });
-        return new Promise((resolve) => {
-            const startedAt = Date.now();
-            // Determine shell
-            const shell = process.platform === 'win32' ? 'cmd.exe' : '/bin/bash';
-            const shellArgs = process.platform === 'win32' ? ['/c', params.command] : ['-c', params.command];
-            // Build environment
-            const env = {
-                ...process.env,
-                ...context.env,
-                ...params.env,
-                PWD: workdir,
-            };
-            logger.debug(`[ExecTool] Running: ${params.command}`, { component: 'ExecTool' });
-            // Spawn process
-            const proc = spawn(shell, shellArgs, {
-                cwd: workdir,
-                env,
-                stdio: ['pipe', 'pipe', 'pipe'],
-                detached: process.platform !== 'win32',
-                windowsHide: true,
-            });
-            // Attach to session manager
-            sessionManager
-                .attachProcess?.(session.id, proc);
-            let stdout = '';
-            let stderr = '';
-            let timedOut = false;
-            let yielded = false;
-            const resolveAsBackgrounded = () => {
-                if (yielded || proc.exitCode !== null) {
-                    return;
-                }
-                yielded = true;
-                sessionManager.background?.(session.id);
-                resolve({
-                    success: true,
-                    data: {
-                        status: 'running',
-                        sessionId: session.id,
-                        pid: proc.pid,
-                        output: stdout || '(running...)',
-                    },
-                    output: `Command running in background (session ${session.id}). Use session_status to check progress.`,
-                    isRunning: true,
-                    isBackgrounded: true,
-                    sessionId: session.id,
-                });
-            };
-            // Timeout handler
-            const timeout = setTimeout(() => {
-                timedOut = true;
-                proc.kill('SIGKILL');
-            }, timeoutSec * 1000);
-            // Yield timer for background execution
-            const yieldTimer = params.background
-                ? null
-                : setTimeout(resolveAsBackgrounded, YIELD_MS);
-            // Handle abort signal
-            if (signal) {
-                signal.addEventListener('abort', () => {
-                    if (!yielded) {
-                        proc.kill('SIGTERM');
-                    }
-                });
+        // PTY execution path
+        if (usePty) {
+            return executePty(params, context, session.id, workdir, timeoutSec, signal, onProgress);
+        }
+        // Standard execution path
+        return executeStandard(params, context, session.id, workdir, timeoutSec, signal, onProgress, sessionManager);
+    },
+};
+// Standard (non-PTY) execution
+function executeStandard(params, context, sessionId, workdir, timeoutSec, signal, onProgress, sessionManager) {
+    return new Promise((resolve) => {
+        const startedAt = Date.now();
+        const shell = process.platform === 'win32' ? 'cmd.exe' : '/bin/bash';
+        const shellArgs = process.platform === 'win32' ? ['/c', params.command] : ['-c', params.command];
+        const env = {
+            ...process.env,
+            ...context.env,
+            ...params.env,
+            PWD: workdir,
+        };
+        logger.debug(`[ExecTool] Running: ${params.command}`, { component: 'ExecTool' });
+        const proc = spawn(shell, shellArgs, {
+            cwd: workdir,
+            env,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            detached: process.platform !== 'win32',
+            windowsHide: true,
+        });
+        sessionManager
+            .attachProcess?.(sessionId, proc);
+        let stdout = '';
+        let stderr = '';
+        let timedOut = false;
+        let yielded = false;
+        const resolveAsBackgrounded = () => {
+            if (yielded || proc.exitCode !== null) {
+                return;
             }
-            // Collect output
-            proc.stdout?.on('data', (data) => {
-                const text = data.toString();
-                stdout += text;
-                // Report progress
-                if (onProgress && !yielded) {
-                    onProgress({
-                        type: 'output',
-                        content: text,
-                        timestamp: Date.now(),
-                    });
-                }
+            yielded = true;
+            sessionManager.background?.(sessionId);
+            resolve({
+                success: true,
+                data: {
+                    status: 'running',
+                    sessionId,
+                    pid: proc.pid,
+                    output: stdout || '(running...)',
+                },
+                output: `Command running in background (session ${sessionId}). Use session_status to check progress.`,
+                isRunning: true,
+                isBackgrounded: true,
+                sessionId,
             });
-            proc.stderr?.on('data', (data) => {
-                const text = data.toString();
-                stderr += text;
-                if (onProgress && !yielded) {
-                    onProgress({
-                        type: 'output',
-                        content: `stderr: ${text}`,
-                        timestamp: Date.now(),
-                    });
+        };
+        const timeout = setTimeout(() => {
+            timedOut = true;
+            proc.kill('SIGKILL');
+        }, timeoutSec * 1000);
+        const yieldTimer = params.background ? null : setTimeout(resolveAsBackgrounded, YIELD_MS);
+        if (signal) {
+            signal.addEventListener('abort', () => {
+                if (!yielded) {
+                    proc.kill('SIGTERM');
                 }
             });
-            // Handle completion
-            proc.on('close', (code, exitSignal) => {
-                clearTimeout(timeout);
-                if (yieldTimer)
-                    clearTimeout(yieldTimer);
-                if (yielded) {
-                    // Already returned as backgrounded
-                    return;
-                }
-                const durationMs = Date.now() - startedAt;
-                const success = code === 0 && !timedOut;
-                // Truncate if needed
-                if (stdout.length > MAX_OUTPUT_CHARS) {
-                    stdout = `[...truncated...]\n${stdout.slice(-MAX_OUTPUT_CHARS)}`;
-                }
-                if (stderr.length > MAX_OUTPUT_CHARS) {
-                    stderr = `[...truncated...]\n${stderr.slice(-MAX_OUTPUT_CHARS)}`;
-                }
-                // Build output message
-                let output = stdout || '';
-                if (stderr) {
-                    output += `\n--- stderr ---\n${stderr}`;
-                }
-                if (timedOut) {
-                    output += `\n\n⚠️ Command timed out after ${timeoutSec} seconds`;
-                }
-                else if (code !== 0) {
-                    output += `\n\n❌ Command exited with code ${code}`;
-                    if (exitSignal) {
-                        output += ` (signal: ${exitSignal})`;
-                    }
+        }
+        proc.stdout?.on('data', (data) => {
+            const text = data.toString();
+            stdout += text;
+            if (onProgress && !yielded) {
+                onProgress({ type: 'output', content: text, timestamp: Date.now() });
+            }
+        });
+        proc.stderr?.on('data', (data) => {
+            const text = data.toString();
+            stderr += text;
+            if (onProgress && !yielded) {
+                onProgress({ type: 'output', content: `stderr: ${text}`, timestamp: Date.now() });
+            }
+        });
+        proc.on('close', (code, exitSignal) => {
+            clearTimeout(timeout);
+            if (yieldTimer)
+                clearTimeout(yieldTimer);
+            if (yielded)
+                return;
+            const durationMs = Date.now() - startedAt;
+            const success = code === 0 && !timedOut;
+            if (stdout.length > MAX_OUTPUT_CHARS) {
+                stdout = `[...truncated...]\n${stdout.slice(-MAX_OUTPUT_CHARS)}`;
+            }
+            if (stderr.length > MAX_OUTPUT_CHARS) {
+                stderr = `[...truncated...]\n${stderr.slice(-MAX_OUTPUT_CHARS)}`;
+            }
+            let output = stdout || '';
+            if (stderr) {
+                output += `\n--- stderr ---\n${stderr}`;
+            }
+            if (timedOut) {
+                output += `\n\nCommand timed out after ${timeoutSec} seconds`;
+            }
+            else if (code !== 0) {
+                output += `\n\nCommand exited with code ${code}`;
+                if (exitSignal) {
+                    output += ` (signal: ${exitSignal})`;
                 }
+            }
+            resolve({
+                success,
+                data: {
+                    status: success ? 'completed' : 'failed',
+                    exitCode: code,
+                    exitSignal: exitSignal?.toString() ?? undefined,
+                    stdout,
+                    stderr,
+                    durationMs,
+                    timedOut,
+                },
+                output: output.trim() || '(no output)',
+                durationMs,
+                sessionId,
+                error: success
+                    ? undefined
+                    : {
+                        code: timedOut ? 'TIMEOUT' : 'EXIT_ERROR',
+                        message: timedOut
+                            ? `Command timed out after ${timeoutSec}s`
+                            : `Command exited with code ${code}`,
+                    },
+            });
+        });
+        proc.on('error', (error) => {
+            clearTimeout(timeout);
+            if (yieldTimer)
+                clearTimeout(yieldTimer);
+            if (!yielded) {
                 resolve({
-                    success,
-                    data: {
-                        status: success ? 'completed' : 'failed',
-                        exitCode: code,
-                        exitSignal: exitSignal?.toString() ?? undefined,
-                        stdout,
-                        stderr,
-                        durationMs,
-                        timedOut,
+                    success: false,
+                    error: {
+                        code: 'SPAWN_ERROR',
+                        message: error.message,
                     },
-                    output: output.trim() || '(no output)',
-                    durationMs,
-                    sessionId: session.id,
-                    error: success
-                        ? undefined
-                        : {
-                            code: timedOut ? 'TIMEOUT' : 'EXIT_ERROR',
-                            message: timedOut
-                                ? `Command timed out after ${timeoutSec}s`
-                                : `Command exited with code ${code}`,
-                        },
+                    output: `Failed to execute command: ${error.message}`,
+                    sessionId,
                 });
+            }
+        });
+        if (params.background) {
+            resolveAsBackgrounded();
+        }
+    });
+}
+// PTY execution
+async function executePty(params, context, sessionId, workdir, timeoutSec, signal, onProgress) {
+    const startedAt = Date.now();
+    const shell = process.platform === 'win32' ? 'cmd.exe' : '/bin/bash';
+    const env = {
+        ...process.env,
+        ...context.env,
+        ...params.env,
+        PWD: workdir,
+        TERM: 'xterm-256color',
+    };
+    logger.debug(`[ExecTool] Running (PTY): ${params.command}`, { component: 'ExecTool' });
+    let ptyProc;
+    try {
+        ptyProc = await spawnWithPty(params.command, {
+            shell,
+            cwd: workdir,
+            env,
+        });
+    }
+    catch (importError) {
+        // Graceful fallback: node-pty not available (native module missing/incompatible)
+        logger.warn(`[ExecTool] node-pty unavailable, falling back to standard spawn: ${importError instanceof Error ? importError.message : String(importError)}`, {
+            component: 'ExecTool',
+        });
+        return executeStandard(params, context, sessionId, workdir, timeoutSec, signal, onProgress, context.sessionManager);
+    }
+    return new Promise((resolve) => {
+        let output = '';
+        let timedOut = false;
+        let settled = false;
+        const settle = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeoutHandle);
+            resolve(result);
+        };
+        const timeoutHandle = setTimeout(() => {
+            timedOut = true;
+            try {
+                ptyProc.kill('SIGKILL');
+            }
+            catch {
+                // process may already be gone
+            }
+            const durationMs = Date.now() - startedAt;
+            settle({
+                success: false,
+                data: {
+                    status: 'failed',
+                    exitCode: null,
+                    output: output.length > MAX_OUTPUT_CHARS
+                        ? `[...truncated...]\n${output.slice(-MAX_OUTPUT_CHARS)}`
+                        : output,
+                    durationMs,
+                    timedOut: true,
+                },
+                output: `${output}\n\nCommand timed out after ${timeoutSec} seconds`.trim() || '(no output)',
+                durationMs,
+                sessionId,
+                error: {
+                    code: 'TIMEOUT',
+                    message: `Command timed out after ${timeoutSec}s`,
+                },
             });
-            proc.on('error', (error) => {
-                clearTimeout(timeout);
-                if (yieldTimer)
-                    clearTimeout(yieldTimer);
-                if (!yielded) {
-                    resolve({
-                        success: false,
-                        error: {
-                            code: 'SPAWN_ERROR',
-                            message: error.message,
-                        },
-                        output: `Failed to execute command: ${error.message}`,
-                        sessionId: session.id,
-                    });
+        }, timeoutSec * 1000);
+        if (signal) {
+            signal.addEventListener('abort', () => {
+                if (!settled) {
+                    try {
+                        ptyProc.kill('SIGTERM');
+                    }
+                    catch {
+                        // process may already be gone
+                    }
                 }
             });
-            if (params.background) {
-                resolveAsBackgrounded();
+        }
+        ptyProc.onData((data) => {
+            output += data;
+            if (onProgress && !settled) {
+                onProgress({ type: 'output', content: data, timestamp: Date.now() });
             }
         });
-    },
-};
+        ptyProc.onExit(({ exitCode, signal: exitSignal }) => {
+            if (timedOut)
+                return;
+            const durationMs = Date.now() - startedAt;
+            const success = exitCode === 0;
+            let finalOutput = output;
+            if (finalOutput.length > MAX_OUTPUT_CHARS) {
+                finalOutput = `[...truncated...]\n${finalOutput.slice(-MAX_OUTPUT_CHARS)}`;
+            }
+            let outputMsg = finalOutput;
+            if (!success) {
+                outputMsg += `\n\nCommand exited with code ${exitCode}`;
+                if (exitSignal !== undefined) {
+                    outputMsg += ` (signal: ${exitSignal})`;
+                }
+            }
+            settle({
+                success,
+                data: {
+                    status: success ? 'completed' : 'failed',
+                    exitCode,
+                    exitSignal: exitSignal !== undefined ? String(exitSignal) : undefined,
+                    stdout: finalOutput,
+                    stderr: '',
+                    durationMs,
+                    timedOut: false,
+                },
+                output: outputMsg.trim() || '(no output)',
+                durationMs,
+                sessionId,
+                error: success
+                    ? undefined
+                    : {
+                        code: 'EXIT_ERROR',
+                        message: `Command exited with code ${exitCode}`,
+                    },
+            });
+        });
+    });
+}
 //# sourceMappingURL=exec.js.map

package/dist/chat/execution/tools/feed-tools.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Feed Tools
+ *
+ * AI agent tools for managing RSS/Atom feeds and news digests.
+ * Allows agents to add feeds, poll for articles, and generate digests.
+ */
+import { z } from 'zod';
+import type { ToolDefinition } from '../types.js';
+declare const FeedListParams: z.ZodObject<{
+    category: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    category?: string | undefined;
+    enabled?: boolean | undefined;
+}, {
+    category?: string | undefined;
+    enabled?: boolean | undefined;
+}>;
+declare const FeedAddParams: z.ZodObject<{
+    name: z.ZodString;
+    url: z.ZodString;
+    category: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    url: string;
+    category?: string | undefined;
+    tags?: string[] | undefined;
+}, {
+    name: string;
+    url: string;
+    category?: string | undefined;
+    tags?: string[] | undefined;
+}>;
+declare const FeedBundleInstallParams: z.ZodObject<{
+    bundle: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    bundle: string;
+}, {
+    bundle: string;
+}>;
+declare const FeedPollParams: z.ZodObject<{
+    feedId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    feedId?: string | undefined;
+}, {
+    feedId?: string | undefined;
+}>;
+declare const FeedDigestParams: z.ZodObject<{
+    category: z.ZodOptional<z.ZodString>;
+    hours: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    limit?: number | undefined;
+    category?: string | undefined;
+    hours?: number | undefined;
+}, {
+    limit?: number | undefined;
+    category?: string | undefined;
+    hours?: number | undefined;
+}>;
+declare const FeedDiscoverParams: z.ZodObject<{
+    url: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+}, {
+    url: string;
+}>;
+export declare const feedListTool: ToolDefinition<z.infer<typeof FeedListParams>, unknown>;
+export declare const feedAddTool: ToolDefinition<z.infer<typeof FeedAddParams>, unknown>;
+export declare const feedBundleInstallTool: ToolDefinition<z.infer<typeof FeedBundleInstallParams>, unknown>;
+export declare const feedPollTool: ToolDefinition<z.infer<typeof FeedPollParams>, unknown>;
+export declare const feedDigestTool: ToolDefinition<z.infer<typeof FeedDigestParams>, unknown>;
+export declare const feedDiscoverTool: ToolDefinition<z.infer<typeof FeedDiscoverParams>, unknown>;
+export declare const feedTools: ToolDefinition[];
+export {};
+//# sourceMappingURL=feed-tools.d.ts.map