brainctl 0.1.7 → 0.1.9

package/dist/services/mcp-preflight-service.js

@@ -1,13 +1,47 @@
 import { stat } from 'node:fs/promises';
 import path from 'node:path';
 import { findExecutable } from '../system/executables.js';
-const SCRIPT_RUNNERS = new Set(['node', 'nodejs', 'python', 'python3', 'bash', 'sh', 'zsh', 'deno', 'bun']);
+const ENTRYPOINT_RUNNERS = new Set(['node', 'nodejs', 'python', 'python3', 'bash', 'sh', 'zsh', 'deno', 'bun']);
+const SUPPORTED_LOCAL_LAUNCHERS = ['npx', 'uvx', 'node', 'python', 'python3', 'java -jar', 'go run', 'cargo run', 'and local binaries/scripts'];
 export function createMcpPreflightService(dependencies = {}) {
     const resolveExecutable = dependencies.resolveExecutable ?? findExecutable;
     const pathExists = dependencies.pathExists ?? defaultPathExists;
     return {
         async execute(options) {
+            if (options.remoteEntry) {
+                return validateRemoteMcp(options.agent, options.remoteEntry);
+            }
             const checks = [];
+            if (!options.entry) {
+                checks.push({
+                    label: 'Launcher',
+                    status: 'error',
+                    message: 'Missing local MCP command metadata.',
+                });
+                return { ok: false, checks };
+            }
+            const launcherCheck = validateLocalLauncher(options.entry);
+            checks.push(launcherCheck);
+            if (launcherCheck.status === 'error') {
+                return { ok: false, checks };
+            }
+            if (isLocalBinaryPath(options.entry.command)) {
+                const commandPath = path.isAbsolute(options.entry.command)
+                    ? options.entry.command
+                    : path.resolve(options.cwd, options.entry.command);
+                const exists = await pathExists(commandPath);
+                checks.push({
+                    label: 'Command',
+                    status: exists ? 'ok' : 'error',
+                    message: exists
+                        ? `Local MCP command was found: ${commandPath}`
+                        : `Local MCP command was not found: ${commandPath}`,
+                });
+                return {
+                    ok: checks.every((check) => check.status !== 'error'),
+                    checks,
+                };
+            }
             const resolvedCommand = await resolveExecutable(options.entry.command);
             if (!resolvedCommand) {
                 checks.push({
@@ -22,20 +56,20 @@ export function createMcpPreflightService(dependencies = {}) {
                 status: 'ok',
                 message: `Command "${options.entry.command}" resolved to ${resolvedCommand}.`,
             });
-            if (options.entry.command === 'npx') {
+            if (options.entry.command === 'npx' || options.entry.command === 'uvx') {
                 const nonFlagArg = options.entry.args?.find((arg) => !arg.startsWith('-'));
                 if (!nonFlagArg) {
                     checks.push({
                         label: 'Package',
                         status: 'error',
-                        message: 'npx-based MCP entries must include a package or executable argument.',
+                        message: `${options.entry.command}-based MCP entries must include a package or executable argument.`,
                     });
                 }
                 else {
                     checks.push({
                         label: 'Package',
                         status: 'ok',
-                        message: `npx will attempt to launch ${nonFlagArg}.`,
+                        message: `${options.entry.command} will attempt to launch ${nonFlagArg}.`,
                     });
                 }
             }
@@ -58,7 +92,21 @@ export function createMcpPreflightService(dependencies = {}) {
     };
 }
 function resolveEntrypointPath(cwd, entry) {
-    if (!SCRIPT_RUNNERS.has(entry.command)) {
+    if (entry.command === 'java') {
+        const jarIndex = entry.args?.indexOf('-jar') ?? -1;
+        const jarPath = jarIndex >= 0 ? entry.args?.[jarIndex + 1] : undefined;
+        if (!jarPath || !looksLikeLocalPath(jarPath))
+            return null;
+        return path.isAbsolute(jarPath) ? jarPath : path.resolve(cwd, jarPath);
+    }
+    if (entry.command === 'go') {
+        const runIndex = entry.args?.indexOf('run') ?? -1;
+        const runPath = runIndex >= 0 ? entry.args?.[runIndex + 1] : undefined;
+        if (!runPath || !looksLikeLocalPath(runPath))
+            return null;
+        return path.isAbsolute(runPath) ? runPath : path.resolve(cwd, runPath);
+    }
+    if (!ENTRYPOINT_RUNNERS.has(entry.command)) {
         return null;
     }
     const firstArg = entry.args?.[0];
@@ -73,6 +121,112 @@ function looksLikeLocalPath(value) {
         value.includes(path.sep) ||
         /\.(cjs|cts|js|json|jsx|mjs|mts|py|sh|ts|tsx)$/i.test(value));
 }
+function validateLocalLauncher(entry) {
+    if (isLocalBinaryPath(entry.command)) {
+        return {
+            label: 'Launcher',
+            status: 'ok',
+            message: `Launcher "${entry.command}" is supported for exact MCP copy.`,
+        };
+    }
+    if (entry.command === 'npx' || entry.command === 'uvx' || entry.command === 'node' || entry.command === 'nodejs' || entry.command === 'python' || entry.command === 'python3') {
+        return {
+            label: 'Launcher',
+            status: 'ok',
+            message: `Launcher "${entry.command}" is supported for exact MCP copy.`,
+        };
+    }
+    if (entry.command === 'java') {
+        const jarIndex = entry.args?.indexOf('-jar') ?? -1;
+        const jarPath = jarIndex >= 0 ? entry.args?.[jarIndex + 1] : undefined;
+        return jarPath
+            ? {
+                label: 'Launcher',
+                status: 'ok',
+                message: 'Launcher "java -jar" is supported for exact MCP copy.',
+            }
+            : {
+                label: 'Launcher',
+                status: 'error',
+                message: 'Launcher "java" is only supported for exact MCP copy when used as "java -jar <path>".',
+            };
+    }
+    if (entry.command === 'go') {
+        const runIndex = entry.args?.indexOf('run') ?? -1;
+        const runPath = runIndex >= 0 ? entry.args?.[runIndex + 1] : undefined;
+        return runPath
+            ? {
+                label: 'Launcher',
+                status: 'ok',
+                message: 'Launcher "go run" is supported for exact MCP copy.',
+            }
+            : {
+                label: 'Launcher',
+                status: 'error',
+                message: 'Launcher "go" is only supported for exact MCP copy when used as "go run <path>".',
+            };
+    }
+    if (entry.command === 'cargo') {
+        return entry.args?.[0] === 'run'
+            ? {
+                label: 'Launcher',
+                status: 'ok',
+                message: 'Launcher "cargo run" is supported for exact MCP copy.',
+            }
+            : {
+                label: 'Launcher',
+                status: 'error',
+                message: 'Launcher "cargo" is only supported for exact MCP copy when used as "cargo run".',
+            };
+    }
+    return {
+        label: 'Launcher',
+        status: 'error',
+        message: `Launcher "${entry.command}" is not supported for exact MCP copy. Supported launchers: ${SUPPORTED_LOCAL_LAUNCHERS.join(', ')}.`,
+    };
+}
+function isLocalBinaryPath(command) {
+    return command.startsWith('./') || command.startsWith('/') || command.startsWith('.\\');
+}
+function validateRemoteMcp(agent, remoteEntry) {
+    const checks = [];
+    let parsedUrl;
+    try {
+        parsedUrl = new URL(remoteEntry.url);
+    }
+    catch {
+        checks.push({
+            label: 'Remote URL',
+            status: 'error',
+            message: `Remote MCP URL is invalid: ${remoteEntry.url}`,
+        });
+        return { ok: false, checks };
+    }
+    if (parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:') {
+        checks.push({
+            label: 'Remote URL',
+            status: 'error',
+            message: `Remote MCP URL must use http or https: ${remoteEntry.url}`,
+        });
+        return { ok: false, checks };
+    }
+    checks.push({
+        label: 'Remote URL',
+        status: 'ok',
+        message: `Remote MCP URL is valid: ${remoteEntry.url}`,
+    });
+    if (agent === 'codex' && (remoteEntry.transport !== 'http' || remoteEntry.headers || remoteEntry.env)) {
+        checks.push({
+            label: 'Remote support',
+            status: 'error',
+            message: 'Codex remote MCP entries only support a plain HTTP url today; headers and env cannot be preserved exactly.',
+        });
+    }
+    return {
+        ok: checks.every((check) => check.status !== 'error'),
+        checks,
+    };
+}
 async function defaultPathExists(targetPath) {
     try {
         await stat(targetPath);

package/dist/services/plugin-install-service.d.ts

@@ -5,25 +5,42 @@ export interface PluginInstallCheck {
     status: 'ok' | 'warn' | 'error';
     message: string;
 }
+export interface PluginBundleAgent {
+    name: string;
+    sourceFormat: 'claude-md' | 'codex-toml';
+    content: string;
+}
+export interface PluginBundleCommand {
+    name: string;
+    content: string;
+}
 export interface PluginInstallPlan {
     ok: boolean;
     checks: PluginInstallCheck[];
     skills: string[];
     mcps: Record<string, AgentMcpEntry>;
+    agents: string[];
+    commands: string[];
 }
 export interface PluginInstallResult {
     installedSkills: string[];
     installedMcps: string[];
+    installedAgents: string[];
+    installedCommands: string[];
 }
 export interface PluginUninstallPlan {
     ok: boolean;
     checks: PluginInstallCheck[];
     skills: string[];
     mcps: string[];
+    agents: string[];
+    commands: string[];
 }
 export interface PluginUninstallResult {
     removedSkills: string[];
     removedMcps: string[];
+    removedAgents: string[];
+    removedCommands: string[];
 }
 export interface PluginInstallService {
     plan(options: {
@@ -52,6 +69,8 @@ export interface PluginInstallService {
 interface PluginBundle {
     skills: string[];
     mcps: Record<string, AgentMcpEntry>;
+    agents: PluginBundleAgent[];
+    commands: PluginBundleCommand[];
 }
 interface PluginInstallDependencies {
     readInstalledPluginBundle?: (installPath: string) => Promise<PluginBundle>;
@@ -64,6 +83,14 @@ interface PluginInstallDependencies {
         skillName: string;
         targetAgent: AgentName;
     }) => Promise<void>;
+    installAgent?: (options: {
+        targetAgent: AgentName;
+        agent: PluginBundleAgent;
+    }) => Promise<void>;
+    installCommand?: (options: {
+        targetAgent: AgentName;
+        command: PluginBundleCommand;
+    }) => Promise<void>;
     addMcpEntry?: (options: {
         cwd: string;
         agent: AgentName;
@@ -78,6 +105,14 @@ interface PluginInstallDependencies {
         targetAgent: AgentName;
         skillName: string;
     }) => Promise<void>;
+    removeAgentFile?: (options: {
+        targetAgent: AgentName;
+        agentName: string;
+    }) => Promise<void>;
+    removeCommandFile?: (options: {
+        targetAgent: AgentName;
+        commandName: string;
+    }) => Promise<void>;
     removeMcpEntry?: (options: {
         cwd: string;
         agent: AgentName;
@@ -87,6 +122,14 @@ interface PluginInstallDependencies {
         agent: AgentName;
         pluginName: string;
     }) => Promise<void>;
+    uninstallCodexPlugin?: (options: {
+        pluginKey: string;
+        installPath: string;
+    }) => Promise<void>;
+    uninstallClaudePlugin?: (options: {
+        pluginKey: string;
+        installPath: string;
+    }) => Promise<void>;
 }
 export declare function createPluginInstallService(dependencies?: PluginInstallDependencies): PluginInstallService;
 export {};