brainctl 0.1.17 → 0.1.18

package/dist/cli.d.ts

@@ -1,22 +1,20 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
 import { type DoctorService } from './services/doctor-service.js';
-import { type InitService } from './services/init-service.js';
+import { type ProfileApplyService } from './services/profile-apply-service.js';
 import { type ProfileExportService } from './services/profile-export-service.js';
 import { type ProfileImportService } from './services/profile-import-service.js';
 import { type ProfileService } from './services/profile-service.js';
-import { type RunService } from './services/run-service.js';
+import { type ProfileSnapshotService } from './services/profile-snapshot-service.js';
 import { type StatusService } from './services/status-service.js';
-import { type SyncService } from './services/sync-service.js';
 export interface CliServices {
-    initService: InitService;
-    runService: RunService;
     statusService: StatusService;
     doctorService: DoctorService;
     profileService: ProfileService;
     profileExportService: ProfileExportService;
     profileImportService: ProfileImportService;
-    syncService: SyncService;
+    profileApplyService: ProfileApplyService;
+    profileSnapshotService: ProfileSnapshotService;
 }
 export declare function createProgram(overrides?: Partial<CliServices>): Command;
 export declare function main(argv?: string[]): Promise<void>;

package/dist/cli.js

@@ -5,24 +5,20 @@ import { createInterface } from 'node:readline';
 import { fileURLToPath } from 'node:url';
 import { Command } from 'commander';
 import { registerDoctorCommand } from './commands/doctor.js';
-import { registerInitCommand } from './commands/init.js';
 import { registerMcpCommand } from './commands/mcp.js';
 import { registerProfileCommand } from './commands/profile.js';
-import { registerRunCommand } from './commands/run.js';
 import { registerStatusCommand } from './commands/status.js';
-import { registerSyncCommand } from './commands/sync.js';
 import { registerUiCommand } from './commands/ui.js';
 import { printError } from './output.js';
 import { createUpdateCheckService } from './services/update-check-service.js';
 import { createDoctorService } from './services/doctor-service.js';
-import { createInitService } from './services/init-service.js';
+import { createProfileApplyService } from './services/profile-apply-service.js';
 import { createProfileExportService } from './services/profile-export-service.js';
 import { createProfileImportService } from './services/profile-import-service.js';
 import { createProfileService } from './services/profile-service.js';
-import { createRunService } from './services/run-service.js';
+import { createProfileSnapshotService } from './services/profile-snapshot-service.js';
 import { createStatusService } from './services/status-service.js';
