brainctl 0.1.5 → 0.1.7

package/dist/services/sync/agent-reader.js

@@ -0,0 +1,232 @@
+import { readFile, readdir } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { mergeManagedPluginsIntoSkills, readManagedPlugins, } from './managed-plugin-registry.js';
+import { readInstalledPlugins } from './plugin-skill-reader.js';
+export function createClaudeReader() {
+    return {
+        async read(options) {
+            const configPath = path.join(homedir(), '.claude.json');
+            try {
+                const source = await readFile(configPath, 'utf8');
+                const data = JSON.parse(source);
+                const projects = (data.projects ?? {});
+                const projectConfig = projects[options.cwd] ?? {};
+                const rawServers = (projectConfig.mcpServers ?? {});
+                const mcpServers = {};
+                for (const [name, entry] of Object.entries(rawServers)) {
+                    mcpServers[name] = {
+                        command: String(entry.command ?? ''),
+                        args: Array.isArray(entry.args) ? entry.args.map(String) : undefined,
+                        env: parseEnvObject(entry.env),
+                    };
+                }
+                const skills = await readClaudePlugins();
+                return { agent: 'claude', configPath, exists: true, mcpServers, skills };
+            }
+            catch {
+                const skills = await readClaudePlugins();
+                return { agent: 'claude', configPath, exists: false, mcpServers: {}, skills };
+            }
+        },
+    };
+}
+export function createCodexReader() {
+    return {
+        async read() {
+            const configPath = path.join(homedir(), '.codex', 'config.toml');
+            try {
+                const source = await readFile(configPath, 'utf8');
+                const mcpServers = parseCodexToml(source);
+                const skills = await readCodexSkills();
+                return { agent: 'codex', configPath, exists: true, mcpServers, skills };
+            }
+            catch {
+                const skills = await readCodexSkills();
+                return { agent: 'codex', configPath, exists: false, mcpServers: {}, skills };
+            }
+        },
+    };
+}
+export function createGeminiReader() {
+    return {
+        async read() {
+            const configPath = path.join(homedir(), '.gemini', 'settings.json');
+            try {
+                const source = await readFile(configPath, 'utf8');
+                const data = JSON.parse(source);
+                const rawServers = (data.mcpServers ?? {});
+                const mcpServers = {};
+                for (const [name, entry] of Object.entries(rawServers)) {
+                    mcpServers[name] = {
+                        command: String(entry.command ?? ''),
+                        args: Array.isArray(entry.args) ? entry.args.map(String) : undefined,
+                        env: parseEnvObject(entry.env),
+                    };
+                }
+                const skills = await readGeminiSkills();
+                return { agent: 'gemini', configPath, exists: true, mcpServers, skills };
+            }
+            catch {
+                const skills = await readGeminiSkills();
+                return { agent: 'gemini', configPath, exists: false, mcpServers: {}, skills };
+            }
+        },
+    };
+}
+function parseEnvObject(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const result = {};
+    for (const [k, v] of Object.entries(value)) {
+        result[k] = String(v);
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+}
+function parseCodexToml(source) {
+    const servers = {};
+    const lines = source.split('\n');
+    let currentServer = null;
+    let inEnv = false;
+    let currentEntry = { command: '' };
+    let currentEnv = {};
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Match [mcp_servers.name.env]
+        const envMatch = trimmed.match(/^\[mcp_servers\.([^.]+)\.env\]$/);
+        if (envMatch) {
+            inEnv = true;
+            continue;
+        }
+        // Match [mcp_servers.name]
+        const serverMatch = trimmed.match(/^\[mcp_servers\.([^\].]+)\]$/);
+        if (serverMatch) {
+            // Save previous server
+            if (currentServer) {
+                if (Object.keys(currentEnv).length > 0)
+                    currentEntry.env = currentEnv;
+                servers[currentServer] = currentEntry;
+            }
+            currentServer = serverMatch[1];
+            currentEntry = { command: '' };
+            currentEnv = {};
+            inEnv = false;
+            continue;
+        }
+        // New non-mcp section — flush current server
+        if (/^\[/.test(trimmed) && !/^\[mcp_servers/.test(trimmed)) {
+            if (currentServer) {
+                if (Object.keys(currentEnv).length > 0)
+                    currentEntry.env = currentEnv;
+                servers[currentServer] = currentEntry;
+                currentServer = null;
+                currentEntry = { command: '' };
+                currentEnv = {};
+            }
+            inEnv = false;
+            continue;
+        }
+        // Key-value pair
+        const kvMatch = trimmed.match(/^(\w+)\s*=\s*(.+)$/);
+        if (!kvMatch || !currentServer)
+            continue;
+        const [, key, rawValue] = kvMatch;
+        if (inEnv) {
+            currentEnv[key] = parseTomlValue(rawValue);
+        }
+        else if (key === 'command') {
+            currentEntry.command = parseTomlValue(rawValue);
+        }
+        else if (key === 'args') {
+            currentEntry.args = parseTomlArray(rawValue);
+        }
+    }
+    // Flush last server
+    if (currentServer) {
+        if (Object.keys(currentEnv).length > 0)
+            currentEntry.env = currentEnv;
+        servers[currentServer] = currentEntry;
+    }
+    return servers;
+}
+function parseTomlValue(raw) {
+    const trimmed = raw.trim();
+    if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+        return trimmed.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, '\\');
+    }
+    return trimmed;
+}
+function parseTomlArray(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed.startsWith('[') || !trimmed.endsWith(']'))
+        return [];
+    const inner = trimmed.slice(1, -1);
+    const result = [];
+    const parts = inner.split(',');
+    for (const part of parts) {
+        const val = parseTomlValue(part.trim());
+        if (val.length > 0)
+            result.push(val);
+    }
+    return result;
+}
+/* ---- Skill readers ---- */
+async function readClaudePlugins() {
+    const results = [];
+    // Read marketplace plugins
+    try {
+        const pluginsPath = path.join(homedir(), '.claude', 'plugins', 'installed_plugins.json');
+        results.push(...await readInstalledPlugins(pluginsPath));
+    }
+    catch {
+        // no plugins file
+    }
+    // Read local skills from ~/.claude/skills/
+    try {
+        const skillsDir = path.join(homedir(), '.claude', 'skills');
+        const localSkills = await readSkillDirs(skillsDir);
+        results.push(...localSkills);
+    }
+    catch {
+        // no skills dir
+    }
+    return results;
+}
+async function readCodexSkills() {
+    try {
+        const skillsDir = path.join(homedir(), '.codex', 'skills');
+        const localSkills = await readSkillDirs(skillsDir);
+        const managedPlugins = await readManagedPlugins({ agent: 'codex' });
+        return mergeManagedPluginsIntoSkills(localSkills, managedPlugins);
+    }
+    catch {
+        return await readManagedPlugins({ agent: 'codex' });
+    }
+}
+async function readGeminiSkills() {
+    try {
+        const skillsDir = path.join(homedir(), '.gemini', 'skills');
+        const localSkills = await readSkillDirs(skillsDir);
+        const managedPlugins = await readManagedPlugins({ agent: 'gemini' });
+        return mergeManagedPluginsIntoSkills(localSkills, managedPlugins);
+    }
+    catch {
+        return await readManagedPlugins({ agent: 'gemini' });
+    }
+}
+/** Shared: read skill directories (Codex and Gemini use the same SKILL.md convention) */
+async function readSkillDirs(skillsDir) {
+    const entries = await readdir(skillsDir, { withFileTypes: true });
+    const skills = [];
+    for (const entry of entries) {
+        if (entry.name.startsWith('.'))
+            continue;
+        if (entry.isDirectory()) {
+            skills.push({ name: entry.name, source: 'local', kind: 'skill' });
+        }
+        else if (entry.isSymbolicLink()) {
+            skills.push({ name: entry.name, source: 'linked', kind: 'skill' });
+        }
+    }
+    return skills;
+}

