morpheus-cli 0.4.0 → 0.4.2

package/dist/devkit/tools/git.js

@@ -0,0 +1,210 @@
+import { tool } from '@langchain/core/tools';
+import { z } from 'zod';
+import { ShellAdapter } from '../adapters/shell.js';
+import { truncateOutput, isCommandAllowed } from '../utils.js';
+import { registerToolFactory } from '../registry.js';
+export function createGitTools(ctx) {
+    const shell = ShellAdapter.create();
+    async function git(args, cwd) {
+        if (!isCommandAllowed('git', ctx.allowed_commands)) {
+            return { success: false, output: `'git' is not in the allowed_commands list.` };
+        }
+        const result = await shell.run('git', args, {
+            cwd: cwd ?? ctx.working_dir,
+            timeout_ms: ctx.timeout_ms ?? 30_000,
+        });
+        return {
+            success: result.exitCode === 0,
+            output: truncateOutput(result.stdout + (result.stderr ? '\n' + result.stderr : '')),
+        };
+    }
+    return [
+        tool(async ({ short }) => {
+            const r = await git(short ? ['status', '-s'] : ['status']);
+            return r.output;
+        }, {
+            name: 'git_status',
+            description: 'Show the working tree status.',
+            schema: z.object({ short: z.boolean().optional().describe('Short format') }),
+        }),
+        tool(async ({ staged, file, base_branch }) => {
+            const args = ['diff'];
+            if (staged)
+                args.push('--staged');
+            if (base_branch)
+                args.push(base_branch);
+            if (file)
+                args.push('--', file);
+            const r = await git(args);
+            return r.output;
+        }, {
+            name: 'git_diff',
+            description: 'Show changes between commits, commit and working tree, etc.',
+            schema: z.object({
+                staged: z.boolean().optional().describe('Show staged changes'),
+                file: z.string().optional().describe('Specific file'),
+                base_branch: z.string().optional().describe('Compare against this branch'),
+            }),
+        }),
+        tool(async ({ max_count, oneline, author, since }) => {
+            const args = ['log'];
+            if (max_count)
+                args.push(`-${max_count}`);
+            if (oneline)
+                args.push('--oneline');
+            if (author)
+                args.push(`--author=${author}`);
+            if (since)
+                args.push(`--since=${since}`);
+            const r = await git(args);
+            return r.output;
+        }, {
+            name: 'git_log',
+            description: 'Show commit logs.',
+            schema: z.object({
+                max_count: z.number().int().optional().describe('Limit number of commits'),
+                oneline: z.boolean().optional(),
+                author: z.string().optional(),
+                since: z.string().optional().describe('e.g. "2 weeks ago"'),
+            }),
+        }),
+        tool(async ({ files }) => {
+            const args = ['add', ...(files ?? ['.'])];
+            const r = await git(args);
+            return JSON.stringify({ success: r.success, output: r.output });
+        }, {
+            name: 'git_add',
+            description: 'Stage files for commit.',
+            schema: z.object({
+                files: z.array(z.string()).optional().describe('Files to stage, defaults to all (".")'),
+            }),
+        }),
+        tool(async ({ message, allow_empty }) => {
+            const args = ['commit', '-m', message];
+            if (allow_empty)
+                args.push('--allow-empty');
+            const r = await git(args);
+            return JSON.stringify({ success: r.success, output: r.output });
+        }, {
+            name: 'git_commit',
+            description: 'Create a commit with the staged changes.',
+            schema: z.object({
+                message: z.string().describe('Commit message'),
+                allow_empty: z.boolean().optional(),
+            }),
+        }),
+        tool(async ({ remote, branch, force }) => {
+            const args = ['push'];
+            if (remote)
+                args.push(remote);
+            if (branch)
+                args.push(branch);
+            if (force)
+                args.push('--force-with-lease');
+            const r = await git(args);
+            return JSON.stringify({ success: r.success, output: r.output });
+        }, {
+            name: 'git_push',
+            description: 'Push commits to the remote repository.',
+            schema: z.object({
+                remote: z.string().optional().describe('Remote name, default origin'),
+                branch: z.string().optional().describe('Branch to push'),
+                force: z.boolean().optional().describe('Force push with lease (safer)'),
+            }),
+        }),
+        tool(async ({ remote, branch, rebase }) => {
+            const args = ['pull'];
+            if (remote)
+                args.push(remote);
+            if (branch)
+                args.push(branch);
+            if (rebase)
+                args.push('--rebase');
+            const r = await git(args);
+            return JSON.stringify({ success: r.success, output: r.output });
+        }, {
+            name: 'git_pull',
+            description: 'Fetch and merge changes from remote.',
+            schema: z.object({
+                remote: z.string().optional(),
+                branch: z.string().optional(),
+                rebase: z.boolean().optional(),
+            }),
+        }),
+        tool(async ({ target, create }) => {
+            const args = ['checkout'];
+            if (create)
+                args.push('-b');
+            args.push(target);
+            const r = await git(args);
+            return JSON.stringify({ success: r.success, output: r.output });
+        }, {
+            name: 'git_checkout',
+            description: 'Switch branches or restore files.',
+            schema: z.object({
+                target: z.string().describe('Branch name or file path'),
+                create: z.boolean().optional().describe('Create the branch if it does not exist'),
+            }),
+        }),
+        tool(async ({ branch_name, from }) => {
+            const args = ['checkout', '-b', branch_name];
+            if (from)
+                args.push(from);
+            const r = await git(args);
+            return JSON.stringify({ success: r.success, output: r.output });
+        }, {
+            name: 'git_create_branch',
+            description: 'Create a new git branch.',
+            schema: z.object({
+                branch_name: z.string(),
+                from: z.string().optional().describe('Base branch or commit'),
+            }),
+        }),
+        tool(async ({ message, pop }) => {
+            const args = pop ? ['stash', 'pop'] : ['stash', 'push'];
+            if (!pop && message)
+                args.push('-m', message);
+            const r = await git(args);
+            return JSON.stringify({ success: r.success, output: r.output });
+        }, {
+            name: 'git_stash',
+            description: 'Stash working directory changes or pop the last stash.',
+            schema: z.object({
+                message: z.string().optional(),
+                pop: z.boolean().optional().describe('Pop the last stash instead of creating'),
+            }),
+        }),
+        tool(async ({ url, destination, depth }) => {
+            const args = ['clone', url];
+            if (destination)
+                args.push(destination);
+            if (depth)
+                args.push('--depth', String(depth));
+            const r = await git(args);
+            return JSON.stringify({ success: r.success, output: r.output });
+        }, {
+            name: 'git_clone',
+            description: 'Clone a git repository.',
+            schema: z.object({
+                url: z.string().describe('Repository URL'),
+                destination: z.string().optional().describe('Target directory'),
+                depth: z.number().int().optional().describe('Shallow clone depth'),
+            }),
+        }),
+        tool(async ({ path: worktreePath, branch }) => {
+            const args = ['worktree', 'add', worktreePath];
+            if (branch)
+                args.push('-b', branch);
+            const r = await git(args);
+            return JSON.stringify({ success: r.success, output: r.output });
+        }, {
+            name: 'git_worktree_add',
+            description: 'Add a new git worktree for parallel development.',
+            schema: z.object({
+                path: z.string().describe('Path for the new worktree'),
+                branch: z.string().optional().describe('New branch to create in the worktree'),
+            }),
+        }),
+    ];
+}
+registerToolFactory(createGitTools);

