codexmate 0.0.31 → 0.0.33

package/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;

package/cli/update.js

@@ -0,0 +1,162 @@
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const { execSync, spawn } = require('child_process');
+
+/**
+ * 快速更新命令实现
+ */
+async function cmdToolUpdate(args = []) {
+    const pkg = require('../package.json');
+    const currentVersion = pkg.version;
+    const isCheckOnly = args.includes('--check');
+
+    console.log(`[Update] 当前版本: v${currentVersion}`);
+
+    let latestVersion = '';
+    try {
+        latestVersion = await fetchLatestVersion();
+    } catch (err) {
+        console.error(`[Update] 获取最新版本失败: ${err.message}`);
+        return;
+    }
+
+    if (!latestVersion) {
+        console.error('[Update] 无法获取最新版本信息');
+        return;
+    }
+
+    if (latestVersion === currentVersion) {
+        console.log('[Update] 已是最新版本。');
+        return;
+    }
+
+    console.log(`[Update] 发现新版本: v${latestVersion}`);
+
+    if (isCheckOnly) {
+        console.log('[Update] 请运行 "codexmate update" 进行更新。');
+        return;
+    }
+
+    // 确定安装方式并执行更新
+    const installMethod = detectInstallMethod();
+    console.log(`[Update] 检测到安装方式: ${installMethod}`);
+
+    try {
+        switch (installMethod) {
+            case 'npm':
+                updateViaNpm();
+                break;
+            case 'git':
+                updateViaGit();
+                break;
+            case 'standalone':
+                updateViaStandalone(latestVersion);
+                break;
+            default:
+                console.log('[Update] 未知安装方式，请手动更新。');
+                return;
+        }
+        console.log('[Update] 更新指令已下达。');
+    } catch (err) {
+        console.error(`[Update] 更新失败: ${err.message}`);
+    }
+}
+
+async function fetchLatestVersion() {
+    return new Promise((resolve, reject) => {
+        const url = 'https://registry.npmjs.org/codexmate/latest';
+        https.get(url, (res) => {
+            let data = '';
+            res.on('data', (chunk) => { data += chunk; });
+            res.on('end', () => {
+                try {
+                    const json = JSON.parse(data);
+                    resolve(json.version || '');
+                } catch (e) {
+                    reject(new Error('解析 NPM 响应失败'));
+                }
+            });
+        }).on('error', (err) => {
+            reject(err);
+        });
+    });
+}
+
+function detectInstallMethod() {
+    const cliPath = path.resolve(__dirname, '..');
+
+    // 1. Git 仓库检测
+    if (fs.existsSync(path.join(cliPath, '.git'))) {
+        return 'git';
+    }
+
+    // 2. Standalone 检测 (通常在 ~/.codexmate)
+    const installDir = process.env.CODEXMATE_INSTALL_DIR || path.join(require('os').homedir(), '.codexmate');
+    if (cliPath.toLowerCase().startsWith(path.resolve(installDir).toLowerCase())) {
+        return 'standalone';
+    }
+
+    // 3. NPM 全局安装检测
+    // 如果路径包含 node_modules，通常是 npm 安装
+    if (cliPath.includes('node_modules')) {
+        return 'npm';
+    }
+
+    return 'unknown';
+}
+
+function updateViaNpm() {
+    console.log('[Update] 正在通过 npm 更新...');
+    // 使用 spawn 运行，这样可以实时看到输出
+    const isWindows = process.platform === 'win32';
+    const npmCmd = isWindows ? 'npm.cmd' : 'npm';
+
+    // 注意：npm install -g 可能会因为权限问题失败
+    console.log(`[Update] 执行: ${npmCmd} install -g codexmate`);
+
+    // 我们不直接在这里结束进程，因为 npm 更新后会覆盖文件
+    // 但为了安全，我们提示用户
+    try {
+        execSync(`${npmCmd} install -g codexmate`, { stdio: 'inherit' });
+        console.log('[Update] NPM 更新完成，请重启程序。');
+    } catch (e) {
+        throw new Error('NPM 更新失败，请尝试使用 sudo 或管理员权限运行。');
+    }
+}
+
+function updateViaGit() {
+    console.log('[Update] 正在通过 Git 更新...');
+    try {
+        execSync('git pull', { stdio: 'inherit', cwd: path.resolve(__dirname, '..') });
+        execSync('npm install', { stdio: 'inherit', cwd: path.resolve(__dirname, '..') });
+        console.log('[Update] Git 更新完成。');
+    } catch (e) {
+        throw new Error('Git 更新失败，请检查网络或本地改动。');
+    }
+}
+
+function updateViaStandalone(version) {
+    console.log(`[Update] 正在更新 Standalone 版本至 v${version}...`);
+    // 对于 Standalone，最简单的方法是重新运行安装脚本
+    // 或者提示用户重新运行 curl 命令
+    console.log('[Update] 请运行以下命令进行快速更新:');
+    console.log('curl -fsSL https://raw.githubusercontent.com/SakuraByteCore/codexmate/main/scripts/install.sh | bash');
+
+    // 尝试自动化（实验性）
+    if (process.platform !== 'win32') {
+        console.log('[Update] 尝试自动执行安装脚本...');
+        try {
+            const script = 'curl -fsSL https://raw.githubusercontent.com/SakuraByteCore/codexmate/main/scripts/install.sh | bash';
+            execSync(script, { stdio: 'inherit' });
+        } catch (e) {
+            console.warn('[Update] 自动脚本执行失败，请手动运行。');
+        }
+    } else {
+        console.log('[Update] Windows 环境下请手动下载最新版本或使用 npm 安装。');
+    }
+}
+
+module.exports = {
+    cmdToolUpdate
+};