brainctl 0.1.6 → 0.1.9

package/dist/services/sync/managed-plugin-registry.js

@@ -0,0 +1,75 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+function getRegistryPath(homeDir) {
+    return path.join(homeDir, '.brainctl', 'managed-plugins.json');
+}
+export async function readManagedPlugins(options) {
+    const homeDir = options.homeDir ?? homedir();
+    const registryPath = getRegistryPath(homeDir);
+    try {
+        const source = await readFile(registryPath, 'utf8');
+        const parsed = JSON.parse(source);
+        return (parsed.agents?.[options.agent] ?? []).map((entry) => ({
+            ...entry,
+            kind: 'plugin',
+            managed: true,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+export async function writeManagedPluginInstall(options) {
+    const homeDir = options.homeDir ?? homedir();
+    const registryPath = getRegistryPath(homeDir);
+    const existing = await readRegistryFile(homeDir);
+    const currentEntries = existing.agents?.[options.agent] ?? [];
+    const nextEntries = [
+        ...currentEntries.filter((entry) => entry.name !== options.plugin.name),
+        {
+            ...options.plugin,
+            kind: 'plugin',
+            managed: true,
+        },
+    ].sort((left, right) => left.name.localeCompare(right.name));
+    const next = {
+        version: 1,
+        agents: {
+            ...existing.agents,
+            [options.agent]: nextEntries,
+        },
+    };
+    await mkdir(path.dirname(registryPath), { recursive: true });
+    await writeFile(registryPath, JSON.stringify(next, null, 2) + '\n', 'utf8');
+}
+export async function removeManagedPluginInstall(options) {
+    const homeDir = options.homeDir ?? homedir();
+    const registryPath = getRegistryPath(homeDir);
+    const existing = await readRegistryFile(homeDir);
+    const currentEntries = existing.agents?.[options.agent] ?? [];
+    const nextEntries = currentEntries.filter((entry) => entry.name !== options.pluginName);
+    const next = {
+        version: 1,
+        agents: {
+            ...existing.agents,
+            [options.agent]: nextEntries,
+        },
+    };
+    await mkdir(path.dirname(registryPath), { recursive: true });
+    await writeFile(registryPath, JSON.stringify(next, null, 2) + '\n', 'utf8');
+}
+export function mergeManagedPluginsIntoSkills(localSkills, managedPlugins) {
+    const pluginOwnedSkills = new Set(managedPlugins.flatMap((plugin) => plugin.pluginSkills ?? []));
+    const filteredLocalSkills = localSkills.filter((skill) => !pluginOwnedSkills.has(skill.name));
+    return [...managedPlugins, ...filteredLocalSkills];
+}
+async function readRegistryFile(homeDir) {
+    try {
+        const source = await readFile(getRegistryPath(homeDir), 'utf8');
+        return JSON.parse(source);
+    }
+    catch {
+        return { version: 1, agents: {} };
+    }
+}

package/dist/services/sync/plugin-skill-reader.d.ts

@@ -0,0 +1,7 @@
+import type { AgentSkillEntry } from './agent-reader.js';
+export declare function readInstalledPlugins(installedPluginsPath: string): Promise<AgentSkillEntry[]>;
+export declare function readCodexPlugins(options: {
+    configTomlPath: string;
+    pluginsCacheDir: string;
+}): Promise<AgentSkillEntry[]>;
+export declare function readPluginMcpKeys(installPath: string): Promise<string[]>;

package/dist/services/sync/plugin-skill-reader.js

@@ -0,0 +1,174 @@
+import { readFile, readdir, stat } from 'node:fs/promises';
+import path from 'node:path';
+export async function readInstalledPlugins(installedPluginsPath) {
+    const source = await readFile(installedPluginsPath, 'utf8');
+    const data = JSON.parse(source);
+    const results = [];
+    for (const [key, records] of Object.entries(data.plugins ?? {})) {
+        const [name, pluginSource] = key.split('@');
+        const installPath = records[0]?.installPath;
+        const pluginSkills = installPath ? await readPluginSkills(installPath) : [];
+        const pluginMcps = installPath ? await readPluginMcpKeys(installPath) : [];
+        const pluginAgents = installPath ? await readPluginAgentNames(installPath) : [];
+        const pluginCommands = installPath ? await readPluginCommandNames(installPath) : [];
+        results.push({
+            name,
+            source: pluginSource,
+            kind: 'plugin',
+            installPath,
+            pluginSkills,
+            ...(pluginMcps.length > 0 ? { pluginMcps } : {}),
+            ...(pluginAgents.length > 0 ? { pluginAgents } : {}),
+            ...(pluginCommands.length > 0 ? { pluginCommands } : {}),
+        });
+    }
+    return results;
+}
+async function readPluginSkills(installPath) {
+    const skillsDir = path.join(installPath, 'skills');
+    try {
+        const entries = await readdir(skillsDir, { withFileTypes: true });
+        return entries
+            .filter((entry) => !entry.name.startsWith('.') && entry.isDirectory())
+            .map((entry) => entry.name)
+            .sort((left, right) => left.localeCompare(right));
+    }
+    catch {
+        return [];
+    }
+}
+export async function readCodexPlugins(options) {
+    let tomlSource;
+    try {
+        tomlSource = await readFile(options.configTomlPath, 'utf8');
+    }
+    catch {
+        return [];
+    }
+    const entries = [];
+    for (const { name, marketplace, enabled } of parseCodexPluginDeclarations(tomlSource)) {
+        if (!enabled)
+            continue;
+        const installPath = await resolveCodexPluginInstallPath({
+            pluginsCacheDir: options.pluginsCacheDir,
+            marketplace,
+            name,
+        });
+        if (!installPath)
+            continue;
+        const pluginSkills = await readPluginSkills(installPath);
+        const pluginMcps = await readPluginMcpKeys(installPath);
+        const pluginAgents = await readPluginAgentNames(installPath);
+        const pluginCommands = await readPluginCommandNames(installPath);
+        entries.push({
+            name,
+            source: marketplace,
+            kind: 'plugin',
+            installPath,
+            pluginSkills,
+            ...(pluginMcps.length > 0 ? { pluginMcps } : {}),
+            ...(pluginAgents.length > 0 ? { pluginAgents } : {}),
+            ...(pluginCommands.length > 0 ? { pluginCommands } : {}),
+        });
+    }
+    return entries.sort((left, right) => left.name.localeCompare(right.name));
+}
+function parseCodexPluginDeclarations(source) {
+    const results = [];
+    const lines = source.split('\n');
+    let current = null;
+    const flush = () => {
+        if (current) {
+            results.push(current);
+            current = null;
+        }
+    };
+    for (const line of lines) {
+        const trimmed = line.trim();
+        const sectionMatch = trimmed.match(/^\[plugins\."([^"@]+)@([^"]+)"\]$/);
+        if (sectionMatch) {
+            flush();
+            current = {
+                name: sectionMatch[1],
+                marketplace: sectionMatch[2],
+                enabled: false,
+            };
+            continue;
+        }
+        if (/^\[/.test(trimmed)) {
+            flush();
+            continue;
+        }
+        if (!current)
+            continue;
+        const kv = trimmed.match(/^(\w+)\s*=\s*(.+)$/);
+        if (kv && kv[1] === 'enabled') {
+            current.enabled = kv[2].trim() === 'true';
+        }
+    }
+    flush();
+    return results;
+}
+async function resolveCodexPluginInstallPath(options) {
+    const pluginRoot = path.join(options.pluginsCacheDir, options.marketplace, options.name);
+    let versionDirs;
+    try {
+        const entries = await readdir(pluginRoot, { withFileTypes: true });
+        versionDirs = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    }
+    catch {
+        return null;
+    }
+    if (versionDirs.length === 0)
+        return null;
+    if (versionDirs.length === 1)
+        return path.join(pluginRoot, versionDirs[0]);
+    const stats = await Promise.all(versionDirs.map(async (dir) => {
+        try {
+            const info = await stat(path.join(pluginRoot, dir));
+            return { dir, mtime: info.mtimeMs };
+        }
+        catch {
+            return { dir, mtime: 0 };
+        }
+    }));
+    stats.sort((left, right) => right.mtime - left.mtime);
+    return path.join(pluginRoot, stats[0].dir);
+}
+async function readPluginAgentNames(installPath) {
+    try {
+        const entries = await readdir(path.join(installPath, 'agents'), { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isFile() && (entry.name.endsWith('.md') || entry.name.endsWith('.toml')))
+            .map((entry) => entry.name.replace(/\.(md|toml)$/, ''))
+            .sort((left, right) => left.localeCompare(right));
+    }
+    catch {
+        return [];
+    }
+}
+async function readPluginCommandNames(installPath) {
+    try {
+        const entries = await readdir(path.join(installPath, 'commands'), { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith('.md'))
+            .map((entry) => entry.name.replace(/\.md$/, ''))
+            .sort((left, right) => left.localeCompare(right));
+    }
+    catch {
+        return [];
+    }
+}
+export async function readPluginMcpKeys(installPath) {
+    try {
+        const source = await readFile(path.join(installPath, '.mcp.json'), 'utf8');
+        const parsed = JSON.parse(source);
+        const servers = parsed.mcpServers && typeof parsed.mcpServers === 'object' && !Array.isArray(parsed.mcpServers)
+            ? parsed.mcpServers
+            : parsed;
+        return Object.keys(servers).sort((left, right) => left.localeCompare(right));
+    }
+    catch {
+        return [];
+    }
+}

package/dist/services/sync-service.js

@@ -1,3 +1,4 @@
+import { ProfileError } from '../errors.js';
 import { createClaudeWriter } from './sync/claude-writer.js';
 import { createCodexWriter } from './sync/codex-writer.js';
 import { createGeminiWriter } from './sync/gemini-writer.js';
@@ -21,6 +22,10 @@ export function createSyncService(dependencies = {}) {
                 throw new Error('No active profile set. Run "brainctl profile use <name>" first.');
             }
             const profile = await profileService.get({ cwd, name: meta.active_profile });
+            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 sync is not supported yet.`);
+            }
             const results = [];
             for (const agent of meta.agents) {
                 const writer = writers[agent];
@@ -35,7 +40,7 @@ export function createSyncService(dependencies = {}) {
                     agent,
                     configPath: result.configPath,
                     backedUpTo: result.backedUpTo,
-                    mcpCount: Object.keys(profile.mcps).length + 1, // +1 for brainctl itself
+                    mcpCount: Object.keys(profile.mcps).length,
                 });
             }
             return results;

package/dist/services/update-check-service.d.ts

@@ -0,0 +1,33 @@
+export interface UpdateCheckResult {
+    current: string;
+    latest: string;
+    isOutdated: boolean;
+    fromCache: boolean;
+}
+export interface SelfUpdateResult {
+    success: boolean;
+    fromVersion: string;
+    toVersion: string;
+    error?: string;
+}
+export interface UpdateCheckService {
+    check(): Promise<UpdateCheckResult>;
+    selfUpdate(): Promise<SelfUpdateResult>;
+}
+interface UpdateCheckCache {
+    lastCheck: string;
+    latestVersion: string;
+}
+interface UpdateCheckDependencies {
+    currentVersion?: string;
+    fetchLatestVersion?: () => Promise<string>;
+    readCache?: () => Promise<UpdateCheckCache | null>;
+    writeCache?: (cache: UpdateCheckCache) => Promise<void>;
+    runInstall?: () => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+}
+export declare function createUpdateCheckService(dependencies?: UpdateCheckDependencies): UpdateCheckService;
+export declare function isNewer(candidate: string, baseline: string): boolean;
+export {};

package/dist/services/update-check-service.js

@@ -0,0 +1,128 @@
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import https from 'node:https';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+const CACHE_DIR = path.join(homedir(), '.brainctl');
+const CACHE_PATH = path.join(CACHE_DIR, 'update-check.json');
+const packageVersion = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8'));
+export function createUpdateCheckService(dependencies = {}) {
+    const currentVersion = dependencies.currentVersion ?? packageVersion.version;
+    const fetchLatestVersion = dependencies.fetchLatestVersion ?? fetchFromRegistry;
+    const readCacheFn = dependencies.readCache ?? readCacheFile;
+    const writeCacheFn = dependencies.writeCache ?? writeCacheFile;
+    const runInstall = dependencies.runInstall ?? runNpmInstall;
+    return {
+        async check() {
+            const cached = await readCacheFn();
+            if (cached && isCacheValid(cached)) {
+                return {
+                    current: currentVersion,
+                    latest: cached.latestVersion,
+                    isOutdated: isNewer(cached.latestVersion, currentVersion),
+                    fromCache: true,
+                };
+            }
+            let latest;
+            try {
+                latest = await fetchLatestVersion();
+            }
+            catch {
+                return {
+                    current: currentVersion,
+                    latest: currentVersion,
+                    isOutdated: false,
+                    fromCache: false,
+                };
+            }
+            await writeCacheFn({
+                lastCheck: new Date().toISOString(),
+                latestVersion: latest,
+            }).catch(() => { });
+            return {
+                current: currentVersion,
+                latest,
+                isOutdated: isNewer(latest, currentVersion),
+                fromCache: false,
+            };
+        },
+        async selfUpdate() {
+            const { success, error } = await runInstall();
+            return {
+                success,
+                fromVersion: currentVersion,
+                toVersion: success ? 'latest' : currentVersion,
+                error,
+            };
+        },
+    };
+}
+function isCacheValid(cache) {
+    const lastCheck = new Date(cache.lastCheck).getTime();
+    return Date.now() - lastCheck < CACHE_TTL_MS;
+}
+export function isNewer(candidate, baseline) {
+    const parse = (v) => v.split('.').map(Number);
+    const [aMaj, aMin, aPat] = parse(candidate);
+    const [bMaj, bMin, bPat] = parse(baseline);
+    if (aMaj !== bMaj)
+        return aMaj > bMaj;
+    if (aMin !== bMin)
+        return aMin > bMin;
+    return aPat > bPat;
+}
+function fetchFromRegistry() {
+    return new Promise((resolve, reject) => {
+        const req = https.get('https://registry.npmjs.org/brainctl/latest', { timeout: 3000 }, (res) => {
+            let data = '';
+            res.on('data', (chunk) => {
+                data += chunk.toString();
+            });
+            res.on('end', () => {
+                try {
+                    const pkg = JSON.parse(data);
+                    resolve(pkg.version);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+        });
+        req.on('error', reject);
+        req.on('timeout', () => {
+            req.destroy();
+            reject(new Error('timeout'));
+        });
+    });
+}
+async function readCacheFile() {
+    try {
+        const content = await readFile(CACHE_PATH, 'utf8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+async function writeCacheFile(cache) {
+    await mkdir(CACHE_DIR, { recursive: true });
+    await writeFile(CACHE_PATH, JSON.stringify(cache, null, 2) + '\n', 'utf8');
+}
+async function runNpmInstall() {
+    try {
+        await execFileAsync('npm', ['install', '-g', 'brainctl@latest'], {
+            timeout: 60_000,
+        });
+        return { success: true };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e instanceof Error ? e.message : String(e),
+        };
+    }
+}

package/dist/system/executables.d.ts

@@ -0,0 +1 @@
+export declare function findExecutable(command: string): Promise<string | null>;

package/dist/system/executables.js

@@ -0,0 +1,38 @@
+import { access } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import path from 'node:path';
+export async function findExecutable(command) {
+    if (command.includes(path.sep)) {
+        return (await isExecutable(command)) ? command : null;
+    }
+    const pathEntries = (process.env.PATH ?? '')
+        .split(path.delimiter)
+        .filter((entry) => entry.length > 0);
+    const extensions = process.platform === 'win32'
+        ? (process.env.PATHEXT ?? '.EXE;.CMD;.BAT;.COM')
+            .split(';')
+            .filter((entry) => entry.length > 0)
+        : [''];
+    for (const pathEntry of pathEntries) {
+        for (const extension of extensions) {
+            const candidate = process.platform === 'win32' &&
+                extension.length > 0 &&
+                !command.toLowerCase().endsWith(extension.toLowerCase())
+                ? path.join(pathEntry, `${command}${extension}`)
+                : path.join(pathEntry, command);
+            if (await isExecutable(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    return null;
+}
+async function isExecutable(filePath) {
+    try {
+        await access(filePath, process.platform === 'win32' ? constants.F_OK : constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/types.d.ts

@@ -55,20 +55,77 @@ export interface DiagnosticCheck {
     status: DiagnosticStatus;
     message: string;
 }
-export interface NpmMcpServerConfig {
-    type: 'npm';
+export interface PortableCredentialSpec {
+    key: string;
+    required: boolean;
+    description?: string;
+}
+export type PortableCredentialPlaceholder = `\${credentials.${string}}`;
+export type PortableCredentialPreservedValue = PortableCredentialPlaceholder | `Bearer ${PortableCredentialPlaceholder}` | `Token ${PortableCredentialPlaceholder}`;
+export type PortableProfileSource = {
+    kind: 'profile';
+    profileName: string;
+} | {
+    kind: 'agent';
+    agent: AgentName;
+};
+export interface PortablePluginSnapshot {
+    agent: AgentName;
+    name: string;
+    source: string;
+    marketplace?: string;
+    version?: string;
+    archivePath: string;
+    managed?: boolean;
+    pluginSkills?: string[];
+    pluginMcps?: string[];
+    pluginAgents?: string[];
+    pluginCommands?: string[];
+}
+export interface PortableUserSkillSnapshot {
+    agent: AgentName;
+    name: string;
+    archivePath: string;
+}
+export interface PortableProfileManifest {
+    schemaVersion: 1 | 2;
+    profileName: string;
+    createdBy?: {
+        tool: string;
+        version: string;
+    };
+    source?: PortableProfileSource;
+    credentials?: PortableCredentialSpec[];
+    plugins?: PortablePluginSnapshot[];
+    userSkills?: PortableUserSkillSnapshot[];
+}
+export interface LocalNpmMcpServerConfig {
+    kind: 'local';
+    source: 'npm';
     package: string;
     env?: Record<string, string>;
 }
-export interface BundledMcpServerConfig {
-    type: 'bundled';
+export type McpRuntime = 'node' | 'python' | 'java' | 'go' | 'rust' | 'binary';
+export interface LocalBundledMcpServerConfig {
+    kind: 'local';
+    source: 'bundled';
+    runtime: McpRuntime;
     path: string;
     install?: string;
     command: string;
     args?: string[];
+    exclude?: string[];
+    env?: Record<string, string>;
+}
+export interface RemoteMcpServerConfig {
+    kind: 'remote';
+    transport: 'http' | 'sse';
+    url: string;
+    headers?: Record<string, string>;
     env?: Record<string, string>;
 }
-export type McpServerConfig = NpmMcpServerConfig | BundledMcpServerConfig;
+export type LocalMcpServerConfig = LocalNpmMcpServerConfig | LocalBundledMcpServerConfig;
+export type McpServerConfig = LocalMcpServerConfig | RemoteMcpServerConfig;
 export interface ProfileConfig {
     name: string;
     description?: string;