package/dist/devkit/tools/network.js

@@ -0,0 +1,158 @@
+import { tool } from '@langchain/core/tools';
+import { z } from 'zod';
+import net from 'net';
+import dns from 'dns';
+import fs from 'fs-extra';
+import path from 'path';
+import { truncateOutput } from '../utils.js';
+import { registerToolFactory } from '../registry.js';
+export function createNetworkTools(ctx) {
+    return [
+        tool(async ({ url, method, headers, body, timeout_ms }) => {
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), timeout_ms ?? 30_000);
+            try {
+                const response = await fetch(url, {
+                    method: method ?? 'GET',
+                    headers: headers,
+                    body: body ? JSON.stringify(body) : undefined,
+                    signal: controller.signal,
+                });
+                const text = await response.text();
+                return JSON.stringify({
+                    success: response.ok,
+                    status: response.status,
+                    statusText: response.statusText,
+                    headers: Object.fromEntries(response.headers.entries()),
+                    body: truncateOutput(text),
+                });
+            }
+            catch (err) {
+                return JSON.stringify({ success: false, error: err.message });
+            }
+            finally {
+                clearTimeout(timer);
+            }
+        }, {
+            name: 'http_request',
+            description: 'Make an HTTP request (GET, POST, PUT, DELETE, PATCH).',
+            schema: z.object({
+                url: z.string().describe('Full URL to request'),
+                method: z.enum(['GET', 'POST', 'PUT', 'DELETE', 'PATCH']).optional().describe('HTTP method, default GET'),
+                headers: z.record(z.string(), z.string()).optional().describe('Request headers'),
+                body: z.any().optional().describe('Request body (will be JSON-stringified)'),
+                timeout_ms: z.number().optional().describe('Timeout in ms, default 30000'),
+            }),
+        }),
+        tool(async ({ host, port, timeout_ms }) => {
+            const checkPort = port ?? 80;
+            return new Promise((resolve) => {
+                const socket = net.createConnection(checkPort, host);
+                const timer = setTimeout(() => {
+                    socket.destroy();
+                    resolve(JSON.stringify({ success: false, host, port: checkPort, error: 'timeout' }));
+                }, timeout_ms ?? 5_000);
+                socket.on('connect', () => {
+                    clearTimeout(timer);
+                    socket.destroy();
+                    resolve(JSON.stringify({ success: true, host, port: checkPort, reachable: true }));
+                });
+                socket.on('error', (err) => {
+                    clearTimeout(timer);
+                    resolve(JSON.stringify({ success: false, host, port: checkPort, error: err.message }));
+                });
+            });
+        }, {
+            name: 'ping',
+            description: 'Check if a host is reachable on a given port (TCP connect check).',
+            schema: z.object({
+                host: z.string().describe('Hostname or IP'),
+                port: z.number().int().optional().describe('Port to check, default 80'),
+                timeout_ms: z.number().optional().describe('Timeout in ms, default 5000'),
+            }),
+        }),
+        tool(async ({ host, port, timeout_ms }) => {
+            return new Promise((resolve) => {
+                const socket = net.createConnection(port, host);
+                const timer = setTimeout(() => {
+                    socket.destroy();
+                    resolve(JSON.stringify({ open: false, host, port, reason: 'timeout' }));
+                }, timeout_ms ?? 5_000);
+                socket.on('connect', () => {
+                    clearTimeout(timer);
+                    socket.destroy();
+                    resolve(JSON.stringify({ open: true, host, port }));
+                });
+                socket.on('error', (err) => {
+                    clearTimeout(timer);
+                    resolve(JSON.stringify({ open: false, host, port, reason: err.message }));
+                });
+            });
+        }, {
+            name: 'port_check',
+            description: 'Check if a specific port is open on a host.',
+            schema: z.object({
+                host: z.string(),
+                port: z.number().int(),
+                timeout_ms: z.number().optional(),
+            }),
+        }),
+        tool(async ({ hostname, record_type }) => {
+            return new Promise((resolve) => {
+                const rtype = (record_type ?? 'A');
+                dns.resolve(hostname, rtype, (err, addresses) => {
+                    if (err) {
+                        resolve(JSON.stringify({ success: false, hostname, error: err.message }));
+                    }
+                    else {
+                        resolve(JSON.stringify({ success: true, hostname, type: record_type ?? 'A', addresses }));
+                    }
+                });
+            });
+        }, {
+            name: 'dns_lookup',
+            description: 'Resolve a hostname to IP addresses.',
+            schema: z.object({
+                hostname: z.string(),
+                record_type: z.enum(['A', 'AAAA', 'MX', 'TXT', 'CNAME']).optional().describe('DNS record type, default A'),
+            }),
+        }),
+        tool(async ({ url, destination, timeout_ms }) => {
+            const destPath = path.isAbsolute(destination)
+                ? destination
+                : path.resolve(ctx.working_dir, destination);
+            await fs.ensureDir(path.dirname(destPath));
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), timeout_ms ?? 60_000);
+            try {
+                const response = await fetch(url, { signal: controller.signal });
+                if (!response.ok) {
+                    return JSON.stringify({ success: false, error: `HTTP ${response.status}: ${response.statusText}` });
+                }
+                const buffer = await response.arrayBuffer();
+                await fs.writeFile(destPath, Buffer.from(buffer));
+                return JSON.stringify({
+                    success: true,
+                    url,
+                    destination: destPath,
+                    size_bytes: buffer.byteLength,
+                });
+            }
+            catch (err) {
+                return JSON.stringify({ success: false, error: err.message });
+            }
+            finally {
+                clearTimeout(timer);
+            }
+        }, {
+            name: 'download_file',
+            description: 'Download a file from a URL to a local path.',
+            schema: z.object({
+                url: z.string().describe('URL to download from'),
+                destination: z.string().describe('Local path to save the file'),
+                timeout_ms: z.number().optional().describe('Timeout in ms, default 60000'),
+            }),
+        }),
+    ];
+}
+registerToolFactory(createNetworkTools);

