brainctl 0.1.17 → 0.1.19

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();
@@ -52,11 +52,26 @@ export function createPortableProfilePackService(deps = {}) {
                         filter: (src) => !matchesPluginExclude(src),
                     });
                 }
+                const format = options.format ?? 'tarball';
+                const credentialsMode = options.credentialsMode ?? 'redact';
+                const warnings = [];
+                if (credentialsMode === 'keep' && Object.keys(packed.rawCredentials).length > 0) {
+                    await writeFile(path.join(stagingDir, '.env'), renderDotEnv(packed.rawCredentials), 'utf8');
+                    warnings.push(`Wrote .env with ${Object.keys(packed.rawCredentials).length} real credential value(s). Do NOT publish this archive publicly.`);
+                }
+                if (format === 'folder') {
+                    await writeRepoReadyFiles(stagingDir, packed);
+                    const outputPath = options.outputPath ?? path.join(cwd, packed.profile.name);
+                    await rm(outputPath, { recursive: true, force: true });
+                    await mkdir(path.dirname(outputPath), { recursive: true });
+                    await cp(stagingDir, outputPath, { recursive: true });
+                    return { archivePath: outputPath, format, warnings };
+                }
                 const outputPath = options.outputPath ?? path.join(cwd, `${packed.profile.name}.tar.gz`);
                 execSync(`tar -czf "${outputPath}" -C "${stagingDir}" .`, {
                     stdio: 'pipe',
                 });
-                return { archivePath: outputPath };
+                return { archivePath: outputPath, format, warnings };
             }
             finally {
                 await rm(stagingDir, { recursive: true, force: true });
@@ -64,6 +79,62 @@ export function createPortableProfilePackService(deps = {}) {
         },
     };
 }
