brainctl 0.1.6 → 0.1.9

package/dist/executor/resolver.js

@@ -1,9 +1,7 @@
-import { access } from 'node:fs/promises';
-import { constants } from 'node:fs';
-import path from 'node:path';
 import { AgentNotAvailableError } from '../errors.js';
 import { ClaudeExecutor } from './claude.js';
 import { CodexExecutor } from './codex.js';
+import { findExecutable } from '../system/executables.js';
 const SUPPORTED_AGENTS = ['claude', 'codex', 'gemini'];
 const AGENT_COMMANDS = {
     claude: 'claude',
@@ -60,38 +58,3 @@ async function checkAvailability(agentName) {
         resolvedPath: resolvedPath ?? undefined
     };
 }
-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/mcp/server.js

@@ -1,3 +1,4 @@
+import { spawn } from 'node:child_process';
 import { readFileSync } from 'node:fs';
 import path from 'node:path';
 import { FastMCP } from 'fastmcp';
@@ -6,6 +7,7 @@ import { loadConfig } from '../config.js';
 import { loadMemory } from '../context/memory.js';
 import { createAgentConfigService } from '../services/agent-config-service.js';
 import { createDoctorService } from '../services/doctor-service.js';
+import { startUiServer } from '../ui/server.js';
 import { createMemoryWriteService } from '../services/memory-write-service.js';
 import { createProfileExportService } from '../services/profile-export-service.js';
 import { createProfileImportService } from '../services/profile-import-service.js';
@@ -287,14 +289,20 @@ export function createMcpServer(options = {}) {
         name: 'brainctl_export_profile',
         description: 'Export a profile as a portable tarball. Packages the profile config and bundled MCP source code for sharing.',
         parameters: z.object({
-            name: z.string().describe('Profile name to export'),
+            name: z.string().optional().describe('Profile name to export'),
+            agent: z.enum(['claude', 'codex', 'gemini']).optional().describe('Pack a live agent config instead of a saved profile'),
             output_path: z.string().optional().describe('Output file path (defaults to <name>.tar.gz in cwd)'),
         }),
         execute: async (args) => {
+            if (!args.name && !args.agent) {
+                return JSON.stringify({ error: 'Provide name or agent.' }, null, 2);
+            }
             const exportService = createProfileExportService();
             const result = await exportService.execute({
                 cwd,
-                name: args.name,
+                source: args.agent
+                    ? { source: 'agent', agent: args.agent, cwd }
+                    : { source: 'profile', name: args.name },
                 outputPath: args.output_path,
             });
             return JSON.stringify(result, null, 2);
@@ -306,6 +314,7 @@ export function createMcpServer(options = {}) {
         parameters: z.object({
             archive_path: z.string().describe('Path to the profile tarball'),
             force: z.boolean().default(false).describe('Overwrite existing profile if it exists'),
+            credentials: z.record(z.string(), z.string()).optional().describe('Credential values keyed by placeholder name'),
         }),
         execute: async (args) => {
             const importService = createProfileImportService();
@@ -313,10 +322,60 @@ export function createMcpServer(options = {}) {
                 cwd,
                 archivePath: args.archive_path,
                 force: args.force,
+                credentials: args.credentials,
             });
             return JSON.stringify(result, null, 2);
         },
     });