package/dist/services/sync/claude-writer.js

@@ -65,7 +65,10 @@ export function createClaudeWriter() {
     };
 }
 function toClaudeFormat(config) {
-    if (config.type === 'npm') {
+    if (config.kind === 'remote') {
+        throw new SyncError('Remote MCP servers are not supported in Claude sync.');
+    }
+    if (config.source === 'npm') {
         return {
             type: 'stdio',
             command: 'npx',

package/dist/services/sync/codex-writer.js

@@ -27,7 +27,8 @@ export function createCodexWriter() {
             const allServers = { ...options.mcpServers };
             // Always include brainctl itself
             allServers['brainctl'] = {
-                type: 'npm',
+                kind: 'local',
+                source: 'npm',
                 package: 'brainctl',
             };
             const mcpToml = buildMcpToml(allServers);
@@ -71,7 +72,10 @@ function buildMcpToml(servers) {
     const lines = [];
     for (const [name, config] of Object.entries(servers)) {
         lines.push(`[mcp_servers.${name}]`);
-        if (config.type === 'npm') {
+        if (config.kind === 'remote') {
+            throw new SyncError('Remote MCP servers are not supported in Codex sync.');
+        }
+        if (config.source === 'npm') {
             lines.push(`command = "npx"`);
             lines.push(`args = ["-y", ${tomlString(config.package)}]`);
         }

package/dist/services/sync/gemini-writer.js

@@ -67,7 +67,10 @@ export function createGeminiWriter() {
     };
 }
 function toGeminiFormat(config) {
-    if (config.type === 'npm') {
+    if (config.kind === 'remote') {
+        throw new SyncError('Remote MCP servers are not supported in Gemini sync.');
+    }
+    if (config.source === 'npm') {
         return {
             command: 'npx',
             args: ['-y', config.package],

package/dist/services/sync/managed-plugin-registry.d.ts

@@ -0,0 +1,17 @@
+import type { AgentName } from '../../types.js';
+import type { AgentSkillEntry } from './agent-reader.js';
+export declare function readManagedPlugins(options: {
+    homeDir?: string;
+    agent: AgentName;
+}): Promise<AgentSkillEntry[]>;
+export declare function writeManagedPluginInstall(options: {
+    homeDir?: string;
+    agent: AgentName;
+    plugin: AgentSkillEntry;
+}): Promise<void>;
+export declare function removeManagedPluginInstall(options: {
+    homeDir?: string;
+    agent: AgentName;
+    pluginName: string;
+}): Promise<void>;
+export declare function mergeManagedPluginsIntoSkills(localSkills: AgentSkillEntry[], managedPlugins: AgentSkillEntry[]): AgentSkillEntry[];

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,2 @@
+import type { AgentSkillEntry } from './agent-reader.js';
+export declare function readInstalledPlugins(installedPluginsPath: string): Promise<AgentSkillEntry[]>;

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

@@ -0,0 +1,33 @@
+import { readFile, readdir } 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) : [];
+        results.push({
+            name,
+            source: pluginSource,
+            kind: 'plugin',
+            installPath,
+            pluginSkills,
+        });
+    }
+    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 [];
+    }
+}

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];

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,30 @@ export interface DiagnosticCheck {
     status: DiagnosticStatus;
     message: string;
 }
-export interface NpmMcpServerConfig {
-    type: 'npm';
+export interface LocalNpmMcpServerConfig {
+    kind: 'local';
+    source: 'npm';
     package: string;
     env?: Record<string, string>;
 }
-export interface BundledMcpServerConfig {
-    type: 'bundled';
+export interface LocalBundledMcpServerConfig {
+    kind: 'local';
+    source: 'bundled';
     path: string;
     install?: string;
     command: string;
     args?: string[];
     env?: Record<string, string>;
 }
-export type McpServerConfig = NpmMcpServerConfig | BundledMcpServerConfig;
+export interface RemoteMcpServerConfig {
+    kind: 'remote';
+    transport: 'http' | 'sse';
+    url: string;
+    headers?: Record<string, string>;
+    env?: Record<string, string>;
+}
+export type LocalMcpServerConfig = LocalNpmMcpServerConfig | LocalBundledMcpServerConfig;
+export type McpServerConfig = LocalMcpServerConfig | RemoteMcpServerConfig;
 export interface ProfileConfig {
     name: string;
     description?: string;