@wangzhizhi/remi 0.1.224 → 0.1.244

package/node_modules/@remi/config/dist/index.js

@@ -37,11 +37,38 @@ export const hookEventNames = [
 ];
 const deepSeekApiKey = '${DEEPSEEK_API_KEY}';
 const defaultAnthropicBaseURL = 'https://api.anthropic.com';
-export function createDeepSeekPresetConfig() {
+export function createDefaultFilesystemMcpServerConfig(platform = process.platform) {
+    if (platform === 'win32') {
+        return {
+            type: 'stdio',
+            command: 'cmd',
+            args: ['/c', 'npx', '-y', '@modelcontextprotocol/server-filesystem', '.'],
+            timeoutMs: 15000,
+        };
+    }
     return {
-        activeProfile: 'daily',
+        type: 'stdio',
+        command: 'npx',
+        args: ['-y', '@modelcontextprotocol/server-filesystem', '.'],
+        timeoutMs: 15000,
+    };
+}
+export function createDeepSeekPresetConfig(options = {}) {
+    return {
+        activeProfile: 'deepseek-v4-flash',
+        mcp: {
+            servers: {
+                filesystem: createDefaultFilesystemMcpServerConfig(options.platform),
+            },
+        },
         providers: {
-            deepseek: {
+            'deepseek-v4-flash': {
+                type: 'openai-compatible',
+                baseURL: 'https://api.deepseek.com',
+                apiKey: deepSeekApiKey,
+                apiKeyEnv: 'DEEPSEEK_API_KEY',
+            },
+            'deepseek-v4-pro': {
                 type: 'openai-compatible',
                 baseURL: 'https://api.deepseek.com',
                 apiKey: deepSeekApiKey,
@@ -49,8 +76,8 @@ export function createDeepSeekPresetConfig() {
             },
         },
         models: {
-            'deepseek.flash': {
-                provider: 'deepseek',
+            'deepseek-v4-flash': {
+                provider: 'deepseek-v4-flash',
                 model: 'deepseek-v4-flash',
                 displayName: 'DeepSeek-V4-Flash',
                 contextWindow: 1_000_000,
@@ -62,8 +89,8 @@ export function createDeepSeekPresetConfig() {
                 usageShape: 'openai-compatible',
                 cacheUsageShape: 'openai-prompt-token-details',
             },
-            'deepseek.pro': {
-                provider: 'deepseek',
+            'deepseek-v4-pro': {
+                provider: 'deepseek-v4-pro',
                 model: 'deepseek-v4-pro',
                 displayName: 'DeepSeek-V4-Pro',
                 contextWindow: 1_000_000,
@@ -77,37 +104,30 @@ export function createDeepSeekPresetConfig() {
             },
         },
         modelSets: {
-            deepseek: ['deepseek.flash', 'deepseek.pro'],
+            deepseek: ['deepseek-v4-flash', 'deepseek-v4-pro'],
         },
         profiles: {
-            daily: {
-                roles: {
-                    main: 'deepseek.flash',
-                    planning: 'deepseek.pro',
-                    subagent: 'deepseek.flash',
-                    compact: 'deepseek.flash',
-                    memory: 'deepseek.flash',
-                    toolRepair: 'deepseek.flash',
-                },
-                effort: 'medium',
-            },
-            pro: {
-                extends: 'daily',
+            'deepseek-v4-flash': {
                 roles: {
-                    main: 'deepseek.pro',
-                    planning: 'deepseek.pro',
-                    compact: 'deepseek.pro',
+                    main: 'deepseek-v4-flash',
+                    planning: 'deepseek-v4-flash',
+                    subagent: 'deepseek-v4-flash',
+                    compact: 'deepseek-v4-flash',
+                    memory: 'deepseek-v4-flash',
+                    toolRepair: 'deepseek-v4-flash',
                 },
-                effort: 'high',
+                effort: 'max',
             },
-            flash: {
-                extends: 'daily',
+            'deepseek-v4-pro': {
                 roles: {
-                    main: 'deepseek.flash',
-                    planning: 'deepseek.flash',
-                    compact: 'deepseek.flash',
+                    main: 'deepseek-v4-pro',
+                    planning: 'deepseek-v4-pro',
+                    subagent: 'deepseek-v4-pro',
+                    compact: 'deepseek-v4-pro',
+                    memory: 'deepseek-v4-pro',
+                    toolRepair: 'deepseek-v4-pro',
                 },
-                effort: 'low',
+                effort: 'max',
             },
         },
     };
@@ -172,7 +192,7 @@ export function configPaths(options = {}) {
     return sources.map(source => ({ ...source, exists: existsSync(source.path) }));
 }
 export function userConfigPath(homeDir = process.env['REMI_HOME'] ?? homedir()) {
-    return join(remiHomeDir(homeDir), 'config.json');
+    return join(remiHomeDir(homeDir), 'config.toml');
 }
 export function remiHomeDir(homeDir = process.env['REMI_HOME'] ?? homedir()) {
     const resolvedHomeDir = resolve(homeDir);
@@ -193,10 +213,10 @@ export function readUserRemiConfig(homeDir = process.env['REMI_HOME'] ?? homedir
 }
 export function writeUserRemiConfig(config, homeDir = process.env['REMI_HOME'] ?? homedir()) {
     mkdirSync(remiHomeDir(homeDir), { recursive: true });
-    writeFileSync(userConfigPath(homeDir), `${JSON.stringify(config, null, 2)}\n`);
+    writeFileSync(userConfigPath(homeDir), serializeRemiConfigToToml(config));
 }
 export function projectConfigPath(cwd = process.cwd(), homeDir = process.env['REMI_HOME'] ?? homedir()) {
-    return join(projectStateDir(cwd, homeDir), 'config.json');
+    return join(projectStateDir(cwd, homeDir), 'config.toml');
 }
 export function readProjectRemiConfig(cwd = process.cwd(), homeDir = process.env['REMI_HOME'] ?? homedir()) {
     const path = projectConfigPath(cwd, homeDir);
@@ -207,7 +227,7 @@ export function readProjectRemiConfig(cwd = process.cwd(), homeDir = process.env
 }
 export function writeProjectRemiConfig(config, cwd = process.cwd(), homeDir = process.env['REMI_HOME'] ?? homedir()) {
     mkdirSync(projectStateDir(cwd, homeDir), { recursive: true });
-    writeFileSync(projectConfigPath(cwd, homeDir), `${JSON.stringify(config, null, 2)}\n`);
+    writeFileSync(projectConfigPath(cwd, homeDir), serializeRemiConfigToToml(config));
 }
 export function isPermissionProfile(value) {
     return typeof value === 'string' && permissionProfiles.includes(value);
@@ -514,11 +534,11 @@ function hasConfigContent(config) {
         Object.keys(config.profiles ?? {}).length > 0);
 }
 function parseConfigFile(path) {
-    const parsed = JSON.parse(readFileSync(path, 'utf8'));
+    const parsed = parseToml(readFileSync(path, 'utf8'));
     if (!isRecord(parsed)) {
-        throw new Error('Config root must be a JSON object');
+        throw new Error('Config root must be a TOML table');
     }
-    return parsed;
+    return remiConfigFromToml(parsed);
 }
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
@@ -527,3 +547,761 @@ function uniqueStrings(values) {
     const unique = Array.from(new Set(values.map(value => value.trim()).filter(Boolean)));
     return unique.length > 0 ? unique : undefined;
 }
+function remiConfigFromToml(parsed) {
+    const config = {};
+    assignString(parsed, 'active_profile', value => {
+        config.activeProfile = value;
+    });
+    assignString(parsed, 'language', value => {
+        if (languageCodes.includes(value)) {
+            config.language = value;
+        }
+    });
+    assignString(parsed, 'response_style', value => {
+        config.responseStyle = value;
+    });
+    assignString(parsed, 'syntax_theme', value => {
+        config.syntaxTheme = value;
+    });
+    assignString(parsed, 'accent_color', value => {
+        config.accentColor = value;
+    });
+    const permissions = parsed['permissions'];
+    if (isRecord(permissions)) {
+        config.permissions = {
+            ...(typeof permissions['mode'] === 'string' ? { mode: permissions['mode'] } : {}),
+            ...(typeof permissions['profile'] === 'string' ? { profile: permissions['profile'] } : {}),
+        };
+        const allow = parsePermissionAllowRules(permissions['allow']);
+        if (allow.length > 0) {
+            config.permissions.allow = allow;
+        }
+    }
+    const agent = parsed['agent'];
+    if (isRecord(agent)) {
+        config.agent = numberFields(agent, [
+            ['max_turns', 'maxTurns'],
+            ['max_tool_calls', 'maxToolCalls'],
+            ['auto_compact_threshold_percent', 'autoCompactThresholdPercent'],
+            ['context_safety_buffer_tokens', 'contextSafetyBufferTokens'],
+            ['max_output_reserve_tokens', 'maxOutputReserveTokens'],
+        ]);
+        if (typeof agent['auto_compact'] === 'boolean')
+            config.agent.autoCompact = agent['auto_compact'];
+        if (agent['compact_strategy'] === 'model' || agent['compact_strategy'] === 'deterministic') {
+            config.agent.compactStrategy = agent['compact_strategy'];
+        }
+    }
+    const statusLine = parsed['status_line'];
+    if (isRecord(statusLine) && isStringArray(statusLine['items'])) {
+        config.statusLine = { items: statusLine['items'] };
+    }
+    const skills = parsed['skills'];
+    if (isRecord(skills) && isStringArray(skills['disabled'])) {
+        config.skills = { disabled: skills['disabled'] };
+    }
+    const mcp = parseMcpConfig(parsed['mcp']);
+    if (mcp !== undefined) {
+        config.mcp = mcp;
+    }
+    const simplifiedProfiles = parseSimpleProfiles(parsed['profiles']);
+    if (simplifiedProfiles.length > 0) {
+        Object.assign(config, mergeRemiConfig(config, remiConfigFromSimpleProfiles(simplifiedProfiles)));
+    }
+    const profileRoles = parseProfileRoles(parsed['profile_roles']);
+    if (profileRoles.length > 0) {
+        Object.assign(config, mergeRemiConfig(config, remiConfigFromProfileRoles(profileRoles)));
+    }
+    const simplifiedHooks = parseSimpleHooks(parsed['hooks']);
+    if (simplifiedHooks.length > 0) {
+        const hooks = mergeHooksConfigs(config.hooks, hooksConfigFromSimpleHooks(simplifiedHooks));
+        if (hooks !== undefined) {
+            config.hooks = hooks;
+        }
+    }
+    return config;
+}
+function assignString(record, key, assign) {
+    const value = record[key];
+    if (typeof value === 'string' && value.trim()) {
+        assign(value);
+    }
+}
+function numberFields(record, fields) {
+    const result = {};
+    for (const [tomlKey, configKey] of fields) {
+        const value = record[tomlKey];
+        if (typeof value === 'number' && Number.isFinite(value)) {
+            result[String(configKey)] = value;
+        }
+    }
+    return result;
+}
+function parseSimpleProfiles(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.flatMap(entry => {
+        if (!isRecord(entry)) {
+            return [];
+        }
+        const provider = stringValue(entry['provider']);
+        const modelId = stringValue(entry['model_id']);
+        const baseUrl = stringValue(entry['base_url']);
+        const contextWindow = numberValue(entry['context_window']);
+        if (!provider || !modelId || !baseUrl || contextWindow === undefined) {
+            return [];
+        }
+        const name = stringValue(entry['name']) ?? modelId;
+        return [
+            {
+                name,
+                provider: provider,
+                modelId,
+                baseUrl,
+                contextWindow,
+                ...(stringValue(entry['api_key']) ? { apiKey: stringValue(entry['api_key']) } : {}),
+                ...(stringValue(entry['api_key_env']) ? { apiKeyEnv: stringValue(entry['api_key_env']) } : {}),
+                ...(stringValue(entry['display_name']) ? { displayName: stringValue(entry['display_name']) } : {}),
+                ...(numberValue(entry['max_output_tokens']) !== undefined ? { maxOutputTokens: numberValue(entry['max_output_tokens']) } : {}),
+                ...(typeof entry['supports_tools'] === 'boolean' ? { supportsTools: entry['supports_tools'] } : {}),
+                ...(typeof entry['supports_reasoning'] === 'boolean' ? { supportsReasoning: entry['supports_reasoning'] } : {}),
+                ...(stringValue(entry['effort']) ? { effort: stringValue(entry['effort']) } : {}),
+            },
+        ];
+    });
+}
+function parsePermissionAllowRules(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.flatMap(entry => {
+        if (!isRecord(entry)) {
+            return [];
+        }
+        const kind = stringValue(entry['kind']);
+        const createdAt = stringValue(entry['created_at']);
+        let rule;
+        if (kind === 'shell-prefix') {
+            const prefix = stringValue(entry['prefix']);
+            if (!prefix) {
+                return [];
+            }
+            const cwd = stringValue(entry['cwd']);
+            rule = {
+                kind,
+                prefix,
+                ...(cwd ? { cwd } : {}),
+                ...(createdAt ? { createdAt } : {}),
+            };
+        }
+        else if (kind === 'filesystem-write-root') {
+            const root = stringValue(entry['root']);
+            if (!root) {
+                return [];
+            }
+            rule = {
+                kind,
+                root,
+                ...(isStringArray(entry['operations']) ? { operations: entry['operations'] } : {}),
+                ...(createdAt ? { createdAt } : {}),
+            };
+        }
+        else if (kind === 'network-tool') {
+            const toolName = stringValue(entry['tool_name']);
+            if (!toolName) {
+                return [];
+            }
+            rule = {
+                kind,
+                toolName,
+                ...(createdAt ? { createdAt } : {}),
+            };
+        }
+        return rule ? [rule] : [];
+    });
+}
+function parseMcpConfig(value) {
+    if (!isRecord(value) || !isRecord(value['servers'])) {
+        return undefined;
+    }
+    const servers = {};
+    for (const [name, entry] of Object.entries(value['servers'])) {
+        if (!isRecord(entry)) {
+            continue;
+        }
+        const command = stringValue(entry['command']);
+        if (!command) {
+            continue;
+        }
+        const server = {
+            command,
+        };
+        if (entry['type'] === 'stdio')
+            server.type = 'stdio';
+        if (isStringArray(entry['args']))
+            server.args = entry['args'];
+        if (typeof entry['cwd'] === 'string')
+            server.cwd = entry['cwd'];
+        if (typeof entry['enabled'] === 'boolean')
+            server.enabled = entry['enabled'];
+        if (typeof entry['timeout_ms'] === 'number' && Number.isFinite(entry['timeout_ms'])) {
+            server.timeoutMs = entry['timeout_ms'];
+        }
+        if (isRecord(entry['env'])) {
+            const env = Object.fromEntries(Object.entries(entry['env']).filter(([, envValue]) => typeof envValue === 'string'));
+            if (Object.keys(env).length > 0) {
+                server.env = env;
+            }
+        }
+        servers[name] = server;
+    }
+    return Object.keys(servers).length > 0 ? { servers } : undefined;
+}
+function remiConfigFromSimpleProfiles(profiles) {
+    const providers = {};
+    const models = {};
+    const modelProfiles = {};
+    for (const profile of profiles) {
+        const profileName = profile.name ?? profile.modelId;
+        providers[profileName] = {
+            type: profile.provider,
+            baseURL: profile.baseUrl,
+            ...(profile.apiKey ? { apiKey: profile.apiKey } : {}),
+            ...(profile.apiKeyEnv ? { apiKeyEnv: profile.apiKeyEnv } : {}),
+        };
+        const model = {
+            provider: profileName,
+            model: profile.modelId,
+            contextWindow: profile.contextWindow,
+            supportsTools: profile.supportsTools ?? true,
+            supportsReasoning: profile.supportsReasoning ?? true,
+            maxOutputTokens: profile.maxOutputTokens ?? defaultSimpleMaxOutputTokens(profile.modelId),
+            tokenEstimator: profile.modelId.toLowerCase().includes('deepseek') ? 'deepseek-local-tokenizer' : 'heuristic',
+            tokenEstimateProfile: 'code-heavy',
+            usageShape: profile.provider === 'anthropic-compatible' ? 'anthropic-compatible' : 'openai-compatible',
+            cacheUsageShape: profile.provider === 'anthropic-compatible' ? 'anthropic-cache-input' : 'openai-prompt-token-details',
+        };
+        if (profile.displayName) {
+            model.displayName = profile.displayName;
+        }
+        models[profileName] = model;
+        modelProfiles[profileName] = {
+            roles: modelRoles.reduce((roles, role) => {
+                if (role !== 'embedding') {
+                    roles[role] = profileName;
+                }
+                return roles;
+            }, {}),
+            effort: profile.effort ?? 'max',
+        };
+    }
+    return {
+        providers,
+        models,
+        modelSets: { configured: profiles.map(profile => profile.name ?? profile.modelId) },
+        profiles: modelProfiles,
+    };
+}
+function defaultSimpleMaxOutputTokens(modelId) {
+    const normalized = modelId.toLowerCase();
+    if (normalized.includes('deepseek')) {
+        return 384_000;
+    }
+    if (normalized.includes('mimo')) {
+        return 128_000;
+    }
+    if (normalized.includes('doubao')) {
+        return 32_000;
+    }
+    return 64_000;
+}
+function parseProfileRoles(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.flatMap(entry => {
+        if (!isRecord(entry)) {
+            return [];
+        }
+        const name = stringValue(entry['name']);
+        if (!name) {
+            return [];
+        }
+        const roles = {};
+        for (const role of modelRoles) {
+            const modelAlias = stringValue(entry[role]);
+            if (modelAlias) {
+                roles[role] = modelAlias;
+            }
+        }
+        if (Object.keys(roles).length === 0) {
+            return [];
+        }
+        return [
+            {
+                name,
+                roles,
+                ...(stringValue(entry['extends']) ? { extends: stringValue(entry['extends']) } : {}),
+                ...(stringValue(entry['effort']) ? { effort: stringValue(entry['effort']) } : {}),
+            },
+        ];
+    });
+}
+function remiConfigFromProfileRoles(profileRoles) {
+    const profiles = {};
+    for (const profile of profileRoles) {
+        profiles[profile.name] = {
+            roles: profile.roles,
+            ...(profile.extends ? { extends: profile.extends } : {}),
+            ...(profile.effort ? { effort: profile.effort } : {}),
+        };
+    }
+    return { profiles };
+}
+function parseSimpleHooks(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.flatMap(entry => {
+        if (!isRecord(entry)) {
+            return [];
+        }
+        const event = normalizeHookEventName(stringValue(entry['event']));
+        const command = stringValue(entry['command']);
+        if (!event || !command) {
+            return [];
+        }
+        return [
+            {
+                event,
+                command,
+                ...(stringValue(entry['matcher']) ? { matcher: stringValue(entry['matcher']) } : {}),
+                ...(numberValue(entry['timeout']) !== undefined ? { timeout: numberValue(entry['timeout']) } : {}),
+                ...(stringValue(entry['status_message']) ? { statusMessage: stringValue(entry['status_message']) } : {}),
+                ...(stringValue(entry['if']) ? { if: stringValue(entry['if']) } : {}),
+                ...(typeof entry['once'] === 'boolean' ? { once: entry['once'] } : {}),
+            },
+        ];
+    });
+}
+function hooksConfigFromSimpleHooks(hooks) {
+    const result = {};
+    for (const hook of hooks) {
+        const matcher = hook.matcher ?? '*';
+        const existing = result[hook.event] ?? [];
+        const group = existing.find(item => (item.matcher ?? '*') === matcher);
+        const command = {
+            type: 'command',
+            command: hook.command,
+            ...(hook.timeout !== undefined ? { timeout: hook.timeout } : {}),
+            ...(hook.statusMessage ? { statusMessage: hook.statusMessage } : {}),
+            ...(hook.if ? { if: hook.if } : {}),
+            ...(hook.once !== undefined ? { once: hook.once } : {}),
+        };
+        if (group) {
+            group.hooks.push(command);
+        }
+        else {
+            existing.push({ matcher, hooks: [command] });
+            result[hook.event] = existing;
+        }
+    }
+    return result;
+}
+function normalizeHookEventName(value) {
+    if (!value) {
+        return undefined;
+    }
+    const direct = hookEventNames.find(eventName => eventName === value);
+    if (direct) {
+        return direct;
+    }
+    return hookEventNames.find(eventName => hookEventNameToToml(eventName) === value);
+}
+function hookEventNameToToml(eventName) {
+    return eventName.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toLowerCase();
+}
+function stringValue(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function numberValue(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every(item => typeof item === 'string');
+}
+export function serializeRemiConfigToToml(config) {
+    const lines = [];
+    writeTomlRoot(lines, 'active_profile', config.activeProfile);
+    writeTomlRoot(lines, 'language', config.language);
+    writeTomlRoot(lines, 'response_style', config.responseStyle);
+    writeTomlRoot(lines, 'syntax_theme', config.syntaxTheme);
+    writeTomlRoot(lines, 'accent_color', config.accentColor);
+    writeTomlSection(lines, 'permissions', {
+        mode: config.permissions?.mode,
+        profile: config.permissions?.profile,
+    });
+    for (const rule of config.permissions?.allow ?? []) {
+        writeTomlTableArray(lines, 'permissions.allow', permissionAllowRuleToToml(rule));
+    }
+    writeTomlSection(lines, 'agent', {
+        max_turns: config.agent?.maxTurns,
+        max_tool_calls: config.agent?.maxToolCalls,
+        auto_compact: config.agent?.autoCompact,
+        compact_strategy: config.agent?.compactStrategy,
+        auto_compact_threshold_percent: config.agent?.autoCompactThresholdPercent,
+        context_safety_buffer_tokens: config.agent?.contextSafetyBufferTokens,
+        max_output_reserve_tokens: config.agent?.maxOutputReserveTokens,
+    });
+    writeTomlSection(lines, 'status_line', {
+        items: config.statusLine?.items,
+    });
+    writeTomlSection(lines, 'skills', {
+        disabled: config.skills?.disabled,
+    });
+    writeMcpConfig(lines, config.mcp);
+    for (const profile of simpleProfilesFromRemiConfig(config)) {
+        const profileName = profile.name ?? profile.modelId;
+        const defaultMaxOutputTokens = defaultSimpleMaxOutputTokens(profile.modelId);
+        writeTomlTableArray(lines, 'profiles', {
+            name: profileName === profile.modelId ? undefined : profileName,
+            provider: profile.provider,
+            model_id: profile.modelId,
+            base_url: profile.baseUrl,
+            api_key: profile.apiKey,
+            api_key_env: profile.apiKeyEnv,
+            display_name: profile.displayName,
+            context_window: profile.contextWindow,
+            max_output_tokens: profile.maxOutputTokens !== undefined && profile.maxOutputTokens !== defaultMaxOutputTokens ? profile.maxOutputTokens : undefined,
+            supports_tools: profile.supportsTools === false ? false : undefined,
+            supports_reasoning: profile.supportsReasoning === false ? false : undefined,
+            effort: profile.effort && profile.effort !== 'max' ? profile.effort : undefined,
+        });
+    }
+    for (const profile of profileRolesFromRemiConfig(config)) {
+        writeTomlTableArray(lines, 'profile_roles', {
+            name: profile.name,
+            extends: profile.extends,
+            main: profile.roles.main,
+            planning: profile.roles.planning,
+            subagent: profile.roles.subagent,
+            compact: profile.roles.compact,
+            memory: profile.roles.memory,
+            toolRepair: profile.roles.toolRepair,
+            embedding: profile.roles.embedding,
+            effort: profile.effort,
+        });
+    }
+    for (const hook of simpleHooksFromRemiConfig(config.hooks)) {
+        writeTomlTableArray(lines, 'hooks', {
+            event: hookEventNameToToml(hook.event),
+            matcher: hook.matcher,
+            command: hook.command,
+            timeout: hook.timeout,
+            status_message: hook.statusMessage,
+            if: hook.if,
+            once: hook.once,
+        });
+    }
+    return `${lines.join('\n').replace(/\n{3,}/g, '\n\n').trim()}\n`;
+}
+function writeMcpConfig(lines, mcp) {
+    for (const [name, server] of Object.entries(mcp?.servers ?? {}).sort(([left], [right]) => left.localeCompare(right))) {
+        writeTomlSection(lines, `mcp.servers.${name}`, {
+            type: server.type,
+            command: server.command,
+            args: server.args,
+            cwd: server.cwd,
+            enabled: server.enabled,
+            timeout_ms: server.timeoutMs,
+        });
+        writeTomlSection(lines, `mcp.servers.${name}.env`, server.env ?? {});
+    }
+}
+function permissionAllowRuleToToml(rule) {
+    if (rule.kind === 'shell-prefix') {
+        return {
+            kind: rule.kind,
+            prefix: rule.prefix,
+            cwd: rule.cwd,
+            created_at: rule.createdAt,
+        };
+    }
+    if (rule.kind === 'filesystem-write-root') {
+        return {
+            kind: rule.kind,
+            root: rule.root,
+            operations: rule.operations,
+            created_at: rule.createdAt,
+        };
+    }
+    return {
+        kind: rule.kind,
+        tool_name: rule.toolName,
+        created_at: rule.createdAt,
+    };
+}
+function simpleProfilesFromRemiConfig(config) {
+    return Object.entries(config.models ?? {}).flatMap(([name, model]) => {
+        const provider = config.providers?.[model.provider];
+        if (!provider) {
+            return [];
+        }
+        const profile = config.profiles?.[name];
+        return [
+            {
+                name,
+                provider: provider.type,
+                modelId: model.model,
+                baseUrl: provider.baseURL,
+                contextWindow: model.contextWindow,
+                ...(provider.apiKey ? { apiKey: provider.apiKey } : {}),
+                ...(provider.apiKeyEnv && !provider.apiKey ? { apiKeyEnv: provider.apiKeyEnv } : {}),
+                ...(model.displayName ? { displayName: model.displayName } : {}),
+                ...(model.maxOutputTokens !== undefined ? { maxOutputTokens: model.maxOutputTokens } : {}),
+                supportsTools: model.supportsTools,
+                supportsReasoning: model.supportsReasoning,
+                ...(profile?.effort ? { effort: profile.effort } : {}),
+            },
+        ];
+    });
+}
+function profileRolesFromRemiConfig(config) {
+    return Object.entries(config.profiles ?? {}).flatMap(([name, profile]) => {
+        if (config.models?.[name]) {
+            return [];
+        }
+        return [
+            {
+                name,
+                roles: profile.roles,
+                ...(profile.extends ? { extends: profile.extends } : {}),
+                ...(profile.effort ? { effort: profile.effort } : {}),
+            },
+        ];
+    });
+}
+function simpleHooksFromRemiConfig(hooks) {
+    return hookEventNames.flatMap(event => (hooks?.[event] ?? []).flatMap(group => group.hooks.flatMap(hook => hook.type === 'command'
+        ? [
+            {
+                event,
+                matcher: group.matcher,
+                command: hook.command,
+                timeout: hook.timeout,
+                statusMessage: hook.statusMessage,
+                if: hook.if,
+                once: hook.once,
+            },
+        ]
+        : [])));
+}
+function writeTomlRoot(lines, key, value) {
+    if (value !== undefined) {
+        lines.push(`${key} = ${formatTomlValue(value)}`);
+    }
+}
+function writeTomlSection(lines, name, values) {
+    const entries = Object.entries(values).filter(([, value]) => value !== undefined && (!Array.isArray(value) || value.length > 0));
+    if (entries.length === 0) {
+        return;
+    }
+    ensureBlankLine(lines);
+    lines.push(`[${name}]`);
+    for (const [key, value] of entries) {
+        lines.push(`${key} = ${formatTomlValue(value)}`);
+    }
+}
+function writeTomlTableArray(lines, name, values) {
+    const entries = Object.entries(values).filter(([, value]) => value !== undefined);
+    if (entries.length === 0) {
+        return;
+    }
+    ensureBlankLine(lines);
+    lines.push(`[[${name}]]`);
+    for (const [key, value] of entries) {
+        lines.push(`${key} = ${formatTomlValue(value)}`);
+    }
+}
+function ensureBlankLine(lines) {
+    if (lines.length > 0 && lines.at(-1) !== '') {
+        lines.push('');
+    }
+}
+function formatTomlValue(value) {
+    if (typeof value === 'string') {
+        return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map(formatTomlValue).join(', ')}]`;
+    }
+    return '""';
+}
+function parseToml(text) {
+    const root = {};
+    let current = root;
+    for (const rawLine of text.split(/\r?\n/u)) {
+        const line = stripTomlComment(rawLine).trim();
+        if (!line) {
+            continue;
+        }
+        const tableArrayMatch = /^\[\[([^\]]+)\]\]$/u.exec(line);
+        if (tableArrayMatch?.[1]) {
+            const items = getTomlArray(root, tableArrayMatch[1]);
+            current = {};
+            items.push(current);
+            continue;
+        }
+        const tableMatch = /^\[([^\]]+)\]$/u.exec(line);
+        if (tableMatch?.[1]) {
+            current = getTomlTable(root, tableMatch[1]);
+            continue;
+        }
+        const assignment = splitTomlAssignment(line);
+        if (!assignment) {
+            throw new Error(`Invalid TOML line: ${rawLine}`);
+        }
+        current[assignment.key] = parseTomlValue(assignment.value);
+    }
+    return root;
+}
+function stripTomlComment(line) {
+    let inString = false;
+    let escaped = false;
+    for (let index = 0; index < line.length; index += 1) {
+        const char = line[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (char === '\\') {
+            escaped = true;
+            continue;
+        }
+        if (char === '"') {
+            inString = !inString;
+            continue;
+        }
+        if (char === '#' && !inString) {
+            return line.slice(0, index);
+        }
+    }
+    return line;
+}
+function splitTomlAssignment(line) {
+    let inString = false;
+    let escaped = false;
+    for (let index = 0; index < line.length; index += 1) {
+        const char = line[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (char === '\\') {
+            escaped = true;
+            continue;
+        }
+        if (char === '"') {
+            inString = !inString;
+            continue;
+        }
+        if (char === '=' && !inString) {
+            const key = line.slice(0, index).trim();
+            const value = line.slice(index + 1).trim();
+            return key && value ? { key: unquoteTomlString(key), value } : undefined;
+        }
+    }
+    return undefined;
+}
+function parseTomlValue(value) {
+    if (value.startsWith('"') && value.endsWith('"')) {
+        return unquoteTomlString(value);
+    }
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    if (value.startsWith('[') && value.endsWith(']')) {
+        return splitTomlArray(value.slice(1, -1)).map(parseTomlValue);
+    }
+    const numeric = Number(value.replace(/_/g, ''));
+    if (Number.isFinite(numeric)) {
+        return numeric;
+    }
+    throw new Error(`Unsupported TOML value: ${value}`);
+}
+function splitTomlArray(value) {
+    const items = [];
+    let current = '';
+    let inString = false;
+    let escaped = false;
+    for (const char of value) {
+        if (escaped) {
+            current += char;
+            escaped = false;
+            continue;
+        }
+        if (char === '\\') {
+            current += char;
+            escaped = true;
+            continue;
+        }
+        if (char === '"') {
+            current += char;
+            inString = !inString;
+            continue;
+        }
+        if (char === ',' && !inString) {
+            if (current.trim())
+                items.push(current.trim());
+            current = '';
+            continue;
+        }
+        current += char;
+    }
+    if (current.trim())
+        items.push(current.trim());
+    return items;
+}
+function unquoteTomlString(value) {
+    const trimmed = value.trim();
+    const unquoted = trimmed.startsWith('"') && trimmed.endsWith('"') ? trimmed.slice(1, -1) : trimmed;
+    return unquoted.replace(/\\"/g, '"').replace(/\\\\/g, '\\');
+}
+function getTomlTable(root, path) {
+    let current = root;
+    for (const part of tomlPathParts(path)) {
+        const existing = current[part];
+        if (existing !== undefined && !isRecord(existing)) {
+            throw new Error(`TOML table conflicts with existing value: ${path}`);
+        }
+        if (!existing) {
+            current[part] = {};
+        }
+        current = current[part];
+    }
+    return current;
+}
+function getTomlArray(root, path) {
+    const parts = tomlPathParts(path);
+    const key = parts.pop();
+    if (!key) {
+        throw new Error(`Invalid TOML table array: ${path}`);
+    }
+    const parent = parts.length > 0 ? getTomlTable(root, parts.join('.')) : root;
+    const existing = parent[key];
+    if (existing !== undefined && !Array.isArray(existing)) {
+        throw new Error(`TOML table array conflicts with existing value: ${path}`);
+    }
+    if (!existing) {
+        parent[key] = [];
+    }
+    return parent[key];
+}
+function tomlPathParts(path) {
+    return path.split('.').map(part => unquoteTomlString(part.trim())).filter(Boolean);
+}