sneakoscope 6.2.0 → 6.4.0

package/dist/core/mcp-config/codex-cli-adapter.js

@@ -0,0 +1,165 @@
+import fsp from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { runProcess, which } from '../fsx.js';
+export class CodexMcpCliAdapter {
+    configuredPath;
+    findExecutable;
+    run;
+    constructor(options = {}) {
+        this.configuredPath = options.codexPath;
+        this.findExecutable = options.dependencies?.findExecutable ?? which;
+        this.run = options.dependencies?.run ?? defaultRun;
+    }
+    async list(ref) {
+        try {
+            const executable = await this.executable();
+            if (!executable)
+                return { available: false, ok: false, rows: [], public_error: 'codex_cli_not_found' };
+            const result = await this.run(executable, ['mcp', 'list', '--json'], {
+                cwd: ref.root,
+                env: scopedEnvironment(ref.codexHome),
+                timeoutMs: 10_000,
+                maxOutputBytes: 1024 * 1024
+            });
+            if (result.code !== 0 || result.timedOut) {
+                return { available: true, ok: false, rows: [], public_error: 'codex_mcp_list_failed' };
+            }
+            const parsed = JSON.parse(result.stdout);
+            const rows = Array.isArray(parsed) ? parsed.map(parseListRow).filter((row) => row !== null) : [];
+            return { available: true, ok: true, rows, public_error: null };
+        }
+        catch {
+            return { available: true, ok: false, rows: [], public_error: 'codex_mcp_list_failed' };
+        }
+    }
+    async transform(before, operation) {
+        let temp = null;
+        try {
+            const executable = await this.executable();
+            if (!executable)
+                return unavailableTransform('codex_cli_not_found');
+            if (!isOfficialServerName(operation.name))
+                return unavailableTransform('codex_cli_server_name_unsupported');
+            temp = await fsp.mkdtemp(path.join(os.tmpdir(), 'sks-mcp-codex-cli-'));
+            const codexHome = path.join(temp, '.codex');
+            const configPath = path.join(codexHome, 'config.toml');
+            await fsp.mkdir(codexHome, { recursive: true });
+            if (before)
+                await fsp.writeFile(configPath, before, { mode: 0o600 });
+            const env = scopedEnvironment(codexHome, temp);
+            if (operation.action === 'edit') {
+                const removed = await this.run(executable, ['mcp', 'remove', operation.name], { cwd: temp, env, timeoutMs: 10_000, maxOutputBytes: 256 * 1024 });
+                if (removed.code !== 0 || removed.timedOut)
+                    return failedTransform('codex_mcp_edit_remove_failed');
+            }
+            const args = operation.action === 'remove'
+                ? ['mcp', 'remove', operation.name]
+                : buildCodexMcpAddArgs(operation.server);
+            if (!args)
+                return unavailableTransform('codex_cli_mutation_unsupported');
+            const result = await this.run(executable, args, { cwd: temp, env, timeoutMs: 10_000, maxOutputBytes: 256 * 1024 });
+            if (result.code !== 0 || result.timedOut)
+                return failedTransform('codex_mcp_mutation_failed');
+            const text = await fsp.readFile(configPath, 'utf8').catch(() => '');
+            return { available: true, ok: true, used: true, text, unsupported_reason: null, public_error: null };
+        }
+        catch {
+            return failedTransform('codex_mcp_cli_transform_failed');
+        }
+        finally {
+            if (temp)
+                await fsp.rm(temp, { recursive: true, force: true }).catch(() => undefined);
+        }
+    }
+    async login(ref, name, scopes = []) {
+        const args = ['mcp', 'login', name];
+        if (scopes.length)
+            args.push('--scopes', scopes.join(','));
+        return this.auth(ref, args);
+    }
+    async logout(ref, name) {
+        return this.auth(ref, ['mcp', 'logout', name]);
+    }
+    async auth(ref, args) {
+        try {
+            const executable = await this.executable();
+            if (!executable)
+                return { available: false, ok: false, public_error: 'codex_cli_not_found' };
+            const result = await this.run(executable, args, {
+                cwd: ref.root,
+                env: scopedEnvironment(ref.codexHome),
+                timeoutMs: 5 * 60_000,
+                maxOutputBytes: 256 * 1024
+            });
+            return {
+                available: true,
+                ok: result.code === 0 && !result.timedOut,
+                public_error: result.code === 0 && !result.timedOut ? null : 'codex_mcp_auth_failed'
+            };
+        }
+        catch {
+            return { available: true, ok: false, public_error: 'codex_mcp_auth_failed' };
+        }
+    }
+    async executable() {
+        return this.configuredPath || await this.findExecutable('codex');
+    }
+}
+export function buildCodexMcpAddArgs(input) {
+    if (!input || !isOfficialServerName(input.name))
+        return null;
+    const args = ['mcp', 'add', input.name];
+    if (input.transport === 'streamable-http') {
+        if (!input.url)
+            return null;
+        args.push('--url', input.url);
+        if (input.bearer_token_env_var)
+            args.push('--bearer-token-env-var', input.bearer_token_env_var);
+        if (input.oauth_client_id)
+            args.push('--oauth-client-id', input.oauth_client_id);
+        if (input.oauth_resource)
+            args.push('--oauth-resource', input.oauth_resource);
+        return args;
+    }
+    if (!input.command)
+        return null;
+    return [...args, '--', input.command, ...(input.args || [])];
+}
+export function isOfficialServerName(name) {
+    return /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/.test(name);
+}
+function scopedEnvironment(codexHome, home = process.env.HOME || os.homedir()) {
+    return { ...process.env, HOME: home, CODEX_HOME: codexHome };
+}
+function parseListRow(value) {
+    if (!isRecord(value) || typeof value.name !== 'string')
+        return null;
+    return {
+        name: value.name,
+        ...(typeof value.enabled === 'boolean' ? { enabled: value.enabled } : {}),
+        ...(typeof value.disabled_reason === 'string' || value.disabled_reason === null ? { disabled_reason: value.disabled_reason } : {}),
+        ...(typeof value.auth_status === 'string' || value.auth_status === null ? { auth_status: value.auth_status } : {}),
+        ...(typeof value.startup_timeout_sec === 'number' || value.startup_timeout_sec === null ? { startup_timeout_sec: value.startup_timeout_sec } : {}),
+        ...(typeof value.tool_timeout_sec === 'number' || value.tool_timeout_sec === null ? { tool_timeout_sec: value.tool_timeout_sec } : {})
+    };
+}
+function unavailableTransform(reason) {
+    return { available: reason !== 'codex_cli_not_found', ok: false, used: false, text: null, unsupported_reason: reason, public_error: null };
+}
+function failedTransform(publicError) {
+    return {
+        available: true,
+        ok: false,
+        used: true,
+        text: null,
+        unsupported_reason: null,
+        public_error: publicError
+    };
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+async function defaultRun(command, args, options) {
+    return runProcess(command, [...args], options);
+}

package/dist/core/mcp-config/config-reader.js

@@ -0,0 +1,148 @@
+import fsp from 'node:fs/promises';
+import { parseCodexConfigToml } from '../codex/codex-config-toml.js';
+import { publicMcpCommand, redactMcpError, redactMcpUrl, sanitizeMcpArgs } from './redaction.js';
+import { normalizeApprovalMode } from './secret-policy.js';
+import { MCP_DEFAULT_STARTUP_TIMEOUT_SEC, MCP_DEFAULT_TOOL_TIMEOUT_SEC, MCP_SERVER_CONFIG_SCHEMA } from './types.js';
+export class McpConfigReadError extends Error {
+    code;
+    constructor(code, cause) {
+        super(code);
+        this.code = code;
+        this.name = 'McpConfigReadError';
+        if (cause !== undefined)
+            this.cause = cause;
+    }
+}
+export async function readMcpConfigDocument(ref) {
+    const stat = await fsp.lstat(ref.configPath).catch((error) => errorCode(error) === 'ENOENT' ? null : Promise.reject(error));
+    if (!stat)
+        return { ref, exists: false, text: '', parsed: {}, rawServers: {} };
+    if (stat.isSymbolicLink())
+        throw new McpConfigReadError('mcp_config_symlink_refused');
+    if (!stat.isFile())
+        throw new McpConfigReadError('mcp_config_not_regular_file');
+    let text;
+    try {
+        text = await fsp.readFile(ref.configPath, 'utf8');
+    }
+    catch (error) {
+        throw new McpConfigReadError('mcp_config_read_failed', error);
+    }
+    let parsed;
+    try {
+        parsed = parseCodexConfigToml(text);
+    }
+    catch (error) {
+        throw new McpConfigReadError('mcp_config_toml_parse_failed', redactMcpError(error));
+    }
+    const servers = isRecord(parsed.mcp_servers) ? parsed.mcp_servers : {};
+    const rawServers = {};
+    for (const [name, value] of Object.entries(servers)) {
+        if (isRecord(value))
+            rawServers[name] = value;
+    }
+    return { ref, exists: true, text, parsed, rawServers };
+}
+export function publicServersFromDocument(document, cliRows = []) {
+    const cliByName = new Map(cliRows.map((row) => [row.name, row]));
+    return Object.entries(document.rawServers)
+        .map(([name, value]) => publicServerFromRaw(name, value, document.ref, cliByName.get(name)))
+        .sort((left, right) => left.name.localeCompare(right.name));
+}
+export function publicServerFromRaw(name, value, ref, cli) {
+    const rawUrl = typeof value.url === 'string' ? value.url : null;
+    const rawCommand = typeof value.command === 'string' ? value.command : null;
+    const transport = rawUrl ? 'streamable-http' : rawCommand ? 'stdio' : 'stdio';
+    const inlineEnv = isRecord(value.env) ? value.env : {};
+    const envVars = stringArray(value.env_vars).filter(isEnvName);
+    const args = stringArray(value.args);
+    const rawApproval = normalizeApprovalMode(value.default_tools_approval_mode ?? value.approval_mode);
+    const toolApprovalModes = parseToolApprovalModes(value.tools);
+    const authStatus = String(cli?.auth_status || '').toLowerCase();
+    const oauthSupported = transport === 'streamable-http'
+        ? authStatus === 'unsupported' ? false : null
+        : false;
+    const authenticated = /oauth.*(?:ok|authenticated)|authenticated/.test(authStatus)
+        ? true
+        : /oauth.*(?:required|expired|missing)/.test(authStatus)
+            ? false
+            : null;
+    return {
+        schema: MCP_SERVER_CONFIG_SCHEMA,
+        name,
+        scope: ref.scope,
+        enabled: cli?.enabled ?? (value.enabled !== false && value.disabled !== true),
+        transport,
+        ...(rawCommand ? { command: publicMcpCommand(rawCommand) } : {}),
+        ...(args.length ? { args: sanitizeMcpArgs(args) } : {}),
+        ...(envVars.length ? { env_vars: [...new Set(envVars)].sort() } : {}),
+        ...(typeof value.cwd === 'string' ? { cwd: value.cwd } : {}),
+        ...(value.experimental_environment === 'remote' ? { experimental_environment: 'remote' } : {}),
+        ...(rawUrl ? { url: redactMcpUrl(rawUrl) } : {}),
+        ...(isEnvName(value.bearer_token_env_var) ? { bearer_token_env_var: value.bearer_token_env_var } : {}),
+        oauth: { supported: oauthSupported, authenticated },
+        startup_timeout_sec: positiveNumber(cli?.startup_timeout_sec ?? value.startup_timeout_sec) ?? MCP_DEFAULT_STARTUP_TIMEOUT_SEC,
+        tool_timeout_sec: positiveNumber(cli?.tool_timeout_sec ?? value.tool_timeout_sec) ?? MCP_DEFAULT_TOOL_TIMEOUT_SEC,
+        ...(stringArray(value.enabled_tools).length ? { enabled_tools: stringArray(value.enabled_tools) } : {}),
+        ...(stringArray(value.disabled_tools).length ? { disabled_tools: stringArray(value.disabled_tools) } : {}),
+        ...(rawApproval ? { default_tools_approval_mode: rawApproval } : {}),
+        ...(Object.keys(toolApprovalModes).length ? { tool_approval_modes: toolApprovalModes } : {}),
+        ...(typeof value.required === 'boolean' ? { required: value.required } : {}),
+        source_path: ref.configPath,
+        managed_by: value.managed_by === 'sks' ? 'sks' : 'user',
+        legacy_inline_secret_present: Object.keys(inlineEnv).length > 0,
+        legacy_env_keys: Object.keys(inlineEnv).filter(isEnvName).sort()
+    };
+}
+export function rawServer(document, name) {
+    return document.rawServers[name] ? { ...document.rawServers[name] } : null;
+}
+export function privateEnvironment(value) {
+    const result = privateInlineEnvironment(value);
+    for (const key of stringArray(value.env_vars).filter(isEnvName)) {
+        if (process.env[key] !== undefined)
+            result[key] = String(process.env[key]);
+    }
+    return result;
+}
+export function privateInlineEnvironment(value) {
+    const inline = isRecord(value.env) ? value.env : {};
+    const result = {};
+    for (const [key, raw] of Object.entries(inline)) {
+        if (isEnvName(key) && typeof raw === 'string')
+            result[key] = raw;
+    }
+    return result;
+}
+export function rawStringArray(value) {
+    return stringArray(value);
+}
+export function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function parseToolApprovalModes(value) {
+    if (!isRecord(value))
+        return {};
+    const result = {};
+    for (const [tool, raw] of Object.entries(value)) {
+        if (!isRecord(raw))
+            continue;
+        const mode = normalizeApprovalMode(raw.approval_mode);
+        if (mode)
+            result[tool] = mode;
+    }
+    return result;
+}
+function stringArray(value) {
+    return Array.isArray(value) ? value.filter((entry) => typeof entry === 'string') : [];
+}
+function isEnvName(value) {
+    return typeof value === 'string' && /^[A-Za-z_][A-Za-z0-9_]*$/.test(value);
+}
+function positiveNumber(value) {
+    const number = Number(value);
+    return Number.isFinite(number) && number > 0 ? number : null;
+}
+function errorCode(error) {
+    return error && typeof error === 'object' && 'code' in error ? String(error.code) : '';
+}

package/dist/core/mcp-config/effective-merge.js

@@ -0,0 +1,24 @@
+const PRECEDENCE = {
+    plugin: 0,
+    global: 1,
+    project: 2
+};
+export function mergeEffectiveMcpServers(groups) {
+    const byName = new Map();
+    for (const server of groups.flat()) {
+        const rows = byName.get(server.name) || [];
+        rows.push(server);
+        byName.set(server.name, rows);
+    }
+    const merged = [];
+    for (const [name, rows] of byName) {
+        const ordered = [...rows].sort((left, right) => PRECEDENCE[right.scope] - PRECEDENCE[left.scope]);
+        const winner = ordered[0];
+        if (!winner)
+            continue;
+        const shadowed = ordered.slice(1).map((row) => ({ scope: row.scope, source_path: row.source_path }));
+        merged.push({ ...winner, ...(shadowed.length ? { shadowed_sources: shadowed } : {}) });
+        void name;
+    }
+    return merged.sort((left, right) => left.name.localeCompare(right.name));
+}

package/dist/core/mcp-config/guarded-patch.js

@@ -0,0 +1,259 @@
+export function replaceOrAppendMcpServer(text, name, block) {
+    const source = String(text || '');
+    const range = serverRange(source, name);
+    const newline = source.includes('\r\n') ? '\r\n' : '\n';
+    const normalized = block.replace(/\r?\n/g, newline).replace(new RegExp(`${escapeRegExp(newline)}*$`), newline);
+    if (!range) {
+        const prefix = source.trim() ? source.replace(/\s*$/, `${newline}${newline}`) : '';
+        return `${prefix}${normalized}`;
+    }
+    return `${source.slice(0, range.start)}${normalized}${source.slice(range.end).replace(/^(?:\r?\n)+/, '')}`;
+}
+export function removeMcpServerText(text, name) {
+    const range = serverRange(String(text || ''), name);
+    if (!range)
+        return null;
+    const source = String(text || '');
+    const newline = source.includes('\r\n') ? '\r\n' : '\n';
+    const before = source.slice(0, range.start).replace(/[ \t\r\n]+$/, '');
+    const after = source.slice(range.end).replace(/^(?:\r?\n)+/, '');
+    return `${before}${before && after ? `${newline}${newline}` : ''}${after}`;
+}
+export function setMcpServerEnabledText(text, name, enabled) {
+    const source = String(text || '');
+    const span = tableSpans(source).find((candidate) => !candidate.array && isServerRoot(candidate.path, name));
+    if (!span)
+        return null;
+    let state = 'normal';
+    for (const line of sourceLines(source, span.headerEnd, span.end)) {
+        if (state === 'normal') {
+            const match = line.content.match(/^([ \t]*enabled[ \t]*=[ \t]*)(true|false)([ \t]*(?:#.*)?)$/);
+            if (match?.[1] !== undefined && match[2] !== undefined) {
+                const valueStart = line.start + match[1].length;
+                return `${source.slice(0, valueStart)}${enabled ? 'true' : 'false'}${source.slice(valueStart + match[2].length)}`;
+            }
+        }
+        state = advanceState(line.content, state);
+    }
+    const newline = source.includes('\r\n') ? '\r\n' : '\n';
+    return `${source.slice(0, span.headerEnd)}enabled = ${enabled ? 'true' : 'false'}${newline}${source.slice(span.headerEnd)}`;
+}
+export function renderMcpServerBlock(input, legacyEnv = {}) {
+    const lines = [`[mcp_servers.${tomlKey(input.name)}]`, `enabled = ${input.enabled !== false}`];
+    if (input.transport === 'streamable-http') {
+        lines.push(`url = ${tomlString(input.url || '')}`);
+        if (input.bearer_token_env_var)
+            lines.push(`bearer_token_env_var = ${tomlString(input.bearer_token_env_var)}`);
+        if (input.oauth_client_id)
+            lines.push(`oauth_client_id = ${tomlString(input.oauth_client_id)}`);
+        if (input.oauth_resource)
+            lines.push(`oauth_resource = ${tomlString(input.oauth_resource)}`);
+    }
+    else {
+        lines.push(`command = ${tomlString(input.command || '')}`);
+        if (input.args?.length)
+            lines.push(`args = ${tomlArray(input.args)}`);
+        if (input.env_vars?.length)
+            lines.push(`env_vars = ${tomlArray(input.env_vars)}`);
+        if (input.cwd)
+            lines.push(`cwd = ${tomlString(input.cwd)}`);
+        if (input.experimental_environment)
+            lines.push(`experimental_environment = ${tomlString(input.experimental_environment)}`);
+        if (Object.keys(legacyEnv).length) {
+            const pairs = Object.entries(legacyEnv).sort(([left], [right]) => left.localeCompare(right));
+            lines.push(`env = { ${pairs.map(([key, value]) => `${tomlKey(key)} = ${tomlString(value)}`).join(', ')} }`);
+        }
+    }
+    lines.push(`startup_timeout_sec = ${input.startup_timeout_sec ?? 10}`);
+    lines.push(`tool_timeout_sec = ${input.tool_timeout_sec ?? 60}`);
+    if (input.enabled_tools)
+        lines.push(`enabled_tools = ${tomlArray(input.enabled_tools)}`);
+    if (input.disabled_tools)
+        lines.push(`disabled_tools = ${tomlArray(input.disabled_tools)}`);
+    if (input.default_tools_approval_mode)
+        lines.push(`default_tools_approval_mode = ${tomlString(input.default_tools_approval_mode)}`);
+    if (input.required !== undefined)
+        lines.push(`required = ${input.required}`);
+    for (const [tool, mode] of Object.entries(input.tool_approval_modes || {}).sort(([left], [right]) => left.localeCompare(right))) {
+        lines.push('', `[mcp_servers.${tomlKey(input.name)}.tools.${tomlKey(tool)}]`, `approval_mode = ${tomlString(mode)}`);
+    }
+    return `${lines.join('\n')}\n`;
+}
+export function extractMcpServerBlock(text, name) {
+    const range = serverRange(String(text || ''), name);
+    return range ? String(text || '').slice(range.start, range.end) : null;
+}
+function serverRange(source, name) {
+    const spans = tableSpans(source).filter((span) => isServerPath(span.path, name));
+    if (!spans.length)
+        return null;
+    return { start: spans[0]?.start ?? 0, end: spans[spans.length - 1]?.end ?? source.length };
+}
+function tableSpans(text) {
+    const headers = [];
+    let state = 'normal';
+    for (const line of sourceLines(text)) {
+        if (state === 'normal') {
+            const header = parseHeader(line.content);
+            if (header)
+                headers.push({ start: line.start, headerEnd: line.end, path: header.path, array: header.array });
+        }
+        state = advanceState(line.content, state);
+    }
+    return headers.map((header, index) => ({ ...header, end: headers[index + 1]?.start ?? text.length }));
+}
+function sourceLines(text, start = 0, end = text.length) {
+    const lines = [];
+    let cursor = start;
+    while (cursor < end) {
+        const found = text.indexOf('\n', cursor);
+        const lineEnd = found === -1 || found >= end ? end : found + 1;
+        let contentEnd = found === -1 || found >= end ? lineEnd : found;
+        if (contentEnd > cursor && text[contentEnd - 1] === '\r')
+            contentEnd -= 1;
+        lines.push({ start: cursor, end: lineEnd, content: text.slice(cursor, contentEnd) });
+        cursor = lineEnd;
+    }
+    return lines;
+}
+function advanceState(line, initial) {
+    let state = initial;
+    let quote = null;
+    let escaped = false;
+    for (let index = 0; index < line.length; index += 1) {
+        const char = line[index] || '';
+        if (state === 'multiline-basic') {
+            if (line.startsWith('"""', index) && !escapedAt(line, index)) {
+                state = 'normal';
+                index += 2;
+            }
+            continue;
+        }
+        if (state === 'multiline-literal') {
+            if (line.startsWith("'''", index)) {
+                state = 'normal';
+                index += 2;
+            }
+            continue;
+        }
+        if (quote === 'basic') {
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (char === '\\') {
+                escaped = true;
+                continue;
+            }
+            if (char === '"')
+                quote = null;
+            continue;
+        }
+        if (quote === 'literal') {
+            if (char === "'")
+                quote = null;
+            continue;
+        }
+        if (char === '#')
+            break;
+        if (line.startsWith('"""', index)) {
+            state = 'multiline-basic';
+            index += 2;
+            continue;
+        }
+        if (line.startsWith("'''", index)) {
+            state = 'multiline-literal';
+            index += 2;
+            continue;
+        }
+        if (char === '"')
+            quote = 'basic';
+        if (char === "'")
+            quote = 'literal';
+    }
+    return state;
+}
+function parseHeader(line) {
+    const arrayMatch = line.match(/^\s*\[\[([^\[\]]+)\]\]\s*(?:#.*)?$/);
+    const tableMatch = arrayMatch ? null : line.match(/^\s*\[([^\[\]]+)\]\s*(?:#.*)?$/);
+    const source = arrayMatch?.[1] || tableMatch?.[1];
+    if (!source)
+        return null;
+    const path = splitTomlPath(source);
+    return path ? { path, array: Boolean(arrayMatch) } : null;
+}
+function splitTomlPath(source) {
+    const parts = [];
+    let current = '';
+    let quote = null;
+    let escaped = false;
+    for (const char of source) {
+        if (quote) {
+            current += char;
+            if (quote === '"' && escaped) {
+                escaped = false;
+                continue;
+            }
+            if (quote === '"' && char === '\\') {
+                escaped = true;
+                continue;
+            }
+            if (char === quote)
+                quote = null;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            current += char;
+            continue;
+        }
+        if (char === '.') {
+            const decoded = decodeKey(current);
+            if (decoded === null)
+                return null;
+            parts.push(decoded);
+            current = '';
+            continue;
+        }
+        current += char;
+    }
+    if (quote)
+        return null;
+    const decoded = decodeKey(current);
+    if (decoded === null)
+        return null;
+    parts.push(decoded);
+    return parts;
+}
+function decodeKey(value) {
+    const token = value.trim();
+    if (!token)
+        return null;
+    if (token.startsWith('"') && token.endsWith('"')) {
+        try {
+            return JSON.parse(token);
+        }
+        catch {
+            return null;
+        }
+    }
+    if (token.startsWith("'") && token.endsWith("'"))
+        return token.slice(1, -1);
+    return /^[A-Za-z0-9_-]+$/.test(token) ? token : null;
+}
+function isServerRoot(path, name) {
+    return path.length === 2 && path[0] === 'mcp_servers' && path[1] === name;
+}
+function isServerPath(path, name) {
+    return path.length >= 2 && path[0] === 'mcp_servers' && path[1] === name;
+}
+function escapedAt(value, index) {
+    let slashes = 0;
+    for (let cursor = index - 1; cursor >= 0 && value[cursor] === '\\'; cursor -= 1)
+        slashes += 1;
+    return slashes % 2 === 1;
+}
+function tomlString(value) { return JSON.stringify(String(value)); }
+function tomlKey(value) { return tomlString(value); }
+function tomlArray(values) { return `[${values.map(tomlString).join(', ')}]`; }
+function escapeRegExp(value) { return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }