@xcanwin/manyoyo 8.5.0 → 8.6.0

package/lib/egress-sidecar-main.js

@@ -6,12 +6,29 @@ const { createEgressProxy } = require('./egress-proxy');
 const { createRecorder } = require('./egress-denied');
 
 // 过滤代理 sidecar 容器里的入口（宿主机把这几个文件只读挂进来，见 egress-sidecar.js）。
-// 数据目录（只读）：clients.json（来源 IP → 容器 id + 策略，宿主机在每次下发规则时原子替换）、upstream.txt（可选，上游代理）；
+// 数据目录（只读）：clients.json（来源 IP → 容器 id + 编译好的有序规则，宿主机在每次下发规则时原子替换）、upstream.txt（可选，上游代理）；
 // 拒绝记录目录（读写）：<容器 id>.jsonl。
 const CLIENTS_FILE = 'clients.json';
 const UPSTREAM_FILE = 'upstream.txt';
 const RELOAD_CHECK_MS = 500;
 
+/**
+ * 运行时注入 sidecar 自己环境的代理（podman containers.conf 的 env / docker config.json 的 proxies）。
+ * 只由运行时配置决定，用户容器写不到；环回地址在容器里没有意义，改写成宿主机别名。
+ */
+function envUpstream(env = process.env) {
+    const text = env.HTTPS_PROXY || env.https_proxy || env.HTTP_PROXY || env.http_proxy || '';
+    if (!text) return '';
+    try {
+        const url = new URL(/^[a-z][a-z0-9+.-]*:\/\//i.test(text) ? text : `http://${text}`);
+        if (url.protocol !== 'http:') return '';
+        if (/^(localhost|127\.\d+\.\d+\.\d+|\[?::1\]?)$/i.test(url.hostname)) url.hostname = env.EGRESS_HOST_ALIAS || 'host.containers.internal';
+        return url.toString().replace(/\/$/, '');
+    } catch (e) {
+        return '';
+    }
+}
+
 function loadClients(file) {
     try {
         const parsed = JSON.parse(fs.readFileSync(file, 'utf-8'));
@@ -32,14 +49,15 @@ function loadClients(file) {
  */
 async function start(options) {
     const clientsFile = path.join(options.dataDir, CLIENTS_FILE);
-    // 上游代理：upstream.txt 变了就热更新（CLI 与 serve 的环境可能不同，不能为此重建容器）
+    // 上游代理：upstream.txt（serve / CLI 进程显式配置的）优先，没有就用运行时注入 sidecar 的代理；
+    // upstream.txt 变了就热更新（CLI 与 serve 的环境可能不同，不能为此重建容器）
     const upstreamFile = path.join(options.dataDir, UPSTREAM_FILE);
     let upstream = '';
     let upstreamSig = '';
     let upstreamCheckedAt = 0;
     const getUpstream = () => {
         const nowMs = Date.now();
-        if (nowMs - upstreamCheckedAt < RELOAD_CHECK_MS) return upstream;
+        if (nowMs - upstreamCheckedAt < RELOAD_CHECK_MS) return upstream || envUpstream();
         upstreamCheckedAt = nowMs;
         try {
             const stat = fs.statSync(upstreamFile);
@@ -52,7 +70,7 @@ async function start(options) {
             upstreamSig = '';
             upstream = '';
         }
-        return upstream;
+        return upstream || envUpstream();
     };
 
     let clients = loadClients(clientsFile);
@@ -109,4 +127,4 @@ if (require.main === module) {
     });
 }
 
-module.exports = { start, CLIENTS_FILE, UPSTREAM_FILE };
+module.exports = { start, envUpstream, CLIENTS_FILE, UPSTREAM_FILE };

package/lib/egress-sidecar.js

@@ -7,8 +7,8 @@ const os = require('os');
 const path = require('path');
 const { writeConfigFileSecure } = require('./secure-file');
 
-// 域名白名单的强制执行点：manyoyo 网络里的一个专用小容器（sidecar），里面用镜像自带的 node 跑 egress-proxy。
-// - 容器按“来源 IP”识别：宿主机在每次下发规则时把「容器 IP → 容器 id + 策略」写进 clients.json（只读挂入），
+// 域名规则的强制执行点：manyoyo 网络里的一个专用小容器（sidecar），里面用镜像自带的 node 跑 egress-proxy。
+// - 容器按“来源 IP”识别：宿主机在每次下发规则时把「容器 IP → 容器 id + 编译好的有序规则」写进 clients.json（只读挂入），
 //   认不出的来源一律 403；宿主机上不监听任何端口，同机其他用户无法占用或冒充。
 // - 固定 IP（--ip）：重启后不变，容器的代理地址与 nft 规则才能稳定。
 // - sidecar 只读挂入程序文件和数据目录，只有拒绝记录目录可写；丢掉全部能力。
@@ -123,7 +123,6 @@ function createSidecarManager(options) {
     const name = sidecarName(homeDir);
     const hash = homeHash(homeDir);
     let inflight = null;
-    let lastClients = '';
 
     async function inspectSidecar() {
         try {
@@ -178,7 +177,7 @@ function createSidecarManager(options) {
         }
         let tail = '';
         try { tail = await run(['logs', '--tail', '5', name]); } catch (e) { /* 取不到就算了 */ }
-        throw new Error(`域名白名单代理没有起来${tail ? `: ${String(tail).trim().split('\n').slice(-2).join(' ')}` : ''}`);
+        throw new Error(`域名规则代理没有起来${tail ? `: ${String(tail).trim().split('\n').slice(-2).join(' ')}` : ''}`);
     }
 
     async function doEnsure() {
@@ -211,7 +210,7 @@ function createSidecarManager(options) {
             '--pull=never',
             '--label', 'manyoyo.role=egress', '--label', `manyoyo.home=${hash}`, '--label', `manyoyo.egress.rev=${rev}`,
             '--volume', `${p.app}:/app:ro`, '--volume', `${p.data}:/data:ro`, '--volume', `${p.denied}:/denied`,
-            '--env', `EGRESS_PORT=${SIDECAR_PORT}`
+            '--env', `EGRESS_PORT=${SIDECAR_PORT}`, '--env', `EGRESS_HOST_ALIAS=${hostAlias}`
         ];
         if (isDocker) args.push('--add-host', 'host.docker.internal:host-gateway');
         args.push('--entrypoint', 'node', options.imageRef(), '/app/egress-sidecar-main.js');
@@ -228,8 +227,8 @@ function createSidecarManager(options) {
                 }
             }
             throw new Error(/address already in use|ip.*(used|allocated)|in use/i.test(message) && !/name/i.test(message)
-                ? `域名白名单代理需要的地址 ${ip} 已被占用（${networkName} 网络里有别的容器用了它）`
-                : `域名白名单代理启动失败: ${message}`);
+                ? `域名规则代理需要的地址 ${ip} 已被占用（${networkName} 网络里有别的容器用了它）`
+                : `域名规则代理启动失败: ${message}`);
         }
         await waitReady();
         return { name, ip, port: SIDECAR_PORT };
@@ -247,18 +246,29 @@ function createSidecarManager(options) {
         return Boolean(info && runningOf(info));
     }
 
-    /** 写入「来源 IP → 容器 id + 策略」；内容没变就不写（避免无谓刷新）。 */
+    /** 写入「来源 IP → 容器 id + 编译好的有序规则」；内容没变就不写（避免无谓刷新）。 */
     function writeClients(clients) {
         const p = egressPaths(homeDir);
         ensureDir(p.dir);
         ensureDir(p.data);
         const text = `${JSON.stringify({ clients }, null, 2)}\n`;
-        if (text === lastClients && fs.existsSync(path.join(p.data, 'clients.json'))) return;
-        writeAtomic(path.join(p.data, 'clients.json'), text, 0o644);
-        lastClients = text;
+        const file = path.join(p.data, 'clients.json');
+        // 与磁盘上的内容比较（别的进程——serve / CLI——可能刚改过它），没变就不写
+        try { if (fs.readFileSync(file, 'utf-8') === text) return; } catch (e) { /* 还没有就写 */ }
+        writeAtomic(file, text, 0o644);
     }
 
-    return { name, ensure, isHealthy, writeClients, paths: () => egressPaths(homeDir), isSidecarName: n => n === name };
+    /** 当前 clients.json 里的映射（没有或损坏返回空对象）。 */
+    function readClients() {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(path.join(egressPaths(homeDir).data, 'clients.json'), 'utf-8'));
+            return parsed && parsed.clients && typeof parsed.clients === 'object' ? parsed.clients : {};
+        } catch (e) {
+            return {};
+        }
+    }
+
+    return { name, ensure, isHealthy, writeClients, readClients, paths: () => egressPaths(homeDir), isSidecarName: n => n === name };
 }
 
 module.exports = {

package/lib/net-proxy.js

@@ -0,0 +1,183 @@
+'use strict';
+
+// 访问 GitHub 的请求读取代理：环境变量（https_proxy 等）或 macOS 系统代理。
+// Node 内置 fetch 不读代理变量，所以这里按请求构造带代理的 fetch，绝不修改全局（serve 进程里还有访问本机/容器的请求）。
+
+const http = require('http');
+const https = require('https');
+const { Readable } = require('stream');
+const { spawnSync } = require('child_process');
+
+const MAX_REDIRECTS = 5;
+const IDLE_TIMEOUT_MS = 60000;
+
+function pick(env, names) {
+    for (const name of names) {
+        const value = String(env[name] || env[name.toUpperCase()] || '').trim();
+        if (value) return value;
+    }
+    return '';
+}
+
+// 去掉账号密码，只留 scheme://host:port，用于打印
+function displayProxy(url) {
+    try {
+        const parsed = new URL(url);
+        return `${parsed.protocol}//${parsed.host}`;
+    } catch (error) {
+        return '';
+    }
+}
+
+function normalizeProxyUrl(value) {
+    return /^[a-z][a-z0-9+.-]*:\/\//i.test(value) ? value : `http://${value}`;
+}
+
+/**
+ * 解析 macOS `scutil --proxy` 的输出。返回 { url, noProxy } 或 { unsupported } 或 null。
+ * 只认 HTTPS 代理（没有就退到 HTTP 代理）；PAC / 自动代理不解析。
+ */
+function parseScutilProxy(text) {
+    const values = {};
+    const exceptions = [];
+    let inExceptions = false;
+    for (const rawLine of String(text || '').split('\n')) {
+        const line = rawLine.trim();
+        if (/^ExceptionsList\s*:/.test(line)) { inExceptions = true; continue; }
+        if (inExceptions) {
+            const item = line.match(/^\d+\s*:\s*(.+)$/);
+            if (item) { exceptions.push(item[1].trim()); continue; }
+            inExceptions = false;
+        }
+        const pair = line.match(/^(\w+)\s*:\s*(.+)$/);
+        if (pair) values[pair[1]] = pair[2].trim();
+    }
+    const noProxy = exceptions.map(item => item.replace(/^\*\./, '.')).join(',');
+    for (const prefix of ['HTTPS', 'HTTP']) {
+        if (values[`${prefix}Enable`] === '1' && values[`${prefix}Proxy`] && /^\d+$/.test(values[`${prefix}Port`] || '')) {
+            return { url: `http://${values[`${prefix}Proxy`]}:${values[`${prefix}Port`]}`, noProxy };
+        }
+    }
+    if (values.ProxyAutoConfigEnable === '1' || values.SOCKSEnable === '1') return { unsupported: true };
+    return null;
+}
+
+function readScutilProxy() {
+    const result = spawnSync('/usr/sbin/scutil', ['--proxy'], { encoding: 'utf-8', timeout: 3000 });
+    return result.status === 0 ? result.stdout : '';
+}
+
+/**
+ * 找出当前该用的代理。优先级：环境变量 > macOS 系统代理 > 无。
+ * 返回 { proxyEnv, source: 'env'|'system'|null, display, notice }；notice 是需要告诉用户的一句话（如暂不支持 socks）。
+ */
+function resolveProxy({ env = process.env, platform = process.platform, readSystemProxy = readScutilProxy } = {}) {
+    const noProxy = pick(env, ['no_proxy']);
+    const candidates = [pick(env, ['https_proxy']), pick(env, ['http_proxy']), pick(env, ['all_proxy'])].filter(Boolean);
+    let notice = '';
+    for (const candidate of candidates) {
+        const url = normalizeProxyUrl(candidate);
+        if (/^socks/i.test(url)) {
+            notice = '暂不支持 socks 代理，请改用 http 代理端口。';
+            continue;
+        }
+        if (!/^https?:\/\//i.test(url) || !displayProxy(url)) continue;
+        return { proxyEnv: { HTTPS_PROXY: url, HTTP_PROXY: url, ...(noProxy ? { NO_PROXY: noProxy } : {}) }, source: 'env', display: displayProxy(url), notice };
+    }
+    if (platform === 'darwin') {
+        let parsed = null;
+        try {
+            parsed = parseScutilProxy(readSystemProxy());
+        } catch (error) {
+            parsed = null;
+        }
+        if (parsed && parsed.url) {
+            const merged = [noProxy, parsed.noProxy].filter(Boolean).join(',');
+            return { proxyEnv: { HTTPS_PROXY: parsed.url, HTTP_PROXY: parsed.url, ...(merged ? { NO_PROXY: merged } : {}) }, source: 'system', display: displayProxy(parsed.url), notice };
+        }
+        if (parsed && parsed.unsupported) notice = '系统代理用了自动配置或 socks，暂不支持，请在终端设置 https_proxy 指向 http 代理端口。';
+    }
+    return { proxyEnv: null, source: null, display: '', notice };
+}
+
+// Agent 的 proxyEnv 选项：Node 22.21+ / 24.5+ 才有
+function supportsProxyEnv(version = process.versions.node) {
+    const [major, minor] = String(version).split('.').map(Number);
+    if (major >= 25) return true;
+    if (major === 24) return minor >= 5;
+    if (major === 22) return minor >= 21;
+    return false;
+}
+
+function requestOnce(url, options, agents) {
+    const target = new URL(url);
+    const client = target.protocol === 'http:' ? http : https;
+    const agent = target.protocol === 'http:' ? agents.http : agents.https;
+    return new Promise((resolve, reject) => {
+        const req = client.request(target, { method: options.method || 'GET', headers: options.headers || {}, agent, signal: options.signal }, resolve);
+        // 连接或下载中途卡住（代理停止转发等）时不能永远挂着：空闲超过 60 秒按超时处理
+        req.setTimeout(IDLE_TIMEOUT_MS, () => req.destroy(Object.assign(new Error('空闲超时'), { code: 'ETIMEDOUT' })));
+        req.on('error', reject);
+        req.end();
+    });
+}
+
+/**
+ * 带代理的最小 fetch 兼容实现（status / ok / headers.get / json / text / body）。
+ * 手动跟随最多 5 次重定向，每一跳都由 Agent 按 NO_PROXY 重新判断是否走代理；HTTPS 目标走 CONNECT 隧道，证书照常校验。
+ */
+function createProxyFetch(proxyEnv, agentOptions = {}) {
+    const agents = {
+        http: new http.Agent({ proxyEnv, keepAlive: false }),
+        https: new https.Agent({ proxyEnv, keepAlive: false, ...agentOptions })
+    };
+    return async function proxyFetch(url, options = {}) {
+        let current = String(url);
+        for (let hop = 0; hop <= MAX_REDIRECTS; hop += 1) {
+            const res = await requestOnce(current, options, agents);
+            const location = res.headers.location;
+            if (res.statusCode >= 300 && res.statusCode < 400 && location && options.redirect !== 'manual') {
+                res.resume();
+                const next = new URL(location, current);
+                // 跨站跳转不带凭据类请求头
+                if (next.host !== new URL(current).host && options.headers) {
+                    options = { ...options, headers: Object.fromEntries(Object.entries(options.headers).filter(([key]) => !/^(authorization|cookie)$/i.test(key))) };
+                }
+                current = next.toString();
+                continue;
+            }
+            const headers = { get: name => { const value = res.headers[String(name).toLowerCase()]; return Array.isArray(value) ? value.join(', ') : value === undefined ? null : value; } };
+            const readText = async () => {
+                const chunks = [];
+                for await (const chunk of res) chunks.push(chunk);
+                return Buffer.concat(chunks).toString('utf-8');
+            };
+            return {
+                status: res.statusCode,
+                ok: res.statusCode >= 200 && res.statusCode < 300,
+                headers,
+                url: current,
+                body: Readable.toWeb(res),
+                text: readText,
+                json: async () => JSON.parse(await readText())
+            };
+        }
+        throw Object.assign(new Error('重定向次数过多'), { cause: { code: 'TOO_MANY_REDIRECTS' } });
+    };
+}
+
+/**
+ * 访问 GitHub 用的 fetch：有可用代理时返回带代理的版本，否则返回内置 fetch。
+ * 返回 { fetch, proxy, notice }；notice 是要打印给用户的提示（使用了哪个代理 / 为什么没用）。
+ */
+function getGithubFetch({ env = process.env, platform = process.platform, readSystemProxy, nodeVersion = process.versions.node, baseFetch = globalThis.fetch } = {}) {
+    const proxy = resolveProxy({ env, platform, readSystemProxy });
+    if (!proxy.proxyEnv) return { fetch: baseFetch, proxy, notice: proxy.notice };
+    if (!supportsProxyEnv(nodeVersion)) {
+        return { fetch: baseFetch, proxy, notice: '当前 Node 版本不支持代理，请升级到 Node 22.21+ 或 24+。' };
+    }
+    const label = proxy.source === 'system' ? '使用系统代理' : '使用代理';
+    return { fetch: createProxyFetch(proxy.proxyEnv), proxy, notice: `${label}: ${proxy.display}` };
+}
+
+module.exports = { resolveProxy, parseScutilProxy, displayProxy, supportsProxyEnv, createProxyFetch, getGithubFetch };

package/lib/network-endpoints.js

@@ -2,13 +2,13 @@
 
 const dns = require('dns').promises;
 const net = require('net');
-const { normalizePolicy, normalizeDomain } = require('./network-policy');
+const { normalizePolicy, normalizeDomain, isUnrestricted } = require('./network-policy');
 const { isRestrictedAddress } = require('./egress-proxy');
 
 // 新建容器时从用户在创建时填写的 env 里推断“Agent 要访问的端点”（如 ANTHROPIC_BASE_URL、OPENAI_BASE_URL 指向宿主机上的
 // Ollama 或局域网网关），把落在私有网段的写进网络策略，否则默认收紧会让 Agent 一上来就连不上自己配置的模型服务。
 // 只在创建时、只读宿主机侧给定的 env（不读容器可写的 /run/manyoyo/env：容器不能靠改自己的 env 来放开自己的防火墙）；
-// 结果写进 network.json，在「容器」页的规则里看得到，也可以删。
+// 结果写进 network.json，在「设置容器」页的规则里看得到，也可以删。
 // 代理变量的主机不算“Agent 要访问的服务”
 const PROXY_KEYS = new Set(['http_proxy', 'https_proxy', 'all_proxy', 'no_proxy', 'HTTP_PROXY', 'HTTPS_PROXY', 'ALL_PROXY', 'NO_PROXY']);
 const HOST_ALIASES = new Set(['host.containers.internal', 'host.docker.internal']);
@@ -26,7 +26,7 @@ function urlOf(value) {
 
 /**
  * env 里 URL 的域名（排除 IP、宿主机别名、代理变量）：Agent 的模型服务（ANTHROPIC_BASE_URL、OPENAI_BASE_URL…）。
- * 域名白名单模式下它们必须放行，否则 Agent 一发请求就被过滤代理拒绝（客户端只会看到 ERR_PROXY_TUNNEL）。
+ * 仅白名单模式下它们必须放行，否则 Agent 一发请求就被过滤代理拒绝（客户端只会看到 ERR_PROXY_TUNNEL）。
  */
 function envUrlDomains(envLines) {
     const out = [];
@@ -76,24 +76,23 @@ async function inferEnvEndpoints(envLines, lookup = async host => (await dns.loo
     return { host, rules, domains: envUrlDomains(envLines) };
 }
 
-/** 把推断出的端点并进（已校验的）策略；open 预设不需要。 */
+/**
+ * 把推断出的端点并进（已校验的）策略，写成出站规则行：宿主机端口 → 允许 @host，私有地址 → 允许该 IP，
+ * 模型服务域名只在「仅白名单」下加（其他模式本来就能访问公网域名）。不限制的自定义策略不需要。
+ */
 async function withEnvEndpoints(policy, envLines, lookup) {
-    if (policy.preset === 'open') return policy;
+    if (isUnrestricted(policy)) return policy;
     const inferred = await inferEnvEndpoints(envLines, lookup);
-    if (!inferred.host.length && !inferred.rules.length && !inferred.domains.length) return policy;
-    const hostKey = r => `${r.ports}/${r.proto}`;
-    const ruleKey = r => `${r.cidr}|${r.ports}|${r.proto}`;
-    const haveHost = new Set(policy.host.map(hostKey));
-    const haveRules = new Set(policy.egress.rules.map(ruleKey));
-    return normalizePolicy({
-        ...policy,
-        host: [...policy.host, ...inferred.host.filter(r => !haveHost.has(hostKey(r)))],
-        egress: {
-            // 域名同样在任何预设下都登记：以后切到白名单时，模型服务的域名已经在列表里
-            domains: [...policy.egress.domains, ...inferred.domains.filter(d => !policy.egress.domains.includes(d))],
-            rules: [...policy.egress.rules, ...inferred.rules.filter(r => !haveRules.has(ruleKey(r)))]
-        }
-    });
+    const wanted = [
+        ...inferred.host.map(r => ({ target: '@host', ports: r.ports, proto: r.proto })),
+        ...inferred.rules.map(r => ({ target: r.cidr, ports: r.ports, proto: r.proto })),
+        ...(policy.preset === 'allowlist' ? inferred.domains.map(domain => ({ target: domain, ports: '', proto: 'all' })) : [])
+    ];
+    const key = r => `${r.target}|${r.ports}|${r.proto}`;
+    const have = new Set(policy.outbound.filter(r => r.action === 'allow').map(key));
+    const added = wanted.filter(r => !have.has(key(r))).map(r => ({ action: 'allow', ...r, enabled: true }));
+    if (!added.length) return policy;
+    return normalizePolicy({ ...policy, outbound: [...policy.outbound, ...added] });
 }
 
 module.exports = { inferEnvEndpoints, withEnvEndpoints, envUrlDomains };