codexmate 0.0.55 → 0.0.57

package/README.md

@@ -58,6 +58,7 @@ Unlike simple wrappers, Codex Mate acts as a **Local Agent Bridge**:
 - **OpenAI-Compatible Bridge**: Use Codex with any OpenAI-compatible UI by normalizing the Responses API; the built-in Codex conversion also fills and normalizes Codex fingerprint headers such as `User-Agent`, `Version`, `OpenAI-Beta`, and `Originator` so upstream providers see an official Codex CLI-shaped request.
 - **Claude Provider Bridge**: Connect Claude Code to OpenAI Chat Completions-compatible providers and Ollama through the built-in local Claude-compatible proxy.
 - **OpenCode Provider Control**: Manage OpenCode provider/model selection with a CodexMate-owned provider store under `~/.codexmate`, projecting only the active provider into native OpenCode config to avoid polluting or deleting user-owned settings.
+- **Provider Health Cleanup**: Probe local Codex and Claude provider routes, surface failed configs in one modal, and bulk-clean selected broken providers without touching healthy or protected entries.
 - **Skills Marketplace**: A local-first market to share and import skills between different agent apps.
 - **Prompt File Editor**: Unified editor for global and project-level `CLAUDE.md` and `AGENTS.md` with auto-detection of project paths.
 - **Task Orchestrator**: Plan and execute complex tasks with dependency tracking.
@@ -77,6 +78,7 @@ Unlike simple wrappers, Codex Mate acts as a **Local Agent Bridge**:
 | **OpenAI Bridge** | ✅ | Convert Codex Responses API to standard OpenAI format and attach/normalize Codex fingerprints in the built-in conversion |
 | **Claude Provider Bridge** | ✅ | Connect Claude Code to OpenAI Chat Completions-compatible providers and Ollama via the built-in Claude-compatible proxy |
 | **OpenCode Provider Store** | ✅ | Keep multiple OpenCode providers in `~/.codexmate` while projecting only the selected provider to native OpenCode config |
+| **Provider Health Check** | ✅ | Probe local Codex/Claude provider routes, highlight failed configs, and bulk-remove selected broken providers safely |
 | **Prompt Templates** | ✅ | Reusable prompt plugins with variables |
 | **Prompt File Editor** | ✅ | Edit global and project-level CLAUDE.md / AGENTS.md with auto-detect and path switching |
 | **MCP Integration** | ✅ | Expose local tools and resources via MCP stdio |

package/README.vi.md

@@ -48,6 +48,7 @@ Bạn có bao giờ cảm thấy rối khi phải quản lý nhiều AI agent c
 Khác với các wrapper đơn giản, Codex Mate hoạt động như một **Agent Bridge cục bộ**:
 - **Trình duyệt phiên thống nhất**: Tìm kiếm và xuất phiên làm việc từ tất cả tool trong một nơi duy nhất.
 - **Bridge tương thích OpenAI**: Dùng Codex với bất kỳ UI nào hỗ trợ OpenAI bằng cách chuẩn hóa Responses API.
+- **Dọn dẹp provider lỗi**: Kiểm tra route provider cục bộ của Codex/Claude, hiển thị cấu hình lỗi trong một modal và xóa hàng loạt các provider hỏng đã chọn mà không chạm vào mục khỏe mạnh hoặc được bảo vệ.
 - **Chợ skill cục bộ**: Chia sẻ và nhập skill giữa các app agent khác nhau.
 - **Điều phối tác vụ**: Lập kế hoạch và thực thi tác vụ phức tạp với theo dõi phụ thuộc.
 
@@ -64,6 +65,7 @@ Khác với các wrapper đơn giản, Codex Mate hoạt động như một **Ag
 | **Chợ skill cục bộ** | ✅ | Import/export skill giữa các app agent |
 | **Hàng đợi tác vụ** | ✅ | Thực thi tác vụ theo DAG và xem log |
 | **Bridge OpenAI** | ✅ | Chuyển đổi Codex Responses API sang định dạng OpenAI chuẩn |
