brainctl 0.1.5 → 0.1.6

package/dist/services/agent-config-service.js

@@ -0,0 +1,189 @@
+import { copyFile, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { createClaudeReader, createCodexReader, createGeminiReader, } from './sync/agent-reader.js';
+import { formatTimestamp } from './sync/agent-writer.js';
+const readers = {
+    claude: createClaudeReader(),
+    codex: createCodexReader(),
+    gemini: createGeminiReader(),
+};
+export function createAgentConfigService() {
+    return {
+        async readAll(options) {
+            const results = await Promise.all([
+                readers.claude.read(options),
+                readers.codex.read(options),
+                readers.gemini.read(options),
+            ]);
+            return results;
+        },
+        async addMcp(options) {
+            const { cwd, agent, key, entry } = options;
+            if (agent === 'claude') {
+                await mutateClaudeConfig(cwd, (servers) => {
+                    servers[key] = toClaudeEntry(entry);
+                });
+            }
+            else if (agent === 'codex') {
+                await mutateCodexConfig((servers) => {
+                    servers[key] = entry;
+                });
+            }
+            else if (agent === 'gemini') {
+                await mutateGeminiConfig(cwd, (servers) => {
+                    servers[key] = toGeminiEntry(entry);
+                });
+            }
+        },
+        async removeMcp(options) {
+            const { cwd, agent, key } = options;
+            if (agent === 'claude') {
+                await mutateClaudeConfig(cwd, (servers) => {
+                    delete servers[key];
+                });
+            }
+            else if (agent === 'codex') {
+                await mutateCodexConfig((servers) => {
+                    delete servers[key];
+                });
+            }
+            else if (agent === 'gemini') {
+                await mutateGeminiConfig(cwd, (servers) => {
+                    delete servers[key];
+                });
+            }
+        },
+    };
+}
+/* ---- Claude: JSON with projects[cwd].mcpServers ---- */
+async function mutateClaudeConfig(cwd, mutate) {
+    const configPath = path.join(homedir(), '.claude.json');
+    let existing = {};
+    try {
+        existing = JSON.parse(await readFile(configPath, 'utf8'));
+        await backupFile(configPath);
+    }
+    catch {
+        // fresh config
+    }
+    const projects = (existing.projects ?? {});
+    const projectConfig = projects[cwd] ?? {};
+    const servers = (projectConfig.mcpServers ?? {});
+    mutate(servers);
+    projectConfig.mcpServers = servers;
+    projects[cwd] = projectConfig;
+    existing.projects = projects;
+    await atomicWriteJson(configPath, existing);
+}
+function toClaudeEntry(entry) {
+    return {
+        type: 'stdio',
+        command: entry.command,
+        args: entry.args ?? [],
+        ...(entry.env ? { env: entry.env } : {}),
+    };
+}
+/* ---- Codex: TOML with [mcp_servers.*] ---- */
+async function mutateCodexConfig(mutate) {
+    const configPath = path.join(homedir(), '.codex', 'config.toml');
+    let existingContent = '';
+    try {
+        existingContent = await readFile(configPath, 'utf8');
+        await backupFile(configPath);
+    }
+    catch {
+        // fresh config
+    }
+    // Read current servers via reader
+    const current = await readers.codex.read({ cwd: '' });
+    const servers = { ...current.mcpServers };
+    mutate(servers);
+    // Rebuild: preserve non-mcp content + new mcp sections
+    const nonMcp = stripCodexMcpSections(existingContent).trim();
+    const mcpToml = buildCodexMcpToml(servers);
+    const final = nonMcp.length > 0 ? `${nonMcp}\n\n${mcpToml}` : mcpToml;
+    await mkdir(path.dirname(configPath), { recursive: true });
+    await atomicWrite(configPath, final + '\n');
+}
+function stripCodexMcpSections(content) {
+    const lines = content.split('\n');
+    const result = [];
+    let inMcp = false;
+    for (const line of lines) {
+        if (/^\[mcp_servers[\].]/.test(line)) {
+            inMcp = true;
+            continue;
+        }
+        if (inMcp && /^\[/.test(line) && !/^\[mcp_servers[\].]/.test(line)) {
+            inMcp = false;
+        }
+        if (!inMcp)
+            result.push(line);
+    }
+    return result.join('\n');
+}
+function buildCodexMcpToml(servers) {
+    const lines = [];
+    for (const [name, entry] of Object.entries(servers)) {
+        lines.push(`[mcp_servers.${name}]`);
+        lines.push(`command = ${tomlStr(entry.command)}`);
+        if (entry.args && entry.args.length > 0) {
+            lines.push(`args = [${entry.args.map(tomlStr).join(', ')}]`);
+        }
+        if (entry.env && Object.keys(entry.env).length > 0) {
+            lines.push('');
+            lines.push(`[mcp_servers.${name}.env]`);
+            for (const [k, v] of Object.entries(entry.env)) {
+                lines.push(`${k} = ${tomlStr(v)}`);
+            }
+        }
+        lines.push('');
+    }
+    return lines.join('\n').trim();
+}
+function tomlStr(value) {
+    return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+/* ---- Gemini: JSON with mcpServers ---- */
+async function mutateGeminiConfig(_cwd, mutate) {
+    const configPath = path.join(homedir(), '.gemini', 'settings.json');
+    let existing = {};
+    try {
+        existing = JSON.parse(await readFile(configPath, 'utf8'));
+        await backupFile(configPath);
+    }
+    catch {
+        // fresh config
+    }
+    const servers = (existing.mcpServers ?? {});
+    mutate(servers);
+    existing.mcpServers = servers;
+    await mkdir(path.dirname(configPath), { recursive: true });
+    await atomicWriteJson(configPath, existing);
+}
+function toGeminiEntry(entry) {
+    return {
+        command: entry.command,
+        args: entry.args ?? [],
+        ...(entry.env ? { env: entry.env } : {}),
+    };
+}
+/* ---- Shared helpers ---- */
+async function backupFile(filePath) {
+    const backupPath = `${filePath}.bak.${formatTimestamp()}`;
+    try {
+        await copyFile(filePath, backupPath);
+    }
+    catch {
+        // File may not exist yet
+    }
+}
+async function atomicWriteJson(filePath, data) {
+    await atomicWrite(filePath, JSON.stringify(data, null, 2) + '\n');
+}
+async function atomicWrite(filePath, content) {
+    const tmpPath = `${filePath}.tmp.${Date.now()}`;
+    await writeFile(tmpPath, content, 'utf8');
+    await rename(tmpPath, filePath);
+}

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

@@ -17,6 +17,15 @@ export interface ProfileService {
     }): Promise<{
         profilePath: string;
     }>;
+    update(options: {
+        cwd?: string;
+        name: string;
+        config: ProfileConfig;
+    }): Promise<void>;
+    delete(options: {
+        cwd?: string;
+        name: string;
+    }): Promise<void>;
     use(options: {
         cwd?: string;
         name: string;

package/dist/services/profile-service.js

@@ -1,4 +1,4 @@
-import { readdir, readFile, writeFile, mkdir, stat } from 'node:fs/promises';
+import { readdir, readFile, writeFile, mkdir, stat, unlink } from 'node:fs/promises';
 import path from 'node:path';
 import YAML from 'yaml';
 import { ProfileError, ProfileNotFoundError } from '../errors.js';
@@ -64,6 +64,33 @@ export function createProfileService() {
             await writeFile(profilePath, YAML.stringify(scaffold), 'utf8');
             return { profilePath };
         },
+        async update(options) {
+            const cwd = options.cwd ?? process.cwd();
+            const profilePath = path.join(cwd, PROFILES_DIR, `${options.name}.yaml`);
+            if (!(await pathExists(profilePath))) {
+                throw new ProfileNotFoundError(`Profile "${options.name}" not found.`);
+            }
+            const data = {
+                name: options.config.name,
+                ...(options.config.description ? { description: options.config.description } : {}),
+                skills: options.config.skills,
+                mcps: options.config.mcps,
+                memory: options.config.memory,
+            };
+            await writeFile(profilePath, YAML.stringify(data), 'utf8');
+        },
+        async delete(options) {
+            const cwd = options.cwd ?? process.cwd();
+            const profilePath = path.join(cwd, PROFILES_DIR, `${options.name}.yaml`);
+            if (!(await pathExists(profilePath))) {
+                throw new ProfileNotFoundError(`Profile "${options.name}" not found.`);
+            }
+            const meta = await loadMetaConfig(cwd);
+            if (meta.active_profile === options.name) {
+                throw new ProfileError('Cannot delete the active profile.');
+            }
+            await unlink(profilePath);
+        },
         async use(options) {
             const cwd = options.cwd ?? process.cwd();
             // Validate profile exists

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

@@ -0,0 +1,25 @@
+import type { AgentName } from '../../types.js';
+export interface AgentMcpEntry {
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+}
+export interface AgentSkillEntry {
+    name: string;
+    source?: string;
+}
+export interface AgentLiveConfig {
+    agent: AgentName;
+    configPath: string;
+    exists: boolean;
+    mcpServers: Record<string, AgentMcpEntry>;
+    skills: AgentSkillEntry[];
+}
+export interface AgentConfigReader {
+    read(options: {
+        cwd: string;
+    }): Promise<AgentLiveConfig>;
+}
+export declare function createClaudeReader(): AgentConfigReader;
+export declare function createCodexReader(): AgentConfigReader;
+export declare function createGeminiReader(): AgentConfigReader;

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

@@ -0,0 +1,221 @@
+import { readFile, readdir } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+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() {
+    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 };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+async function readCodexSkills() {
+    try {
+        const skillsDir = path.join(homedir(), '.codex', 'skills');
+        return await readSkillDirs(skillsDir);
+    }
+    catch {
+        return [];
+    }
+}
+async function readGeminiSkills() {
+    try {
+        const skillsDir = path.join(homedir(), '.gemini', 'skills');
+        return await readSkillDirs(skillsDir);
+    }
+    catch {
+        return [];
+    }
+}
+/** 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' });
+        }
+        else if (entry.isSymbolicLink()) {
+            skills.push({ name: entry.name, source: 'linked' });
+        }
+    }
+    return skills;
+}