brainctl 0.1.7 → 0.1.9

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

@@ -2,7 +2,7 @@ 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';
+import { readCodexPlugins, readInstalledPlugins } from './plugin-skill-reader.js';
 export function createClaudeReader() {
     return {
         async read(options) {
@@ -10,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,
@@ -22,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,
+                };
             }
         },
     };
@@ -37,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,
+                };
             }
         },
     };
@@ -52,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;
@@ -83,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]
@@ -103,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;
@@ -134,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);
         }
@@ -143,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 servers;
+    return { mcpServers, remoteMcpServers };
+}
+function flushCodexServer(options) {
+    const { currentServer, currentEntry, currentEnv, currentUrl, mcpServers, remoteMcpServers } = options;
+    if (currentUrl) {
+        remoteMcpServers[currentServer] = {
+            transport: 'http',
+            url: currentUrl,
+        };
+        return;
+    }
+    if (Object.keys(currentEnv).length > 0)
+        currentEntry.env = currentEnv;
+    mcpServers[currentServer] = currentEntry;
 }
 function parseTomlValue(raw) {
     const trimmed = raw.trim();
@@ -193,15 +322,28 @@ async function readClaudePlugins() {
     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');
-        const localSkills = await readSkillDirs(skillsDir);
-        const managedPlugins = await readManagedPlugins({ agent: 'codex' });
-        return mergeManagedPluginsIntoSkills(localSkills, managedPlugins);
+        localSkills = await readSkillDirs(skillsDir);
     }
     catch {
-        return await readManagedPlugins({ agent: 'codex' });
+        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 {

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] ?? {};

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,14 +24,7 @@ export function createCodexWriter() {
                 backedUpTo = backupPath;
             }
             // Build MCP servers section
-            const allServers = { ...options.mcpServers };
-            // Always include brainctl itself
-            allServers['brainctl'] = {
-                kind: 'local',
-                source: '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
@@ -100,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;

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

@@ -1,2 +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

@@ -1,4 +1,4 @@
-import { readFile, readdir } from 'node:fs/promises';
+import { readFile, readdir, stat } from 'node:fs/promises';
 import path from 'node:path';
 export async function readInstalledPlugins(installedPluginsPath) {
     const source = await readFile(installedPluginsPath, 'utf8');
@@ -8,12 +8,18 @@ export async function readInstalledPlugins(installedPluginsPath) {
         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;
@@ -31,3 +37,138 @@ async function readPluginSkills(installPath) {
         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

@@ -40,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 {};