SakuraByteCore · ymkiux · May 18, 2026 · May 17, 2026 · May 17, 2026 · May 17, 2026
diff --git a/README.md b/README.md
diff --git a/README.zh.md b/README.zh.md
diff --git a/cli.js b/cli.js
diff --git a/cli/local-bridge.js b/cli/local-bridge.js
@@ -1,4 +1,6 @@
 const fs = require('fs');
+const http = require('http');
+const https = require('https');
 const { URL } = require('url');
 const {
     readOpenaiBridgeSettings,
@@ -21,6 +23,8 @@ const { isValidHttpUrl, normalizeBaseUrl, joinApiUrl } = require('../lib/cli-uti
 
 const BUILTIN_PROXY_PROVIDER_NAME = 'codexmate-proxy';
 const BUILTIN_LOCAL_PROVIDER_NAME = 'local';
+const CLAUDE_LOCAL_PROVIDER_NAME = 'claude-local';
+const CLAUDE_LOCAL_EXCLUDED_KEY = 'claudeLocalExcluded';
 const CIRCUIT_BREAKER_THRESHOLD = 3;
 const CIRCUIT_BREAKER_COOLDOWN_MS = 5 * 60 * 1000;
 
@@ -51,6 +55,31 @@ function buildUpstreamPool(readConfigFn, openaiBridgeFile, excludedProviders) {
     return { pool };
 }
 
+function buildClaudeUpstreamPool(claudeProvidersFile, excludedProviders) {
+    let raw;
+    try {
+        if (!fs.existsSync(claudeProvidersFile)) return { error: '暂无可用上游 provider，请先添加 Claude 提供商' };
+        raw = JSON.parse(fs.readFileSync(claudeProvidersFile, 'utf-8'));
+    } catch (e) { return { error: '读取 Claude 提供商配置失败' }; }
+    const providers = (raw && typeof raw.providers === 'object' && !Array.isArray(raw.providers))
+        ? raw.providers : {};
+    const pool = [];
+    const excludedSet = new Set(
+        (Array.isArray(excludedProviders) ? excludedProviders : [])
+            .filter(n => typeof n === 'string' && n.trim())
+            .map(n => n.trim().toLowerCase())
+    );
+    for (const [name, p] of Object.entries(providers)) {
+        if (!p || typeof p !== 'object') continue;
+        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 : '' });
+    }
+    if (pool.length === 0) return { error: '请先添加可用的 Claude 上游提供商' };
+    return { pool };
+}
+
 function resolveUpstreamAuth(entry, openaiBridgeFile, reqAuthToken) {
     if (entry.authMethod === 'codexmate' || entry.requiresOpenaiAuth) {
         const token = reqAuthToken || '';
@@ -69,6 +98,7 @@ function resolveUpstreamAuth(entry, openaiBridgeFile, reqAuthToken) {
 function createLocalBridgeHttpHandler(options = {}) {
     const readConfigFn = options.readConfigFn;
     const openaiBridgeFile = options.openaiBridgeFile;
+    const claudeProvidersFile = options.claudeProvidersFile || '';
     const expectedToken = typeof options.expectedToken === 'string' ? options.expectedToken.trim() : '';
     const maxBodySize = Number.isFinite(options.maxBodySize) ? options.maxBodySize : 0;
     const httpAgent = options.httpAgent;
@@ -128,10 +158,207 @@ function createLocalBridgeHttpHandler(options = {}) {
         } catch (e) { return []; }
     }
 
+    function streamClaudeUpstream(targetUrl, options) {
+        const parsed = new URL(targetUrl);
+        const transport = parsed.protocol === 'https:' ? https : http;
+        const bodyText = options.body || '';
+        const headers = {
+            'Accept': 'text/event-stream',
+            'Content-Type': 'application/json',
+            ...(options.headers || {})
+        };
+        if (bodyText) {
+            headers['Content-Length'] = Buffer.byteLength(bodyText, 'utf-8');
+        }
+        const maxBytes = Number.isFinite(options.maxBytes) && options.maxBytes > 0 ? options.maxBytes : 0;
+        const res = options.res;
+
+        return new Promise((resolve) => {
+            let settled = false;
+            let upstreamReq = null;
+            const finish = (value) => { if (!settled) { settled = true; resolve(value); } };
+            const abortUpstream = () => { if (upstreamReq) try { upstreamReq.destroy(new Error('client aborted')); } catch (_) {} };
+            if (res && typeof res.once === 'function') res.once('close', abortUpstream);
+
+            upstreamReq = transport.request({
+                protocol: parsed.protocol,
+                hostname: parsed.hostname,
+                port: parsed.port || (parsed.protocol === 'https:' ? 443 : 80),
+                method: options.method || 'POST',
+                path: `${parsed.pathname}${parsed.search}`,
+                headers,
+                agent: parsed.protocol === 'https:' ? options.httpsAgent : options.httpAgent
+            }, (upstreamRes) => {
+                const status = upstreamRes.statusCode || 0;
+                if (status >= 400) {
+                    const chunks = [];
+                    let size = 0;
+                    upstreamRes.on('data', (chunk) => {
+                        if (!chunk) return;
+                        if (maxBytes > 0) { size += chunk.length; if (size > maxBytes) { finish({ ok: false, status, error: 'response too large' }); return; } }
+                        chunks.push(chunk);
+                    });
+                    upstreamRes.on('end', () => finish({ ok: false, status, error: chunks.length ? Buffer.concat(chunks).toString('utf-8') : 'Upstream error' }));
+                    return;
+                }
+                // SSE: pipe directly to client
+                if (!res.headersSent) {
+                    res.writeHead(200, {
+                        'Content-Type': 'text/event-stream; charset=utf-8',
+                        'Cache-Control': 'no-cache',
+                        'Connection': 'keep-alive',
+                        'X-Accel-Buffering': 'no'
+                    });
+                    if (typeof res.flushHeaders === 'function') res.flushHeaders();
+                }
+                upstreamRes.pipe(res);
+                upstreamRes.on('end', () => finish({ ok: true, status }));
+                upstreamRes.on('error', (err) => finish({ ok: false, status, error: err.message }));
+            });
+            upstreamReq.on('error', (err) => finish({ ok: false, error: err.message }));
+            upstreamReq.setTimeout(5 * 60 * 1000, () => { try { upstreamReq.destroy(new Error('timeout')); } catch (_) {} });
+            if (bodyText) upstreamReq.write(bodyText);
+            upstreamReq.end();
+        });
+    }
+
+    function readClaudeExcludedProviders() {
+        if (!claudeProvidersFile) return [];
+        try {
+            if (!fs.existsSync(claudeProvidersFile)) return [];
+            const raw = JSON.parse(fs.readFileSync(claudeProvidersFile, 'utf-8'));
+            return Array.isArray(raw.excludedProviders)
+                ? raw.excludedProviders.filter(n => typeof n === 'string' && n.trim())
+                : [];
+        } catch (e) { return []; }
+    }
+
+    async function handleClaudeLocalBridge(req, res, parsedUrl) {
+        try {
+            const token = extractAuthorizationToken(req);
+            const remoteAddr = req && req.socket ? req.socket.remoteAddress : '';
+            const isLoopback = isLoopbackAddress(remoteAddr);
+            if (!isLoopback && !expectedToken) {
+                res.writeHead(403, { 'Content-Type': 'application/json; charset=utf-8' });
+                res.end(JSON.stringify({ error: 'Remote access is disabled (set CODEXMATE_HTTP_TOKEN)' }));
+                return;
+            }
+            if (!token && !isLoopback) {
+                res.writeHead(401, { 'Content-Type': 'application/json; charset=utf-8' });
+                res.end(JSON.stringify({ error: 'Unauthorized' }));
+                return;
+            }
+            if (!isLoopback && token && token !== expectedToken) {
+                res.writeHead(401, { 'Content-Type': 'application/json; charset=utf-8' });
+                res.end(JSON.stringify({ error: 'Unauthorized' }));
+                return;
+            }
+
+            const poolResult = buildClaudeUpstreamPool(claudeProvidersFile, readClaudeExcludedProviders());
+            if (poolResult.error) {
+                res.writeHead(503, { 'Content-Type': 'application/json; charset=utf-8' });
+                res.end(JSON.stringify({ error: poolResult.error }));
+                return;
+            }
+            const pool = poolResult.pool;
+            const { entry } = pickUpstream(pool);
+
+            const suffix = (parsedUrl.pathname || '').replace(/^\/bridge\/claude-local\/?/, '');
+            if (!suffix) {
+                if ((req.method || 'GET').toUpperCase() !== 'GET') {
+                    res.writeHead(405, { 'Content-Type': 'application/json; charset=utf-8' });
+                    res.end(JSON.stringify({ error: 'Method Not Allowed' }));
+                    return;
+                }
+                res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+                res.end(JSON.stringify({ object: 'codexmate.claude_local_bridge', provider: entry.name, status: 'ok', pool: pool.map(p => p.name) }));
+                return;
+            }
+
+            // Proxy Anthropic Messages API requests
+            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;
+            }
+
+            let parsedBody;
+            try { parsedBody = bodyResult.body ? JSON.parse(bodyResult.body) : {}; } catch (_) { parsedBody = {}; }
+            const wantsStream = !!(parsedBody && parsedBody.stream);
+            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';
+
+            if (wantsStream) {
+                // Streaming proxy: pipe upstream SSE directly to client
+                const upstreamResult = await streamClaudeUpstream(upstreamUrl, {
+                    method: req.method || 'POST',
+                    body: bodyResult.body,
+                    headers,
+                    maxBytes: maxUpstreamBytes,
+                    httpAgent,
+                    httpsAgent,
+                    res
+                });
+                if (!upstreamResult.ok) {
+                    recordFailure(entry.name);
+                    if (!res.headersSent) {
+                        res.writeHead(upstreamResult.status || 502, { 'Content-Type': 'application/json; charset=utf-8' });
+                        res.end(JSON.stringify({ error: upstreamResult.error || 'Upstream error' }));
+                    }
+                    return;
+                }
+                recordSuccess(entry.name);
+                return;
+            }
+
+            // Non-streaming proxy
+            const upstreamResult = await retryTransientRequest(() => proxyRequestJson(upstreamUrl, {
+                method: req.method || 'POST',
+                body: bodyResult.body || null,
+                headers,
+                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;
+            }
+
+            recordSuccess(entry.name);
+            const statusCode = Number.isFinite(upstreamResult.status) ? upstreamResult.status : 200;
+            res.writeHead(statusCode, { 'Content-Type': 'application/json; charset=utf-8' });
+            res.end(upstreamResult.bodyText || '{}');
+        } catch (e) {
+            res.writeHead(500, { 'Content-Type': 'application/json; charset=utf-8' });
+            res.end(JSON.stringify({ error: e && e.message ? e.message : 'Internal Error' }));
+        }
+    }
+
     const handler = (req, res) => {
         let parsedUrl;
         try { parsedUrl = new URL(req.url || '/', 'http://localhost'); } catch (_) { return false; }
         const pathname = parsedUrl.pathname || '/';
+
+        // Claude local bridge: /bridge/claude-local/v1/messages
+        if (pathname.startsWith('/bridge/claude-local/')) {
+            if (!claudeProvidersFile) return false;
+            void handleClaudeLocalBridge(req, res, parsedUrl);
+            return true;
+        }
+
+        // Codex local bridge: /bridge/local/v1
         if (!pathname.startsWith('/bridge/local/')) return false;
         const suffix = pathname.replace(/^\/bridge\/local\/?/, '');
         if (!suffix.startsWith('v1')) return false;