brainctl 0.1.6 → 0.1.9

package/dist/services/skill-paths.js

@@ -0,0 +1,26 @@
+import { homedir } from 'node:os';
+import path from 'node:path';
+export function getSkillDir(agent, skillName) {
+    const safeName = path.basename(skillName);
+    if (agent === 'claude')
+        return path.join(homedir(), '.claude', 'skills', safeName);
+    if (agent === 'codex')
+        return path.join(homedir(), '.codex', 'skills', safeName);
+    if (agent === 'gemini')
+        return path.join(homedir(), '.gemini', 'skills', safeName);
+    throw new Error(`Skill management is not supported for ${agent}`);
+}
+export function getAgentFilePath(agent, agentName) {
+    const safeName = path.basename(agentName);
+    if (agent === 'claude')
+        return path.join(homedir(), '.claude', 'agents', `${safeName}.md`);
+    if (agent === 'codex')
+        return path.join(homedir(), '.codex', 'agents', `${safeName}.toml`);
+    throw new Error(`Subagent management is not supported for ${agent}`);
+}
+export function getCommandFilePath(agent, commandName) {
+    const safeName = path.basename(commandName);
+    if (agent === 'claude')
+        return path.join(homedir(), '.claude', 'commands', `${safeName}.md`);
+    throw new Error(`Slash-command management is not supported for ${agent}`);
+}

package/dist/services/skill-preflight-service.d.ts

@@ -0,0 +1,23 @@
+import type { AgentName } from '../types.js';
+export interface SkillPreflightCheck {
+    label: string;
+    status: 'ok' | 'warn' | 'error';
+    message: string;
+}
+export interface SkillPreflightResult {
+    ok: boolean;
+    checks: SkillPreflightCheck[];
+}
+export interface SkillPreflightService {
+    execute(options: {
+        sourceAgent: AgentName;
+        targetAgent: AgentName;
+        skillName: string;
+        source?: string;
+    }): Promise<SkillPreflightResult>;
+}
+interface SkillPreflightDependencies {
+    pathExists?: (targetPath: string) => Promise<boolean>;
+}
+export declare function createSkillPreflightService(dependencies?: SkillPreflightDependencies): SkillPreflightService;
+export {};

package/dist/services/skill-preflight-service.js