+function renderDotEnv(values) {
+    return (Object.entries(values)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([key, value]) => `${key.toUpperCase()}=${escapeEnvValue(value)}`)
+        .join('\n') + '\n');
+}
+function escapeEnvValue(value) {
+    if (/[\s"'#$\\]/.test(value)) {
+        return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+    }
+    return value;
+}
+async function writeRepoReadyFiles(stagingDir, packed) {
+    const credentials = packed.manifest.credentials ?? [];
+    const envLines = credentials.map((c) => `${c.key.toUpperCase()}=${c.description ? `# ${c.description}` : ''}`);
+    const envExample = envLines.length > 0
+        ? `# Credentials required by this profile\n# Copy to .env and fill in values before \`brainctl profile import\`.\n${envLines.join('\n')}\n`
+        : '# No credentials required by this profile.\n';
+    const gitignore = ['.env', 'node_modules/', '.DS_Store', '*.bak.*', ''].join('\n');
+    const readme = renderReadme(packed);
+    await writeFile(path.join(stagingDir, '.env.example'), envExample, 'utf8');
+    await writeFile(path.join(stagingDir, '.gitignore'), gitignore, 'utf8');
+    await writeFile(path.join(stagingDir, 'README.md'), readme, 'utf8');
+}
+function renderReadme(packed) {
+    const { manifest, profile } = packed;
+    const mcpNames = Object.keys(profile.mcps);
+    const credNames = (manifest.credentials ?? []).map((c) => `- \`${c.key}\`${c.description ? ` — ${c.description}` : ''}`);
+    const lines = [
+        `# ${profile.name}`,
+        '',
+        profile.description ?? 'A brainctl portable profile.',
+        '',
+        `Packed by ${manifest.createdBy?.tool ?? 'brainctl'} v${manifest.createdBy?.version ?? packageVersion.version}.`,
+        '',
+        '## Contents',
+        '',
+        `- **MCPs:** ${mcpNames.length > 0 ? mcpNames.join(', ') : '(none)'}`,
+        ...(manifest.plugins ? [`- **Plugins:** ${manifest.plugins.map((p) => `${p.agent}:${p.name}`).join(', ')}`] : []),
+        ...(manifest.userSkills ? [`- **User skills:** ${manifest.userSkills.map((s) => `${s.agent}:${s.name}`).join(', ')}`] : []),
+        '',
+        '## Install',
+        '',
+        '```bash',
+        `brainctl profile import ./${profile.name}`,
+        '```',
+        '',
+    ];
+    if (credNames.length > 0) {
+        lines.push('## Required credentials', '', 'Copy `.env.example` to `.env` (gitignored) and fill in values, or pass them at import time:', '', '```bash', `brainctl profile import ./${profile.name} \\`, ...credNames.map((c) => {
+            const key = c.match(/`([^`]+)`/)?.[1] ?? '';
+            return `  --credential ${key}=<value> \\`;
+        }), '```', '', '### Keys', '', ...credNames, '');
+    }
+    return lines.join('\n');
+}
 async function buildPackedProfile(options) {
     if (options.source.source === 'profile') {
         const profile = await options.profileService.get({
@@ -117,9 +188,7 @@ async function buildPackedProfile(options) {
     const extras = collectAgentExtras(agentConfig);
     return redactAndNormalizeProfile({
         name: profileName,
-        skills: {},
         mcps,
-        memory: { paths: [] },
     }, agentSource.cwd, {
         kind: 'agent',
         agent: agentSource.agent,
@@ -186,14 +255,18 @@ function inferPluginVersion(agent, installPath) {
     const base = path.basename(installPath);
     return base.length > 0 ? base : undefined;
 }
-function redactAndNormalizeProfile(profile, cwd, source, extras) {
+async function redactAndNormalizeProfile(profile, cwd, source, extras) {
     const bundledSources = new Map();
     const credentials = new Map();
+    const rawCredentials = {};
     const mcps = Object.fromEntries(Object.entries(profile.mcps).map(([key, config]) => {
         const result = redactPortableMcpCredentials(config);
         for (const credential of result.credentials) {
             credentials.set(credential.key, credential);
         }
+        for (const [credKey, credValue] of Object.entries(result.rawValues)) {
+            rawCredentials[credKey] = credValue;
+        }
         if (result.redacted.kind === 'local' && result.redacted.source === 'bundled') {
             const sourcePath = path.isAbsolute(result.redacted.path)
                 ? result.redacted.path
@@ -230,6 +303,7 @@ function redactAndNormalizeProfile(profile, cwd, source, extras) {
         bundledSources,
         bundledPlugins: extras?.bundledPlugins ?? new Map(),
         bundledUserSkills: extras?.bundledUserSkills ?? new Map(),
+        rawCredentials,
     };
 }
 function sanitizePackName(value) {

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

@@ -0,0 +1,34 @@
+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';
+export type ItemType = 'mcp' | 'plugin' | 'skill';
+export interface ItemSelector {
+    type: ItemType;
+    name: string;
+}
+export interface ApplyOptions {
+    cwd?: string;
+    profileName: string;
+    agents: AgentName[];
+    items?: ItemSelector[];
+    backup?: boolean;
+}
+export interface ApplyResult extends SyncResult {
+}
+export interface ProfileApplyService {
+    execute(options: ApplyOptions): Promise<{
+        backups: Array<{
+            agent: AgentName;
+            profileName: string;
+        }>;
+        applied: ApplyResult;
+    }>;
+}
+interface ProfileApplyDependencies {
+    profileService?: ProfileService;
+    snapshotService?: ProfileSnapshotService;
+    writers?: Partial<Record<AgentName, AgentConfigWriter>>;
+}
+export declare function createProfileApplyService(deps?: ProfileApplyDependencies): ProfileApplyService;
+export {};

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

@@ -0,0 +1,102 @@
+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/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';
+export function createProfileApplyService(deps = {}) {
+    const profileService = deps.profileService ?? createProfileService();
+    const snapshotService = deps.snapshotService ?? createProfileSnapshotService();
+    const defaultWriters = {
+        claude: createClaudeWriter(),
+        codex: createCodexWriter(),
+        gemini: createGeminiWriter(),
+    };
+    const writers = { ...defaultWriters, ...deps.writers };
+    return {
+        async execute(options) {
+            const cwd = options.cwd ?? process.cwd();
+            const profile = await profileService.get({ cwd, name: options.profileName });
+            const remoteMcpName = Object.entries(profile.mcps).find(([, config]) => config.kind === 'remote')?.[0];
+            if (remoteMcpName) {
+                throw new ProfileError(`Profile "${profile.name}" includes remote MCP "${remoteMcpName}". Remote MCP apply is not supported yet.`);
+            }
+            const isPartial = options.items !== undefined && options.items.length > 0;
+            const shouldBackup = options.backup ?? !isPartial;
+            const backups = [];
+            if (shouldBackup) {
+                for (const agent of options.agents) {
+                    const backupName = defaultBackupProfileName(agent);
+                    try {
+                        await snapshotService.execute({ cwd, agent, profileName: backupName });
+                        backups.push({ agent, profileName: backupName });
+                    }
+                    catch {
+                        // Agent may not have a live config to back up — skip silently
+                    }
+                }
+            }
+            const folder = profileDir(cwd, options.profileName);
+            const manifest = await readProfileManifest(folder);
+            const applied = [];
+            const wantMcp = (name) => matches(options.items, 'mcp', name);
+            const wantPlugin = (name) => matches(options.items, 'plugin', name);
+            const wantSkill = (name) => matches(options.items, 'skill', name);
+            for (const agent of options.agents) {
+                const writer = writers[agent];
+                if (!writer)
+                    continue;
+                const filteredMcps = Object.fromEntries(Object.entries(profile.mcps).filter(([name]) => wantMcp(name)));
+                let mcpResult;
+                if (Object.keys(filteredMcps).length > 0 || options.items === undefined) {
+                    mcpResult = await writer.write({ mcpServers: filteredMcps, cwd });
+                }
+                else {
+                    mcpResult = { configPath: '', backedUpTo: null };
+                }
+                const pluginsInstalled = [];
+                for (const plugin of (manifest?.plugins ?? []).filter((p) => p.agent === agent && wantPlugin(p.name))) {
+                    const sourceDir = path.join(folder, plugin.archivePath);
+                    await installPlugin(sourceDir, plugin);
+                    pluginsInstalled.push(plugin.name);
+                }
+                const userSkillsInstalled = [];
+                for (const skill of (manifest?.userSkills ?? []).filter((s) => s.agent === agent && wantSkill(s.name))) {
+                    const sourceDir = path.join(folder, skill.archivePath);
+                    await installUserSkill(sourceDir, skill);
+                    userSkillsInstalled.push(skill.name);
+                }
+                applied.push({
+                    agent,
+                    configPath: mcpResult.configPath,
+                    backedUpTo: mcpResult.backedUpTo,
+                    mcpCount: Object.keys(filteredMcps).length,
+                    ...(pluginsInstalled.length > 0 ? { pluginsInstalled } : {}),
+                    ...(userSkillsInstalled.length > 0 ? { userSkillsInstalled } : {}),
+                });
+            }
+            return { backups, applied };
+        },
+    };
+}
+function matches(items, type, name) {
+    if (items === undefined)
+        return true;
+    return items.some((s) => s.type === type && s.name === name);
+}
+async function readProfileManifest(folder) {
+    try {
+        const source = await readFile(path.join(folder, 'manifest.yaml'), 'utf8');
+        const parsed = YAML.parse(source);
+        if (!parsed || typeof parsed !== 'object')
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}

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

@@ -1,6 +1,6 @@
-import type { AgentName } from '../types.js';
-import type { AgentConfigService } from './agent-config-service.js';
-import { type PortableProfilePackService } from './portable-profile-pack-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 {
     execute(options: {
@@ -14,8 +14,12 @@ export interface ProfileExportService {
             cwd: string;
         };
         outputPath?: string;
+        format?: PortablePackFormat;
+        credentialsMode?: PortableCredentialsMode;
     }): Promise<{
         archivePath: string;
+        format: PortablePackFormat;
+        warnings: string[];
     }>;
 }
 interface ProfileExportDependencies {

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

@@ -1,4 +1,4 @@
-import { createPortableProfilePackService } from './portable-profile-pack-service.js';
+import { createPortableProfilePackService, } from './portable-profile-pack-service.js';
 export function createProfileExportService(deps = {}) {
     const portableProfilePackService = deps.portableProfilePackService ?? createPortableProfilePackService({
         profileService: deps.profileService,
@@ -10,6 +10,8 @@ export function createProfileExportService(deps = {}) {
                 cwd: options.cwd,
                 source: options.source,
                 outputPath: options.outputPath,
+                format: options.format,
+                credentialsMode: options.credentialsMode,
             });
         },
     };

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}

@@ -1,31 +1,46 @@
 import { execSync } from 'node:child_process';
-import { copyFile, cp, mkdir, mkdtemp, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
-import { homedir, tmpdir } from 'node:os';
+import { copyFile, 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 { formatTimestamp } from './sync/agent-writer.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) {
+    try {
+        await stat(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 export function createProfileImportService(deps = {}) {
     const mcpPreflightService = deps.mcpPreflightService ?? createMcpPreflightService();
     return {
         async execute(options) {
             const cwd = options.cwd ?? process.cwd();
             const archivePath = path.resolve(cwd, options.archivePath);
+            let archiveStats;
             try {
-                await stat(archivePath);
+                archiveStats = await stat(archivePath);
             }
             catch {
                 throw new ProfileError(`Archive not found: ${archivePath}`);
             }
-            const extractDir = await mkdtemp(path.join(tmpdir(), 'brainctl-import-'));
+            const isFolderSource = archiveStats.isDirectory();
+            const extractDir = isFolderSource
+                ? archivePath
+                : await mkdtemp(path.join(tmpdir(), 'brainctl-import-'));
             try {
-                execSync(`tar -xzf "${archivePath}" -C "${extractDir}"`, {
-                    stdio: 'pipe',
-                });
+                if (!isFolderSource) {
+                    execSync(`tar -xzf "${archivePath}" -C "${extractDir}"`, {
+                        stdio: 'pipe',
+                    });
+                }
                 const manifest = await readPortableManifest(extractDir);
                 const profileSource = await readFile(path.join(extractDir, 'profile.yaml'), 'utf8');
                 const profile = parseProfile(profileSource, 'imported');
@@ -33,21 +48,26 @@ export function createProfileImportService(deps = {}) {
                 if (manifest.profileName !== profileName) {
                     throw new ProfileError(`Portable profile manifest name "${manifest.profileName}" does not match profile name "${profileName}".`);
                 }
-                const profilePath = path.join(cwd, PROFILES_DIR, `${profileName}.yaml`);
+                const profileFolder = path.join(cwd, PROFILES_DIR, profileName);
+                const profilePath = path.join(profileFolder, 'profile.yaml');
+                const legacyProfilePath = path.join(cwd, PROFILES_DIR, `${profileName}.yaml`);
                 if (!options.force) {
-                    try {
-                        await stat(profilePath);
+                    if ((await pathExists(profilePath)) || (await pathExists(legacyProfilePath))) {
                         throw new ProfileError(`Profile "${profileName}" already exists. Use --force to overwrite.`);
                     }
-                    catch (err) {
-                        if (err instanceof ProfileError)
-                            throw err;
+                }
+                else {
+                    // clean up legacy single-file profile so it doesn't shadow the new layout
+                    if (await pathExists(legacyProfilePath)) {
+                        await rm(legacyProfilePath, { force: true });
                     }
                 }
+                const dotEnvCreds = await readDotEnvCredentials(extractDir);
+                const combinedCreds = { ...dotEnvCreds, ...(options.credentials ?? {}) };
                 const missingCredentials = new Map();
                 for (const [name, mcp] of Object.entries(profile.mcps)) {
                     const resolution = resolvePortableMcpCredentials(mcp, {
-                        credentials: options.credentials,
+                        credentials: combinedCreds,
                         credentialSpecs: manifest.credentials,
                         environment: process.env,
                     });
@@ -102,27 +122,44 @@ export function createProfileImportService(deps = {}) {
                 await validateImportedMcps(profile, cwd, mcpPreflightService);
                 const installedPlugins = [];
                 for (const plugin of manifest.plugins ?? []) {
-                    await restorePlugin(extractDir, plugin);
+                    const sourceDir = resolveBundledArchivePath(extractDir, plugin.archivePath);
+                    const profileLocalDir = path.join(cwd, PROFILES_DIR, profileName, plugin.archivePath);
+                    await rm(profileLocalDir, { recursive: true, force: true });
+                    await mkdir(path.dirname(profileLocalDir), { recursive: true });
+                    await cp(sourceDir, profileLocalDir, { recursive: true });
+                    await installPlugin(profileLocalDir, plugin);
                     installedPlugins.push(`${plugin.agent}:${plugin.name}`);
                 }
                 const installedUserSkills = [];
                 for (const skill of manifest.userSkills ?? []) {
-                    await restoreUserSkill(extractDir, skill);
+                    const sourceDir = resolveBundledArchivePath(extractDir, skill.archivePath);
+                    const profileLocalDir = path.join(cwd, PROFILES_DIR, profileName, skill.archivePath);
+                    await rm(profileLocalDir, { recursive: true, force: true });
+                    await mkdir(path.dirname(profileLocalDir), { recursive: true });
+                    await cp(sourceDir, profileLocalDir, { recursive: true });
+                    await installUserSkill(profileLocalDir, skill);
                     installedUserSkills.push(`${skill.agent}:${skill.name}`);
                 }
+                // retain manifest in profile folder so sync can reapply assets
+                try {
+                    await copyFile(path.join(extractDir, 'manifest.yaml'), path.join(cwd, PROFILES_DIR, profileName, 'manifest.yaml'));
+                }
+                catch {
+                    // best-effort
+                }
                 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, installedPlugins, installedUserSkills };
             }
             finally {
-                await rm(extractDir, { recursive: true, force: true });
+                if (!isFolderSource) {
+                    await rm(extractDir, { recursive: true, force: true });
+                }
             }
         },
     };
@@ -187,6 +224,31 @@ function formatExecError(error) {
     }
     return 'Unknown install error.';
 }
+async function readDotEnvCredentials(extractDir) {
+    try {
+        const content = await readFile(path.join(extractDir, '.env'), 'utf8');
+        const out = {};
+        for (const rawLine of content.split(/\r?\n/)) {
+            const line = rawLine.trim();
+            if (!line || line.startsWith('#'))
+                continue;
+            const eq = line.indexOf('=');
+            if (eq <= 0)
+                continue;
+            const key = line.slice(0, eq).trim();
+            let value = line.slice(eq + 1).trim();
+            if ((value.startsWith('"') && value.endsWith('"')) ||
+                (value.startsWith("'") && value.endsWith("'"))) {
+                value = value.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, '\\');
+            }
+            out[key.toLowerCase()] = value;
+        }
+        return out;
+    }
+    catch {
+        return {};
+    }
+}
 async function readPortableManifest(extractDir) {
     let source;
     try {
@@ -227,110 +289,3 @@ function resolveBundledArchivePath(extractDir, bundlePath) {
     }
     return resolved;
 }
-async function restorePlugin(extractDir, plugin) {
-    const sourceDir = resolveBundledArchivePath(extractDir, plugin.archivePath);
-    try {
-        await stat(sourceDir);
-    }
-    catch {
-        throw new ProfileError(`Bundled plugin "${plugin.name}" source missing in archive at ${plugin.archivePath}.`);
-    }
-    if (plugin.agent === 'gemini') {
-        // Gemini has no plugin cache concept. Treat as user-skill-equivalent no-op.
-        return;
-    }
-    const marketplace = plugin.marketplace ?? plugin.source;
-    const version = plugin.version ?? 'unknown';
-    const cacheRoot = path.join(homedir(), `.${plugin.agent}`, 'plugins', 'cache');
-    const targetDir = path.join(cacheRoot, marketplace, plugin.name, version);
-    await rm(targetDir, { recursive: true, force: true });
-    await mkdir(path.dirname(targetDir), { recursive: true });
-    await cp(sourceDir, targetDir, { recursive: true });
-    if (plugin.agent === 'claude') {
-        await registerClaudePlugin({
-            pluginKey: `${plugin.name}@${marketplace}`,
-            installPath: targetDir,
-            version,
-        });
-        return;
-    }
-    if (plugin.agent === 'codex') {
-        await registerCodexPlugin({
-            pluginKey: `${plugin.name}@${marketplace}`,
-        });
-    }
-}
-async function restoreUserSkill(extractDir, skill) {
-    const sourceDir = resolveBundledArchivePath(extractDir, skill.archivePath);
-    try {
-        await stat(sourceDir);
-    }
-    catch {
-        throw new ProfileError(`Bundled user skill "${skill.name}" source missing in archive at ${skill.archivePath}.`);
-    }
-    const targetDir = path.join(homedir(), `.${skill.agent}`, 'skills', skill.name);
-    await rm(targetDir, { recursive: true, force: true });
-    await mkdir(path.dirname(targetDir), { recursive: true });
-    await cp(sourceDir, targetDir, { recursive: true });
-}
-async function registerClaudePlugin(options) {
-    const filePath = path.join(homedir(), '.claude', 'plugins', 'installed_plugins.json');
-    let existing = { version: 2, plugins: {} };
-    try {
-        const source = await readFile(filePath, 'utf8');
-        existing = JSON.parse(source);
-        await backupFile(filePath);
-    }
-    catch {
-        // fresh file
-    }
-    const plugins = (existing.plugins ?? {});
-    const now = new Date().toISOString();
-    const entry = {
-        scope: 'user',
-        installPath: options.installPath,
-        version: options.version,
-        installedAt: now,
-        lastUpdated: now,
-    };
-    plugins[options.pluginKey] = [entry];
-    existing.plugins = plugins;
-    if (typeof existing.version !== 'number')
-        existing.version = 2;
-    await mkdir(path.dirname(filePath), { recursive: true });
-    await atomicWrite(filePath, JSON.stringify(existing, null, 2) + '\n');
-}
-async function registerCodexPlugin(options) {
-    const filePath = path.join(homedir(), '.codex', 'config.toml');
-    let existing = '';
-    try {
-        existing = await readFile(filePath, 'utf8');
-        await backupFile(filePath);
-    }
-    catch {
-        existing = '';
-    }
-    const header = `[plugins."${options.pluginKey}"]`;
-    if (existing.includes(header))
-        return;
-    const prefix = existing.length > 0 && !existing.endsWith('\n') ? '\n' : '';
-    const separator = existing.length > 0 ? '\n' : '';
-    const block = `${header}\nenabled = true\n`;
-    const next = existing + prefix + separator + block;
-    await mkdir(path.dirname(filePath), { recursive: true });
-    await atomicWrite(filePath, next);
-}
-async function backupFile(filePath) {
-    const backupPath = `${filePath}.bak.${formatTimestamp()}`;
-    try {
-        await copyFile(filePath, backupPath);
-    }
-    catch {
-        // file may not exist
-    }
-}
-async function atomicWrite(filePath, content) {
-    const tmpPath = `${filePath}.tmp.${Date.now()}`;
-    await writeFile(tmpPath, content, 'utf8');
-    await rename(tmpPath, filePath);
-}

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

@@ -1,10 +1,11 @@
-import type { BrainctlMetaConfig, 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 {
     list(options?: {
         cwd?: string;
     }): Promise<{
         profiles: string[];
-        activeProfile: string | null;
     }>;
     get(options: {
         cwd?: string;
@@ -26,15 +27,6 @@ export interface ProfileService {
         cwd?: string;
         name: string;
     }): Promise<void>;
-    use(options: {
-        cwd?: string;
-        name: string;
-    }): Promise<{
-        previousProfile: string | null;
-    }>;
-    getMetaConfig(options?: {
-        cwd?: string;
-    }): Promise<BrainctlMetaConfig>;
 }
 export declare function createProfileService(): ProfileService;
 export declare function parseProfile(source: string, name: string): ProfileConfig;