+    let uiServerInstance = null;
+    server.addTool({
+        name: 'brainctl_open_ui',
+        description: 'Start the brainctl web dashboard and open it in the default browser. Returns the URL. If already running, reopens the existing URL in the browser.',
+        parameters: z.object({
+            port: z.number().default(3333).describe('Port number for the UI server'),
+            openBrowser: z
+                .boolean()
+                .default(true)
+                .describe('Whether to launch the default browser at the UI URL'),
+        }),
+        execute: async (args) => {
+            if (uiServerInstance) {
+                if (args.openBrowser)
+                    openInBrowser(uiServerInstance.url);
+                return JSON.stringify({
+                    url: uiServerInstance.url,
+                    status: 'already_running',
+                    browserOpened: args.openBrowser,
+                });
+            }
+            try {
+                uiServerInstance = await startUiServer({ cwd, port: args.port });
+                if (args.openBrowser)
+                    openInBrowser(uiServerInstance.url);
+                return JSON.stringify({
+                    url: uiServerInstance.url,
+                    status: 'started',
+                    browserOpened: args.openBrowser,
+                });
+            }
+            catch (err) {
+                return JSON.stringify({ error: err.message, status: 'failed' });
+            }
+        },
+    });
+    server.addTool({
+        name: 'brainctl_close_ui',
+        description: 'Stop the brainctl web dashboard if it is running.',
+        parameters: z.object({}),
+        execute: async () => {
+            if (!uiServerInstance) {
+                return JSON.stringify({ status: 'not_running' });
+            }
+            await uiServerInstance.close();
+            uiServerInstance = null;
+            return JSON.stringify({ status: 'stopped' });
+        },
+    });
     server.addTool({
         name: 'brainctl_read_agent_configs',
         description: 'Read the live MCP configs from all agents (Claude, Codex, Gemini). Shows what is actually configured in each agent right now, by reading their real config files.',
@@ -366,3 +425,24 @@ export async function startMcpServer(options = {}) {
     const server = createMcpServer(options);
     await server.start({ transportType: 'stdio' });
 }
+function openInBrowser(url) {
+    const platform = process.platform;
+    const { command, args } = platform === 'darwin'
+        ? { command: 'open', args: [url] }
+        : platform === 'win32'
+            ? { command: 'cmd', args: ['/c', 'start', '""', url] }
+            : { command: 'xdg-open', args: [url] };
+    try {
+        const child = spawn(command, args, {
+            detached: true,
+            stdio: 'ignore',
+        });
+        child.on('error', () => {
+            // Browser open is best-effort; swallow errors so the MCP call still succeeds.
+        });
+        child.unref();
+    }
+    catch {
+        // ignore
+    }
+}

package/dist/services/agent-config-service.d.ts

@@ -1,6 +1,9 @@
 import type { AgentName } from '../types.js';
-import { type AgentLiveConfig, type AgentMcpEntry } from './sync/agent-reader.js';
+import { type AgentLiveConfig, type AgentMcpEntry, type PortableRemoteMcpMetadata } from './sync/agent-reader.js';
+import { type McpPreflightService } from './mcp-preflight-service.js';
+import { type SkillPreflightService } from './skill-preflight-service.js';
 export type { AgentLiveConfig, AgentMcpEntry, AgentSkillEntry } from './sync/agent-reader.js';
+export type { PortableRemoteMcpMetadata } from './sync/agent-reader.js';
 export interface AgentConfigService {
     readAll(options: {
         cwd: string;
@@ -9,12 +12,26 @@ export interface AgentConfigService {
         cwd: string;
         agent: AgentName;
         key: string;
-        entry: AgentMcpEntry;
+        entry?: AgentMcpEntry;
+        remoteEntry?: PortableRemoteMcpMetadata;
     }): Promise<void>;
     removeMcp(options: {
         cwd: string;
         agent: AgentName;
         key: string;
     }): Promise<void>;
+    copySkill(options: {
+        sourceAgent: AgentName;
+        targetAgent: AgentName;
+        skillName: string;
+    }): Promise<void>;
+    removeSkill(options: {
+        agent: AgentName;
+        skillName: string;
+    }): Promise<void>;
+}
+interface AgentConfigServiceDependencies {
+    mcpPreflightService?: McpPreflightService;
+    skillPreflightService?: SkillPreflightService;
 }
-export declare function createAgentConfigService(): AgentConfigService;
+export declare function createAgentConfigService(dependencies?: AgentConfigServiceDependencies): AgentConfigService;

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

@@ -1,14 +1,20 @@
-import { copyFile, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { copyFile, cp, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import path from 'node:path';
+import { ValidationError } from '../errors.js';
 import { createClaudeReader, createCodexReader, createGeminiReader, } from './sync/agent-reader.js';
 import { formatTimestamp } from './sync/agent-writer.js';
+import { createMcpPreflightService } from './mcp-preflight-service.js';
+import { createSkillPreflightService } from './skill-preflight-service.js';
+import { getSkillDir } from './skill-paths.js';
 const readers = {
     claude: createClaudeReader(),
     codex: createCodexReader(),
     gemini: createGeminiReader(),
 };
-export function createAgentConfigService() {
+export function createAgentConfigService(dependencies = {}) {
+    const mcpPreflightService = dependencies.mcpPreflightService ?? createMcpPreflightService();
+    const skillPreflightService = dependencies.skillPreflightService ?? createSkillPreflightService();
     return {
         async readAll(options) {
             const results = await Promise.all([
@@ -19,20 +25,32 @@ export function createAgentConfigService() {
             return results;
         },
         async addMcp(options) {
-            const { cwd, agent, key, entry } = options;
+            const { cwd, agent, key, entry, remoteEntry } = options;
+            const preflight = await mcpPreflightService.execute({ cwd, agent, key, entry, remoteEntry });
+            const firstError = preflight.checks.find((check) => check.status === 'error');
+            if (firstError) {
+                throw new ValidationError(`MCP "${key}" cannot be added to ${agent}: ${firstError.message}`);
+            }
             if (agent === 'claude') {
                 await mutateClaudeConfig(cwd, (servers) => {
-                    servers[key] = toClaudeEntry(entry);
+                    servers[key] = remoteEntry ? toClaudeRemoteEntry(remoteEntry) : toClaudeEntry(entry);
                 });
             }
             else if (agent === 'codex') {
-                await mutateCodexConfig((servers) => {
-                    servers[key] = entry;
+                await mutateCodexConfig(cwd, (state) => {
+                    delete state.mcpServers[key];
+                    delete state.remoteMcpServers[key];
+                    if (remoteEntry) {
+                        state.remoteMcpServers[key] = remoteEntry;
+                    }
+                    else {
+                        state.mcpServers[key] = entry;
+                    }
                 });
             }
             else if (agent === 'gemini') {
                 await mutateGeminiConfig(cwd, (servers) => {
-                    servers[key] = toGeminiEntry(entry);
+                    servers[key] = remoteEntry ? toGeminiRemoteEntry(remoteEntry) : toGeminiEntry(entry);
                 });
             }
         },
@@ -44,8 +62,9 @@ export function createAgentConfigService() {
                 });
             }
             else if (agent === 'codex') {
-                await mutateCodexConfig((servers) => {
-                    delete servers[key];
+                await mutateCodexConfig(cwd, (state) => {
+                    delete state.mcpServers[key];
+                    delete state.remoteMcpServers[key];
                 });
             }
             else if (agent === 'gemini') {
@@ -54,6 +73,28 @@ export function createAgentConfigService() {
                 });
             }
         },
+        async copySkill(options) {
+            const { sourceAgent, targetAgent, skillName } = options;
+            const preflight = await skillPreflightService.execute({
+                sourceAgent,
+                targetAgent,
+                skillName,
+                source: 'local',
+            });
+            const firstError = preflight.checks.find((check) => check.status === 'error');
+            if (firstError) {
+                throw new ValidationError(`Skill "${skillName}" cannot be copied from ${sourceAgent} to ${targetAgent}: ${firstError.message}`);
+            }
+            const sourceDir = getSkillDir(sourceAgent, skillName);
+            const targetDir = getSkillDir(targetAgent, skillName);
+            await mkdir(path.dirname(targetDir), { recursive: true });
+            await cp(sourceDir, targetDir, { recursive: true });
+        },
+        async removeSkill(options) {
+            const { agent, skillName } = options;
+            const skillDir = getSkillDir(agent, skillName);
+            await rm(skillDir, { recursive: true, force: true });
+        },
     };
 }
 /* ---- Claude: JSON with projects[cwd].mcpServers ---- */
@@ -67,6 +108,11 @@ async function mutateClaudeConfig(cwd, mutate) {
     catch {
         // fresh config
     }
+    // Apply mutation to user-scoped (top-level) MCPs
+    const userServers = (existing.mcpServers ?? {});
+    mutate(userServers);
+    existing.mcpServers = userServers;
+    // Apply mutation to project-scoped MCPs
     const projects = (existing.projects ?? {});
     const projectConfig = projects[cwd] ?? {};
     const servers = (projectConfig.mcpServers ?? {});
@@ -84,8 +130,15 @@ function toClaudeEntry(entry) {
         ...(entry.env ? { env: entry.env } : {}),
     };
 }
+function toClaudeRemoteEntry(entry) {
+    return {
+        type: entry.transport === 'sse' ? 'sse' : 'http',
+        url: entry.url,
+        ...(entry.headers ? { headers: entry.headers } : {}),
+    };
+}
 /* ---- Codex: TOML with [mcp_servers.*] ---- */
-async function mutateCodexConfig(mutate) {
+async function mutateCodexConfig(cwd, mutate) {
     const configPath = path.join(homedir(), '.codex', 'config.toml');
     let existingContent = '';
     try {
@@ -96,12 +149,15 @@ async function mutateCodexConfig(mutate) {
         // fresh config
     }
     // Read current servers via reader
-    const current = await readers.codex.read({ cwd: '' });
-    const servers = { ...current.mcpServers };
-    mutate(servers);
+    const current = await readers.codex.read({ cwd });
+    const state = {
+        mcpServers: { ...current.mcpServers },
+        remoteMcpServers: { ...current.remoteMcpServers },
+    };
+    mutate(state);
     // Rebuild: preserve non-mcp content + new mcp sections
     const nonMcp = stripCodexMcpSections(existingContent).trim();
-    const mcpToml = buildCodexMcpToml(servers);
+    const mcpToml = buildCodexMcpToml(state);
     const final = nonMcp.length > 0 ? `${nonMcp}\n\n${mcpToml}` : mcpToml;
     await mkdir(path.dirname(configPath), { recursive: true });
     await atomicWrite(configPath, final + '\n');
@@ -123,9 +179,9 @@ function stripCodexMcpSections(content) {
     }
     return result.join('\n');
 }
-function buildCodexMcpToml(servers) {
+function buildCodexMcpToml(state) {
     const lines = [];
-    for (const [name, entry] of Object.entries(servers)) {
+    for (const [name, entry] of Object.entries(state.mcpServers)) {
         lines.push(`[mcp_servers.${name}]`);
         lines.push(`command = ${tomlStr(entry.command)}`);
         if (entry.args && entry.args.length > 0) {
@@ -140,6 +196,11 @@ function buildCodexMcpToml(servers) {
         }
         lines.push('');
     }
+    for (const [name, entry] of Object.entries(state.remoteMcpServers)) {
+        lines.push(`[mcp_servers.${name}]`);
+        lines.push(`url = ${tomlStr(entry.url)}`);
+        lines.push('');
+    }
     return lines.join('\n').trim();
 }
 function tomlStr(value) {
@@ -169,6 +230,13 @@ function toGeminiEntry(entry) {
         ...(entry.env ? { env: entry.env } : {}),
     };
 }
+function toGeminiRemoteEntry(entry) {
+    return {
+        ...(entry.transport === 'http' ? { httpUrl: entry.url } : { url: entry.url }),
+        ...(entry.headers ? { headers: entry.headers } : {}),
+        ...(entry.env ? { env: entry.env } : {}),
+    };
+}
 /* ---- Shared helpers ---- */
 async function backupFile(filePath) {
     const backupPath = `${filePath}.bak.${formatTimestamp()}`;

package/dist/services/agent-converter-service.d.ts

@@ -0,0 +1,21 @@
+export interface ParsedClaudeAgent {
+    frontmatter: Record<string, unknown>;
+    body: string;
+}
+export interface ParsedCodexAgent {
+    name: string;
+    description: string;
+    developerInstructions: string;
+    sandboxMode?: string;
+    model?: string;
+    extra: Record<string, unknown>;
+}
+export declare function parseMarkdownWithFrontmatter(source: string): ParsedClaudeAgent;
+export declare function serializeMarkdownWithFrontmatter(frontmatter: Record<string, unknown>, body: string): string;
+export declare function claudeAgentMdToCodexToml(source: string): string;
+export declare function codexAgentTomlToClaudeMd(source: string): string;
+export declare function claudeCommandMdToCodexSkill(source: string): {
+    frontmatter: Record<string, unknown>;
+    skillMarkdown: string;
+};
+export declare function parseCodexAgentToml(source: string): ParsedCodexAgent;

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

@@ -0,0 +1,182 @@
+import YAML from 'yaml';
+const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+export function parseMarkdownWithFrontmatter(source) {
+    const match = source.match(FRONTMATTER_RE);
+    if (!match) {
+        return { frontmatter: {}, body: source };
+    }
+    const parsed = YAML.parse(match[1]);
+    return {
+        frontmatter: parsed ?? {},
+        body: match[2],
+    };
+}
+export function serializeMarkdownWithFrontmatter(frontmatter, body) {
+    const keys = Object.keys(frontmatter);
+    if (keys.length === 0)
+        return body;
+    const yaml = YAML.stringify(frontmatter).trimEnd();
+    const normalizedBody = body.startsWith('\n') ? body : `\n${body}`;
+    return `---\n${yaml}\n---${normalizedBody}`;
+}
+export function claudeAgentMdToCodexToml(source) {
+    const { frontmatter, body } = parseMarkdownWithFrontmatter(source);
+    const name = String(frontmatter.name ?? '').trim();
+    const description = String(frontmatter.description ?? '').trim();
+    if (!name)
+        throw new Error('Claude agent is missing required "name" frontmatter field.');
+    if (!description)
+        throw new Error('Claude agent is missing required "description" frontmatter field.');
+    const sandboxMode = inferSandboxModeFromClaudeTools(frontmatter.tools);
+    const lines = [];
+    lines.push(`name = ${tomlString(name)}`);
+    lines.push(`description = ${tomlString(description)}`);
+    lines.push(`developer_instructions = ${tomlMultiline(body.trim())}`);
+    if (sandboxMode)
+        lines.push(`sandbox_mode = ${tomlString(sandboxMode)}`);
+    return lines.join('\n') + '\n';
+}
+export function codexAgentTomlToClaudeMd(source) {
+    const parsed = parseCodexAgentToml(source);
+    const frontmatter = {
+        name: parsed.name,
+        description: parsed.description,
+    };
+    if (parsed.sandboxMode) {
+        frontmatter.tools = claudeToolsFromSandboxMode(parsed.sandboxMode);
+    }
+    return serializeMarkdownWithFrontmatter(frontmatter, `\n${parsed.developerInstructions.trim()}\n`);
+}
+export function claudeCommandMdToCodexSkill(source) {
+    const { frontmatter, body } = parseMarkdownWithFrontmatter(source);
+    const description = String(frontmatter.description ?? '').trim();
+    if (!description) {
+        throw new Error('Claude command is missing required "description" frontmatter field.');
+    }
+    const skillFrontmatter = {
+        description,
+    };
+    if (frontmatter['argument-hint']) {
+        skillFrontmatter['argument-hint'] = frontmatter['argument-hint'];
+    }
+    return {
+        frontmatter: skillFrontmatter,
+        skillMarkdown: serializeMarkdownWithFrontmatter(skillFrontmatter, body.startsWith('\n') ? body : `\n${body}`),
+    };
+}
+function inferSandboxModeFromClaudeTools(rawTools) {
+    const tools = normalizeClaudeToolList(rawTools);
+    if (tools.length === 0)
+        return undefined;
+    const mutating = new Set(['Edit', 'Write', 'MultiEdit', 'NotebookEdit']);
+    return tools.some((tool) => mutating.has(tool)) ? 'workspace-write' : 'read-only';
+}
+function normalizeClaudeToolList(raw) {
+    if (Array.isArray(raw))
+        return raw.map((item) => String(item).trim()).filter(Boolean);
+    if (typeof raw === 'string') {
+        return raw.split(',').map((item) => item.trim()).filter(Boolean);
+    }
+    return [];
+}
+function claudeToolsFromSandboxMode(sandboxMode) {
+    const readOnlyTools = 'Glob, Grep, LS, Read, NotebookRead, WebFetch, WebSearch';
+    if (sandboxMode === 'read-only')
+        return readOnlyTools;
+    return `${readOnlyTools}, Edit, Write, Bash`;
+}
+export function parseCodexAgentToml(source) {
+    const lines = source.split('\n');
+    const simple = new Map();
+    const extra = {};
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#')) {
+            i++;
+            continue;
+        }
+        if (/^\[/.test(trimmed)) {
+            i++;
+            continue;
+        }
+        const kvMatch = trimmed.match(/^(\w+)\s*=\s*(.+)$/);
+        if (!kvMatch) {
+            i++;
+            continue;
+        }
+        const [, key, rawValue] = kvMatch;
+        if (rawValue.startsWith('"""')) {
+            const { value, nextIndex } = readTomlMultiline(lines, i, rawValue);
+            simple.set(key, value);
+            i = nextIndex;
+            continue;
+        }
+        simple.set(key, parseTomlScalar(rawValue));
+        i++;
+    }
+    const name = simple.get('name');
+    const description = simple.get('description');
+    const developerInstructions = simple.get('developer_instructions');
+    if (!name)
+        throw new Error('Codex agent is missing required "name" field.');
+    if (!description)
+        throw new Error('Codex agent is missing required "description" field.');
+    if (!developerInstructions) {
+        throw new Error('Codex agent is missing required "developer_instructions" field.');
+    }
+    return {
+        name,
+        description,
+        developerInstructions,
+        sandboxMode: simple.get('sandbox_mode'),
+        model: simple.get('model'),
+        extra,
+    };
+}
+function readTomlMultiline(lines, startIndex, firstLine) {
+    const afterOpen = firstLine.slice(3);
+    if (afterOpen.endsWith('"""') && afterOpen.length >= 3) {
+        return { value: unescapeTomlString(afterOpen.slice(0, -3)), nextIndex: startIndex + 1 };
+    }
+    const collected = [];
+    if (afterOpen.length > 0)
+        collected.push(afterOpen);
+    let i = startIndex + 1;
+    while (i < lines.length) {
+        const line = lines[i];
+        const closeIdx = line.indexOf('"""');
+        if (closeIdx === -1) {
+            collected.push(line);
+            i++;
+            continue;
+        }
+        if (closeIdx > 0)
+            collected.push(line.slice(0, closeIdx));
+        return { value: unescapeTomlString(collected.join('\n').replace(/^\n/, '')), nextIndex: i + 1 };
+    }
+    throw new Error('Unterminated TOML multiline string.');
+}
+function parseTomlScalar(raw) {
+    const trimmed = raw.trim();
+    if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+        return unescapeTomlString(trimmed.slice(1, -1));
+    }
+    return trimmed;
+}
+function unescapeTomlString(value) {
+    return value
+        .replace(/\\\\/g, '\\')
+        .replace(/\\"/g, '"')
+        .replace(/\\n/g, '\n')
+        .replace(/\\r/g, '\r')
+        .replace(/\\t/g, '\t');
+}
+function tomlString(value) {
+    return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+function tomlMultiline(value) {
+    const escaped = value.replace(/"""/g, '\\"\\"\\"');
+    return `"""\n${escaped}\n"""`;
+}

package/dist/services/credential-redaction-service.d.ts

@@ -0,0 +1,13 @@
+import type { McpServerConfig, PortableCredentialSpec } from '../types.js';
+export interface CredentialRedactionResult<T extends McpServerConfig> {
+    redacted: T;
+    credentials: PortableCredentialSpec[];
+}
+export declare function redactPortableMcpCredentials<T extends McpServerConfig>(config: T): CredentialRedactionResult<T>;
+interface CredentialAccumulator {
+    key: string;
+    required: true;
+    descriptions: Set<string>;
+}
+export declare function finalizePortableCredentialSpecs(credentialsByKey: Map<string, CredentialAccumulator>): PortableCredentialSpec[];
+export {};