-import { createSyncService } from './services/sync-service.js';
-import { createExecutorResolver } from './executor/resolver.js';
+import { createAgentAvailabilityService } from './services/agent-availability-service.js';
 const packageVersion = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
 export function createProgram(overrides = {}) {
     const services = createDefaultServices(overrides);
@@ -31,16 +27,15 @@ export function createProgram(overrides = {}) {
         .name('brainctl')
         .description('Manage repeatable AI environments for local agent workflows')
         .version(packageVersion.version);
-    registerInitCommand(program, services.initService);
     registerStatusCommand(program, services.statusService);
-    registerRunCommand(program, services.runService);
     registerDoctorCommand(program, services.doctorService);
     registerProfileCommand(program, {
         profileService: services.profileService,
         profileExportService: services.profileExportService,
         profileImportService: services.profileImportService,
+        profileApplyService: services.profileApplyService,
+        profileSnapshotService: services.profileSnapshotService,
     });
-    registerSyncCommand(program, services.syncService);
     registerUiCommand(program);
     registerMcpCommand(program);
     return program;
@@ -100,17 +95,17 @@ export function shouldRunMain(entryPointPath, moduleUrl) {
     return resolveRealPath(entryPointPath) === resolveRealPath(fileURLToPath(moduleUrl));
 }
 function createDefaultServices(overrides) {
-    const resolver = createExecutorResolver();
+    const availabilityService = createAgentAvailabilityService();
     const profileService = createProfileService();
+    const profileSnapshotService = createProfileSnapshotService();
     return {
-        initService: createInitService(),
-        runService: createRunService({ resolver }),
-        statusService: createStatusService({ resolver }),
-        doctorService: createDoctorService({ resolver }),
+        statusService: createStatusService({ availabilityService }),
+        doctorService: createDoctorService({ availabilityService }),
         profileService,
         profileExportService: createProfileExportService({ profileService }),
         profileImportService: createProfileImportService(),
-        syncService: createSyncService({ profileService }),
+        profileApplyService: createProfileApplyService({ profileService, snapshotService: profileSnapshotService }),
+        profileSnapshotService,
         ...overrides
     };
 }

package/dist/commands/profile.d.ts

@@ -1,10 +1,14 @@
 import type { Command } from 'commander';
+import type { ProfileApplyService } from '../services/profile-apply-service.js';
 import type { ProfileExportService } from '../services/profile-export-service.js';
 import type { ProfileImportService } from '../services/profile-import-service.js';
 import type { ProfileService } from '../services/profile-service.js';
+import type { ProfileSnapshotService } from '../services/profile-snapshot-service.js';
 export interface ProfileCommandServices {
     profileService: ProfileService;
     profileExportService: ProfileExportService;
     profileImportService: ProfileImportService;
+    profileApplyService: ProfileApplyService;
+    profileSnapshotService: ProfileSnapshotService;
 }
 export declare function registerProfileCommand(program: Command, services: ProfileCommandServices): void;

package/dist/commands/profile.js

@@ -1,6 +1,7 @@
 import pc from 'picocolors';
+const ALL_AGENTS = ['claude', 'codex', 'gemini'];
 export function registerProfileCommand(program, services) {
-    const { profileService, profileExportService, profileImportService } = services;
+    const { profileService, profileExportService, profileImportService, profileApplyService, profileSnapshotService, } = services;
     const profileCmd = program
         .command('profile')
         .description('Manage brainctl profiles');
@@ -8,15 +9,14 @@ export function registerProfileCommand(program, services) {
         .command('list')
         .description('List available profiles')
         .action(async () => {
-        const { profiles, activeProfile } = await profileService.list({ cwd: process.cwd() });
+        const { profiles } = await profileService.list({ cwd: process.cwd() });
         if (profiles.length === 0) {
             console.log('No profiles found. Run "brainctl profile create <name>" to create one.');
             return;
         }
         console.log(pc.bold('Profiles:'));
         for (const name of profiles) {
-            const marker = name === activeProfile ? pc.green(' (active)') : '';
-            console.log(`  ${name}${marker}`);
+            console.log(`  ${name}`);
         }
     });
     profileCmd
@@ -32,21 +32,14 @@ export function registerProfileCommand(program, services) {
         });
         console.log(`Created profile at ${result.profilePath}`);
     });
-    profileCmd
-        .command('use')
-        .argument('<name>', 'Profile name to activate')
-        .description('Switch the active profile')
-        .action(async (name) => {
-        const result = await profileService.use({ cwd: process.cwd(), name });
-        const prev = result.previousProfile ? ` (was "${result.previousProfile}")` : '';
-        console.log(`Switched to profile "${name}"${prev}`);
-    });
     profileCmd
         .command('export')
         .argument('[name]', 'Profile name to export')
         .option('-a, --agent <name>', 'Pack a live agent config instead (claude, codex, gemini)')
-        .option('-o, --output <path>', 'Output file path')
-        .description('Export a profile as a portable tarball')
+        .option('-o, --output <path>', 'Output file or directory path')
+        .option('-f, --format <format>', 'Output format: tarball (default) or folder', 'tarball')
+        .option('--credentials <mode>', 'How to handle secrets: redact (default, public-safe) or keep (writes .env with real values for self-sync)', 'redact')
+        .description('Export a profile as a portable tarball or folder')
         .action(async (name, options) => {
         const agent = options.agent === 'claude' || options.agent === 'codex' || options.agent === 'gemini'
             ? options.agent
@@ -54,14 +47,28 @@ export function registerProfileCommand(program, services) {
         if (!agent && !name) {
             throw new Error('Provide a profile name or --agent <name>.');
         }
+        if (options.format && options.format !== 'tarball' && options.format !== 'folder') {
+            throw new Error(`Invalid --format "${options.format}". Use "tarball" or "folder".`);
+        }
+        if (options.credentials &&
+            options.credentials !== 'redact' &&
+            options.credentials !== 'keep') {
+            throw new Error(`Invalid --credentials "${options.credentials}". Use "redact" or "keep".`);
+        }
         const result = await profileExportService.execute({
             cwd: process.cwd(),
             source: agent
                 ? { source: 'agent', agent, cwd: process.cwd() }
                 : { source: 'profile', name: name },
             outputPath: options.output,
+            format: options.format ?? 'tarball',
+            credentialsMode: options.credentials ?? 'redact',
         });
-        console.log(`Exported profile to ${result.archivePath}`);
+        for (const warning of result.warnings) {
+            console.warn(pc.yellow(`warning: ${warning}`));
+        }
+        const label = result.format === 'folder' ? 'profile folder' : 'profile tarball';
+        console.log(`Exported ${label} to ${result.archivePath}`);
     });
     profileCmd
         .command('import')
@@ -81,6 +88,89 @@ export function registerProfileCommand(program, services) {
             console.log(`Installed bundled MCPs: ${result.installedMcps.join(', ')}`);
         }
     });
