morpheus-cli 0.8.8 → 0.9.0

package/dist/devkit/tools/filesystem.js

@@ -1,235 +0,0 @@
-import { tool } from '@langchain/core/tools';
-import { z } from 'zod';
-import fs from 'fs-extra';
-import path from 'path';
-import { glob } from 'glob';
-import { truncateOutput, isWithinDir } from '../utils.js';
-import { registerToolFactory } from '../registry.js';
-function resolveSafe(ctx, filePath) {
-    // Resolve relative to sandbox_dir (preferred) or working_dir
-    const base = ctx.sandbox_dir || ctx.working_dir;
-    const resolved = path.isAbsolute(filePath) ? filePath : path.resolve(base, filePath);
-    return resolved;
-}
-/**
- * Guards a resolved path against the sandbox directory.
- * When sandbox_dir is set, ALL paths (read and write) must be within it.
- * When readonly_mode is true, destructive operations are blocked.
- */
-function guardPath(ctx, resolved, destructive = false) {
-    // Enforce readonly_mode for destructive operations
-    if (destructive && ctx.readonly_mode) {
-        throw new Error(`Operation denied: DevKit is in read-only mode. Write/delete operations are blocked.`);
-    }
-    // Enforce sandbox_dir for ALL operations (read and write)
-    if (ctx.sandbox_dir && !isWithinDir(resolved, ctx.sandbox_dir)) {
-        throw new Error(`Path '${resolved}' is outside the sandbox directory '${ctx.sandbox_dir}'. Operation denied.`);
-    }
-}
-export function createFilesystemTools(ctx) {
-    return [
-        tool(async ({ file_path, encoding, start_line, end_line }) => {
-            const resolved = resolveSafe(ctx, file_path);
-            guardPath(ctx, resolved);
-            const content = await fs.readFile(resolved, encoding ?? 'utf8');
-            const lines = content.split('\n');
-            const sliced = (start_line || end_line)
-                ? lines.slice((start_line ?? 1) - 1, end_line).join('\n')
-                : content;
-            return truncateOutput(sliced);
-        }, {
-            name: 'read_file',
-            description: 'Read the contents of a file. Optionally specify line range.',
-            schema: z.object({
-                file_path: z.string().describe('Path to the file (absolute or relative to working_dir)'),
-                encoding: z.string().optional().describe('File encoding, default utf8'),
-                start_line: z.number().int().positive().optional().describe('Start line (1-based)'),
-                end_line: z.number().int().positive().optional().describe('End line (inclusive)'),
-            }),
-        }),
-        tool(async ({ file_path, content }) => {
-            const resolved = resolveSafe(ctx, file_path);
-            guardPath(ctx, resolved, true);
-            await fs.ensureDir(path.dirname(resolved));
-            await fs.writeFile(resolved, content, 'utf8');
-            return JSON.stringify({ success: true, path: resolved });
-        }, {
-            name: 'write_file',
-            description: 'Write content to a file, creating it and parent directories if needed.',
-            schema: z.object({
-                file_path: z.string(),
-                content: z.string().describe('Content to write'),
-            }),
-        }),
-        tool(async ({ file_path, content }) => {
-            const resolved = resolveSafe(ctx, file_path);
-            guardPath(ctx, resolved, true);
-            await fs.ensureDir(path.dirname(resolved));
-            await fs.appendFile(resolved, content, 'utf8');
-            return JSON.stringify({ success: true, path: resolved });
-        }, {
-            name: 'append_file',
-            description: 'Append content to a file without overwriting existing content.',
-            schema: z.object({
-                file_path: z.string(),
-                content: z.string(),
-            }),
-        }),
-        tool(async ({ file_path }) => {
-            const resolved = resolveSafe(ctx, file_path);
-            guardPath(ctx, resolved, true);
-            await fs.remove(resolved);
-            return JSON.stringify({ success: true, deleted: resolved });
-        }, {
-            name: 'delete_file',
-            description: 'Delete a file or directory.',
-            schema: z.object({ file_path: z.string() }),
-        }),
-        tool(async ({ source, destination }) => {
-            const src = resolveSafe(ctx, source);
-            const dest = resolveSafe(ctx, destination);
-            guardPath(ctx, src, true);
-            guardPath(ctx, dest, true);
-            await fs.ensureDir(path.dirname(dest));
-            await fs.move(src, dest, { overwrite: true });
-            return JSON.stringify({ success: true, from: src, to: dest });
-        }, {
-            name: 'move_file',
-            description: 'Move or rename a file or directory.',
-            schema: z.object({
-                source: z.string(),
-                destination: z.string(),
-            }),
-        }),
-        tool(async ({ source, destination }) => {
-            const src = resolveSafe(ctx, source);
-            const dest = resolveSafe(ctx, destination);
-            guardPath(ctx, src);
-            guardPath(ctx, dest, true);
-            await fs.ensureDir(path.dirname(dest));
-            await fs.copy(src, dest);
-            return JSON.stringify({ success: true, from: src, to: dest });
-        }, {
-            name: 'copy_file',
-            description: 'Copy a file or directory to a new location.',
-            schema: z.object({
-                source: z.string(),
-                destination: z.string(),
-            }),
-        }),
-        tool(async ({ dir_path, recursive, pattern }) => {
-            const resolved = resolveSafe(ctx, dir_path ?? '.');
-            guardPath(ctx, resolved);
-            const entries = await fs.readdir(resolved, { withFileTypes: true });
-            let results = entries.map(e => ({
-                name: e.name,
-                type: e.isDirectory() ? 'dir' : 'file',
-                path: path.join(resolved, e.name),
-            }));
-            if (pattern) {
-                const re = new RegExp(pattern.replace('*', '.*').replace('?', '.'));
-                results = results.filter(r => re.test(r.name));
-            }
-            if (recursive) {
-                const subResults = [];
-                for (const entry of results.filter(r => r.type === 'dir')) {
-                    try {
-                        const subEntries = await fs.readdir(entry.path, { withFileTypes: true });
-                        subResults.push(...subEntries.map(e => ({
-                            name: e.name,
-                            type: e.isDirectory() ? 'dir' : 'file',
-                            path: path.join(entry.path, e.name),
-                        })));
-                    }
-                    catch { /* skip inaccessible */ }
-                }
-                results.push(...subResults);
-            }
-            return truncateOutput(JSON.stringify(results, null, 2));
-        }, {
-            name: 'list_dir',
-            description: 'List files and directories in a path.',
-            schema: z.object({
-                dir_path: z.string().optional().describe('Directory path, defaults to working_dir'),
-                recursive: z.boolean().optional().describe('Include subdirectory contents'),
-                pattern: z.string().optional().describe('Filter by name pattern (glob-like)'),
-            }),
-        }),
-        tool(async ({ dir_path }) => {
-            const resolved = resolveSafe(ctx, dir_path);
-            guardPath(ctx, resolved, true);
-            await fs.ensureDir(resolved);
-            return JSON.stringify({ success: true, path: resolved });
-        }, {
-            name: 'create_dir',
-            description: 'Create a directory and all parent directories.',
-            schema: z.object({ dir_path: z.string() }),
-        }),
-        tool(async ({ file_path }) => {
-            const resolved = resolveSafe(ctx, file_path);
-            guardPath(ctx, resolved);
-            const stat = await fs.stat(resolved);
-            return JSON.stringify({
-                path: resolved,
-                size: stat.size,
-                isDirectory: stat.isDirectory(),
-                isFile: stat.isFile(),
-                created: stat.birthtime.toISOString(),
-                modified: stat.mtime.toISOString(),
-                permissions: stat.mode.toString(8),
-            });
-        }, {
-            name: 'file_info',
-            description: 'Get metadata about a file or directory (size, dates, permissions).',
-            schema: z.object({ file_path: z.string() }),
-        }),
-        tool(async ({ pattern, search_path, regex, case_insensitive, max_results }) => {
-            const base = resolveSafe(ctx, search_path ?? '.');
-            guardPath(ctx, base);
-            const files = await glob('**/*', { cwd: base, nodir: true, absolute: true });
-            const re = new RegExp(pattern, case_insensitive ? 'i' : undefined);
-            const results = [];
-            for (const file of files) {
-                if (results.length >= (max_results ?? 100))
-                    break;
-                try {
-                    const content = await fs.readFile(file, 'utf8');
-                    const lines = content.split('\n');
-                    for (let i = 0; i < lines.length; i++) {
-                        if (re.test(lines[i])) {
-                            results.push({ file: path.relative(base, file), line: i + 1, match: lines[i].trim() });
-                            if (results.length >= (max_results ?? 100))
-                                break;
-                        }
-                    }
-                }
-                catch { /* skip binary/unreadable files */ }
-            }
-            return truncateOutput(JSON.stringify(results, null, 2));
-        }, {
-            name: 'search_in_files',
-            description: 'Search for a pattern (regex) inside file contents.',
-            schema: z.object({
-                pattern: z.string().describe('Regex pattern to search for'),
-                search_path: z.string().optional().describe('Directory to search in, defaults to working_dir'),
-                regex: z.boolean().optional().describe('Treat pattern as regex (default true)'),
-                case_insensitive: z.boolean().optional(),
-                max_results: z.number().int().positive().optional().describe('Max matches to return (default 100)'),
-            }),
-        }),
-        tool(async ({ pattern, search_path }) => {
-            const base = resolveSafe(ctx, search_path ?? '.');
-            guardPath(ctx, base);
-            const files = await glob(pattern, { cwd: base, absolute: true });
-            return truncateOutput(JSON.stringify(files.map(f => path.relative(base, f)), null, 2));
-        }, {
-            name: 'find_files',
-            description: 'Find files matching a glob pattern.',
-            schema: z.object({
-                pattern: z.string().describe('Glob pattern e.g. "**/*.ts", "src/**/*.json"'),
-                search_path: z.string().optional().describe('Base directory, defaults to working_dir'),
-            }),
-        }),
-    ];
-}
-registerToolFactory(createFilesystemTools, 'filesystem');

