morpheus-cli 0.8.8 → 0.9.0

package/dist/devkit/tools/packages.js

@@ -1,73 +0,0 @@
-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, 'packages');

package/dist/devkit/tools/processes.js

@@ -1,130 +0,0 @@
-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, 'processes');

package/dist/devkit/tools/shell.js

@@ -1,106 +0,0 @@
-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, isWithinDir } 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(', ')}]`,
-                });
-            }
-            // Enforce sandbox_dir: override cwd to stay within sandbox
-            let effectiveCwd = cwd ?? ctx.working_dir;
-            if (ctx.sandbox_dir) {
-                const resolvedCwd = path.isAbsolute(effectiveCwd) ? effectiveCwd : path.resolve(ctx.sandbox_dir, effectiveCwd);
-                if (!isWithinDir(resolvedCwd, ctx.sandbox_dir)) {
-                    return JSON.stringify({
-                        success: false,
-                        error: `Working directory '${resolvedCwd}' is outside the sandbox directory '${ctx.sandbox_dir}'. Operation denied.`,
-                    });
-                }
-                effectiveCwd = resolvedCwd;
-            }
-            const result = await shell.run(command, args ?? [], {
-                cwd: effectiveCwd,
-                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, 'shell');

package/dist/devkit/tools/system.js

@@ -1,132 +0,0 @@
-import { tool } from '@langchain/core/tools';
-import { z } from 'zod';
-import { ShellAdapter } from '../adapters/shell.js';
-import { registerToolFactory } from '../registry.js';
-import { platform } from 'os';
-export function createSystemTools(ctx) {
-    const shell = ShellAdapter.create();
-    const isWindows = platform() === 'win32';
-    const isMac = platform() === 'darwin';
-    return [
-        tool(async ({ title, message, urgency }) => {
-            try {
-                if (isWindows) {
-                    // PowerShell toast notification
-                    const ps = `[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType=WindowsRuntime] | Out-Null; $template = [Windows.UI.Notifications.ToastNotificationManager]::GetTemplateContent([Windows.UI.Notifications.ToastTemplateType]::ToastText02); $template.GetElementsByTagName('text')[0].AppendChild($template.CreateTextNode('${title}')); $template.GetElementsByTagName('text')[1].AppendChild($template.CreateTextNode('${message}')); [Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('Morpheus').Show([Windows.UI.Notifications.ToastNotification]::new($template))`;
-                    await shell.run('powershell', ['-Command', ps], { cwd: ctx.working_dir, timeout_ms: 5_000 });
-                }
-                else if (isMac) {
-                    await shell.run('osascript', ['-e', `display notification "${message}" with title "${title}"`], {
-                        cwd: ctx.working_dir, timeout_ms: 5_000,
-                    });
-                }
-                else {
-                    // Linux — notify-send
-                    const args = [title, message];
-                    if (urgency)
-                        args.unshift(`-u`, urgency);
-                    await shell.run('notify-send', args, { cwd: ctx.working_dir, timeout_ms: 5_000 });
-                }
-                return JSON.stringify({ success: true });
-            }
-            catch (err) {
-                return JSON.stringify({ success: false, error: err.message });
-            }
-        }, {
-            name: 'notify',
-            description: 'Send a desktop notification.',
-            schema: z.object({
-                title: z.string(),
-                message: z.string(),
-                urgency: z.enum(['low', 'normal', 'critical']).optional().describe('Linux urgency level'),
-            }),
-        }),
-        tool(async () => {
-            try {
-                let result;
-                if (isWindows) {
-                    result = await shell.run('powershell', ['-Command', 'Get-Clipboard'], {
-                        cwd: ctx.working_dir, timeout_ms: 5_000,
-                    });
-                }
-                else if (isMac) {
-                    result = await shell.run('pbpaste', [], { cwd: ctx.working_dir, timeout_ms: 5_000 });
-                }
-                else {
-                    result = await shell.run('xclip', ['-selection', 'clipboard', '-o'], {
-                        cwd: ctx.working_dir, timeout_ms: 5_000,
-                    });
-                }
-                return JSON.stringify({ success: result.exitCode === 0, content: result.stdout });
-            }
-            catch (err) {
-                return JSON.stringify({ success: false, error: err.message });
-            }
-        }, {
-            name: 'read_clipboard',
-            description: 'Read the current clipboard contents.',
-            schema: z.object({}),
-        }),
-        tool(async ({ content }) => {
-            try {
-                let result;
-                if (isWindows) {
-                    result = await shell.run('powershell', ['-Command', `Set-Clipboard -Value '${content.replace(/'/g, "''")}'`], {
-                        cwd: ctx.working_dir, timeout_ms: 5_000,
-                    });
-                }
-                else if (isMac) {
-                    result = await shell.run('sh', ['-c', `printf '%s' '${content.replace(/'/g, "'\\''")}' | pbcopy`], {
-                        cwd: ctx.working_dir, timeout_ms: 5_000,
-                    });
-                }
-                else {
-                    result = await shell.run('sh', ['-c', `printf '%s' '${content.replace(/'/g, "'\\''")}' | xclip -selection clipboard`], {
-                        cwd: ctx.working_dir, timeout_ms: 5_000,
-                    });
-                }
-                return JSON.stringify({ success: result.exitCode === 0 });
-            }
-            catch (err) {
-                return JSON.stringify({ success: false, error: err.message });
-            }
-        }, {
-            name: 'write_clipboard',
-            description: 'Write content to the clipboard.',
-            schema: z.object({ content: z.string() }),
-        }),
-        tool(async ({ url }) => {
-            try {
-                const open = isWindows ? 'start' : isMac ? 'open' : 'xdg-open';
-                const result = await shell.run(isWindows ? 'cmd' : open, isWindows ? ['/c', 'start', url] : [url], {
-                    cwd: ctx.working_dir, timeout_ms: 5_000,
-                });
-                return JSON.stringify({ success: result.exitCode === 0, url });
-            }
-            catch (err) {
-                return JSON.stringify({ success: false, error: err.message });
-            }
-        }, {
-            name: 'open_url',
-            description: 'Open a URL in the default browser.',
-            schema: z.object({ url: z.string() }),
-        }),
-        tool(async ({ file_path }) => {
-            try {
-                const open = isWindows ? 'start' : isMac ? 'open' : 'xdg-open';
-                const result = await shell.run(isWindows ? 'cmd' : open, isWindows ? ['/c', 'start', '""', file_path] : [file_path], {
-                    cwd: ctx.working_dir, timeout_ms: 5_000,
-                });
-                return JSON.stringify({ success: result.exitCode === 0, file_path });
-            }
-            catch (err) {
-                return JSON.stringify({ success: false, error: err.message });
-            }
-        }, {
-            name: 'open_file',
-            description: 'Open a file with the default application.',
-            schema: z.object({ file_path: z.string() }),
-        }),
-    ];
-}
-registerToolFactory(createSystemTools, 'system');

