@xcanwin/manyoyo 8.5.1 → 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/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 };