package/dist/devkit/tools/packages.js

@@ -0,0 +1,73 @@
+import { tool } from '@langchain/core/tools';
+import { z } from 'zod';
+import { ShellAdapter } from '../adapters/shell.js';
+import { truncateOutput, isCommandAllowed } from '../utils.js';
+import { registerToolFactory } from '../registry.js';
+export function createPackageTools(ctx) {
+    const shell = ShellAdapter.create();
+    async function run(binary, args, timeout_ms) {
+        if (!isCommandAllowed(binary, ctx.allowed_commands)) {
+            return `'${binary}' is not in the allowed_commands list.`;
+        }
+        const result = await shell.run(binary, args, {
+            cwd: ctx.working_dir,
+            timeout_ms: timeout_ms ?? ctx.timeout_ms ?? 120_000,
+        });
+        return truncateOutput(result.stdout + (result.stderr ? '\n' + result.stderr : ''));
+    }
+    return [
+        tool(async ({ packages, save_dev, timeout_ms }) => {
+            const args = ['install'];
+            if (packages?.length)
+                args.push(...packages);
+            if (save_dev)
+                args.push('--save-dev');
+            return run('npm', args, timeout_ms);
+        }, {
+            name: 'npm_install',
+            description: 'Install npm packages. Runs "npm install [packages]".',
+            schema: z.object({
+                packages: z.array(z.string()).optional().describe('Specific packages to install, omit to install all from package.json'),
+                save_dev: z.boolean().optional().describe('Install as devDependency'),
+                timeout_ms: z.number().optional(),
+            }),
+        }),
+        tool(async ({ script, args, timeout_ms }) => {
+            const npmArgs = ['run', script];
+            if (args?.length)
+                npmArgs.push('--', ...args);
+            return run('npm', npmArgs, timeout_ms);
+        }, {
+            name: 'npm_run',
+            description: 'Run an npm script defined in package.json.',
+            schema: z.object({
+                script: z.string().describe('Script name from package.json'),
+                args: z.array(z.string()).optional().describe('Additional arguments after --'),
+                timeout_ms: z.number().optional(),
+            }),
+        }),
+        tool(async ({ packages, upgrade, timeout_ms }) => {
+            const args = [upgrade ? 'install' : 'install', '--upgrade', ...packages];
+            return run('pip3', packages.length ? ['install', ...packages] : ['install', '-r', 'requirements.txt'], timeout_ms);
+        }, {
+            name: 'pip_install',
+            description: 'Install Python packages with pip3.',
+            schema: z.object({
+                packages: z.array(z.string()).default([]).describe('Package names, omit to use requirements.txt'),
+                upgrade: z.boolean().optional().describe('Upgrade packages if already installed'),
+                timeout_ms: z.number().optional(),
+            }),
+        }),
+        tool(async ({ args, timeout_ms }) => {
+            return run('cargo', ['build', ...(args ?? [])], timeout_ms);
+        }, {
+            name: 'cargo_build',
+            description: 'Build a Rust project using cargo.',
+            schema: z.object({
+                args: z.array(z.string()).optional().describe('Additional cargo build arguments'),
+                timeout_ms: z.number().optional(),
+            }),
+        }),
+    ];
+}
+registerToolFactory(createPackageTools);