+    profileCmd
+        .command('apply')
+        .argument('<name>', 'Profile name to apply')
+        .option('-a, --agent <list>', 'Comma-separated agents to target (claude, codex, gemini, or all)', 'all')
+        .option('-i, --items <list>', 'Comma-separated items to apply (e.g. mcp:github,plugin:demo,skill:reviewer). Default: everything matching.')
+        .option('--no-backup', 'Skip auto-backup of live agent state before applying')
+        .description('Apply a profile (MCPs + plugins + skills) to selected agents')
+        .action(async (name, options) => {
+        const agents = parseAgentList(options.agent);
+        const items = options.items ? parseItemList(options.items) : undefined;
+        const { backups, applied } = await profileApplyService.execute({
+            cwd: process.cwd(),
+            profileName: name,
+            agents,
+            items,
+            backup: options.backup,
+        });
+        if (backups.length > 0) {
+            console.log(pc.bold('Backups:'));
+            for (const b of backups) {
+                console.log(`  ${b.agent} -> ${b.profileName}`);
+            }
+        }
+        console.log(pc.bold(`Applied "${name}" to:`));
+        for (const r of applied) {
+            const extras = [`${r.mcpCount} MCPs`];
+            if (r.pluginsInstalled?.length)
+                extras.push(`plugins: ${r.pluginsInstalled.join(',')}`);
+            if (r.userSkillsInstalled?.length)
+                extras.push(`skills: ${r.userSkillsInstalled.join(',')}`);
+            console.log(`  ${r.agent}: ${extras.join(' | ')}`);
+        }
+    });
+    profileCmd
+        .command('snapshot')
+        .option('-a, --agent <name>', 'Agent to snapshot (claude, codex, gemini)')
+        .option('--as <name>', 'Profile name to write into (default: backup-<agent>-<timestamp>)')
+        .description("Snapshot a live agent's MCPs+plugins+skills into a new profile folder")
+        .action(async (options) => {
+        if (!options.agent || !ALL_AGENTS.includes(options.agent)) {
+            throw new Error('Provide --agent <claude|codex|gemini>.');
+        }
+        const agent = options.agent;
+        const { defaultBackupProfileName } = await import('../services/profile-snapshot-service.js');
+        const profileName = options.as ?? defaultBackupProfileName(agent);
+        const result = await profileSnapshotService.execute({
+            cwd: process.cwd(),
+            agent,
+            profileName,
+        });
+        console.log(`Snapshotted ${agent} into ${result.profilePath}`);
+    });
+}
+function parseAgentList(value) {
+    if (value === 'all')
+        return [...ALL_AGENTS];
+    const parts = value.split(',').map((s) => s.trim()).filter(Boolean);
+    for (const p of parts) {
+        if (!ALL_AGENTS.includes(p)) {
+            throw new Error(`Invalid agent "${p}". Use claude, codex, gemini, or all.`);
+        }
+    }
+    return parts;
+}
+function parseItemList(value) {
+    return value
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean)
+        .map((entry) => {
+        const colonIdx = entry.indexOf(':');
+        if (colonIdx <= 0) {
+            throw new Error(`Invalid item "${entry}". Use type:name (e.g. mcp:github).`);
+        }
+        const type = entry.slice(0, colonIdx);
+        const name = entry.slice(colonIdx + 1);
+        if (type !== 'mcp' && type !== 'plugin' && type !== 'skill') {
+            throw new Error(`Invalid item type "${type}". Use mcp, plugin, or skill.`);
+        }
+        if (!name)
+            throw new Error(`Item "${entry}" missing name.`);
+        return { type, name };
+    });
 }
 function collectCredentialOption(value, previous) {
     return [...previous, value];

package/dist/commands/status.js

@@ -2,17 +2,17 @@ import pc from 'picocolors';
 export function registerStatusCommand(program, statusService) {
     program
         .command('status')
-        .description('Show current brainctl configuration status')
+        .description('Show agent availability and profile inventory')
         .action(async () => {
         const status = await statusService.execute({ cwd: process.cwd() });
         console.log(pc.bold('brainctl status'));
-        console.log(`Config: ${status.configPath}`);
-        console.log(`Memory files loaded: ${status.memory.count}`);
-        console.log(`Available skills: ${status.skills.length > 0 ? status.skills.join(', ') : 'none'}`);
-        console.log(`MCP count: ${status.mcpCount}`);
-        console.log('Available agents:');
+        console.log(`Profiles: ${status.profiles.count}`);
+        for (const name of status.profiles.names) {
+            console.log(`  ${name}`);
+        }
+        console.log('Agents:');
         for (const agent of Object.values(status.agents)) {
-            console.log(`- ${agent.agent}: ${agent.available ? pc.green('available') : pc.yellow('missing')}`);
+            console.log(`  ${agent.agent}: ${agent.available ? pc.green('available') : pc.yellow('missing')}`);
         }
     });
 }

package/dist/mcp/server.js

@@ -1,20 +1,17 @@
 import { spawn } from 'node:child_process';
 import { readFileSync } from 'node:fs';
-import path from 'node:path';
 import { FastMCP } from 'fastmcp';
 import { z } from 'zod';
-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';
+import { createProfileApplyService } from '../services/profile-apply-service.js';
 import { createProfileService } from '../services/profile-service.js';
-import { createRunService } from '../services/run-service.js';
+import { createProfileSnapshotService, defaultBackupProfileName, } from '../services/profile-snapshot-service.js';
 import { createStatusService } from '../services/status-service.js';
-import { createSyncService } from '../services/sync-service.js';
+const ALL_AGENTS = ['claude', 'codex', 'gemini'];
 const packageVersion = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8'));
 export function createMcpServer(options = {}) {
     const cwd = options.cwd ?? process.cwd();
@@ -23,53 +20,6 @@ export function createMcpServer(options = {}) {
         name: 'brainctl',
         version: packageVersion.version,
     });
-    server.addTool({
-        name: 'brainctl_list_skills',
-        description: 'List available skills from the ai-stack.yaml config',
-        parameters: z.object({}),
-        execute: async () => {
-            const config = await loadConfig({ cwd });
-            const skills = Object.entries(config.skills).map(([name, skill]) => ({
-                name,
-                description: skill.description ?? null,
-            }));
-            return JSON.stringify(skills, null, 2);
-        },
-    });
-    server.addTool({
-        name: 'brainctl_run',
-        description: 'Execute a skill with input text. Runs the skill through the configured agent and returns the output.',
-        parameters: z.object({
-            skill: z.string().describe('Skill name as defined in ai-stack.yaml'),
-            input: z.string().describe('Input text to pass to the skill'),
-            agent: z.enum(['claude', 'codex']).default('claude').describe('Agent to use for execution'),
-            fallback_agent: z.enum(['claude', 'codex']).optional().describe('Fallback agent if primary is unavailable'),
-        }),
-        execute: async (args) => {
-            const inputPath = path.join(cwd, `.brainctl-mcp-input-${Date.now()}.tmp`);
-            const { writeFile: writeFileAsync, unlink } = await import('node:fs/promises');
-            try {
-                await writeFileAsync(inputPath, args.input, 'utf8');
-                const runService = createRunService();
-                const trace = await runService.execute({
-                    cwd,
-                    skill: args.skill,
-                    inputFile: path.basename(inputPath),
-                    primaryAgent: args.agent,
-                    fallbackAgent: args.fallback_agent,
-                });
-                return trace.finalOutput;
-            }
-            finally {
-                try {
-                    await unlink(inputPath);
-                }
-                catch {
-                    // temp file cleanup is best-effort
-                }
-            }
-        },
-    });
     server.addTool({
         name: 'brainctl_status',
         description: 'Show project status: config path, memory files, available skills, and agent availability',
@@ -91,94 +41,67 @@ export function createMcpServer(options = {}) {
         },
     });
     server.addTool({
-        name: 'brainctl_read_memory',
-        description: 'Read all shared memory files. Returns every markdown file from configured memory paths with file names and content. Use this to understand context left by other agents.',
+        name: 'brainctl_list_profiles',
+        description: 'List available profiles and show which one is active.',
         parameters: z.object({}),
         execute: async () => {
-            const config = await loadConfig({ cwd });
-            const memory = await loadMemory({ paths: config.memory.paths });
-            const result = {
-                count: memory.count,
-                files: memory.entries.map((entry) => ({
-                    path: entry.path,
-                    content: entry.content,
-                })),
-            };
+            const profileService = createProfileService();
+            const result = await profileService.list({ cwd });
             return JSON.stringify(result, null, 2);
         },
     });
     server.addTool({
-        name: 'brainctl_write_memory',
-        description: 'Write or update a shared memory file. Use this to leave notes, decisions, or context for other agents. The file must be within a configured memory path.',
+        name: 'brainctl_apply_profile',
+        description: 'Apply a profile (MCPs, plugins, user skills) to the specified agents. Selective by --agents and --items. Auto-backs up live agent state before a full apply unless backup=false.',
         parameters: z.object({
-            file_path: z.string().describe('Relative path for the memory file (e.g., "memory/notes.md")'),
-            content: z.string().describe('Markdown content to write'),
+            name: z.string().describe('Profile name to apply'),
+            agents: z
+                .array(z.enum(['claude', 'codex', 'gemini']))
+                .optional()
+                .describe('Agents to target (default: all three)'),
+            items: z
+                .array(z.object({
+                type: z.enum(['mcp', 'plugin', 'skill']),
+                name: z.string(),
+            }))
+                .optional()
+                .describe('Specific items to apply (default: everything matching)'),
+            backup: z
+                .boolean()
+                .optional()
+                .describe('Force backup on/off (default: on for full apply, off for partial)'),
         }),
         execute: async (args) => {
-            const memoryWriteService = createMemoryWriteService();
-            const result = await memoryWriteService.execute({
+            const applyService = createProfileApplyService();
+            const result = await applyService.execute({
                 cwd,
-                filePath: args.file_path,
-                content: args.content,
+                profileName: args.name,
+                agents: args.agents ?? ALL_AGENTS,
+                items: args.items,
+                backup: args.backup,
             });
-            return JSON.stringify({ written: result.filePath });
-        },
-    });
-    server.addTool({
-        name: 'brainctl_get_skill',
-        description: 'Get the full details of a specific skill including its prompt text and description. Use this to understand what a skill does before running it.',
-        parameters: z.object({
-            skill: z.string().describe('Skill name as defined in ai-stack.yaml'),
-        }),
-        execute: async (args) => {
-            const config = await loadConfig({ cwd });
-            const skillConfig = config.skills[args.skill];
-            if (!skillConfig) {
-                throw new Error(`Skill "${args.skill}" is not defined in ai-stack.yaml.`);
-            }
-            return JSON.stringify({
-                name: args.skill,
-                description: skillConfig.description ?? null,
-                prompt: skillConfig.prompt,
-            }, null, 2);
-        },
-    });
-    server.addTool({
-        name: 'brainctl_list_profiles',
-        description: 'List available profiles and show which one is active.',
-        parameters: z.object({}),
-        execute: async () => {
-            const profileService = createProfileService();
-            const result = await profileService.list({ cwd });
             return JSON.stringify(result, null, 2);
         },
     });
     server.addTool({
-        name: 'brainctl_switch_profile',
-        description: 'Switch the active profile and sync it to all configured agents. Combines profile switch + sync in one step.',
+        name: 'brainctl_snapshot_agent',
+        description: "Snapshot a live agent's MCPs+plugins+skills into a new profile folder. Useful for backups or capturing your current setup as a shareable profile.",
         parameters: z.object({
-            name: z.string().describe('Profile name to activate'),
+            agent: z.enum(['claude', 'codex', 'gemini']),
+            as: z
+                .string()
+                .optional()
+                .describe('Profile name to write into (default: backup-<agent>-<timestamp>)'),
         }),
         execute: async (args) => {
-            const profileService = createProfileService();
-            const switchResult = await profileService.use({ cwd, name: args.name });
-            const syncService = createSyncService({ profileService });
-            const syncResult = await syncService.execute({ cwd });
-            return JSON.stringify({
-                previousProfile: switchResult.previousProfile,
-                activeProfile: args.name,
-                synced: syncResult,
-            }, null, 2);
-        },
-    });
-    server.addTool({
-        name: 'brainctl_sync',
-        description: 'Sync the active profile to all configured agent configs (Claude, Codex). Creates backups before overwriting.',
-        parameters: z.object({}),
-        execute: async () => {
-            const syncService = createSyncService();
-            const result = await syncService.execute({ cwd });
-            return JSON.stringify(result, null, 2);
+            const snapshotService = createProfileSnapshotService();
+            const profileName = args.as ?? defaultBackupProfileName(args.agent);
+            const result = await snapshotService.execute({
+                cwd,
+                agent: args.agent,
+                profileName,
+            });
+            return JSON.stringify({ profileName, ...result }, null, 2);
         },
     });
     server.addTool({
@@ -212,20 +135,13 @@ export function createMcpServer(options = {}) {
     });
     server.addTool({
         name: 'brainctl_update_profile',
-        description: 'Update a profile config. Pass the full profile object with skills, mcps, and memory fields. Use this to add, remove, or modify skills and MCPs within a profile.',
+        description: 'Update a profile config. Pass the full profile object with name, optional description, and mcps map.',
         parameters: z.object({
             name: z.string().describe('Profile name to update'),
             config: z.object({
                 name: z.string(),
                 description: z.string().optional(),
-                skills: z.record(z.string(), z.object({
-                    description: z.string().optional(),
-                    prompt: z.string(),
-                })),
                 mcps: z.record(z.string(), z.unknown()),
-                memory: z.object({
-                    paths: z.array(z.string()),
-                }),
             }).describe('Full profile config object'),
         }),
         execute: async (args) => {
@@ -252,25 +168,17 @@ export function createMcpServer(options = {}) {
     });
     server.addTool({
         name: 'brainctl_copy_profile_items',
-        description: 'Copy skills and/or MCPs from one profile to another. Specify which skill and MCP keys to copy. Existing items with the same key in the target are overwritten.',
+        description: 'Copy MCPs from one profile to another. Existing MCPs with the same key in the target are overwritten.',
         parameters: z.object({
             source: z.string().describe('Source profile name'),
             target: z.string().describe('Target profile name'),
-            skills: z.array(z.string()).default([]).describe('Skill keys to copy'),
             mcps: z.array(z.string()).default([]).describe('MCP keys to copy'),
         }),
         execute: async (args) => {
             const profileService = createProfileService();
             const sourceProfile = await profileService.get({ cwd, name: args.source });
             const targetProfile = await profileService.get({ cwd, name: args.target });
-            const copiedSkills = [];
             const copiedMcps = [];
-            for (const key of args.skills) {
-                if (sourceProfile.skills[key]) {
-                    targetProfile.skills[key] = sourceProfile.skills[key];
-                    copiedSkills.push(key);
-                }
-            }
             for (const key of args.mcps) {
                 if (sourceProfile.mcps[key]) {
                     targetProfile.mcps[key] = sourceProfile.mcps[key];
@@ -281,7 +189,6 @@ export function createMcpServer(options = {}) {
             return JSON.stringify({
                 source: args.source,
                 target: args.target,
-                copiedSkills,
                 copiedMcps,
             }, null, 2);
         },

package/dist/services/agent-asset-installer.d.ts

@@ -0,0 +1,3 @@
+import type { PortablePluginSnapshot, PortableUserSkillSnapshot } from '../types.js';
+export declare function installPlugin(sourceDir: string, plugin: PortablePluginSnapshot): Promise<void>;
+export declare function installUserSkill(sourceDir: string, skill: PortableUserSkillSnapshot): Promise<void>;