brainctl 0.1.18 → 0.1.20

package/dist/services/{portable-profile-pack-service.d.ts → profile/portable-profile-pack-service.d.ts}

@@ -1,5 +1,5 @@
-import type { AgentName } from '../types.js';
-import { type AgentConfigService } from './agent-config-service.js';
+import type { AgentName } from '../../types.js';
+import { type AgentConfigService } from '../agent/agent-config-service.js';
 import { type ProfileService } from './profile-service.js';
 export type PortablePackSource = {
     source: 'profile';

package/dist/services/{portable-profile-pack-service.js → profile/portable-profile-pack-service.js}

@@ -4,13 +4,13 @@ import { cp, mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { homedir, tmpdir } from 'node:os';
 import path from 'node:path';
 import YAML from 'yaml';
-import { ProfileError } from '../errors.js';
-import { createAgentConfigService } from './agent-config-service.js';
-import { redactPortableMcpCredentials } from './credential-redaction-service.js';
+import { ProfileError } from '../../errors.js';
+import { createAgentConfigService } from '../agent/agent-config-service.js';
+import { redactPortableMcpCredentials } from '../credential/credential-redaction-service.js';
 import { createProfileService } from './profile-service.js';
 import { classifyPortableMcp } from './portable-mcp-classifier.js';
-import { findProjectRoot, getDefaultExclude, getDefaultInstall } from './runtime-detector.js';
-const packageVersion = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8'));
+import { findProjectRoot, getDefaultExclude, getDefaultInstall } from '../platform/runtime-detector.js';
+const packageVersion = JSON.parse(readFileSync(new URL('../../../package.json', import.meta.url), 'utf8'));
 export function createPortableProfilePackService(deps = {}) {
     const profileService = deps.profileService ?? createProfileService();
     const agentConfigService = deps.agentConfigService ?? createAgentConfigService();
@@ -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-apply-service.d.ts → profile/profile-apply-service.d.ts}

@@ -1,7 +1,7 @@
-import type { AgentName, SyncResult } from '../types.js';
+import type { AgentName, SyncResult } from '../../types.js';
 import { type ProfileSnapshotService } from './profile-snapshot-service.js';
 import { type ProfileService } from './profile-service.js';
-import type { AgentConfigWriter } from './sync/agent-writer.js';
+import type { AgentConfigWriter } from '../sync/agent-writer.js';
 export type ItemType = 'mcp' | 'plugin' | 'skill';
 export interface ItemSelector {
     type: ItemType;

package/dist/services/{profile-apply-service.js → profile/profile-apply-service.js}

@@ -1,13 +1,13 @@
 import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import YAML from 'yaml';
-import { ProfileError } from '../errors.js';
-import { installPlugin, installUserSkill } from './agent-asset-installer.js';
+import { ProfileError } from '../../errors.js';
+import { installPlugin, installUserSkill } from '../agent/agent-asset-installer.js';
 import { createProfileSnapshotService, defaultBackupProfileName, } from './profile-snapshot-service.js';
 import { createProfileService, profileDir } from './profile-service.js';
-import { createClaudeWriter } from './sync/claude-writer.js';
-import { createCodexWriter } from './sync/codex-writer.js';
-import { createGeminiWriter } from './sync/gemini-writer.js';
+import { createClaudeWriter } from '../sync/claude-writer.js';
+import { createCodexWriter } from '../sync/codex-writer.js';
+import { createGeminiWriter } from '../sync/gemini-writer.js';
 export function createProfileApplyService(deps = {}) {
     const profileService = deps.profileService ?? createProfileService();
     const snapshotService = deps.snapshotService ?? createProfileSnapshotService();
@@ -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-export-service.d.ts → profile/profile-export-service.d.ts}

@@ -1,5 +1,5 @@
-import type { AgentName } from '../types.js';
-import type { AgentConfigService } from './agent-config-service.js';
+import type { AgentName } from '../../types.js';
+import type { AgentConfigService } from '../agent/agent-config-service.js';
 import { type PortableCredentialsMode, type PortablePackFormat, type PortableProfilePackService } from './portable-profile-pack-service.js';
 import type { ProfileService } from './profile-service.js';
 export interface ProfileExportService {

package/dist/services/{profile-import-service.d.ts → profile/profile-import-service.d.ts}

@@ -1,4 +1,4 @@
-import { type McpPreflightService } from './mcp-preflight-service.js';
+import { type McpPreflightService } from '../platform/mcp-preflight-service.js';
 export interface ProfileImportService {
     execute(options: {
         cwd?: string;

package/dist/services/{profile-import-service.js → profile/profile-import-service.js}

@@ -3,10 +3,10 @@ import { copyFile, cp, mkdir, mkdtemp, readFile, rm, stat, writeFile } from 'nod
 import { tmpdir } from 'node:os';
 import path from 'node:path';
 import YAML from 'yaml';
-import { ProfileError } from '../errors.js';
-import { installPlugin, installUserSkill } from './agent-asset-installer.js';
-import { resolvePortableMcpCredentials } from './credential-resolution-service.js';
-import { createMcpPreflightService } from './mcp-preflight-service.js';
+import { ProfileError } from '../../errors.js';
+import { installPlugin, installUserSkill } from '../agent/agent-asset-installer.js';
+import { resolvePortableMcpCredentials } from '../credential/credential-resolution-service.js';
+import { createMcpPreflightService } from '../platform/mcp-preflight-service.js';
 import { parseProfile } from './profile-service.js';
 const PROFILES_DIR = '.brainctl/profiles';
 async function pathExists(p) {
@@ -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-service.d.ts → profile/profile-service.d.ts}

@@ -1,4 +1,4 @@
-import type { ProfileConfig } from '../types.js';
+import type { ProfileConfig } from '../../types.js';
 export declare function profileDir(cwd: string, name: string): string;
 export declare function profileFile(cwd: string, name: string): string;
 export interface ProfileService {
@@ -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-service.js → profile/profile-service.js}

@@ -1,7 +1,7 @@
 import { readdir, readFile, writeFile, mkdir, rename, rm, stat } from 'node:fs/promises';
 import path from 'node:path';
 import YAML from 'yaml';
-import { ProfileError, ProfileNotFoundError } from '../errors.js';
+import { ProfileError, ProfileNotFoundError } from '../../errors.js';
 const VALID_RUNTIMES = new Set(['node', 'python', 'java', 'go', 'rust', 'binary']);
 const PROFILES_DIR = '.brainctl/profiles';
 const PROFILE_FILE = 'profile.yaml';
@@ -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/services/{profile-snapshot-service.d.ts → profile/profile-snapshot-service.d.ts}

@@ -1,4 +1,4 @@
-import type { AgentName } from '../types.js';
+import type { AgentName } from '../../types.js';
 export interface ProfileSnapshotService {
     execute(options: {
         cwd: string;

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.d.ts

@@ -1,5 +1,5 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
-import type { StatusService } from '../services/status-service.js';
+import type { StatusService } from '../services/platform/status-service.js';
 export interface UiRouteDependencies {
     cwd: string;
     statusService?: StatusService;

package/dist/ui/routes.js

@@ -1,18 +1,19 @@
 import { existsSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { BrainctlError, ProfileError, ProfileNotFoundError, ValidationError } from '../errors.js';
-import { createAgentConfigService } from '../services/agent-config-service.js';
-import { createMcpPreflightService } from '../services/mcp-preflight-service.js';
-import { createPluginInstallService } from '../services/plugin-install-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 { createSkillPreflightService } from '../services/skill-preflight-service.js';
-import { createStatusService } from '../services/status-service.js';
-import { createProfileApplyService, } from '../services/profile-apply-service.js';
-import { createProfileSnapshotService, defaultBackupProfileName, } from '../services/profile-snapshot-service.js';
+import { createAgentConfigService } from '../services/agent/agent-config-service.js';
+import { createMcpPreflightService } from '../services/platform/mcp-preflight-service.js';
+import { createPluginInstallService } from '../services/plugin/plugin-install-service.js';
+import { createProfileExportService } from '../services/profile/profile-export-service.js';
+import { createProfileImportService } from '../services/profile/profile-import-service.js';
+import { createProfileService } from '../services/profile/profile-service.js';
+import { createSkillPreflightService } from '../services/plugin/skill-preflight-service.js';
+import { createStatusService } from '../services/platform/status-service.js';
+import { createProfileApplyService, } from '../services/profile/profile-apply-service.js';
+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]);

package/dist/ui/server.d.ts

@@ -1,5 +1,5 @@
 import { type Server } from 'node:http';
-import type { StatusService } from '../services/status-service.js';
+import type { StatusService } from '../services/platform/status-service.js';
 export interface StartUiServerOptions {
     cwd?: string;
     host?: string;