package/dist/devkit/types.js

@@ -1 +0,0 @@
-export const MAX_OUTPUT_BYTES = 50 * 1024; // 50 KB

package/dist/devkit/utils.js

@@ -1,45 +0,0 @@
-import path from 'path';
-import { MAX_OUTPUT_BYTES } from './types.js';
-/**
- * Truncates a string to MAX_OUTPUT_BYTES (50 KB) if needed.
- * Returns a UTF-8-safe truncation with a note when truncated.
- */
-export function truncateOutput(output) {
-    const bytes = Buffer.byteLength(output, 'utf8');
-    if (bytes <= MAX_OUTPUT_BYTES)
-        return output;
-    const truncated = Buffer.from(output).subarray(0, MAX_OUTPUT_BYTES).toString('utf8');
-    return truncated + `\n\n[OUTPUT TRUNCATED: ${bytes} bytes total, showing first ${MAX_OUTPUT_BYTES} bytes]`;
-}
-/**
- * Returns true if filePath is inside dir (or equal to dir).
- * Both paths are resolved before comparison.
- */
-export function isWithinDir(filePath, dir) {
-    const resolved = path.resolve(filePath);
-    const resolvedDir = path.resolve(dir);
-    return resolved === resolvedDir || resolved.startsWith(resolvedDir + path.sep);
-}
-/**
- * Extracts the binary base name from a command string.
- * Handles full paths (/usr/bin/node, C:\bin\node.exe) and plain names.
- */
-export function extractBinaryName(command) {
-    // Take first token (before any space), then get the basename, strip extension
-    const firstToken = command.split(/\s+/)[0] ?? command;
-    const base = path.basename(firstToken);
-    return base.replace(/\.(exe|cmd|bat|sh|ps1)$/i, '').toLowerCase();
-}
-/**
- * Checks if a command is allowed based on the allowlist.
- * Empty allowlist means ALL commands are allowed (Merovingian mode).
- */
-export function isCommandAllowed(command, allowedCommands) {
-    if (allowedCommands.length === 0)
-        return true;
-    const binary = extractBinaryName(command);
-    return allowedCommands.some(allowed => {
-        const allowedBinary = extractBinaryName(allowed);
-        return allowedBinary === binary;
-    });
-}