@xcanwin/manyoyo 8.5.1 → 8.6.2

package/lib/egress-proxy.js

@@ -3,27 +3,43 @@
 const dns = require('dns').promises;
 const http = require('http');
 const net = require('net');
-const { domainAllowed, PRIVATE_V4, PRIVATE_V6 } = require('./network-policy');
+const { domainMatches, PRIVATE_V4, PRIVATE_V6 } = require('./network-policy');
 
-// 域名白名单的强制执行点：运行在 manyoyo 网络里专用 sidecar 容器中的 HTTP(S) 过滤代理（见 egress-sidecar.js）。
-// 开启 allowlist 的容器防火墙只放行到这个代理，直连被挡；这里按连接的来源 IP 认出是哪个容器（getClient），
-// 认不出的来源一律 403；按域名放行 CONNECT / 普通 HTTP，
-// 并且解析出的 IP 属于私有 / 环回 / 链路本地段一律拒绝（防借代理打宿主机 loopback 与 DNS 重绑定），
-// 除非该容器的 egress.rules 显式放行该 IP:端口。
+// 域名规则的强制执行点：运行在 manyoyo 网络里专用 sidecar 容器中的 HTTP(S) 过滤代理（见 egress-sidecar.js）。
+// 有启用域名规则的容器，HTTP(S) 都走这个代理，防火墙只放行到它；这里按连接的来源 IP 认出是哪个容器（getClient），
+// 认不出的来源一律 403；然后按该容器编译好的有序规则（域名行 + 地址行 + 模式默认行）从上往下找第一条命中的。
+// 地址行按“任一解析结果”匹配；通配域名命中后，解析结果若落在 @host / @private / @metadata，仍要有一条允许该地址的规则。
+// 环回 / 未指定 / 组播地址永远拒绝（防借代理打 sidecar 自己）。
 // 被拒绝时统一回 403（带 Proxy-Status，不带任何能暴露代理身份的内容），并通过 onDenied 记录。
 const CONNECT_TIMEOUT_MS = 15000;
 const IDLE_TIMEOUT_MS = 10 * 60 * 1000;
 const MAX_TUNNELS_PER_CONTAINER = 256;
+const LOOKUP_TIMEOUT_MS = 5000;
 