+| **Kiểm tra sức khỏe Provider** | ✅ | Kiểm tra route provider Codex/Claude, đánh dấu cấu hình lỗi và xóa hàng loạt các provider hỏng đã chọn một cách an toàn |
 | **Mẫu Prompt** | ✅ | Plugin prompt tái sử dụng được với hỗ trợ biến |
 | **Tích hợp MCP** | ✅ | Expose tool và resource cục bộ qua MCP stdio |
 | **Tự động cập nhật** | ✅ | Cập nhật nhanh qua `codexmate update` |

package/README.zh.md

@@ -57,6 +57,7 @@
 - **OpenAI 兼容桥接**：通过归一化 Responses API，让 Codex 能够与任何支持 OpenAI 格式的 UI 配合使用；内建 Codex 转换会补齐并规范化 `User-Agent`、`Version`、`OpenAI-Beta`、`Originator` 等 Codex 指纹，对上游伪装为官方 Codex CLI 请求。
 - **Claude Provider 桥接**：通过内建本地 Claude 兼容代理，让 Claude Code 接入 OpenAI Chat Completions 兼容 provider 与 Ollama。
 - **OpenCode Provider 控制**：在 `~/.codexmate` 下维护 CodexMate 自有的 OpenCode 多 provider 存储，只将当前选中的 provider 投影到 OpenCode 原生配置，避免污染或误删用户已有配置。
+- **Provider 健康清理**：探测本地 Codex 与 Claude provider 路由，在同一个弹窗里集中展示失败配置，并批量清理已选坏配置，不影响正常或受保护项。
 - **Skills 市场**：本地优先的市场，支持在不同的智能体应用之间共享和导入 Skills。
 - **提示词文件编辑器**：统一编辑全局和项目级 `CLAUDE.md` 与 `AGENTS.md`，支持项目路径自动检测。
 - **任务编排器**：支持带有依赖跟踪的复杂任务规划与执行。
@@ -76,6 +77,7 @@
 | **OpenAI 桥接** | ✅ | 将 Codex Responses API 转换为标准 OpenAI 格式，并在内建转换中附加/规范化 Codex 指纹 |
 | **Claude Provider 桥接** | ✅ | 通过内建 Claude 兼容代理，让 Claude Code 接入 OpenAI Chat Completions 兼容 provider 与 Ollama |
 | **OpenCode Provider 存储** | ✅ | 在 `~/.codexmate` 中保留多个 OpenCode provider，只将当前选中的 provider 投影到 OpenCode 原生配置 |
+| **Provider 健康检查** | ✅ | 探测本地 Codex/Claude provider 路由，标记失败配置，并安全批量移除已选坏配置 |
 | **提示词模板** | ✅ | 支持变量的可复用提示词插件 |
 | **提示词文件编辑器** | ✅ | 编辑全局和项目级 CLAUDE.md / AGENTS.md，支持自动检测与路径切换 |
 | **MCP 集成** | ✅ | 通过 MCP stdio 暴露本地工具与资源 |

package/cli/local-bridge.js

@@ -20,6 +20,14 @@ const {
     isLoopbackAddress
 } = require('./openai-bridge');
 const { isValidHttpUrl, normalizeBaseUrl, joinApiUrl } = require('../lib/cli-utils');
+const {
+    buildBuiltinClaudeChatCompletionsRequest,
+    buildBuiltinClaudeOllamaChatRequest,
+    buildAnthropicMessageFromChatCompletion,
+    buildAnthropicMessageFromOllamaChat,
+    buildAnthropicModelsPayload,
+    buildAnthropicStreamEvents
+} = require('./claude-proxy');
 
 const BUILTIN_PROXY_PROVIDER_NAME = 'codexmate-proxy';
 const BUILTIN_LOCAL_PROVIDER_NAME = 'local';
@@ -28,6 +36,52 @@ const CLAUDE_LOCAL_EXCLUDED_KEY = 'claudeLocalExcluded';
 const CIRCUIT_BREAKER_THRESHOLD = 3;
 const CIRCUIT_BREAKER_COOLDOWN_MS = 5 * 60 * 1000;
 
