brainctl 0.1.19 → 0.1.21

package/dist/commands/mcp.js

@@ -1,4 +1,4 @@
-import { spawn } from 'node:child_process';
+import { spawnSync } from 'node:child_process';
 import { startMcpServer } from '../mcp-server.js';
 import { createUpdateCheckService } from '../services/platform/update-check-service.js';
 export function registerMcpCommand(program) {
@@ -6,39 +6,52 @@ export function registerMcpCommand(program) {
         .command('mcp')
         .description('Start the brainctl MCP server (stdio transport)')
         .action(async () => {
+        killPriorMcpServers();
+        process.stdin.on('end', () => process.exit(0));
+        process.stdin.on('close', () => process.exit(0));
+        await startMcpServer({ cwd: process.cwd() });
         if (!process.env.BRAINCTL_NO_UPDATE_CHECK) {
-            await autoUpdateIfNeeded();
+            // Fire-and-forget after the server is up so cold-start isn't blocked
+            // on a network round-trip (or `npm install brainctl@latest`).
+            void notifyIfOutdated();
         }
-        await startMcpServer({ cwd: process.cwd() });
     });
 }
-async function autoUpdateIfNeeded() {
+function killPriorMcpServers() {
+    const self = process.pid;
+    const ppid = process.ppid;
     try {
-        const service = createUpdateCheckService();
-        const check = await service.check();
-        if (!check.isOutdated)
-            return;
-        const result = await service.selfUpdate();
-        if (result.success) {
-            // Re-exec with the updated binary
-            const child = spawn(process.execPath, process.argv.slice(1), {
-                stdio: 'inherit',
-            });
-            await new Promise((resolve) => {
-                child.on('exit', (code) => {
-                    process.exit(code ?? 0);
-                });
-                child.on('error', () => {
-                    resolve(); // fall through to current version
-                });
-            });
+        const result = spawnSync('pgrep', ['-f', 'brainctl/dist/cli\\.js mcp'], {
+            encoding: 'utf8',
+        });
+        if (result.status !== 0 || !result.stdout)
             return;
+        const pids = result.stdout
+            .split('\n')
+            .map((line) => Number.parseInt(line.trim(), 10))
+            .filter((pid) => Number.isFinite(pid) && pid !== self && pid !== ppid);
+        for (const pid of pids) {
+            try {
+                process.kill(pid, 'SIGTERM');
+            }
+            catch {
+                // already gone
+            }
         }
-        if (result.error) {
-            process.stderr.write(`brainctl: auto-update failed: ${result.error}\n`);
+    }
+    catch {
+        // pgrep unavailable — skip
+    }
+}
+async function notifyIfOutdated() {
+    try {
+        const service = createUpdateCheckService();
+        const check = await service.check();
+        if (check.isOutdated) {
+            process.stderr.write(`brainctl: a newer version is available (${check.latest}). Run \`npm i -g brainctl@latest\` to update.\n`);
         }
     }
     catch {
-        // Update check failed entirely — continue silently
+        // Update check failed — stay silent
     }
 }

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

@@ -1,3 +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>;
+import type { AgentName, PortablePluginSnapshot, PortableUserSkillSnapshot } from '../../types.js';
+export declare function installPlugin(sourceDir: string, plugin: PortablePluginSnapshot, targetAgent?: AgentName): Promise<void>;
+export declare function installUserSkill(sourceDir: string, skill: PortableUserSkillSnapshot, targetAgent?: PortableUserSkillSnapshot['agent']): Promise<void>;

package/dist/services/agent/agent-asset-installer.js

@@ -2,14 +2,22 @@ import { copyFile, cp, mkdir, readFile, rename, rm, stat, writeFile } from 'node
 import { homedir } from 'node:os';
 import path from 'node:path';
 import { ProfileError } from '../../errors.js';
+import { defaultReadInstalledPluginBundle, isAgentInstallableOnTarget, isCommandInstallableOnTarget, } from '../plugin/plugin-install-bundle.js';
+import { defaultCopySkillDirectory, defaultInstallAgent, defaultInstallCommand, } from '../plugin/plugin-install-fs.js';
+import { writeManagedPluginInstall } from '../sync/managed-plugin-registry.js';
 import { formatTimestamp } from '../sync/agent-writer.js';
-export async function installPlugin(sourceDir, plugin) {
+export async function installPlugin(sourceDir, plugin, targetAgent) {
     try {
         await stat(sourceDir);
     }
     catch {
         throw new ProfileError(`Bundled plugin "${plugin.name}" source missing at ${sourceDir}.`);
     }
+    const target = targetAgent ?? plugin.agent;
+    if (target !== plugin.agent) {
+        await installPluginCrossAgent(sourceDir, plugin, target);
+        return;
+    }
     if (plugin.agent === 'gemini') {
         return;
     }
@@ -34,14 +42,52 @@ export async function installPlugin(sourceDir, plugin) {
         });
     }
 }
-export async function installUserSkill(sourceDir, skill) {
+async function installPluginCrossAgent(sourceDir, plugin, targetAgent) {
+    const bundle = await defaultReadInstalledPluginBundle(sourceDir);
+    for (const skillName of bundle.skills) {
+        await defaultCopySkillDirectory({
+            sourceInstallPath: sourceDir,
+            skillName,
+            targetAgent,
+        });
+    }
+    const installedAgents = [];
+    if (isAgentInstallableOnTarget(targetAgent)) {
+        for (const agent of bundle.agents) {
+            await defaultInstallAgent({ targetAgent, agent });
+            installedAgents.push(agent.name);
+        }
+    }
+    const installedCommands = [];
+    if (isCommandInstallableOnTarget(targetAgent)) {
+        for (const command of bundle.commands) {
+            await defaultInstallCommand({ targetAgent, command });
+            installedCommands.push(command.name);
+        }
+    }
+    await writeManagedPluginInstall({
+        agent: targetAgent,
+        plugin: {
+            name: plugin.name,
+            kind: 'plugin',
+            managed: true,
+            source: plugin.source,
+            pluginSkills: bundle.skills,
+            pluginMcps: Object.keys(bundle.mcps),
+            pluginAgents: installedAgents,
+            pluginCommands: installedCommands,
+        },
+    });
+}
+export async function installUserSkill(sourceDir, skill, targetAgent) {
     try {
         await stat(sourceDir);
     }
     catch {
         throw new ProfileError(`Bundled user skill "${skill.name}" source missing at ${sourceDir}.`);
     }
-    const targetDir = path.join(homedir(), `.${skill.agent}`, 'skills', skill.name);
+    const agent = targetAgent ?? skill.agent;
+    const targetDir = path.join(homedir(), `.${agent}`, 'skills', skill.name);
     await rm(targetDir, { recursive: true, force: true });
     await mkdir(path.dirname(targetDir), { recursive: true });
     await cp(sourceDir, targetDir, { recursive: true });

package/dist/services/profile/portable-profile-pack-service.js

@@ -205,8 +205,8 @@ function collectAgentExtras(agentConfig) {
             const source = skill.source;
             if (!installPath || !source)
                 continue;
-            const safeName = sanitizePackName(`${skill.name}--${source}`);
-            const archivePath = `plugins/${agentConfig.agent}/${safeName}`;
+            const safeName = sanitizePackName(skill.name);
+            const archivePath = `plugins/${safeName}`;
             bundledPlugins.set(archivePath, installPath);
             plugins.push({
                 agent: agentConfig.agent,
@@ -225,7 +225,7 @@ function collectAgentExtras(agentConfig) {
         }
         if (skill.kind === 'skill' && skill.source === 'local') {
             const localSkillDir = path.join(homedir(), `.${agentConfig.agent}`, 'skills', skill.name);
-            const archivePath = `skills/${agentConfig.agent}/${skill.name}`;
+            const archivePath = `skills/${sanitizePackName(skill.name)}`;
             bundledUserSkills.set(archivePath, localSkillDir);
             userSkills.push({
                 agent: agentConfig.agent,
@@ -285,7 +285,7 @@ async function redactAndNormalizeProfile(profile, cwd, source, extras) {
     const hasExtras = extras !== undefined && (extras.plugins.length > 0 || extras.userSkills.length > 0);
     return {
         manifest: {
-            schemaVersion: hasExtras ? 2 : 1,
+            schemaVersion: hasExtras ? 3 : 1,
             profileName: profile.name,
             createdBy: {
                 tool: 'brainctl',

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

@@ -59,15 +59,32 @@ export function createProfileApplyService(deps = {}) {
                     mcpResult = { configPath: '', backedUpTo: null };
                 }
                 const pluginsInstalled = [];
-                for (const plugin of (manifest?.plugins ?? []).filter((p) => p.agent === agent && wantPlugin(p.name))) {
+                const pluginsByName = new Map();
+                for (const p of manifest?.plugins ?? []) {
+                    if (!wantPlugin(p.name))
+                        continue;
+                    const existing = pluginsByName.get(p.name);
+                    if (!existing || p.agent === agent)
+                        pluginsByName.set(p.name, p);
+                }
+                for (const plugin of pluginsByName.values()) {
                     const sourceDir = path.join(folder, plugin.archivePath);
-                    await installPlugin(sourceDir, plugin);
+                    await installPlugin(sourceDir, plugin, agent);
                     pluginsInstalled.push(plugin.name);
                 }
                 const userSkillsInstalled = [];
-                for (const skill of (manifest?.userSkills ?? []).filter((s) => s.agent === agent && wantSkill(s.name))) {
+                const skillsByName = new Map();
+                for (const s of manifest?.userSkills ?? []) {
+                    if (!wantSkill(s.name))
+                        continue;
+                    if (!skillsByName.has(s.name))
+                        skillsByName.set(s.name, s);
+                    else if (s.agent === agent)
+                        skillsByName.set(s.name, s); // prefer matching source if available
+                }
+                for (const skill of skillsByName.values()) {
                     const sourceDir = path.join(folder, skill.archivePath);
-                    await installUserSkill(sourceDir, skill);
+                    await installUserSkill(sourceDir, skill, agent);
                     userSkillsInstalled.push(skill.name);
                 }
                 applied.push({

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

@@ -268,7 +268,7 @@ async function readPortableManifest(extractDir) {
         throw new ProfileError('Portable profile manifest has invalid structure.');
     }
     const manifest = parsed;
-    if (manifest.schemaVersion !== 1 && manifest.schemaVersion !== 2) {
+    if (manifest.schemaVersion !== 1 && manifest.schemaVersion !== 2 && manifest.schemaVersion !== 3) {
         throw new ProfileError(`Unsupported portable profile schema version: ${String(manifest.schemaVersion)}.`);
     }
     if (typeof manifest.profileName !== 'string' || manifest.profileName.trim().length === 0) {

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

@@ -23,6 +23,11 @@ export interface ProfileService {
         name: string;
         config: ProfileConfig;
     }): Promise<void>;
+    rename(options: {
+        cwd?: string;
+        oldName: string;
+        newName: string;
+    }): Promise<void>;
     delete(options: {
         cwd?: string;
         name: string;

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

@@ -25,6 +25,7 @@ async function migrateLegacyProfile(cwd, name) {
     await mkdir(folder, { recursive: true });
     await rename(legacy, newFile);
 }
+const PROFILE_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
 export function createProfileService() {
     return {
         async list(options = {}) {
@@ -68,14 +69,18 @@ export function createProfileService() {
         },
         async create(options) {
             const cwd = options.cwd ?? process.cwd();
-            const folder = profileDir(cwd, options.name);
-            const filePath = profileFile(cwd, options.name);
+            const trimmed = options.name.trim();
+            if (!PROFILE_NAME_PATTERN.test(trimmed)) {
+                throw new ProfileError(`Invalid profile name "${trimmed}". Use letters, numbers, ".", "_", or "-".`);
+            }
+            const folder = profileDir(cwd, trimmed);
+            const filePath = profileFile(cwd, trimmed);
             if ((await pathExists(filePath)) ||
-                (await pathExists(legacyProfileFile(cwd, options.name)))) {
-                throw new ProfileError(`Profile "${options.name}" already exists.`);
+                (await pathExists(legacyProfileFile(cwd, trimmed)))) {
+                throw new ProfileError(`Profile "${trimmed}" already exists.`);
             }
             const scaffold = {
-                name: options.name,
+                name: trimmed,
                 description: options.description ?? '',
                 mcps: {},
             };
@@ -98,6 +103,44 @@ export function createProfileService() {
             };
             await writeFile(filePath, YAML.stringify(data), 'utf8');
         },
+        async rename(options) {
+            const cwd = options.cwd ?? process.cwd();
+            const trimmedNew = options.newName.trim();
+            if (!PROFILE_NAME_PATTERN.test(trimmedNew)) {
+                throw new ProfileError(`Invalid profile name "${trimmedNew}". Use letters, numbers, ".", "_", or "-".`);
+            }
+            if (trimmedNew === options.oldName)
+                return;
+            await migrateLegacyProfile(cwd, options.oldName);
+            const oldFolder = profileDir(cwd, options.oldName);
+            const oldFile = profileFile(cwd, options.oldName);
+            const newFolder = profileDir(cwd, trimmedNew);
+            const newFile = profileFile(cwd, trimmedNew);
+            if (!(await pathExists(oldFile))) {
+                throw new ProfileNotFoundError(`Profile "${options.oldName}" not found.`);
+            }
+            if ((await pathExists(newFolder)) ||
+                (await pathExists(legacyProfileFile(cwd, trimmedNew)))) {
+                throw new ProfileError(`Profile "${trimmedNew}" already exists.`);
+            }
+            await rename(oldFolder, newFolder);
+            const profileSource = await readFile(newFile, 'utf8');
+            const parsed = YAML.parse(profileSource) ?? {};
+            parsed.name = trimmedNew;
+            await writeFile(newFile, YAML.stringify(parsed), 'utf8');
+            const manifestPath = path.join(newFolder, 'manifest.yaml');
+            if (await pathExists(manifestPath)) {
+                try {
+                    const manifestSource = await readFile(manifestPath, 'utf8');
+                    const manifest = YAML.parse(manifestSource) ?? {};
+                    manifest.profileName = trimmedNew;
+                    await writeFile(manifestPath, YAML.stringify(manifest), 'utf8');
+                }
+                catch {
+                    // Manifest is best-effort; pack-time will rewrite it on next export.
+                }
+            }
+        },
         async delete(options) {
             const cwd = options.cwd ?? process.cwd();
             await migrateLegacyProfile(cwd, options.name);

package/dist/types.d.ts

@@ -39,7 +39,7 @@ export interface PortableUserSkillSnapshot {
     archivePath: string;
 }
 export interface PortableProfileManifest {
-    schemaVersion: 1 | 2;
+    schemaVersion: 1 | 2 | 3;
     profileName: string;
     createdBy?: {
         tool: string;

package/dist/ui/routes.js

@@ -13,6 +13,7 @@ import { createProfileApplyService, } from '../services/profile/profile-apply-se
 import { createProfileSnapshotService, defaultBackupProfileName, } from '../services/profile/profile-snapshot-service.js';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { spawn } from 'node:child_process';
 const uiAssetRoot = resolveUiAssetRoot();
 export function createUiRouteHandler(dependencies) {
     const statusService = dependencies.statusService ?? createStatusService();
@@ -162,6 +163,32 @@ export function createUiRouteHandler(dependencies) {
                 }
             }
             default: {
+                // Open profile folder in OS file explorer: POST /api/profiles/:name/open-folder
+                const openFolderMatch = url.pathname.match(/^\/api\/profiles\/([^/]+)\/open-folder$/);
+                if (openFolderMatch) {
+                    if (request.method !== 'POST') {
+                        return sendJson(response, 405, { error: 'Method not allowed' });
+                    }
+                    const profileName = decodeURIComponent(openFolderMatch[1]);
+                    const folderPath = path.join(dependencies.cwd, '.brainctl', 'profiles', profileName);
+                    if (!existsSync(folderPath)) {
+                        return sendJson(response, 404, { error: `Profile folder not found: ${folderPath}` });
+                    }
+                    const opener = process.platform === 'darwin'
+                        ? 'open'
+                        : process.platform === 'win32'
+                            ? 'explorer'
+                            : 'xdg-open';
+                    try {
+                        spawn(opener, [folderPath], { detached: true, stdio: 'ignore' }).unref();
+                        return sendJson(response, 200, { ok: true, path: folderPath });
+                    }
+                    catch (error) {
+                        return sendJson(response, 500, {
+                            error: error instanceof Error ? error.message : 'Failed to open folder',
+                        });
+                    }
+                }
                 // Profile apply: POST /api/profiles/:name/apply
                 const applyMatch = url.pathname.match(/^\/api\/profiles\/([^/]+)\/apply$/);
                 if (applyMatch) {
@@ -441,6 +468,32 @@ export function createUiRouteHandler(dependencies) {
                         return sendProfileError(response, error);
                     }
                 }
+                const profileRenameMatch = url.pathname.match(/^\/api\/profiles\/([^/]+)\/rename$/);
+                if (profileRenameMatch) {
+                    const oldName = decodeURIComponent(profileRenameMatch[1]);
+                    if (request.method !== 'POST') {
+                        return sendJson(response, 405, { error: 'Method not allowed' });
+                    }
+                    const body = await readJsonBody(request);
+                    if (!body.ok) {
+                        return sendJson(response, 400, { error: 'Invalid JSON body' });
+                    }
+                    const data = body.value;
+                    if (typeof data.newName !== 'string' || data.newName.trim().length === 0) {
+                        return sendJson(response, 400, { error: 'Missing newName' });
+                    }
+                    try {
+                        await profileService.rename({
+                            cwd: dependencies.cwd,
+                            oldName,
+                            newName: data.newName.trim(),
+                        });
+                        return sendJson(response, 200, { ok: true, name: data.newName.trim() });
+                    }
+                    catch (error) {
+                        return sendProfileError(response, error);
+                    }
+                }
                 const profileMatch = url.pathname.match(/^\/api\/profiles\/([^/]+)$/);
                 if (profileMatch) {
                     const name = decodeURIComponent(profileMatch[1]);