@@ -0,0 +1,40 @@
+import { stat } from 'node:fs/promises';
+import { getSkillDir } from './skill-paths.js';
+export function createSkillPreflightService(dependencies = {}) {
+    const pathExists = dependencies.pathExists ?? defaultPathExists;
+    return {
+        async execute(options) {
+            const checks = [];
+            if (options.source && options.source !== 'local' && options.source !== 'linked') {
+                checks.push({
+                    label: 'Source',
+                    status: 'error',
+                    message: `Only local skill folders can be copied today. "${options.skillName}" is a plugin/managed entry from ${options.source}.`,
+                });
+                return { ok: false, checks };
+            }
+            const sourceDir = getSkillDir(options.sourceAgent, options.skillName);
+            const exists = await pathExists(sourceDir);
+            checks.push({
+                label: 'Source',
+                status: exists ? 'ok' : 'error',
+                message: exists
+                    ? `Skill folder was found: ${sourceDir}`
+                    : `Skill folder was not found: ${sourceDir}`,
+            });
+            return {
+                ok: exists,
+                checks,
+            };
+        },
+    };
+}
+async function defaultPathExists(targetPath) {
+    try {
+        await stat(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/services/sync/agent-reader.d.ts

@@ -4,15 +4,29 @@ export interface AgentMcpEntry {
     args?: string[];
     env?: Record<string, string>;
 }
+export interface PortableRemoteMcpMetadata {
+    transport: 'http' | 'sse';
+    url: string;
+    headers?: Record<string, string>;
+    env?: Record<string, string>;
+}
 export interface AgentSkillEntry {
     name: string;
     source?: string;
+    kind?: 'skill' | 'plugin';
+    pluginSkills?: string[];
+    pluginMcps?: string[];
+    pluginAgents?: string[];
+    pluginCommands?: string[];
+    installPath?: string;
+    managed?: boolean;
 }
 export interface AgentLiveConfig {
     agent: AgentName;
     configPath: string;
     exists: boolean;
     mcpServers: Record<string, AgentMcpEntry>;
+    remoteMcpServers: Record<string, PortableRemoteMcpMetadata>;
     skills: AgentSkillEntry[];
 }
 export interface AgentConfigReader {

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

@@ -1,6 +1,8 @@
 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 { readCodexPlugins, readInstalledPlugins } from './plugin-skill-reader.js';
 export function createClaudeReader() {
     return {
         async read(options) {
@@ -8,11 +10,25 @@ export function createClaudeReader() {
             try {
                 const source = await readFile(configPath, 'utf8');
                 const data = JSON.parse(source);
+                // Merge user-scoped MCPs (top-level) with project-scoped MCPs (project overrides user)
+                const userServers = (data.mcpServers ?? {});
                 const projects = (data.projects ?? {});
                 const projectConfig = projects[options.cwd] ?? {};
-                const rawServers = (projectConfig.mcpServers ?? {});
+                const projectServers = (projectConfig.mcpServers ?? {});
+                const rawServers = { ...userServers, ...projectServers };
                 const mcpServers = {};
+                const remoteMcpServers = {};
                 for (const [name, entry] of Object.entries(rawServers)) {
+                    if (isClaudeRemoteEntry(entry)) {
+                        const url = typeof entry.url === 'string' ? entry.url : '';
+                        remoteMcpServers[name] = {
+                            transport: entry.type === 'sse' ? 'sse' : 'http',
+                            url,
+                            headers: parseEnvObject(entry.headers),
+                            env: parseEnvObject(entry.env),
+                        };
+                        continue;
+                    }
                     mcpServers[name] = {
                         command: String(entry.command ?? ''),
                         args: Array.isArray(entry.args) ? entry.args.map(String) : undefined,
@@ -20,11 +36,26 @@ export function createClaudeReader() {
                     };
                 }
                 const skills = await readClaudePlugins();
-                return { agent: 'claude', configPath, exists: true, mcpServers, skills };
+                const filtered = filterPluginOwnedMcps({ mcpServers, remoteMcpServers, skills });
+                return {
+                    agent: 'claude',
+                    configPath,
+                    exists: true,
+                    mcpServers: filtered.mcpServers,
+                    remoteMcpServers: filtered.remoteMcpServers,
+                    skills,
+                };
             }
             catch {
                 const skills = await readClaudePlugins();
-                return { agent: 'claude', configPath, exists: false, mcpServers: {}, skills };
+                return {
+                    agent: 'claude',
+                    configPath,
+                    exists: false,
+                    mcpServers: {},
+                    remoteMcpServers: {},
+                    skills,
+                };
             }
         },
     };
@@ -35,13 +66,28 @@ export function createCodexReader() {
             const configPath = path.join(homedir(), '.codex', 'config.toml');
             try {
                 const source = await readFile(configPath, 'utf8');
-                const mcpServers = parseCodexToml(source);
+                const { mcpServers, remoteMcpServers } = parseCodexToml(source);
                 const skills = await readCodexSkills();
-                return { agent: 'codex', configPath, exists: true, mcpServers, skills };
+                const filtered = filterPluginOwnedMcps({ mcpServers, remoteMcpServers, skills });
+                return {
+                    agent: 'codex',
+                    configPath,
+                    exists: true,
+                    mcpServers: filtered.mcpServers,
+                    remoteMcpServers: filtered.remoteMcpServers,
+                    skills,
+                };
             }
             catch {
                 const skills = await readCodexSkills();
-                return { agent: 'codex', configPath, exists: false, mcpServers: {}, skills };
+                return {
+                    agent: 'codex',
+                    configPath,
+                    exists: false,
+                    mcpServers: {},
+                    remoteMcpServers: {},
+                    skills,
+                };
             }
         },
     };
@@ -50,28 +96,53 @@ export function createGeminiReader() {
     return {
         async read() {
             const configPath = path.join(homedir(), '.gemini', 'settings.json');
+            let rawServers = {};
+            let exists = false;
             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 };
+                rawServers = (data.mcpServers ?? {});
+                exists = true;
             }
             catch {
-                const skills = await readGeminiSkills();
-                return { agent: 'gemini', configPath, exists: false, mcpServers: {}, skills };
+                // no global config
             }
+            const mcpServers = {};
+            const remoteMcpServers = {};
+            for (const [name, entry] of Object.entries(rawServers)) {
+                const remoteEntry = toGeminiRemoteEntry(entry);
+                if (remoteEntry) {
+                    remoteMcpServers[name] = remoteEntry;
+                    continue;
+                }
+                mcpServers[name] = {
+                    command: String(entry.command ?? ''),
+                    args: Array.isArray(entry.args) ? entry.args.map(String) : undefined,
+                    env: parseEnvObject(entry.env),
+                };
+            }
+            const skills = await readGeminiSkills();
+            const filtered = filterPluginOwnedMcps({ mcpServers, remoteMcpServers, skills });
+            return {
+                agent: 'gemini',
+                configPath,
+                exists,
+                mcpServers: filtered.mcpServers,
+                remoteMcpServers: filtered.remoteMcpServers,
+                skills,
+            };
         },
     };
 }
+function filterPluginOwnedMcps(options) {
+    const pluginOwned = new Set(options.skills.flatMap((skill) => skill.pluginMcps ?? []));
+    if (pluginOwned.size === 0) {
+        return { mcpServers: options.mcpServers, remoteMcpServers: options.remoteMcpServers };
+    }
+    const mcpServers = Object.fromEntries(Object.entries(options.mcpServers).filter(([key]) => !pluginOwned.has(key)));
+    const remoteMcpServers = Object.fromEntries(Object.entries(options.remoteMcpServers).filter(([key]) => !pluginOwned.has(key)));
+    return { mcpServers, remoteMcpServers };
+}
 function parseEnvObject(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
         return undefined;
@@ -81,13 +152,40 @@ function parseEnvObject(value) {
     }
     return Object.keys(result).length > 0 ? result : undefined;
 }
+function isClaudeRemoteEntry(entry) {
+    if (typeof entry.url !== 'string' || entry.url.trim().length === 0) {
+        return false;
+    }
+    return entry.type === 'http' || entry.type === 'sse' || !('command' in entry);
+}
+function toGeminiRemoteEntry(entry) {
+    if (typeof entry.httpUrl === 'string' && entry.httpUrl.trim().length > 0) {
+        return {
+            transport: 'http',
+            url: entry.httpUrl,
+            headers: parseEnvObject(entry.headers),
+            env: parseEnvObject(entry.env),
+        };
+    }
+    if (typeof entry.url === 'string' && entry.url.trim().length > 0) {
+        return {
+            transport: 'sse',
+            url: entry.url,
+            headers: parseEnvObject(entry.headers),
+            env: parseEnvObject(entry.env),
+        };
+    }
+    return null;
+}
 function parseCodexToml(source) {
-    const servers = {};
+    const mcpServers = {};
+    const remoteMcpServers = {};
     const lines = source.split('\n');
     let currentServer = null;
     let inEnv = false;
     let currentEntry = { command: '' };
     let currentEnv = {};
+    let currentUrl = null;
     for (const line of lines) {
         const trimmed = line.trim();
         // Match [mcp_servers.name.env]
@@ -101,25 +199,37 @@ function parseCodexToml(source) {
         if (serverMatch) {
             // Save previous server
             if (currentServer) {
-                if (Object.keys(currentEnv).length > 0)
-                    currentEntry.env = currentEnv;
-                servers[currentServer] = currentEntry;
+                flushCodexServer({
+                    currentServer,
+                    currentEntry,
+                    currentEnv,
+                    currentUrl,
+                    mcpServers,
+                    remoteMcpServers,
+                });
             }
             currentServer = serverMatch[1];
             currentEntry = { command: '' };
             currentEnv = {};
+            currentUrl = null;
             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;
+                flushCodexServer({
+                    currentServer,
+                    currentEntry,
+                    currentEnv,
+                    currentUrl,
+                    mcpServers,
+                    remoteMcpServers,
+                });
                 currentServer = null;
                 currentEntry = { command: '' };
                 currentEnv = {};
+                currentUrl = null;
             }
             inEnv = false;
             continue;
@@ -132,6 +242,9 @@ function parseCodexToml(source) {
         if (inEnv) {
             currentEnv[key] = parseTomlValue(rawValue);
         }
+        else if (key === 'url') {
+            currentUrl = parseTomlValue(rawValue);
+        }
         else if (key === 'command') {
             currentEntry.command = parseTomlValue(rawValue);
         }
@@ -141,11 +254,29 @@ function parseCodexToml(source) {
     }
     // Flush last server
     if (currentServer) {
-        if (Object.keys(currentEnv).length > 0)
-            currentEntry.env = currentEnv;
-        servers[currentServer] = currentEntry;
+        flushCodexServer({
+            currentServer,
+            currentEntry,
+            currentEnv,
+            currentUrl,
+            mcpServers,
+            remoteMcpServers,
+        });
+    }
+    return { mcpServers, remoteMcpServers };
+}
+function flushCodexServer(options) {
+    const { currentServer, currentEntry, currentEnv, currentUrl, mcpServers, remoteMcpServers } = options;
+    if (currentUrl) {
+        remoteMcpServers[currentServer] = {
+            transport: 'http',
+            url: currentUrl,
+        };
+        return;
     }
-    return servers;
+    if (Object.keys(currentEnv).length > 0)
+        currentEntry.env = currentEnv;
+    mcpServers[currentServer] = currentEntry;
 }
 function parseTomlValue(raw) {
     const trimmed = raw.trim();
@@ -170,37 +301,59 @@ function parseTomlArray(raw) {
 }
 /* ---- Skill readers ---- */
 async function readClaudePlugins() {
+    const results = [];
+    // Read marketplace plugins
     try {
         const pluginsPath = path.join(homedir(), '.claude', 'plugins', 'installed_plugins.json');
-        const source = await readFile(pluginsPath, 'utf8');
-        const data = JSON.parse(source);
-        if (!data.plugins)
-            return [];
-        return Object.keys(data.plugins).map((key) => {
-            const [name, source] = key.split('@');
-            return { name, source };
-        });
+        results.push(...await readInstalledPlugins(pluginsPath));
     }
     catch {
-        return [];
+        // 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() {
+    const configTomlPath = path.join(homedir(), '.codex', 'config.toml');
+    const pluginsCacheDir = path.join(homedir(), '.codex', 'plugins', 'cache');
+    const nativePlugins = await readCodexPlugins({ configTomlPath, pluginsCacheDir });
+    const managedPlugins = await readManagedPlugins({ agent: 'codex' });
+    let localSkills = [];
     try {
         const skillsDir = path.join(homedir(), '.codex', 'skills');
-        return await readSkillDirs(skillsDir);
+        localSkills = await readSkillDirs(skillsDir);
     }
     catch {
-        return [];
+        localSkills = [];
     }
+    const allPlugins = dedupePluginsByName([...managedPlugins, ...nativePlugins]);
+    return mergeManagedPluginsIntoSkills(localSkills, allPlugins);
+}
+function dedupePluginsByName(plugins) {
+    const seen = new Map();
+    for (const plugin of plugins) {
+        if (!seen.has(plugin.name))
+            seen.set(plugin.name, plugin);
+    }
+    return Array.from(seen.values());
 }
 async function readGeminiSkills() {
     try {
         const skillsDir = path.join(homedir(), '.gemini', 'skills');
-        return await readSkillDirs(skillsDir);
+        const localSkills = await readSkillDirs(skillsDir);
+        const managedPlugins = await readManagedPlugins({ agent: 'gemini' });
+        return mergeManagedPluginsIntoSkills(localSkills, managedPlugins);
     }
     catch {
-        return [];
+        return await readManagedPlugins({ agent: 'gemini' });
     }
 }
 /** Shared: read skill directories (Codex and Gemini use the same SKILL.md convention) */
@@ -211,10 +364,10 @@ async function readSkillDirs(skillsDir) {
         if (entry.name.startsWith('.'))
             continue;
         if (entry.isDirectory()) {
-            skills.push({ name: entry.name, source: 'local' });
+            skills.push({ name: entry.name, source: 'local', kind: 'skill' });
         }
         else if (entry.isSymbolicLink()) {
-            skills.push({ name: entry.name, source: 'linked' });
+            skills.push({ name: entry.name, source: 'linked', kind: 'skill' });
         }
     }
     return skills;

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

@@ -28,12 +28,6 @@ export function createClaudeWriter() {
             for (const [name, config] of Object.entries(options.mcpServers)) {
                 mcpServers[name] = toClaudeFormat(config);
             }
-            // Always include brainctl itself
-            mcpServers['brainctl'] = {
-                type: 'stdio',
-                command: 'npx',
-                args: ['-y', 'brainctl', 'mcp'],
-            };
             // Merge into existing config (preserve other projects)
             const projects = (existing.projects ?? {});
             const projectConfig = projects[options.cwd] ?? {};
@@ -65,7 +59,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.d.ts

@@ -1,2 +1,3 @@
 import type { AgentConfigWriter } from './agent-writer.js';
 export declare function createCodexWriter(): AgentConfigWriter;
+export declare function stripPluginSection(content: string, pluginKey: string): string;

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

@@ -24,13 +24,7 @@ export function createCodexWriter() {
                 backedUpTo = backupPath;
             }
             // Build MCP servers section
-            const allServers = { ...options.mcpServers };
-            // Always include brainctl itself
-            allServers['brainctl'] = {
-                type: 'npm',
-                package: 'brainctl',
-            };
-            const mcpToml = buildMcpToml(allServers);
+            const mcpToml = buildMcpToml(options.mcpServers);
             // Preserve non-mcp_servers content from existing config
             const existingNonMcp = stripMcpSections(existingContent);
             const finalContent = existingNonMcp.trim().length > 0
@@ -71,7 +65,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)}]`);
         }
@@ -96,6 +93,26 @@ function buildMcpToml(servers) {
 function tomlString(value) {
     return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
 }
+export function stripPluginSection(content, pluginKey) {
+    const target = `[plugins."${pluginKey}"]`;
+    const lines = content.split('\n');
+    const result = [];
+    let inTarget = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed === target) {
+            inTarget = true;
+            continue;
+        }
+        if (inTarget && /^\[/.test(trimmed)) {
+            inTarget = false;
+        }
+        if (!inTarget) {
+            result.push(line);
+        }
+    }
+    return result.join('\n');
+}
 function stripMcpSections(content) {
     const lines = content.split('\n');
     const result = [];

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

@@ -1,11 +1,13 @@
 import { copyFile, mkdir, readdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
 import path from 'node:path';
 import { SyncError } from '../../errors.js';
 import { formatTimestamp } from './agent-writer.js';
 export function createGeminiWriter() {
     return {
         async write(options) {
-            const geminiDir = path.join(options.cwd, '.gemini');
+            void options.cwd;
+            const geminiDir = path.join(homedir(), '.gemini');
             const configPath = path.join(geminiDir, 'settings.json');
             let existing = {};
             let backedUpTo = null;
@@ -28,11 +30,6 @@ export function createGeminiWriter() {
             for (const [name, config] of Object.entries(options.mcpServers)) {
                 mcpServers[name] = toGeminiFormat(config);
             }
-            // Always include brainctl itself
-            mcpServers['brainctl'] = {
-                command: 'npx',
-                args: ['-y', 'brainctl', 'mcp'],
-            };
             // Merge into existing config (preserve other settings)
             existing.mcpServers = mcpServers;
             // Atomic write
@@ -43,7 +40,8 @@ export function createGeminiWriter() {
             return { configPath, backedUpTo };
         },
         async restore(options) {
-            const configPath = path.join(options.cwd, '.gemini', 'settings.json');
+            void options.cwd;
+            const configPath = path.join(homedir(), '.gemini', 'settings.json');
             const dir = path.dirname(configPath);
             const base = path.basename(configPath);
             let entries;
@@ -67,7 +65,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[];