+function normalizeClaudeLocalTargetApi(value) {
+    const raw = typeof value === 'string' ? value.trim().toLowerCase() : '';
+    if (raw === 'chat_completions' || raw === 'chat-completions' || raw === 'chat/completions') return 'chat_completions';
+    if (raw === 'ollama') return 'ollama';
+    return 'responses';
+}
+
+function normalizeClaudeLocalSuffix(pathname) {
+    const suffix = String(pathname || '').replace(/^\/bridge\/claude-local\/?/, '').replace(/^\/+/, '');
+    if (!suffix || suffix === 'v1') return '';
+    return suffix.replace(/^v1\/?/, '');
+}
+
+function joinClaudeLocalUpstreamUrl(baseUrl, pathSuffix) {
+    const suffix = typeof pathSuffix === 'string' ? pathSuffix.replace(/^\/+/, '') : '';
+    if (suffix === 'api/tags' || suffix === 'api/chat') {
+        const normalized = normalizeBaseUrl(baseUrl);
+        return normalized ? `${normalized}/${suffix}` : '';
+    }
+    return joinApiUrl(baseUrl, suffix);
+}
+
+function buildClaudeLocalAuthHeaders(entry, requestToken, targetApi, expectedToken = '') {
+    const headers = { 'Content-Type': 'application/json' };
+    const trimmedRequestToken = typeof requestToken === 'string' ? requestToken.trim() : '';
+    const bridgeToken = typeof expectedToken === 'string' ? expectedToken.trim() : '';
+    const upstreamRequestToken = trimmedRequestToken && (!bridgeToken || trimmedRequestToken !== bridgeToken)
+        ? trimmedRequestToken
+        : '';
+    const token = entry && typeof entry.apiKey === 'string' && entry.apiKey.trim()
+        ? entry.apiKey.trim()
+        : upstreamRequestToken;
+    if (!token) {
+        if (targetApi === 'responses') headers['anthropic-version'] = '2023-06-01';
+        return headers;
+    }
+    const bareToken = token.replace(/^Bearer\s+/i, '');
+    if (targetApi === 'responses') {
+        headers['x-api-key'] = bareToken;
+        headers['anthropic-version'] = '2023-06-01';
+    } else {
+        headers.Authorization = /^Bearer\s+/i.test(token) ? token : `Bearer ${token}`;
+    }
+    return headers;
+}
+
 function buildUpstreamPool(readConfigFn, openaiBridgeFile, excludedProviders) {
     let config;
     try { config = readConfigFn(); } catch (e) { return { error: '读取配置失败' }; }
@@ -74,7 +128,13 @@ function buildClaudeUpstreamPool(claudeProvidersFile, excludedProviders) {
         if (excludedSet.has(name.toLowerCase())) continue;
         const baseUrl = typeof p.baseUrl === 'string' ? p.baseUrl.trim() : '';
         if (!baseUrl || !isValidHttpUrl(normalizeBaseUrl(baseUrl))) continue;
-        pool.push({ name, baseUrl: normalizeBaseUrl(baseUrl), apiKey: typeof p.apiKey === 'string' ? p.apiKey : '', model: typeof p.model === 'string' ? p.model.trim() : '' });
+        pool.push({
+            name,
+            baseUrl: normalizeBaseUrl(baseUrl),
+            apiKey: typeof p.apiKey === 'string' ? p.apiKey : '',
+            model: typeof p.model === 'string' ? p.model.trim() : '',
+            targetApi: normalizeClaudeLocalTargetApi(p.targetApi)
+        });
     }
     if (pool.length === 0) return { error: '请先添加可用的 Claude 上游提供商' };
     return { pool };
@@ -263,7 +323,7 @@ function createLocalBridgeHttpHandler(options = {}) {
             const pool = poolResult.pool;
             const { entry } = pickUpstream(pool);
 
-            const suffix = (parsedUrl.pathname || '').replace(/^\/bridge\/claude-local\/?/, '');
+            const suffix = normalizeClaudeLocalSuffix(parsedUrl.pathname || '');
             if (!suffix) {
                 if ((req.method || 'GET').toUpperCase() !== 'GET') {
                     res.writeHead(405, { 'Content-Type': 'application/json; charset=utf-8' });
@@ -271,11 +331,151 @@ function createLocalBridgeHttpHandler(options = {}) {
                     return;
                 }
                 res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
-                res.end(JSON.stringify({ object: 'codexmate.claude_local_bridge', provider: entry.name, model: entry.model || '', status: 'ok', pool: pool.map(p => p.name) }));
+                res.end(JSON.stringify({
+                    object: 'codexmate.claude_local_bridge',
+                    provider: entry.name,
+                    model: entry.model || '',
+                    targetApi: entry.targetApi,
+                    status: 'ok',
+                    pool: pool.map(p => p.name),
+                    targetApis: Object.fromEntries(pool.map(p => [p.name, p.targetApi]))
+                }));
+                return;
+            }
+
+            const targetApi = normalizeClaudeLocalTargetApi(entry.targetApi);
+            const method = (req.method || 'GET').toUpperCase();
+            const isMessagesRequest = suffix === 'messages';
+            const isModelsRequest = suffix === 'models';
+
+            if ((targetApi === 'chat_completions' || targetApi === 'ollama') && !isMessagesRequest && !isModelsRequest) {
+                res.writeHead(404, { 'Content-Type': 'application/json; charset=utf-8' });
+                res.end(JSON.stringify({ error: 'Claude local bridge transform providers only support /v1/messages and /v1/models' }));
+                return;
+            }
+
+            if (targetApi === 'chat_completions' || targetApi === 'ollama') {
+                if (isModelsRequest) {
+                    if (method !== 'GET') {
+                        res.writeHead(405, { 'Content-Type': 'application/json; charset=utf-8', Allow: 'GET' });
+                        res.end(JSON.stringify({ error: 'Method Not Allowed' }));
+                        return;
+                    }
+                    const modelsUrl = joinClaudeLocalUpstreamUrl(entry.baseUrl.replace(/\/+$/, ''), targetApi === 'ollama' ? 'api/tags' : 'models');
+                    const upstreamResult = await retryTransientRequest(() => proxyRequestJson(modelsUrl, {
+                        method: 'GET',
+                        body: null,
+                        headers: buildClaudeLocalAuthHeaders(entry, token, targetApi, expectedToken),
+                        maxBytes: maxUpstreamBytes,
+                        httpAgent,
+                        httpsAgent
+                    }));
+                    if (!upstreamResult.ok) {
+                        recordFailure(entry.name);
+                        res.writeHead(502, { 'Content-Type': 'application/json; charset=utf-8' });
+                        res.end(JSON.stringify({ error: `Upstream request failed: ${upstreamResult.error}` }));
+                        return;
+                    }
+                    const parsedModels = parseJsonOrError(upstreamResult.bodyText || '{}');
+                    if (upstreamResult.status >= 400) {
+                        recordFailure(entry.name);
+                        res.writeHead(upstreamResult.status, { 'Content-Type': 'application/json; charset=utf-8' });
+                        res.end(upstreamResult.bodyText || JSON.stringify({ error: 'Upstream error' }));
+                        return;
+                    }
+                    if (parsedModels.error) {
+                        res.writeHead(502, { 'Content-Type': 'application/json; charset=utf-8' });
+                        res.end(JSON.stringify({ error: `Upstream parse failed: ${parsedModels.error}` }));
+                        return;
+                    }
+                    recordSuccess(entry.name);
+                    res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+                    res.end(JSON.stringify(buildAnthropicModelsPayload(parsedModels.value)));
+                    return;
+                }
+
+                if (method !== 'POST') {
+                    res.writeHead(405, { 'Content-Type': 'application/json; charset=utf-8', Allow: 'POST' });
+                    res.end(JSON.stringify({ error: 'Method Not Allowed' }));
+                    return;
+                }
+                const bodyResult = await readRequestBody(req, maxBodySize);
+                if (bodyResult.error) {
+                    res.writeHead(413, { 'Content-Type': 'application/json; charset=utf-8' });
+                    res.end(JSON.stringify({ error: bodyResult.error }));
+                    return;
+                }
+                const parsed = parseJsonOrError(bodyResult.body);
+                if (parsed.error) {
+                    res.writeHead(400, { 'Content-Type': 'application/json; charset=utf-8' });
+                    res.end(JSON.stringify({ error: parsed.error }));
+                    return;
+                }
+                const requestPayload = parsed.value && typeof parsed.value === 'object' ? parsed.value : {};
+                if (entry.model) requestPayload.model = entry.model;
+                let upstreamBody;
+                try {
+                    upstreamBody = targetApi === 'ollama'
+                        ? buildBuiltinClaudeOllamaChatRequest(requestPayload)
+                        : buildBuiltinClaudeChatCompletionsRequest(requestPayload);
+                } catch (e) {
+                    res.writeHead(400, { 'Content-Type': 'application/json; charset=utf-8' });
+                    res.end(JSON.stringify({ error: e && e.message ? e.message : 'Invalid request payload' }));
+                    return;
+                }
+                const upstreamUrl = joinClaudeLocalUpstreamUrl(entry.baseUrl.replace(/\/+$/, ''), targetApi === 'ollama' ? 'api/chat' : 'chat/completions');
+                const upstreamResult = await retryTransientRequest(() => proxyRequestJson(upstreamUrl, {
+                    method: 'POST',
+                    body: upstreamBody,
+                    headers: buildClaudeLocalAuthHeaders(entry, token, targetApi, expectedToken),
+                    maxBytes: maxUpstreamBytes,
+                    httpAgent,
+                    httpsAgent
+                }));
+
+                if (!upstreamResult.ok) {
+                    recordFailure(entry.name);
+                    res.writeHead(502, { 'Content-Type': 'application/json; charset=utf-8' });
+                    res.end(JSON.stringify({ error: `Upstream request failed: ${upstreamResult.error}` }));
+                    return;
+                }
+                if (upstreamResult.status >= 400) {
+                    recordFailure(entry.name);
+                    res.writeHead(upstreamResult.status, { 'Content-Type': 'application/json; charset=utf-8' });
+                    res.end(upstreamResult.bodyText || JSON.stringify({ error: 'Upstream error' }));
+                    return;
+                }
+                const parsedUpstream = parseJsonOrError(upstreamResult.bodyText || '{}');
+                if (parsedUpstream.error) {
+                    res.writeHead(502, { 'Content-Type': 'application/json; charset=utf-8' });
+                    res.end(JSON.stringify({ error: `Upstream parse failed: ${parsedUpstream.error}` }));
+                    return;
+                }
+                recordSuccess(entry.name);
+                const anthropicMessage = targetApi === 'ollama'
+                    ? buildAnthropicMessageFromOllamaChat(parsedUpstream.value || {}, requestPayload)
+                    : buildAnthropicMessageFromChatCompletion(parsedUpstream.value || {}, requestPayload);
+                if (requestPayload.stream === true) {
+                    const events = buildAnthropicStreamEvents(anthropicMessage);
+                    res.writeHead(200, {
+                        'Content-Type': 'text/event-stream; charset=utf-8',
+                        'Cache-Control': 'no-cache, no-transform',
+                        Connection: 'keep-alive',
+                        'X-Accel-Buffering': 'no'
+                    });
+                    for (const event of events) {
+                        if (event && event.event) res.write(`event: ${event.event}\n`);
+                        res.write(`data: ${JSON.stringify(event && event.data ? event.data : {})}\n\n`);
+                    }
+                    res.end();
+                    return;
+                }
+                res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+                res.end(JSON.stringify(anthropicMessage));
                 return;
             }
 
-            // Proxy Anthropic Messages API requests
+            // Native Anthropic-compatible provider: keep /v1/messages passthrough.
             const bodyResult = await readRequestBody(req, maxBodySize);
             if (bodyResult.error) {
                 res.writeHead(413, { 'Content-Type': 'application/json; charset=utf-8' });
@@ -283,26 +483,26 @@ function createLocalBridgeHttpHandler(options = {}) {
                 return;
             }
 
-            let parsedBody;
-            try { parsedBody = bodyResult.body ? JSON.parse(bodyResult.body) : {}; } catch (_) { parsedBody = {}; }
-            // Override model to match the selected upstream provider
+            const hasRequestBody = typeof bodyResult.body === 'string' && bodyResult.body.trim().length > 0;
+            let parsedBody = null;
+            if (hasRequestBody) {
+                const parsed = parseJsonOrError(bodyResult.body);
+                if (parsed.error) {
+                    res.writeHead(400, { 'Content-Type': 'application/json; charset=utf-8' });
+                    res.end(JSON.stringify({ error: parsed.error }));
+                    return;
+                }
+                parsedBody = parsed.value;
+            }
             if (entry.model && parsedBody && typeof parsedBody === 'object') {
                 parsedBody.model = entry.model;
             }
-            const wantsStream = !!(parsedBody && parsedBody.stream);
-            const bodyToForward = JSON.stringify(parsedBody);
+            const wantsStream = !!(parsedBody && typeof parsedBody === 'object' && parsedBody.stream);
+            const bodyToForward = hasRequestBody ? JSON.stringify(parsedBody) : null;
             const upstreamUrl = joinApiUrl(entry.baseUrl.replace(/\/+$/, ''), suffix);
-            const headers = { 'Content-Type': 'application/json' };
-            if (entry.apiKey) {
-                headers['x-api-key'] = entry.apiKey.startsWith('Bearer ') ? entry.apiKey.slice(7) : entry.apiKey;
-            }
-            if (token && !entry.apiKey) {
-                headers['x-api-key'] = token.startsWith('Bearer ') ? token.slice(7) : token;
-            }
-            headers['anthropic-version'] = '2023-06-01';
+            const headers = buildClaudeLocalAuthHeaders(entry, token, targetApi, expectedToken);
 
             if (wantsStream) {
-                // Streaming proxy: pipe upstream SSE directly to client
                 const upstreamResult = await streamClaudeUpstream(upstreamUrl, {
                     method: req.method || 'POST',
                     body: bodyToForward,
@@ -324,10 +524,9 @@ function createLocalBridgeHttpHandler(options = {}) {
                 return;
             }
 
-            // Non-streaming proxy
             const upstreamResult = await retryTransientRequest(() => proxyRequestJson(upstreamUrl, {
                 method: req.method || 'POST',
-                body: bodyToForward || null,
+                body: parsedBody || null,
                 headers,
                 maxBytes: maxUpstreamBytes,
                 httpAgent,
@@ -432,7 +631,7 @@ function createLocalBridgeHttpHandler(options = {}) {
                 const upstreamResponsesUrl = joinApiUrl(upstreamBase, 'responses');
                 const upstreamResponsesResult = await retryTransientRequest(() => proxyRequestJson(upstreamResponsesUrl, {
                     method: 'POST',
-                    body: bodyResult.body,
+                    body: responsesRequest,
                     headers: { ...(authHeader ? { Authorization: authHeader } : {}) },
                     maxBytes: maxUpstreamBytes,
                     httpAgent,
@@ -484,7 +683,7 @@ function createLocalBridgeHttpHandler(options = {}) {
                 const chatUrl = joinApiUrl(upstreamBase, 'chat/completions');
                 const chatResult = await retryTransientRequest(() => proxyRequestJson(chatUrl, {
                     method: 'POST',
-                    body: JSON.stringify(converted.chat),
+                    body: converted.chat,
                     headers: { ...(authHeader ? { Authorization: authHeader } : {}), 'Content-Type': 'application/json' },
                     maxBytes: maxUpstreamBytes,
                     httpAgent,