fix: disambiguate nested legacy provider section targeting

Author: SurviveM

cli.js

@@ -330,6 +330,7 @@ function collectNestedProviderConfigs(node, pathSegments, collector) {
     if (isRecoverableNestedProviderConfig(node)) {
         collector.push({
             name: segments.join('.'),
+            segments: segments.slice(),
             provider: node
         });
         return;
@@ -349,10 +350,21 @@ function normalizeLegacyModelProviders(modelProviders) {
     const normalized = {};
     const addRecovered = (entry) => {
         const name = entry && typeof entry.name === 'string' ? entry.name : '';
+        const segments = entry && Array.isArray(entry.segments) ? entry.segments.slice() : null;
         const provider = entry ? entry.provider : null;
         if (!name || !isPlainObject(provider)) return;
         if (Object.prototype.hasOwnProperty.call(modelProviders, name)) return;
         if (Object.prototype.hasOwnProperty.call(normalized, name)) return;
+        if (Array.isArray(segments) && segments.length > 0) {
+            try {
+                Object.defineProperty(provider, '__codexmate_legacy_segments', {
+                    value: segments,
+                    enumerable: false,
+                    configurable: true,
+                    writable: true
+                });
+            } catch (e) {}
+        }
         normalized[name] = provider;
         changed = true;
     };
@@ -391,6 +403,14 @@ function escapeRegex(value) {
     return String(value || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
+function areStringArraysEqual(a, b) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+        if (String(a[i]) !== String(b[i])) return false;
+    }
+    return true;
+}
+
 function parseTomlDottedKeyExpression(expression) {
     const text = String(expression || '');
     let index = 0;
@@ -471,9 +491,10 @@ function parseTomlDottedKeyExpression(expression) {
     return segments.length > 0 ? segments : null;
 }
 
-function findProviderSectionRanges(content, providerName) {
+function findProviderSectionRanges(content, providerName, exactSegments = null) {
     const text = typeof content === 'string' ? content : '';
     const name = typeof providerName === 'string' ? providerName.trim() : '';
+    const targetSegments = Array.isArray(exactSegments) ? exactSegments.map((item) => String(item)) : null;
     if (!text || !name) return [];
 
     const safeName = escapeRegex(name);
@@ -494,14 +515,24 @@ function findProviderSectionRanges(content, providerName) {
 
         const parsedSegments = parseTomlDottedKeyExpression(headerExpr);
         if (Array.isArray(parsedSegments) && parsedSegments.length >= 2 && parsedSegments[0] === 'model_providers') {
-            const parsedName = parsedSegments.slice(1).join('.');
-            if (parsedName === name) {
+            const providerSegments = parsedSegments.slice(1);
+            if (targetSegments && targetSegments.length > 0 && areStringArraysEqual(providerSegments, targetSegments)) {
                 const prev = targetPriorityByStart.get(start);
-                if (prev === undefined || -2 < prev) {
-                    targetPriorityByStart.set(start, -2);
+                if (prev === undefined || -3 < prev) {
+                    targetPriorityByStart.set(start, -3);
                 }
                 continue;
             }
+            if (!targetSegments || targetSegments.length === 0) {
+                const parsedName = providerSegments.join('.');
+                if (parsedName === name) {
+                    const prev = targetPriorityByStart.get(start);
+                    if (prev === undefined || -2 < prev) {
+                        targetPriorityByStart.set(start, -2);
+                    }
+                    continue;
+                }
+            }
         }
 
         for (const pattern of headerPatterns) {
@@ -2058,6 +2089,10 @@ function performProviderDeletion(name, options = {}) {
     const content = fs.readFileSync(CONFIG_FILE, 'utf-8');
     const lineEnding = content.includes('\r\n') ? '\r\n' : '\n';
     const hasBom = content.charCodeAt(0) === 0xFEFF;
+    const providerConfig = config.model_providers[name];
+    const providerSegments = providerConfig && Array.isArray(providerConfig.__codexmate_legacy_segments)
+        ? providerConfig.__codexmate_legacy_segments
+        : null;
 
     const remainingProviders = Object.keys(config.model_providers || {}).filter(item => item !== name);
     if (remainingProviders.length === 0) {
@@ -2096,7 +2131,7 @@ function performProviderDeletion(name, options = {}) {
     };
 
     let updatedContent = null;
-    const ranges = findProviderSectionRanges(content, name);
+    const ranges = findProviderSectionRanges(content, name, providerSegments);
     if (ranges.length > 0) {
         const sorted = ranges.sort((a, b) => b.start - a.start);
         let removedContent = content;
@@ -5361,7 +5396,11 @@ function cmdUpdate(name, baseUrl, apiKey, silent = false, options = {}) {
     }
 
     const content = fs.readFileSync(CONFIG_FILE, 'utf-8');
-    const ranges = findProviderSectionRanges(content, name);
+    const providerConfig = config.model_providers[name];
+    const providerSegments = providerConfig && Array.isArray(providerConfig.__codexmate_legacy_segments)
+        ? providerConfig.__codexmate_legacy_segments
+        : null;
+    const ranges = findProviderSectionRanges(content, name, providerSegments);
     if (ranges.length === 0) {
         if (!silent) console.error('错误: 无法找到提供商配置块');
         throw new Error('无法找到提供商配置块');

tests/e2e/test-config.js

@@ -460,6 +460,48 @@ module.exports = async function testConfig(ctx) {
             'update-provider should preserve preferred_auth_method inline comment'
         );
 
+        const multilineStringConfig = [
+            'model_provider = "foo"',
+            'model = "gpt-5.3-codex"',
+            '',
+            '[model_providers.foo]',
+            'name = "foo"',
+            'base_url = "https://api.example.com/v1"',
+            'wire_api = "responses"',
+            'requires_openai_auth = false',
+            'preferred_auth_method = """sk-old',
+            'line-2""" # keep-triple-comment',
+            'request_max_retries = 4',
+            'stream_max_retries = 10',
+            'stream_idle_timeout_ms = 300000',
+            '',
+            '[model_providers.openai]',
+            'name = "openai"',
+            'base_url = "https://api.openai.com/v1"',
+            'wire_api = "responses"',
+            'requires_openai_auth = false',
+            'preferred_auth_method = ""',
+            'request_max_retries = 4',
+            'stream_max_retries = 10',
+            'stream_idle_timeout_ms = 300000',
+            ''
+        ].join('\n');
+        fs.writeFileSync(legacyConfigPath, multilineStringConfig, 'utf-8');
+        const updateMultilineString = await legacyApi('update-provider', {
+            name: 'foo',
+            key: 'sk-triple-updated'
+        });
+        assert(updateMultilineString.success === true, 'update-provider should handle multiline TOML string values');
+        const configAfterMultilineUpdate = fs.readFileSync(legacyConfigPath, 'utf-8');
+        assert(
+            configAfterMultilineUpdate.includes('preferred_auth_method = "sk-triple-updated" # keep-triple-comment'),
+            'update-provider should safely replace multiline TOML string and preserve comment'
+        );
+        assert(
+            !configAfterMultilineUpdate.includes('line-2"""'),
+            'update-provider should remove previous multiline TOML string tail'
+        );
+
         const nestedMetadataConfig = [
             'model_provider = "foo"',
             'model = "gpt-5.3-codex"',
@@ -536,6 +578,69 @@ module.exports = async function testConfig(ctx) {
             'nested provider with dotted segment should update apiKey'
         );
 
+        const ambiguousNestedProviderConfig = [
+            'model_provider = "foo"',
+            'model = "gpt-5.3-codex"',
+            '',
+            '[model_providers.foo]',
+            'name = "foo"',
+            'base_url = "https://api.example.com/v1"',
+            'wire_api = "responses"',
+            'requires_openai_auth = false',
+            'preferred_auth_method = "sk-foo"',
+            'request_max_retries = 4',
+            'stream_max_retries = 10',
+            'stream_idle_timeout_ms = 300000',
+            '',
+            "[ model_providers . foo . 'bar.baz' ]",
+            'base_url = "https://primary.example.com/v1"',
+            'wire_api = "responses"',
+            'preferred_auth_method = "sk-primary"',
+            '',
+            '[model_providers."foo.bar".baz]',
+            'base_url = "https://alt.example.com/v1"',
+            'wire_api = "responses"',
+            'preferred_auth_method = "sk-alt"',
+            ''
+        ].join('\n');
+        fs.writeFileSync(legacyConfigPath, ambiguousNestedProviderConfig, 'utf-8');
+        const ambiguousList = await legacyApi('list');
+        assert(
+            ambiguousList.providers.some((item) => item && item.name === 'foo.bar.baz'),
+            'ambiguous nested provider config should expose flattened provider name'
+        );
+        const ambiguousUpdate = await legacyApi('update-provider', {
+            name: 'foo.bar.baz',
+            url: 'https://primary-updated.example.com/v1',
+            key: 'sk-primary-updated'
+        });
+        assert(ambiguousUpdate.success === true, 'ambiguous nested provider update should succeed');
+        const configAfterAmbiguousUpdate = fs.readFileSync(legacyConfigPath, 'utf-8');
+        const primaryBlockMatch = configAfterAmbiguousUpdate.match(
+            /(?:^|\n)\s*\[\s*model_providers\s*\.\s*foo\s*\.\s*'bar\.baz'\s*\][\s\S]*?(?=\n\s*\[|$)/
+        );
+        assert(primaryBlockMatch, 'primary nested provider block should exist after ambiguous update');
+        assert(
+            primaryBlockMatch[0].includes('base_url = "https://primary-updated.example.com/v1"'),
+            'ambiguous update should target primary nested provider block url'
+        );
+        assert(
+            primaryBlockMatch[0].includes('preferred_auth_method = "sk-primary-updated"'),
+            'ambiguous update should target primary nested provider block key'
+        );
+        const alternateBlockMatch = configAfterAmbiguousUpdate.match(
+            /(?:^|\n)\s*\[\s*model_providers\s*\.\s*"foo\.bar"\s*\.\s*baz\s*\][\s\S]*?(?=\n\s*\[|$)/
+        );
+        assert(alternateBlockMatch, 'alternate nested provider block should exist after ambiguous update');
+        assert(
+            alternateBlockMatch[0].includes('base_url = "https://alt.example.com/v1"'),
+            'ambiguous update should not rewrite alternate nested provider block url'
+        );
+        assert(
+            alternateBlockMatch[0].includes('preferred_auth_method = "sk-alt"'),
+            'ambiguous update should not rewrite alternate nested provider block key'
+        );
+
         const ipv6Config = [
             'model_provider = "foo"',
             'model = "gpt-5.3-codex"',