package/dist/devkit/tools/processes.js

@@ -0,0 +1,130 @@
+import { tool } from '@langchain/core/tools';
+import { z } from 'zod';
+import os from 'os';
+import { ShellAdapter } from '../adapters/shell.js';
+import { truncateOutput } from '../utils.js';
+import { registerToolFactory } from '../registry.js';
+import { platform } from 'os';
+export function createProcessTools(ctx) {
+    const shell = ShellAdapter.create();
+    const isWindows = platform() === 'win32';
+    return [
+        tool(async ({ filter }) => {
+            let result;
+            if (isWindows) {
+                result = await shell.run('tasklist', filter ? ['/FI', `IMAGENAME eq ${filter}*`] : [], {
+                    cwd: ctx.working_dir, timeout_ms: 10_000,
+                });
+            }
+            else {
+                result = await shell.run('ps', ['aux'], { cwd: ctx.working_dir, timeout_ms: 10_000 });
+                if (filter && result.exitCode === 0) {
+                    result.stdout = result.stdout
+                        .split('\n')
+                        .filter((l, i) => i === 0 || l.toLowerCase().includes(filter.toLowerCase()))
+                        .join('\n');
+                }
+            }
+            return truncateOutput(result.stdout || result.stderr);
+        }, {
+            name: 'list_processes',
+            description: 'List running processes, optionally filtered by name.',
+            schema: z.object({
+                filter: z.string().optional().describe('Filter by process name (partial match)'),
+            }),
+        }),
+        tool(async ({ pid, name }) => {
+            let result;
+            if (isWindows) {
+                const filter = pid ? `/FI "PID eq ${pid}"` : `/FI "IMAGENAME eq ${name}*"`;
+                result = await shell.run('tasklist', ['/FI', filter.replace(/"/g, '').split(' ').join(' ')], {
+                    cwd: ctx.working_dir, timeout_ms: 5_000,
+                });
+            }
+            else {
+                const query = pid ? String(pid) : name ?? '';
+                result = await shell.run('ps', ['-p', query, '-o', 'pid,ppid,cmd,%cpu,%mem'], {
+                    cwd: ctx.working_dir, timeout_ms: 5_000,
+                });
+            }
+            return truncateOutput(result.stdout || result.stderr);
+        }, {
+            name: 'get_process',
+            description: 'Get info about a specific process by PID or name.',
+            schema: z.object({
+                pid: z.number().int().optional().describe('Process ID'),
+                name: z.string().optional().describe('Process name'),
+            }),
+        }),
+        tool(async ({ pid, force }) => {
+            let result;
+            if (isWindows) {
+                const args = ['taskkill', '/PID', String(pid)];
+                if (force)
+                    args.push('/F');
+                result = await shell.run('taskkill', ['/PID', String(pid), ...(force ? ['/F'] : [])], {
+                    cwd: ctx.working_dir, timeout_ms: 10_000,
+                });
+            }
+            else {
+                const signal = force ? '-9' : '-15';
+                result = await shell.run('kill', [signal, String(pid)], {
+                    cwd: ctx.working_dir, timeout_ms: 10_000,
+                });
+            }
+            return JSON.stringify({
+                success: result.exitCode === 0,
+                stdout: result.stdout.trim(),
+                stderr: result.stderr.trim(),
+            });
+        }, {
+            name: 'kill_process',
+            description: 'Kill a process by PID. Use force=true for SIGKILL.',
+            schema: z.object({
+                pid: z.number().int().describe('Process ID to kill'),
+                force: z.boolean().optional().describe('Force kill (SIGKILL / /F), default false'),
+            }),
+        }),
+        tool(async () => {
+            const cpus = os.cpus();
+            return JSON.stringify({
+                platform: os.platform(),
+                arch: os.arch(),
+                release: os.release(),
+                hostname: os.hostname(),
+                cpus: cpus.length,
+                cpu_model: cpus[0]?.model ?? 'unknown',
+                total_memory_mb: Math.round(os.totalmem() / 1024 / 1024),
+                free_memory_mb: Math.round(os.freemem() / 1024 / 1024),
+                uptime_seconds: Math.round(os.uptime()),
+                load_avg: os.loadavg(),
+                home_dir: os.homedir(),
+                tmp_dir: os.tmpdir(),
+            });
+        }, {
+            name: 'system_info',
+            description: 'Get system information (OS, CPU, RAM, uptime).',
+            schema: z.object({}),
+        }),
+        tool(async ({ name, all }) => {
+            if (all)
+                return JSON.stringify(process.env);
+            if (name)
+                return JSON.stringify({ [name]: process.env[name] ?? null });
+            // Return non-sensitive vars
+            const safe = Object.fromEntries(Object.entries(process.env).filter(([k]) => !k.toLowerCase().includes('key') &&
+                !k.toLowerCase().includes('token') &&
+                !k.toLowerCase().includes('secret') &&
+                !k.toLowerCase().includes('password')));
+            return truncateOutput(JSON.stringify(safe, null, 2));
+        }, {
+            name: 'env_read',
+            description: 'Read environment variables. Sensitive keys (API_KEY, TOKEN, etc.) are filtered unless all=true.',
+            schema: z.object({
+                name: z.string().optional().describe('Specific env var name'),
+                all: z.boolean().optional().describe('Include all vars including sensitive ones'),
+            }),
+        }),
+    ];
+}
+registerToolFactory(createProcessTools);

package/dist/devkit/tools/shell.js

@@ -0,0 +1,94 @@
+import { tool } from '@langchain/core/tools';
+import { z } from 'zod';
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import { randomUUID } from 'crypto';
+import { ShellAdapter } from '../adapters/shell.js';
+import { truncateOutput, isCommandAllowed } from '../utils.js';
+import { registerToolFactory } from '../registry.js';
+export function createShellTools(ctx) {
+    const shell = ShellAdapter.create();
+    return [
+        tool(async ({ command, args, timeout_ms, cwd }) => {
+            if (!isCommandAllowed(command, ctx.allowed_commands)) {
+                return JSON.stringify({
+                    success: false,
+                    error: `Command '${command}' is not in the allowed_commands list for this project. Allowed: [${ctx.allowed_commands.join(', ')}]`,
+                });
+            }
+            const result = await shell.run(command, args ?? [], {
+                cwd: cwd ?? ctx.working_dir,
+                timeout_ms: timeout_ms ?? ctx.timeout_ms ?? 30_000,
+            });
+            return JSON.stringify({
+                success: result.exitCode === 0,
+                stdout: truncateOutput(result.stdout),
+                stderr: truncateOutput(result.stderr),
+                exitCode: result.exitCode,
+                timedOut: result.timedOut,
+            });
+        }, {
+            name: 'run_command',
+            description: 'Run a shell command. The command binary must be in the project allowlist.',
+            schema: z.object({
+                command: z.string().describe('Command/binary to run'),
+                args: z.array(z.string()).optional().describe('Arguments array'),
+                timeout_ms: z.number().optional().describe('Override timeout in milliseconds'),
+                cwd: z.string().optional().describe('Override working directory'),
+            }),
+        }),
+        tool(async ({ script, language, timeout_ms }) => {
+            const lang = language ?? 'bash';
+            const ext = lang === 'python' ? 'py' : lang === 'node' ? 'js' : 'sh';
+            const tmpFile = path.join(os.tmpdir(), `morpheus-script-${randomUUID()}.${ext}`);
+            try {
+                await fs.writeFile(tmpFile, script, 'utf8');
+                const binaryMap = {
+                    bash: 'bash',
+                    python: 'python3',
+                    node: 'node',
+                    sh: 'sh',
+                };
+                const binary = binaryMap[lang] ?? lang;
+                if (!isCommandAllowed(binary, ctx.allowed_commands)) {
+                    return JSON.stringify({
+                        success: false,
+                        error: `Script runtime '${binary}' is not in the allowed_commands list.`,
+                    });
+                }
+                const result = await shell.run(binary, [tmpFile], {
+                    cwd: ctx.working_dir,
+                    timeout_ms: timeout_ms ?? ctx.timeout_ms ?? 60_000,
+                });
+                return JSON.stringify({
+                    success: result.exitCode === 0,
+                    stdout: truncateOutput(result.stdout),
+                    stderr: truncateOutput(result.stderr),
+                    exitCode: result.exitCode,
+                    timedOut: result.timedOut,
+                });
+            }
+            finally {
+                await fs.remove(tmpFile).catch(() => { });
+            }
+        }, {
+            name: 'run_script',
+            description: 'Write and execute an inline script (bash, python, node, sh).',
+            schema: z.object({
+                script: z.string().describe('Script content to execute'),
+                language: z.enum(['bash', 'python', 'node', 'sh']).optional().describe('Script language, default bash'),
+                timeout_ms: z.number().optional(),
+            }),
+        }),
+        tool(async ({ binary }) => {
+            const location = await shell.which(binary);
+            return JSON.stringify({ found: Boolean(location), path: location });
+        }, {
+            name: 'which',
+            description: 'Find the location of a binary in the system PATH.',
+            schema: z.object({ binary: z.string() }),
+        }),
+    ];
+}
+registerToolFactory(createShellTools);