package/dist/devkit/tools/git.js

@@ -1,226 +0,0 @@
-import { tool } from '@langchain/core/tools';
-import { z } from 'zod';
-import path from 'path';
-import { ShellAdapter } from '../adapters/shell.js';
-import { truncateOutput, isCommandAllowed, isWithinDir } 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) {
-                // Enforce sandbox_dir on clone destination
-                if (ctx.sandbox_dir) {
-                    const resolvedDest = path.isAbsolute(destination) ? destination : path.resolve(ctx.working_dir, destination);
-                    if (!isWithinDir(resolvedDest, ctx.sandbox_dir)) {
-                        return JSON.stringify({ success: false, output: `Clone destination '${resolvedDest}' is outside the sandbox directory '${ctx.sandbox_dir}'. Operation denied.` });
-                    }
-                }
-                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 }) => {
-            // Enforce sandbox_dir on worktree path
-            if (ctx.sandbox_dir) {
-                const resolvedPath = path.isAbsolute(worktreePath) ? worktreePath : path.resolve(ctx.working_dir, worktreePath);
-                if (!isWithinDir(resolvedPath, ctx.sandbox_dir)) {
-                    return JSON.stringify({ success: false, output: `Worktree path '${resolvedPath}' is outside the sandbox directory '${ctx.sandbox_dir}'. Operation denied.` });
-                }
-            }
-            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, 'git');

package/dist/devkit/tools/network.js

@@ -1,165 +0,0 @@
-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, isWithinDir } 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: 'Preferred connectivity check tool. Verify if a host is reachable on a given port (TCP connect check). Use this instead of shell ping for routine reachability checks.',
-            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);
-            // Enforce sandbox_dir on download destination
-            if (ctx.sandbox_dir && !isWithinDir(destPath, ctx.sandbox_dir)) {
-                return JSON.stringify({
-                    success: false,
-                    error: `Download destination '${destPath}' is outside the sandbox directory '${ctx.sandbox_dir}'. Operation denied.`,
-                });
-            }
-            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, 'network');