brainctl 0.1.6 → 0.1.7

package/README.md

@@ -112,6 +112,32 @@ brainctl run analyze ./report.md --with codex --fallback claude
 brainctl run review ./code.md --with gemini
 ```
 
+### Profile MCP Format
+
+Packed/published profiles should classify every MCP as either `local` or `remote`.
+
+```yaml
+mcps:
+  github:
+    kind: local
+    source: npm
+    package: "@modelcontextprotocol/server-github"
+
+  internal-docs:
+    kind: remote
+    transport: http
+    url: "https://mcp.example.com"
+```
+
+Rules:
+
+- local profile files may still use the older `type: npm` / `type: bundled` MCP shape
+- `brainctl profile export` writes the packed profile using the explicit format below
+- `local` MCPs must declare `source: npm` or `source: bundled`
+- `remote` MCPs must declare `transport` and `url`
+- bundled local MCPs must declare `path` and `command`
+- `brainctl sync` currently supports local MCPs only; remote MCPs remain in the profile package but are not written into agent configs yet
+
 ---
 
 ## 🧠 Config: `ai-stack.yaml`

package/dist/executor/resolver.js

@@ -1,9 +1,7 @@
-import { access } from 'node:fs/promises';
-import { constants } from 'node:fs';
-import path from 'node:path';
 import { AgentNotAvailableError } from '../errors.js';
 import { ClaudeExecutor } from './claude.js';
 import { CodexExecutor } from './codex.js';
+import { findExecutable } from '../system/executables.js';
 const SUPPORTED_AGENTS = ['claude', 'codex', 'gemini'];
 const AGENT_COMMANDS = {
     claude: 'claude',
@@ -60,38 +58,3 @@ async function checkAvailability(agentName) {
         resolvedPath: resolvedPath ?? undefined
     };
 }
-async function findExecutable(command) {
-    if (command.includes(path.sep)) {
-        return (await isExecutable(command)) ? command : null;
-    }
-    const pathEntries = (process.env.PATH ?? '')
-        .split(path.delimiter)
-        .filter((entry) => entry.length > 0);
-    const extensions = process.platform === 'win32'
-        ? (process.env.PATHEXT ?? '.EXE;.CMD;.BAT;.COM')
-            .split(';')
-            .filter((entry) => entry.length > 0)
-        : [''];
-    for (const pathEntry of pathEntries) {
-        for (const extension of extensions) {
-            const candidate = process.platform === 'win32' &&
-                extension.length > 0 &&
-                !command.toLowerCase().endsWith(extension.toLowerCase())
-                ? path.join(pathEntry, `${command}${extension}`)
-                : path.join(pathEntry, command);
-            if (await isExecutable(candidate)) {
-                return candidate;
-            }
-        }
-    }
-    return null;
-}
-async function isExecutable(filePath) {
-    try {
-        await access(filePath, process.platform === 'win32' ? constants.F_OK : constants.X_OK);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}

package/dist/mcp/server.js

@@ -6,6 +6,7 @@ import { loadConfig } from '../config.js';
 import { loadMemory } from '../context/memory.js';
 import { createAgentConfigService } from '../services/agent-config-service.js';
 import { createDoctorService } from '../services/doctor-service.js';
+import { startUiServer } from '../ui/server.js';
 import { createMemoryWriteService } from '../services/memory-write-service.js';
 import { createProfileExportService } from '../services/profile-export-service.js';
 import { createProfileImportService } from '../services/profile-import-service.js';
@@ -317,6 +318,39 @@ export function createMcpServer(options = {}) {
             return JSON.stringify(result, null, 2);
         },
     });
+    let uiServerInstance = null;
+    server.addTool({
+        name: 'brainctl_open_ui',
+        description: 'Start the brainctl web dashboard. Returns the URL to open in a browser. If already running, returns the existing URL.',
+        parameters: z.object({
+            port: z.number().default(3333).describe('Port number for the UI server'),
+        }),
+        execute: async (args) => {
+            if (uiServerInstance) {
+                return JSON.stringify({ url: uiServerInstance.url, status: 'already_running' });
+            }
+            try {
+                uiServerInstance = await startUiServer({ cwd, port: args.port });
+                return JSON.stringify({ url: uiServerInstance.url, status: 'started' });
+            }
+            catch (err) {
+                return JSON.stringify({ error: err.message, status: 'failed' });
+            }
+        },
+    });
+    server.addTool({
+        name: 'brainctl_close_ui',
+        description: 'Stop the brainctl web dashboard if it is running.',
+        parameters: z.object({}),
+        execute: async () => {
+            if (!uiServerInstance) {
+                return JSON.stringify({ status: 'not_running' });
+            }
+            await uiServerInstance.close();
+            uiServerInstance = null;
+            return JSON.stringify({ status: 'stopped' });
+        },
+    });
     server.addTool({
         name: 'brainctl_read_agent_configs',
         description: 'Read the live MCP configs from all agents (Claude, Codex, Gemini). Shows what is actually configured in each agent right now, by reading their real config files.',

package/dist/services/agent-config-service.d.ts

@@ -1,5 +1,7 @@
 import type { AgentName } from '../types.js';
 import { type AgentLiveConfig, type AgentMcpEntry } from './sync/agent-reader.js';
+import { type McpPreflightService } from './mcp-preflight-service.js';
+import { type SkillPreflightService } from './skill-preflight-service.js';
 export type { AgentLiveConfig, AgentMcpEntry, AgentSkillEntry } from './sync/agent-reader.js';
 export interface AgentConfigService {
     readAll(options: {
@@ -16,5 +18,18 @@ export interface AgentConfigService {
         agent: AgentName;
         key: string;
     }): Promise<void>;
+    copySkill(options: {
+        sourceAgent: AgentName;
+        targetAgent: AgentName;
+        skillName: string;
+    }): Promise<void>;
+    removeSkill(options: {
+        agent: AgentName;
+        skillName: string;
+    }): Promise<void>;
+}
+interface AgentConfigServiceDependencies {
+    mcpPreflightService?: McpPreflightService;
+    skillPreflightService?: SkillPreflightService;
 }
-export declare function createAgentConfigService(): AgentConfigService;
+export declare function createAgentConfigService(dependencies?: AgentConfigServiceDependencies): AgentConfigService;

package/dist/services/agent-config-service.js

@@ -1,14 +1,20 @@
-import { copyFile, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { copyFile, cp, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import path from 'node:path';
+import { ValidationError } from '../errors.js';
 import { createClaudeReader, createCodexReader, createGeminiReader, } from './sync/agent-reader.js';
 import { formatTimestamp } from './sync/agent-writer.js';
+import { createMcpPreflightService } from './mcp-preflight-service.js';
+import { createSkillPreflightService } from './skill-preflight-service.js';
+import { getSkillDir } from './skill-paths.js';
 const readers = {
     claude: createClaudeReader(),
     codex: createCodexReader(),
     gemini: createGeminiReader(),
 };
-export function createAgentConfigService() {
+export function createAgentConfigService(dependencies = {}) {
+    const mcpPreflightService = dependencies.mcpPreflightService ?? createMcpPreflightService();
+    const skillPreflightService = dependencies.skillPreflightService ?? createSkillPreflightService();
     return {
         async readAll(options) {
             const results = await Promise.all([
@@ -20,6 +26,11 @@ export function createAgentConfigService() {
         },
         async addMcp(options) {
             const { cwd, agent, key, entry } = options;
+            const preflight = await mcpPreflightService.execute({ cwd, agent, key, entry });
+            const firstError = preflight.checks.find((check) => check.status === 'error');
+            if (firstError) {
+                throw new ValidationError(`MCP "${key}" cannot be added to ${agent}: ${firstError.message}`);
+            }
             if (agent === 'claude') {
                 await mutateClaudeConfig(cwd, (servers) => {
                     servers[key] = toClaudeEntry(entry);
@@ -54,6 +65,28 @@ export function createAgentConfigService() {
                 });
             }
         },
+        async copySkill(options) {
+            const { sourceAgent, targetAgent, skillName } = options;
+            const preflight = await skillPreflightService.execute({
+                sourceAgent,
+                targetAgent,
+                skillName,
+                source: 'local',
+            });
+            const firstError = preflight.checks.find((check) => check.status === 'error');
+            if (firstError) {
+                throw new ValidationError(`Skill "${skillName}" cannot be copied from ${sourceAgent} to ${targetAgent}: ${firstError.message}`);
+            }
+            const sourceDir = getSkillDir(sourceAgent, skillName);
+            const targetDir = getSkillDir(targetAgent, skillName);
+            await mkdir(path.dirname(targetDir), { recursive: true });
+            await cp(sourceDir, targetDir, { recursive: true });
+        },
+        async removeSkill(options) {
+            const { agent, skillName } = options;
+            const skillDir = getSkillDir(agent, skillName);
+            await rm(skillDir, { recursive: true, force: true });
+        },
     };
 }
 /* ---- Claude: JSON with projects[cwd].mcpServers ---- */

package/dist/services/mcp-preflight-service.d.ts

@@ -0,0 +1,25 @@
+import type { AgentName } from '../types.js';
+import type { AgentMcpEntry } from './agent-config-service.js';
+export interface McpPreflightCheck {
+    label: string;
+    status: 'ok' | 'warn' | 'error';
+    message: string;
+}
+export interface McpPreflightResult {
+    ok: boolean;
+    checks: McpPreflightCheck[];
+}
+export interface McpPreflightService {
+    execute(options: {
+        cwd: string;
+        agent: AgentName;
+        key: string;
+        entry: AgentMcpEntry;
+    }): Promise<McpPreflightResult>;
+}
+interface McpPreflightDependencies {
+    resolveExecutable?: (command: string) => Promise<string | null>;
+    pathExists?: (targetPath: string) => Promise<boolean>;
+}
+export declare function createMcpPreflightService(dependencies?: McpPreflightDependencies): McpPreflightService;
+export {};

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

@@ -0,0 +1,84 @@
+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']);
+export function createMcpPreflightService(dependencies = {}) {
+    const resolveExecutable = dependencies.resolveExecutable ?? findExecutable;
+    const pathExists = dependencies.pathExists ?? defaultPathExists;
+    return {
+        async execute(options) {
+            const checks = [];
+            const resolvedCommand = await resolveExecutable(options.entry.command);
+            if (!resolvedCommand) {
+                checks.push({
+                    label: 'Command',
+                    status: 'error',
+                    message: `Command "${options.entry.command}" is not available on PATH.`,
+                });
+                return { ok: false, checks };
+            }
+            checks.push({
+                label: 'Command',
+                status: 'ok',
+                message: `Command "${options.entry.command}" resolved to ${resolvedCommand}.`,
+            });
+            if (options.entry.command === 'npx') {
+                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.',
+                    });
+                }
+                else {
+                    checks.push({
+                        label: 'Package',
+                        status: 'ok',
+                        message: `npx will attempt to launch ${nonFlagArg}.`,
+                    });
+                }
+            }
+            const entrypointPath = resolveEntrypointPath(options.cwd, options.entry);
+            if (entrypointPath) {
+                const exists = await pathExists(entrypointPath);
+                checks.push({
+                    label: 'Entrypoint',
+                    status: exists ? 'ok' : 'error',
+                    message: exists
+                        ? `Entrypoint script was found: ${entrypointPath}`
+                        : `Entrypoint script was not found: ${entrypointPath}`,
+                });
+            }
+            return {
+                ok: checks.every((check) => check.status !== 'error'),
+                checks,
+            };
+        },
+    };
+}
+function resolveEntrypointPath(cwd, entry) {
+    if (!SCRIPT_RUNNERS.has(entry.command)) {
+        return null;
+    }
+    const firstArg = entry.args?.[0];
+    if (!firstArg || !looksLikeLocalPath(firstArg)) {
+        return null;
+    }
+    return path.isAbsolute(firstArg) ? firstArg : path.resolve(cwd, firstArg);
+}
+function looksLikeLocalPath(value) {
+    return (value.startsWith('.') ||
+        value.startsWith('/') ||
+        value.includes(path.sep) ||
+        /\.(cjs|cts|js|json|jsx|mjs|mts|py|sh|ts|tsx)$/i.test(value));
+}
+async function defaultPathExists(targetPath) {
+    try {
+        await stat(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -0,0 +1,92 @@
+import type { AgentName } from '../types.js';
+import type { AgentLiveConfig, AgentMcpEntry, AgentSkillEntry } from './agent-config-service.js';
+export interface PluginInstallCheck {
+    label: string;
+    status: 'ok' | 'warn' | 'error';
+    message: string;
+}
+export interface PluginInstallPlan {
+    ok: boolean;
+    checks: PluginInstallCheck[];
+    skills: string[];
+    mcps: Record<string, AgentMcpEntry>;
+}
+export interface PluginInstallResult {
+    installedSkills: string[];
+    installedMcps: string[];
+}
+export interface PluginUninstallPlan {
+    ok: boolean;
+    checks: PluginInstallCheck[];
+    skills: string[];
+    mcps: string[];
+}
+export interface PluginUninstallResult {
+    removedSkills: string[];
+    removedMcps: string[];
+}
+export interface PluginInstallService {
+    plan(options: {
+        cwd: string;
+        targetAgent: AgentName;
+        sourceAgent: AgentName;
+        plugin: AgentSkillEntry;
+    }): Promise<PluginInstallPlan>;
+    execute(options: {
+        cwd: string;
+        targetAgent: AgentName;
+        sourceAgent: AgentName;
+        plugin: AgentSkillEntry;
+    }): Promise<PluginInstallResult>;
+    planRemoval(options: {
+        cwd: string;
+        targetAgent: AgentName;
+        plugin: AgentSkillEntry;
+    }): Promise<PluginUninstallPlan>;
+    remove(options: {
+        cwd: string;
+        targetAgent: AgentName;
+        plugin: AgentSkillEntry;
+    }): Promise<PluginUninstallResult>;
+}
+interface PluginBundle {
+    skills: string[];
+    mcps: Record<string, AgentMcpEntry>;
+}
+interface PluginInstallDependencies {
+    readInstalledPluginBundle?: (installPath: string) => Promise<PluginBundle>;
+    readTargetState?: (options: {
+        cwd: string;
+        agent: AgentName;
+    }) => Promise<Pick<AgentLiveConfig, 'skills' | 'mcpServers'>>;
+    copySkillDirectory?: (options: {
+        sourceInstallPath: string;
+        skillName: string;
+        targetAgent: AgentName;
+    }) => Promise<void>;
+    addMcpEntry?: (options: {
+        cwd: string;
+        agent: AgentName;
+        key: string;
+        entry: AgentMcpEntry;
+    }) => Promise<void>;
+    recordManagedPluginInstall?: (options: {
+        agent: AgentName;
+        plugin: AgentSkillEntry;
+    }) => Promise<void>;
+    removeSkillDirectory?: (options: {
+        targetAgent: AgentName;
+        skillName: string;
+    }) => Promise<void>;
+    removeMcpEntry?: (options: {
+        cwd: string;
+        agent: AgentName;
+        key: string;
+    }) => Promise<void>;
+    removeManagedPluginInstall?: (options: {
+        agent: AgentName;
+        pluginName: string;
+    }) => Promise<void>;
+}
+export declare function createPluginInstallService(dependencies?: PluginInstallDependencies): PluginInstallService;
+export {};

package/dist/services/plugin-install-service.js

@@ -0,0 +1,243 @@
+import { cp, mkdir, readFile, rm } from 'node:fs/promises';
+import path from 'node:path';
+import { ValidationError } from '../errors.js';
+import { createAgentConfigService } from './agent-config-service.js';
+import { getSkillDir } from './skill-paths.js';
+import { removeManagedPluginInstall, writeManagedPluginInstall, } from './sync/managed-plugin-registry.js';
+export function createPluginInstallService(dependencies = {}) {
+    const agentConfigService = createAgentConfigService();
+    const readInstalledPluginBundle = dependencies.readInstalledPluginBundle ?? defaultReadInstalledPluginBundle;
+    const readTargetState = dependencies.readTargetState ?? (async ({ cwd, agent }) => {
+        const configs = await agentConfigService.readAll({ cwd });
+        const match = configs.find((config) => config.agent === agent);
+        return {
+            skills: match?.skills ?? [],
+            mcpServers: match?.mcpServers ?? {},
+        };
+    });
+    const copySkillDirectory = dependencies.copySkillDirectory ?? defaultCopySkillDirectory;
+    const addMcpEntry = dependencies.addMcpEntry ?? (async ({ cwd, agent, key, entry }) => {
+        await agentConfigService.addMcp({ cwd, agent, key, entry });
+    });
+    const recordManagedPluginInstall = dependencies.recordManagedPluginInstall ??
+        (async ({ agent, plugin }) => {
+            await writeManagedPluginInstall({ agent, plugin });
+        });
+    const removeSkillDirectory = dependencies.removeSkillDirectory ?? defaultRemoveSkillDirectory;
+    const removeMcpEntry = dependencies.removeMcpEntry ?? (async ({ cwd, agent, key }) => {
+        await agentConfigService.removeMcp({ cwd, agent, key });
+    });
+    const removeRecordedManagedPluginInstall = dependencies.removeManagedPluginInstall ??
+        (async ({ agent, pluginName }) => {
+            await removeManagedPluginInstall({ agent, pluginName });
+        });
+    return {
+        async plan(options) {
+            const checks = [];
+            if (options.plugin.kind !== 'plugin' || !options.plugin.installPath) {
+                checks.push({
+                    label: 'Source plugin',
+                    status: 'error',
+                    message: `Plugin "${options.plugin.name}" is missing an install path and cannot be installed as a bundle.`,
+                });
+                return { ok: false, checks, skills: [], mcps: {} };
+            }
+            const bundle = await readInstalledPluginBundle(options.plugin.installPath);
+            const targetState = await readTargetState({
+                cwd: options.cwd,
+                agent: options.targetAgent,
+            });
+            checks.push({
+                label: 'Bundle',
+                status: 'ok',
+                message: `Discovered ${bundle.skills.length} skills and ${Object.keys(bundle.mcps).length} MCPs in plugin "${options.plugin.name}".`,
+            });
+            if (bundle.skills.length === 0 && Object.keys(bundle.mcps).length === 0) {
+                checks.push({
+                    label: 'Bundle',
+                    status: 'error',
+                    message: `Plugin "${options.plugin.name}" does not expose portable skills or MCPs for installation.`,
+                });
+            }
+            for (const skillName of bundle.skills) {
+                if (targetState.skills.some((skill) => skill.name === skillName)) {
+                    checks.push({
+                        label: 'Target skill',
+                        status: 'error',
+                        message: `Skill "${skillName}" already exists in ${options.targetAgent}.`,
+                    });
+                }
+            }
+            for (const key of Object.keys(bundle.mcps)) {
+                if (targetState.mcpServers[key]) {
+                    checks.push({
+                        label: 'Target MCP',
+                        status: 'error',
+                        message: `MCP "${key}" already exists in ${options.targetAgent}.`,
+                    });
+                }
+            }
+            return {
+                ok: checks.every((check) => check.status !== 'error'),
+                checks,
+                skills: bundle.skills,
+                mcps: bundle.mcps,
+            };
+        },
+        async execute(options) {
+            const plan = await this.plan(options);
+            if (!plan.ok) {
+                const firstError = plan.checks.find((check) => check.status === 'error');
+                throw new ValidationError(firstError?.message ?? 'Plugin install plan failed.');
+            }
+            const installPath = options.plugin.installPath;
+            for (const skillName of plan.skills) {
+                await copySkillDirectory({
+                    sourceInstallPath: installPath,
+                    skillName,
+                    targetAgent: options.targetAgent,
+                });
+            }
+            for (const [key, entry] of Object.entries(plan.mcps)) {
+                await addMcpEntry({
+                    cwd: options.cwd,
+                    agent: options.targetAgent,
+                    key,
+                    entry,
+                });
+            }
+            await recordManagedPluginInstall({
+                agent: options.targetAgent,
+                plugin: {
+                    ...options.plugin,
+                    kind: 'plugin',
+                    pluginSkills: plan.skills,
+                    pluginMcps: Object.keys(plan.mcps),
+                    managed: true,
+                },
+            });
+            return {
+                installedSkills: plan.skills,
+                installedMcps: Object.keys(plan.mcps),
+            };
+        },
+        async planRemoval(options) {
+            const checks = [];
+            if (options.plugin.kind !== 'plugin') {
+                checks.push({
+                    label: 'Target plugin',
+                    status: 'error',
+                    message: `"${options.plugin.name}" is not a plugin entry.`,
+                });
+                return { ok: false, checks, skills: [], mcps: [] };
+            }
+            if (!options.plugin.managed) {
+                checks.push({
+                    label: 'Target plugin',
+                    status: 'error',
+                    message: `Only Brainctl-managed plugin installs can be removed today. "${options.plugin.name}" is not managed by Brainctl on ${options.targetAgent}.`,
+                });
+                return { ok: false, checks, skills: [], mcps: [] };
+            }
+            let skills = [...(options.plugin.pluginSkills ?? [])];
+            let mcps = [...(options.plugin.pluginMcps ?? [])];
+            if ((skills.length === 0 || mcps.length === 0) && options.plugin.installPath) {
+                const bundle = await readInstalledPluginBundle(options.plugin.installPath);
+                if (skills.length === 0) {
+                    skills = bundle.skills;
+                }
+                if (mcps.length === 0) {
+                    mcps = Object.keys(bundle.mcps);
+                }
+            }
+            checks.push({
+                label: 'Bundle',
+                status: 'ok',
+                message: `Will remove ${skills.length} skills and ${mcps.length} MCPs from plugin "${options.plugin.name}".`,
+            });
+            return {
+                ok: true,
+                checks,
+                skills,
+                mcps,
+            };
+        },
+        async remove(options) {
+            const plan = await this.planRemoval(options);
+            if (!plan.ok) {
+                const firstError = plan.checks.find((check) => check.status === 'error');
+                throw new ValidationError(firstError?.message ?? 'Plugin removal plan failed.');
+            }
+            for (const skillName of plan.skills) {
+                await removeSkillDirectory({
+                    targetAgent: options.targetAgent,
+                    skillName,
+                });
+            }
+            for (const key of plan.mcps) {
+                await removeMcpEntry({
+                    cwd: options.cwd,
+                    agent: options.targetAgent,
+                    key,
+                });
+            }
+            await removeRecordedManagedPluginInstall({
+                agent: options.targetAgent,
+                pluginName: options.plugin.name,
+            });
+            return {
+                removedSkills: plan.skills,
+                removedMcps: plan.mcps,
+            };
+        },
+    };
+}
+async function defaultReadInstalledPluginBundle(installPath) {
+    const skillsDir = path.join(installPath, 'skills');
+    let skills = [];
+    try {
+        const { readdir } = await import('node:fs/promises');
+        const entries = await readdir(skillsDir, { withFileTypes: true });
+        skills = entries
+            .filter((entry) => !entry.name.startsWith('.') && entry.isDirectory())
+            .map((entry) => entry.name)
+            .sort((left, right) => left.localeCompare(right));
+    }
+    catch {
+        skills = [];
+    }
+    let mcps = {};
+    try {
+        const mcpSource = await readFile(path.join(installPath, '.mcp.json'), 'utf8');
+        const parsed = JSON.parse(mcpSource);
+        mcps = Object.fromEntries(Object.entries(parsed)
+            .filter(([, value]) => typeof value?.command === 'string')
+            .map(([key, value]) => [
+            key,
+            {
+                command: String(value.command),
+                args: Array.isArray(value.args) ? value.args.map(String) : undefined,
+                env: value.env && typeof value.env === 'object' && !Array.isArray(value.env)
+                    ? Object.fromEntries(Object.entries(value.env).map(([envKey, envValue]) => [
+                        envKey,
+                        String(envValue),
+                    ]))
+                    : undefined,
+            },
+        ]));
+    }
+    catch {
+        mcps = {};
+    }
+    return { skills, mcps };
+}
+async function defaultCopySkillDirectory(options) {
+    const sourceDir = path.join(options.sourceInstallPath, 'skills', options.skillName);
+    const targetDir = getSkillDir(options.targetAgent, options.skillName);
+    await mkdir(path.dirname(targetDir), { recursive: true });
+    await cp(sourceDir, targetDir, { recursive: true });
+}
+async function defaultRemoveSkillDirectory(options) {
+    const targetDir = getSkillDir(options.targetAgent, options.skillName);
+    await rm(targetDir, { recursive: true, force: true });
+}