-const blocked = new net.BlockList();
-[...PRIVATE_V4, '127.0.0.0/8', '224.0.0.0/4', '255.255.255.255/32'].forEach(cidr => {
-    const [addr, prefix] = cidr.split('/');
-    blocked.addSubnet(addr, Number(prefix), 'ipv4');
-});
-[...PRIVATE_V6, 'fe80::/10', 'ff00::/8', '::1/128', '::/128'].forEach(cidr => {
-    const [addr, prefix] = cidr.split('/');
-    blocked.addSubnet(addr, Number(prefix), 'ipv6');
-});
+function withTimeout(promise, ms) {
+    let timer;
+    return Promise.race([promise, new Promise((resolve, reject) => { timer = setTimeout(() => reject(new Error('timeout')), ms); })]).finally(() => clearTimeout(timer));
+}
+
+async function liveOnly(ips) {
+    return ips.filter(ip => !checkList(floor, ip));
+}
+
+function blockListOf(cidrs) {
+    const list = new net.BlockList();
+    (cidrs || []).forEach(cidr => {
+        const [addr, prefix] = String(cidr).split('/');
+        const family = net.isIP(addr);
+        if (!family) return;
+        const type = family === 4 ? 'ipv4' : 'ipv6';
+        if (prefix === undefined) list.addAddress(addr, type);
+        else list.addSubnet(addr, Number(prefix), type);
+    });
+    return list;
+}
+
+const blocked = blockListOf([...PRIVATE_V4, ...PRIVATE_V6, 'fe80::/10', 'ff00::/8', '::1/128', '::/128', '127.0.0.0/8', '255.255.255.255/32']);
+const floor = blockListOf(['127.0.0.0/8', '0.0.0.0/8', '224.0.0.0/4', '255.255.255.255/32', '::1/128', '::/128', 'ff00::/8']);
 
 // ::ffff:a.b.c.d 与 NAT64（64:ff9b::/96）里嵌的 IPv4 要按 IPv4 判断
 function embeddedV4(ip) {
@@ -39,29 +55,102 @@ function embeddedV4(ip) {
     return '';
 }
 
+function checkList(list, ip) {
+    const addr = embeddedV4(ip) || ip;
+    const family = net.isIP(addr);
+    return family ? list.check(addr, family === 4 ? 'ipv4' : 'ipv6') : null;
+}
+
 function isRestrictedAddress(ip) {
-    const v4 = embeddedV4(ip);
-    if (v4) return blocked.check(v4, 'ipv4');
-    const family = net.isIP(ip);
-    if (!family) return true;
-    return blocked.check(ip, family === 4 ? 'ipv4' : 'ipv6');
+    const hit = checkList(blocked, ip);
+    return hit === null ? true : hit;
 }
 
-function ruleCovers(rule, ip, port) {
-    if (rule.proto && rule.proto !== 'tcp') return false;
-    if (rule.ports) {
-        const ok = rule.ports.split(',').some(item => {
-            const [a, b] = item.split('-').map(Number);
-            return port >= a && port <= (b === undefined ? a : b);
-        });
-        if (!ok) return false;
+const setCache = new WeakMap();
+function compiledSet(set) {
+    let compiled = setCache.get(set);
+    if (!compiled) {
+        compiled = { inc: blockListOf(set.inc), exc: blockListOf(set.exc) };
+        setCache.set(set, compiled);
     }
-    const [addr, prefixText] = rule.cidr.split('/');
-    const family = net.isIP(addr);
-    if (!family || net.isIP(ip) !== family) return false;
-    const list = new net.BlockList();
-    list.addSubnet(addr, prefixText === undefined ? (family === 4 ? 32 : 128) : Number(prefixText), family === 4 ? 'ipv4' : 'ipv6');
-    return list.check(ip, family === 4 ? 'ipv4' : 'ipv6');
+    return compiled;
+}
+
+/** 地址集合 {any, inc, exc} 是否包含 ip。 */
+function setCovers(set, ip) {
+    if (!set) return false;
+    const compiled = compiledSet(set);
+    if (!set.any && !checkList(compiled.inc, ip)) return false;
+    return !checkList(compiled.exc, ip);
+}
+
+const listCache = new WeakMap();
+function listCovers(cidrs, ip) {
+    let list = listCache.get(cidrs);
+    if (!list) {
+        list = blockListOf(cidrs);
+        listCache.set(cidrs, list);
+    }
+    return Boolean(checkList(list, ip));
+}
+
+function portsCover(ports, port) {
+    if (!ports) return true;
+    return String(ports).split(',').some(item => {
+        const [a, b] = item.split('-').map(Number);
+        return port >= a && port <= (b === undefined ? a : b);
+    });
+}
+
+/**
+ * 按容器编译好的有序规则判断一次连接。解析是惰性的：只有规则需要看地址时才查 DNS（被域名规则直接拒绝 / 放行的不用等 DNS）。
+ * @param {{rules: object[], default: string, sensitive?: string[]}} policy
+ * @param {string} host 目标主机（域名或 IP 字面量）
+ * @param {number} port
+ * @param {string[]|(() => Promise<string[]>)} ipsOrResolve 目标的解析结果，或惰性解析函数（目标本身是 IP 时就是它自己；解析不出来为空）
+ * @returns {Promise<{ok: boolean, reason?: string, usable?: string[]|null}>} usable 为 null 表示判断时没看地址，由调用方按解析结果挑
+ */
+async function decide(policy, host, port, ipsOrResolve) {
+    const isIp = net.isIP(host) !== 0;
+    const deny = reason => ({ ok: false, reason });
+    let live = null;
+    const liveIps = async () => {
+        if (live === null) {
+            const ips = Array.isArray(ipsOrResolve) ? ipsOrResolve : (isIp ? [host] : await ipsOrResolve());
+            live = { all: ips, ok: ips.filter(ip => !checkList(floor, ip)) };
+        }
+        return live;
+    };
+    const applies = rule => rule.proto !== 'udp' && portsCover(rule.ports, port);
+    const addressAllowed = ip => {
+        for (const rule of policy.rules) {
+            if (rule.domain || !applies(rule) || !setCovers(rule.addr, ip)) continue;
+            return rule.action === 'allow';
+        }
+        return policy.default === 'allow';
+    };
+    for (const rule of policy.rules) {
+        if (!applies(rule)) continue;
+        if (rule.domain) {
+            if (isIp || !domainMatches(rule.domain, host)) continue;
+            if (rule.action === 'deny') return deny('domain');
+            if (rule.domain.startsWith('*.')) {
+                const { all, ok } = await liveIps();
+                if (all.length && !ok.length) return deny('address');
+                const sensitive = policy.sensitive || [];
+                const usable = ok.filter(ip => !listCovers(sensitive, ip) || addressAllowed(ip));
+                if (ok.length && !usable.length) return deny('address');
+                return { ok: true, usable };
+            }
+            return { ok: true, usable: null };
+        }
+        const { all, ok } = await liveIps();
+        if (all.length && !ok.length) return deny('address');
+        const hit = ok.filter(ip => setCovers(rule.addr, ip));
+        if (!hit.length) continue;
+        return rule.action === 'allow' ? { ok: true, usable: isIp ? ok : hit } : deny('address');
+    }
+    return policy.default === 'allow' ? { ok: true, usable: null } : deny('domain');
 }
 
 function parseTarget(text) {
@@ -74,14 +163,16 @@ function parseTarget(text) {
 
 /**
  * @param {object} options
- * @param {(ip: string) => {id: string, preset: string, domains: string[], rules: object[]}|null} options.getClient 按来源 IP 认容器（认不出返回 null）
+ * @param {(ip: string) => {id: string, default: string, sensitive?: string[], rules: object[]}|null} options.getClient 按来源 IP 认容器（认不出返回 null）
  * @param {(event: {id: string, host: string, port: number, reason: string}) => void} [options.onDenied] 拒绝记录
  * @param {string} [options.upstream] 上游 HTTP 代理 URL（串联）
  * @param {(host: string) => Promise<string[]>} [options.lookup] 测试替身
+ * @param {(ip: string) => string} [options.mapAddress] 测试替身：实际拨号的地址（单测里把虚构的公网 IP 映射到本机夹具）
  */
 function createEgressProxy(options) {
     const getClient = options.getClient;
     const onDenied = options.onDenied || (() => {});
+    const mapAddress = options.mapAddress || (ip => ip);
     const lookup = options.lookup || (async host => (await dns.lookup(host, { all: true })).map(r => r.address));
     // upstream 可以是字符串或返回字符串的函数（sidecar 里按文件改动热更新）；解析结果按字符串缓存
     let parsedFor = null;
@@ -120,33 +211,24 @@ function createEgressProxy(options) {
 
     // 返回 {ok:true, ip?} 或 {ok:false, status, message}
     async function authorize(policy, host, port, upstream) {
-        if (!policy || policy.preset !== 'allowlist') return { ok: false, status: 403, message: 'domain' };
+        if (!policy || !Array.isArray(policy.rules)) return { ok: false, status: 403, message: 'domain' };
         const isIp = net.isIP(host) !== 0;
-        const explicit = (ip, p) => (policy.rules || []).some(rule => ruleCovers(rule, ip, p));
-        if (isIp) {
-            if (isRestrictedAddress(host) && !explicit(host, port)) return { ok: false, status: 403, message: 'address' };
-            if (!explicit(host, port)) return { ok: false, status: 403, message: 'domain' };
-            return { ok: true, ip: host };
-        }
-        if (!domainAllowed(policy.domains, host)) return { ok: false, status: 403, message: 'domain' };
-        if (upstream) {
-            // 经上游代理时真正的连接由上游解析；这里仍做一次本地解析，解析得到私有 / 环回地址（且没有被显式放行）就拒绝。
-            // 本地解析不出来（宿主机不一定能解析）则放行给上游。残余风险：白名单里的通配域名若被控制了 DNS，
-            // 本地与上游可能得到不同答案——不要在白名单里放你不信任的通配域名。
-            try {
-                const local = await lookup(host);
-                if (local.length && local.every(ip => isRestrictedAddress(ip) && !explicit(ip, port))) return { ok: false, status: 403, message: 'address' };
-            } catch (e) { /* 本地解析失败：交给上游 */ }
-            return { ok: true, ip: '' };
-        }
-        let addresses;
-        try {
-            addresses = await lookup(host);
-        } catch (e) {
-            return { ok: false, status: 502, message: 'dns' };
-        }
-        const usable = addresses.filter(ip => !isRestrictedAddress(ip) || explicit(ip, port));
-        if (!usable.length) return { ok: false, status: 403, message: 'address' };
+        let addresses = null;
+        const resolveIps = async () => {
+            if (addresses === null) {
+                addresses = [];
+                try {
+                    addresses = await withTimeout(lookup(host), LOOKUP_TIMEOUT_MS);
+                } catch (e) { /* 解析不出来：规则里的域名行仍然判断；经上游代理时交给上游解析 */ }
+            }
+            return addresses;
+        };
+        const verdict = await decide(policy, host, port, isIp ? [host] : resolveIps);
+        if (!verdict.ok) return { ok: false, status: 403, message: verdict.reason };
+        if (upstream) return { ok: true, ip: '' };
+        // 直接拨号：需要地址。规则没看过地址时，从解析结果里挑非环回的
+        const usable = verdict.usable || (await liveOnly(isIp ? [host] : await resolveIps()));
+        if (!usable.length) return isIp || (addresses && addresses.length) ? { ok: false, status: 403, message: 'address' } : { ok: false, status: 502, message: 'dns' };
         return { ok: true, ip: usable[0] };
     }
 
@@ -234,7 +316,7 @@ function createEgressProxy(options) {
                 upstreamSocket.on('data', onData);
             });
         } else {
-            upstreamSocket = track(net.connect({ host: verdict.ip, port: target.port }));
+            upstreamSocket = track(net.connect({ host: mapAddress(verdict.ip), port: target.port }));
             upstreamSocket.setTimeout(CONNECT_TIMEOUT_MS, () => upstreamSocket.destroy());
             upstreamSocket.once('connect', () => {
                 upstreamSocket.setTimeout(IDLE_TIMEOUT_MS, () => upstreamSocket.destroy());
@@ -271,7 +353,7 @@ function createEgressProxy(options) {
         delete headers['proxy-connection'];
         const outbound = upstream
             ? { host: upstream.host, port: upstream.port, path: req.url, headers: { ...headers, ...(upstream.auth ? { 'proxy-authorization': upstream.auth } : {}) } }
-            : { host: verdict.ip, port, path: `${url.pathname}${url.search}`, headers };
+            : { host: mapAddress(verdict.ip), port, path: `${url.pathname}${url.search}`, headers };
         const proxyReq = http.request({ ...outbound, method: req.method, timeout: CONNECT_TIMEOUT_MS });
         let released = false;
         const done = () => { if (!released) { released = true; release(id); } };
@@ -312,4 +394,4 @@ function createEgressProxy(options) {
     return { start, stop, authorize, isListening: () => Boolean(server && server.listening) };
 }
 
-module.exports = { createEgressProxy, isRestrictedAddress, ruleCovers, parseTarget };
+module.exports = { createEgressProxy, isRestrictedAddress, decide, setCovers, parseTarget };

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 };