brainctl 0.1.16 → 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.d.ts

@@ -1,6 +1,11 @@
 import { FastMCP } from 'fastmcp';
+import { type UiServer } from '../ui/server.js';
+export interface UiServerState {
+    current: UiServer | null;
+}
 export declare function createMcpServer(options?: {
     cwd?: string;
+    uiServerState?: UiServerState;
 }): FastMCP;
 export declare function startMcpServer(options?: {
     cwd?: string;