brainctl 0.1.4 → 0.1.5

package/dist/cli.d.ts

@@ -2,6 +2,8 @@
 import { Command } from 'commander';
 import { type DoctorService } from './services/doctor-service.js';
 import { type InitService } from './services/init-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 StatusService } from './services/status-service.js';
@@ -12,6 +14,8 @@ export interface CliServices {
     statusService: StatusService;
     doctorService: DoctorService;
     profileService: ProfileService;
+    profileExportService: ProfileExportService;
+    profileImportService: ProfileImportService;
     syncService: SyncService;
 }
 export declare function createProgram(overrides?: Partial<CliServices>): Command;

package/dist/cli.js

@@ -14,6 +14,8 @@ import { registerUiCommand } from './commands/ui.js';
 import { printError } from './output.js';
 import { createDoctorService } from './services/doctor-service.js';
 import { createInitService } from './services/init-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 { createStatusService } from './services/status-service.js';
@@ -31,7 +33,11 @@ export function createProgram(overrides = {}) {
     registerStatusCommand(program, services.statusService);
     registerRunCommand(program, services.runService);
     registerDoctorCommand(program, services.doctorService);
-    registerProfileCommand(program, services.profileService);
+    registerProfileCommand(program, {
+        profileService: services.profileService,
+        profileExportService: services.profileExportService,
+        profileImportService: services.profileImportService,
+    });
     registerSyncCommand(program, services.syncService);
     registerUiCommand(program);
     registerMcpCommand(program);
@@ -62,6 +68,8 @@ function createDefaultServices(overrides) {
         statusService: createStatusService({ resolver }),
         doctorService: createDoctorService({ resolver }),
         profileService,
+        profileExportService: createProfileExportService({ profileService }),
+        profileImportService: createProfileImportService(),
         syncService: createSyncService({ profileService }),
         ...overrides
     };

package/dist/commands/profile.d.ts

@@ -1,3 +1,10 @@
 import type { Command } from 'commander';
+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';
-export declare function registerProfileCommand(program: Command, profileService: ProfileService): void;
+export interface ProfileCommandServices {
+    profileService: ProfileService;
+    profileExportService: ProfileExportService;
+    profileImportService: ProfileImportService;
+}
+export declare function registerProfileCommand(program: Command, services: ProfileCommandServices): void;

package/dist/commands/profile.js

@@ -1,5 +1,6 @@
 import pc from 'picocolors';
-export function registerProfileCommand(program, profileService) {
+export function registerProfileCommand(program, services) {
+    const { profileService, profileExportService, profileImportService } = services;
     const profileCmd = program
         .command('profile')
         .description('Manage brainctl profiles');
@@ -40,4 +41,33 @@ export function registerProfileCommand(program, profileService) {
         const prev = result.previousProfile ? ` (was "${result.previousProfile}")` : '';
         console.log(`Switched to profile "${name}"${prev}`);
     });
+    profileCmd
+        .command('export')
+        .argument('<name>', 'Profile name to export')
+        .option('-o, --output <path>', 'Output file path')
+        .description('Export a profile as a portable tarball')
+        .action(async (name, options) => {
+        const result = await profileExportService.execute({
+            cwd: process.cwd(),
+            name,
+            outputPath: options.output,
+        });
+        console.log(`Exported profile to ${result.archivePath}`);
+    });
+    profileCmd
+        .command('import')
+        .argument('<archive>', 'Path to profile tarball')
+        .option('--force', 'Overwrite existing profile', false)
+        .description('Import a profile from a tarball')
+        .action(async (archive, options) => {
+        const result = await profileImportService.execute({
+            cwd: process.cwd(),
+            archivePath: archive,
+            force: options.force,
+        });
+        console.log(`Imported profile "${result.profileName}"`);
+        if (result.installedMcps.length > 0) {
+            console.log(`Installed bundled MCPs: ${result.installedMcps.join(', ')}`);
+        }
+    });
 }

package/dist/mcp/server.js

@@ -6,6 +6,8 @@ import { loadConfig } from '../config.js';
 import { loadMemory } from '../context/memory.js';
 import { createDoctorService } from '../services/doctor-service.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 { createProfileService } from '../services/profile-service.js';
 import { createRunService } from '../services/run-service.js';
 import { createStatusService } from '../services/status-service.js';
@@ -175,6 +177,40 @@ export function createMcpServer(options = {}) {
             return JSON.stringify(result, null, 2);
         },
     });
