codexmate 0.0.28 → 0.0.30

package/cli/builtin-proxy.js

@@ -127,6 +127,42 @@ function createBuiltinProxyRuntimeController(deps = {}) {
         return false;
     }
 
+    function isTransientNetworkError(error) {
+        const text = String(error || '').trim();
+        if (!text) return false;
+        if (/socket hang up/i.test(text)) return true;
+        if (/ECONNRESET|ECONNREFUSED|EPIPE|EPROTO|ETIMEDOUT/i.test(text)) return true;
+        if (/EAI_AGAIN/i.test(text)) return true;
+        if (/UND_ERR_SOCKET/i.test(text)) return true;
+        if (/disconnected before|secure tls|tls handshake/i.test(text)) return true;
+        return false;
+    }
+
+    const TRANSIENT_RETRY_DELAYS_MS = [200, 600];
+
+    async function retryTransientRequest(executor) {
+        let lastResult = null;
+        for (let attempt = 0; attempt <= TRANSIENT_RETRY_DELAYS_MS.length; attempt += 1) {
+            if (attempt > 0) {
+                const delay = TRANSIENT_RETRY_DELAYS_MS[attempt - 1];
+                // eslint-disable-next-line no-await-in-loop
+                await new Promise((r) => {
+                    const t = setTimeout(r, delay);
+                    if (typeof t.unref === 'function') t.unref();
+                });
+            }
+            // eslint-disable-next-line no-await-in-loop
+            const result = await executor(attempt);
+            lastResult = result;
+            if (!result) return result;
+            if (result.ok) return result;
+            if (result.retry) return result;
+            if (result.status && result.status > 0) return result;
+            if (!isTransientNetworkError(result.error)) return result;
+        }
+        return lastResult;
+    }
+
     function proxyRequestJson(targetUrl, options = {}) {
         const parsed = new URL(targetUrl);
         const transport = parsed.protocol === 'https:' ? https : http;
@@ -206,7 +242,7 @@ function createBuiltinProxyRuntimeController(deps = {}) {
         }
         let lastResult = null;
         for (let index = 0; index < urls.length; index += 1) {
-            const result = await proxyRequestJson(urls[index], options);
+            const result = await retryTransientRequest(() => proxyRequestJson(urls[index], options));
             lastResult = result;
             if (!result.ok) {
                 return result;
@@ -702,9 +738,34 @@ function createBuiltinProxyRuntimeController(deps = {}) {
         }
     }
 
+    function stopChatStreamHeartbeat(state) {
+        if (!state || !state.heartbeatTimer) return;
+        clearInterval(state.heartbeatTimer);
+        state.heartbeatTimer = null;
+    }
+
+    function startChatStreamHeartbeat(state) {
+        if (!state || state.heartbeatTimer) return;
+        const timer = setInterval(() => {
+            if (state.finished) {
+                stopChatStreamHeartbeat(state);
+                return;
+            }
+            const target = state.res;
+            if (!target || target.writableEnded || target.destroyed) {
+                stopChatStreamHeartbeat(state);
+                return;
+            }
+            try { target.write(': keepalive\n\n'); } catch (_) {}
+        }, 15000);
+        if (typeof timer.unref === 'function') timer.unref();
+        state.heartbeatTimer = timer;
+    }
+
     function finishChatStreamResponsesSse(state) {
         if (state.finished) return;
         state.finished = true;
+        stopChatStreamHeartbeat(state);
 
         if (state.messageItem) {
             const outputIndex = state.output.indexOf(state.messageItem);
@@ -759,6 +820,22 @@ function createBuiltinProxyRuntimeController(deps = {}) {
         state.res.end();
     }
 
+    function failResponsesSseRaw(res, message) {
+        if (!res || res.writableEnded || res.destroyed) return;
+        try {
+            writeSse(res, 'response.failed', { type: 'response.failed', error: message || 'upstream stream failed' });
+            writeSse(res, 'done', '[DONE]');
+            res.end();
+        } catch (_) {}
+    }
+
+    function failChatStreamResponsesSse(state, message) {
+        if (!state || state.finished) return;
+        state.finished = true;
+        stopChatStreamHeartbeat(state);
+        failResponsesSseRaw(state.res, message);
+    }
+
     function streamChatCompletionsAsResponsesSse(targetUrl, options = {}) {
         const parsed = new URL(targetUrl);
         const transport = parsed.protocol === 'https:' ? https : http;
@@ -796,6 +873,29 @@ function createBuiltinProxyRuntimeController(deps = {}) {
                 const status = upstreamRes.statusCode || 0;
                 const chunks = [];
                 const contentType = String(upstreamRes.headers && upstreamRes.headers['content-type'] || '');
+                let streamState = null;
+
+                const handleAbort = (reason) => {
+                    if (settled) return;
+                    if (streamState) {
+                        failChatStreamResponsesSse(streamState, reason);
+                        finish({ ok: true });
+                        return;
+                    }
+                    if (res.headersSent) {
+                        failResponsesSseRaw(res, reason);
+                        finish({ ok: true });
+                        return;
+                    }
+                    finish({
+                        ok: false,
+                        status,
+                        error: reason,
+                        bodyText: chunks.length ? Buffer.concat(chunks).toString('utf-8') : ''
+                    });
+                };
+                upstreamRes.on('error', (err) => handleAbort(err && err.message ? err.message : 'upstream stream failed'));
+                upstreamRes.on('aborted', () => handleAbort('upstream stream aborted'));
 
                 if (status === 404 || status === 405) {
                     upstreamRes.on('data', (chunk) => chunk && chunks.push(chunk));
@@ -851,6 +951,11 @@ function createBuiltinProxyRuntimeController(deps = {}) {
                         return sequence;
                     }
                 };
+                streamState = state;
+                startChatStreamHeartbeat(state);
+                if (typeof res.on === 'function') {
+                    res.on('close', () => stopChatStreamHeartbeat(state));
+                }
                 writeSse(res, 'response.created', {
                     type: 'response.created',
                     response: {
@@ -914,7 +1019,7 @@ function createBuiltinProxyRuntimeController(deps = {}) {
         }
         let lastResult = null;
         for (const url of urls) {
-            const result = await streamChatCompletionsAsResponsesSse(url, options);
+            const result = await retryTransientRequest(() => streamChatCompletionsAsResponsesSse(url, options));
             lastResult = result;
             if (result && result.retry) continue;
             return result;

package/cli/config-bootstrap.js

@@ -30,6 +30,7 @@ function createConfigBootstrapController(deps = {}) {
         DEFAULT_MODEL_AUTO_COMPACT_TOKEN_LIMIT,
         CODEXMATE_MANAGED_MARKER,
         BUILTIN_PROXY_PROVIDER_NAME,
+        BUILTIN_LOCAL_PROVIDER_NAME,
         EMPTY_CONFIG_FALLBACK_TEMPLATE
     } = deps;
 
@@ -58,6 +59,7 @@ function createConfigBootstrapController(deps = {}) {
     if (!Array.isArray(DEFAULT_MODELS)) throw new Error('createConfigBootstrapController 缺少 DEFAULT_MODELS');
     if (!CODEXMATE_MANAGED_MARKER) throw new Error('createConfigBootstrapController 缺少 CODEXMATE_MANAGED_MARKER');
     if (!BUILTIN_PROXY_PROVIDER_NAME) throw new Error('createConfigBootstrapController 缺少 BUILTIN_PROXY_PROVIDER_NAME');
+    if (!BUILTIN_LOCAL_PROVIDER_NAME) throw new Error('createConfigBootstrapController 缺少 BUILTIN_LOCAL_PROVIDER_NAME');
     if (typeof EMPTY_CONFIG_FALLBACK_TEMPLATE !== 'string') throw new Error('createConfigBootstrapController 缺少 EMPTY_CONFIG_FALLBACK_TEMPLATE');
 
     let initNotice = '';
@@ -118,17 +120,18 @@ function createConfigBootstrapController(deps = {}) {
         return `${CODEXMATE_MANAGED_MARKER}
 # codexmate-initialized-at: ${initializedAt}
 
-model_provider = "openai"
+model_provider = "local"
 model = "${defaultModel}"
 model_context_window = ${DEFAULT_MODEL_CONTEXT_WINDOW}
 model_auto_compact_token_limit = ${DEFAULT_MODEL_AUTO_COMPACT_TOKEN_LIMIT}
 
-[model_providers.openai]
-name = "openai"
-base_url = "https://api.openai.com/v1"
+[model_providers.local]
+name = "local"
+base_url = "http://127.0.0.1:3737/bridge/local/v1"
 wire_api = "responses"
-requires_openai_auth = false
-preferred_auth_method = ""
+requires_openai_auth = true
+preferred_auth_method = "codexmate"
+codexmate_bridge = "local"
 request_max_retries = 4
 stream_max_retries = 10
 stream_idle_timeout_ms = 300000
@@ -145,9 +148,8 @@ stream_idle_timeout_ms = 300000
         const currentProvider = typeof safeConfig.model_provider === 'string' ? safeConfig.model_provider.trim() : '';
         const hasRemovedBuiltin = !!(providers && providers[BUILTIN_PROXY_PROVIDER_NAME]);
         const currentIsRemovedBuiltin = currentProvider === BUILTIN_PROXY_PROVIDER_NAME;
-        const currentIsRemovedVirtualLocal = currentProvider === 'local' && !(providers && isPlainObject(providers.local));
 
-        if (!hasRemovedBuiltin && !currentIsRemovedBuiltin && !currentIsRemovedVirtualLocal) {
+        if (!hasRemovedBuiltin && !currentIsRemovedBuiltin) {
             return safeConfig;
         }
 
@@ -163,11 +165,26 @@ stream_idle_timeout_ms = 300000
         return {
             ...safeConfig,
             model_providers: nextProviders,
-            model_provider: (currentIsRemovedBuiltin || currentIsRemovedVirtualLocal) ? fallbackProvider : safeConfig.model_provider,
-            model: (currentIsRemovedBuiltin || currentIsRemovedVirtualLocal) ? fallbackModel : safeConfig.model
+            model_provider: currentIsRemovedBuiltin ? fallbackProvider : safeConfig.model_provider,
+            model: currentIsRemovedBuiltin ? fallbackModel : safeConfig.model
         };
     }
 
+    function ensureLocalProviderSection() {
+        if (!fs.existsSync(CONFIG_FILE)) return;
+        let content;
+        try {
+            content = fs.readFileSync(CONFIG_FILE, 'utf-8');
+        } catch (e) {
+            return;
+        }
+        // Check if [model_providers.local] section already exists
+        if (/\[model_providers\.local\]/.test(content)) return;
+
+        const localSection = `\n[model_providers.local]\nname = "local"\nbase_url = "http://127.0.0.1:3737/bridge/local/v1"\nwire_api = "responses"\nrequires_openai_auth = true\npreferred_auth_method = "codexmate"\ncodexmate_bridge = "local"\nrequest_max_retries = 4\nstream_max_retries = 10\nstream_idle_timeout_ms = 300000\n`;
+        fs.appendFileSync(CONFIG_FILE, localSection, 'utf-8');
+    }
+
     function readConfigOrVirtualDefault() {
         if (fs.existsSync(CONFIG_FILE)) {
             try {
@@ -260,7 +277,7 @@ stream_idle_timeout_ms = 300000
         ensureConfigDir();
 
         const initializedAt = new Date().toISOString();
-        const defaultProvider = 'openai';
+        const defaultProvider = 'local';
         const defaultModel = DEFAULT_MODELS[0] || 'gpt-4';
         const forceResetExistingConfig = process.env.CODEXMATE_FORCE_RESET_EXISTING_CONFIG === '1';
         const mark = readJsonFile(INIT_MARK_FILE, null);
@@ -273,6 +290,7 @@ stream_idle_timeout_ms = 300000
                 initNotice = '检测到配置缺失，已自动重建默认配置。';
                 return { notice: initNotice };
             }
+            ensureLocalProviderSection();
             ensureSupportFiles(defaultProvider, defaultModel);
             return { notice: '' };
         }
@@ -338,7 +356,7 @@ stream_idle_timeout_ms = 300000
     function resetConfigToDefault() {
         ensureConfigDir();
         const initializedAt = new Date().toISOString();
-        const defaultProvider = 'openai';
+        const defaultProvider = 'local';
         const defaultModel = DEFAULT_MODELS[0] || 'gpt-4';
 
         let backupFile = '';

package/cli/config-health.js

@@ -332,7 +332,123 @@ async function buildConfigHealthReport(params = {}, deps = {}) {
     };
 }
 
+async function buildAllProvidersHealthReport(params = {}, deps = {}) {
+    const {
+        readConfigOrVirtualDefault,
+        readCurrentModels,
+        probeJsonPost: probeJsonPostDep
+    } = deps;
+
+    if (typeof readConfigOrVirtualDefault !== 'function') {
+        throw new Error('buildAllProvidersHealthReport 缺少 readConfigOrVirtualDefault 依赖');
+    }
+
+    const status = readConfigOrVirtualDefault();
+    const config = status.config || {};
+    const providerEntries = config.model_providers && typeof config.model_providers === 'object'
+        ? Object.entries(config.model_providers)
+        : [];
+    const currentProvider = typeof config.model_provider === 'string' ? config.model_provider.trim() : '';
+    const currentModels = typeof readCurrentModels === 'function' ? readCurrentModels() : {};
+
+    if (!providerEntries.length) {
+        return {
+            ok: true,
+            currentProvider,
+            providers: [],
+            summary: { total: 0, green: 0, yellow: 0, red: 0 }
+        };
+    }
+
+    const remote = !!(params && params.remote);
+    const timeoutMs = Number.isFinite(params && params.timeoutMs) ? Number(params.timeoutMs) : DEFAULT_TIMEOUT_MS;
+
+    const entries = providerEntries.map(([name, provider]) => {
+        const baseUrl = typeof provider.base_url === 'string' ? provider.base_url.trim() : '';
+        const requiresAuth = provider.requires_openai_auth !== false;
+        const apiKey = typeof provider.preferred_auth_method === 'string'
+            ? provider.preferred_auth_method.trim() : '';
+        const modelName = currentModels[name] || (name === currentProvider ? (config.model || '').trim() : '');
+
+        const checks = {
+            baseUrlValid: isValidHttpUrl(baseUrl),
+            apiKeyPresent: !requiresAuth || !!apiKey
+        };
+
+        const issues = [];
+        if (!baseUrl) {
+            issues.push({ code: 'base-url-empty', message: `${name} 的 base_url 为空`, suggestion: '设置 base_url' });
+        } else if (!checks.baseUrlValid) {
+            issues.push({ code: 'base-url-invalid', message: `${name} 的 base_url 无效`, suggestion: '设置为 http/https 完整 URL' });
+        }
+        if (!checks.apiKeyPresent) {
+            issues.push({ code: 'api-key-missing', message: `${name} 未配置 API Key`, suggestion: '设置 preferred_auth_method' });
+        }
+
+        return { name, provider, baseUrl, modelName, checks, issues };
+    });
+
+    if (remote) {
+        const remotePromises = entries.map(async (entry) => {
+            if (!entry.checks.baseUrlValid || !entry.modelName) {
+                entry.remote = null;
+                return;
+            }
+            try {
+                const report = await runRemoteHealthCheck(entry.name, entry.provider, entry.modelName, {
+                    timeoutMs,
+                    probeJsonPost: probeJsonPostDep
+                });
+                entry.remote = report.remote;
+                entry.issues.push(...report.issues);
+            } catch (e) {
+                entry.remote = null;
+                entry.issues.push({
+                    code: 'remote-probe-error',
+                    message: `${entry.name} 远程探测异常: ${e.message}`,
+                    suggestion: '检查网络连接与 endpoint'
+                });
+            }
+        });
+        await Promise.allSettled(remotePromises);
+    }
+
+    const providers = entries.map((entry) => {
+        const hasConfigIssue = !entry.checks.baseUrlValid || !entry.checks.apiKeyPresent;
+        const remoteFailed = entry.remote && !entry.remote.ok;
+        let statusValue = 'green';
+        if (remoteFailed) {
+            statusValue = 'red';
+        } else if (hasConfigIssue) {
+            statusValue = 'yellow';
+        }
+        return {
+            provider: entry.name,
+            isCurrent: entry.name === currentProvider,
+            status: statusValue,
+            checks: entry.checks,
+            remote: entry.remote || null,
+            issues: entry.issues
+        };
+    });
+
+    const summary = {
+        total: providers.length,
+        green: providers.filter((p) => p.status === 'green').length,
+        yellow: providers.filter((p) => p.status === 'yellow').length,
+        red: providers.filter((p) => p.status === 'red').length
+    };
+
+    return {
+        ok: summary.red === 0 && summary.yellow === 0,
+        currentProvider,
+        providers,
+        summary
+    };
+}
+
 module.exports = {
     runRemoteHealthCheck,
-    buildConfigHealthReport
+    buildConfigHealthReport,
+    buildAllProvidersHealthReport
 };