+    server.addTool({
+        name: 'brainctl_export_profile',
+        description: 'Export a profile as a portable tarball. Packages the profile config and bundled MCP source code for sharing.',
+        parameters: z.object({
+            name: z.string().describe('Profile name to export'),
+            output_path: z.string().optional().describe('Output file path (defaults to <name>.tar.gz in cwd)'),
+        }),
+        execute: async (args) => {
+            const exportService = createProfileExportService();
+            const result = await exportService.execute({
+                cwd,
+                name: args.name,
+                outputPath: args.output_path,
+            });
+            return JSON.stringify(result, null, 2);
+        },
+    });
+    server.addTool({
+        name: 'brainctl_import_profile',
+        description: 'Import a profile from a tarball. Extracts bundled MCP source, installs dependencies, and registers the profile.',
+        parameters: z.object({
+            archive_path: z.string().describe('Path to the profile tarball'),
+            force: z.boolean().default(false).describe('Overwrite existing profile if it exists'),
+        }),
+        execute: async (args) => {
+            const importService = createProfileImportService();
+            const result = await importService.execute({
+                cwd,
+                archivePath: args.archive_path,
+                force: args.force,
+            });
+            return JSON.stringify(result, null, 2);
+        },
+    });
     return server;
 }
 export async function startMcpServer(options = {}) {

package/dist/services/profile-export-service.d.ts

@@ -0,0 +1,15 @@
+import { type ProfileService } from './profile-service.js';
+export interface ProfileExportService {
+    execute(options: {
+        cwd?: string;
+        name: string;
+        outputPath?: string;
+    }): Promise<{
+        archivePath: string;
+    }>;
+}
+interface ProfileExportDependencies {
+    profileService?: ProfileService;
+}
+export declare function createProfileExportService(deps?: ProfileExportDependencies): ProfileExportService;
+export {};

package/dist/services/profile-export-service.js

@@ -0,0 +1,63 @@
+import { execSync } from 'node:child_process';
+import { cp, mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import YAML from 'yaml';
+import { createProfileService } from './profile-service.js';
+export function createProfileExportService(deps = {}) {
+    const profileService = deps.profileService ?? createProfileService();
+    return {
+        async execute(options) {
+            const cwd = options.cwd ?? process.cwd();
+            const profile = await profileService.get({ cwd, name: options.name });
+            const stagingDir = await mkdtemp(path.join(tmpdir(), 'brainctl-export-'));
+            try {
+                const exportProfile = await stageProfile(profile, cwd, stagingDir);
+                await writeFile(path.join(stagingDir, 'profile.yaml'), YAML.stringify(exportProfile), 'utf8');
+                const outputPath = options.outputPath ?? path.join(cwd, `${profile.name}.tar.gz`);
+                execSync(`tar -czf "${outputPath}" -C "${stagingDir}" .`, {
+                    stdio: 'pipe',
+                });
+                return { archivePath: outputPath };
+            }
+            finally {
+                await rm(stagingDir, { recursive: true, force: true });
+            }
+        },
+    };
+}
+async function stageProfile(profile, cwd, stagingDir) {
+    const mcpsDir = path.join(stagingDir, 'mcps');
+    const exportMcps = {};
+    for (const [name, mcp] of Object.entries(profile.mcps)) {
+        if (mcp.type === 'bundled') {
+            const sourcePath = path.isAbsolute(mcp.path)
+                ? mcp.path
+                : path.resolve(cwd, mcp.path);
+            const destPath = path.join(mcpsDir, name);
+            await mkdir(destPath, { recursive: true });
+            await cp(sourcePath, destPath, {
+                recursive: true,
+                filter: (src) => !src.includes('node_modules'),
+            });
+            exportMcps[name] = {
+                type: 'bundled',
+                path: `./mcps/${name}`,
+                ...(mcp.install ? { install: mcp.install } : {}),
+                command: mcp.command,
+                ...(mcp.args ? { args: mcp.args } : {}),
+                ...(mcp.env ? { env: mcp.env } : {}),
+            };
+        }
+        else {
+            exportMcps[name] = mcp;
+        }
+    }
+    return {
+        name: profile.name,
+        ...(profile.description ? { description: profile.description } : {}),
+        skills: profile.skills,
+        mcps: exportMcps,
+        memory: profile.memory,
+    };
+}

package/dist/services/profile-import-service.d.ts

@@ -0,0 +1,11 @@
+export interface ProfileImportService {
+    execute(options: {
+        cwd?: string;
+        archivePath: string;
+        force?: boolean;
+    }): Promise<{
+        profileName: string;
+        installedMcps: string[];
+    }>;
+}
+export declare function createProfileImportService(): ProfileImportService;

package/dist/services/profile-import-service.js

@@ -0,0 +1,81 @@
+import { execSync } from 'node:child_process';
+import { cp, mkdir, mkdtemp, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import YAML from 'yaml';
+import { ProfileError } from '../errors.js';
+import { parseProfile } from './profile-service.js';
+const PROFILES_DIR = '.brainctl/profiles';
+export function createProfileImportService() {
+    return {
+        async execute(options) {
+            const cwd = options.cwd ?? process.cwd();
+            const archivePath = path.resolve(cwd, options.archivePath);
+            try {
+                await stat(archivePath);
+            }
+            catch {
+                throw new ProfileError(`Archive not found: ${archivePath}`);
+            }
+            const extractDir = await mkdtemp(path.join(tmpdir(), 'brainctl-import-'));
+            try {
+                execSync(`tar -xzf "${archivePath}" -C "${extractDir}"`, {
+                    stdio: 'pipe',
+                });
+                const profileSource = await readFile(path.join(extractDir, 'profile.yaml'), 'utf8');
+                const profile = parseProfile(profileSource, 'imported');
+                const profileName = profile.name;
+                const profilePath = path.join(cwd, PROFILES_DIR, `${profileName}.yaml`);
+                if (!options.force) {
+                    try {
+                        await stat(profilePath);
+                        throw new ProfileError(`Profile "${profileName}" already exists. Use --force to overwrite.`);
+                    }
+                    catch (err) {
+                        if (err instanceof ProfileError)
+                            throw err;
+                    }
+                }
+                const installedMcps = [];
+                const mcpsBaseDir = path.join(cwd, PROFILES_DIR, profileName, 'mcps');
+                for (const [name, mcp] of Object.entries(profile.mcps)) {
+                    if (mcp.type !== 'bundled')
+                        continue;
+                    const extractedMcpPath = path.join(extractDir, 'mcps', name);
+                    const destMcpPath = path.join(mcpsBaseDir, name);
+                    try {
+                        await stat(extractedMcpPath);
+                    }
+                    catch {
+                        throw new ProfileError(`Bundled MCP "${name}" source not found in archive.`);
+                    }
+                    await mkdir(destMcpPath, { recursive: true });
+                    await cp(extractedMcpPath, destMcpPath, { recursive: true });
+                    const installCmd = mcp.install ?? 'npm install';
+                    execSync(installCmd, {
+                        cwd: destMcpPath,
+                        stdio: 'pipe',
+                    });
+                    profile.mcps[name] = {
+                        ...mcp,
+                        path: destMcpPath,
+                    };
+                    installedMcps.push(name);
+                }
+                const outputYaml = {
+                    name: profile.name,
+                    ...(profile.description ? { description: profile.description } : {}),
+                    skills: profile.skills,
+                    mcps: profile.mcps,
+                    memory: profile.memory,
+                };
+                await mkdir(path.dirname(profilePath), { recursive: true });
+                await writeFile(profilePath, YAML.stringify(outputYaml), 'utf8');
+                return { profileName, installedMcps };
+            }
+            finally {
+                await rm(extractDir, { recursive: true, force: true });
+            }
+        },
+    };
+}

package/dist/services/profile-service.d.ts

@@ -28,3 +28,4 @@ export interface ProfileService {
     }): Promise<BrainctlMetaConfig>;
 }
 export declare function createProfileService(): ProfileService;
+export declare function parseProfile(source: string, name: string): ProfileConfig;

package/dist/services/profile-service.js

@@ -99,7 +99,7 @@ async function loadMetaConfig(cwd) {
         return { active_profile: '', agents: ['claude', 'codex', 'gemini'] };
     }
 }
-function parseProfile(source, name) {
+export function parseProfile(source, name) {
     let parsed;
     try {
         parsed = YAML.parse(source) ?? {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brainctl",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "CLI environment manager for consistent AI workflows",
   "type": "module",
   "repository": {