@xcanwin/manyoyo 8.5.1 → 8.6.2

package/bin/manyoyo.js

@@ -49,7 +49,7 @@ const { applyAptMirror } = require('../lib/mirrors');
 const containerState = require('../lib/container-state');
 const { buildExecArgs, resolveContainerId } = require('../lib/container-exec');
 const { createNetworkManager, NETWORK_NAME } = require('../lib/container-network');
-const { normalizePolicy } = require('../lib/network-policy');
+const { normalizePolicy, isUnrestricted: isUnrestrictedPolicy } = require('../lib/network-policy');
 const { withEnvEndpoints } = require('../lib/network-endpoints');
 const { resolveManageOptions } = require('../lib/container-manage-options');
 const {
@@ -354,7 +354,7 @@ function installServeProcessDiagnostics(logger) {
  * @property {string} [containerRuntime] - 容器运行时（auto/docker/podman，默认 auto；仅全局配置生效）
  * @property {string} [autostart] - 容器每次启动时由容器内 init 执行的 bash 脚本（新建容器时写入状态目录）
  * @property {boolean} [autostartOnServe] - serve 启动时自动拉起此容器
- * @property {object} [network] - 网络策略（preset / host / egress / peers，见 lib/network-policy.js），不写为默认收紧
+ * @property {object} [network] - 网络策略（preset / outbound / inbound / expose，见 lib/network-policy.js），不写为默认收紧
  * @property {{apt?: string, npm?: string, pip?: string}} [mirrors] - 容器内 apt/npm/pip 软件源（http/https URL，空/缺省为官方默认；仅全局配置生效）
  * @property {boolean} [updateCheck] - serve 是否每天检查一次新版本（默认 true；仅全局配置生效，请求不附带任何本机信息）
  * @property {number} [cacheTTL] - 缓存过期天数
@@ -2141,8 +2141,8 @@ async function createNewContainer(runtime) {
 
     await ensureRunImage(runtime);
 
-    const networkPolicy = await withEnvEndpoints(normalizePolicy(runtime.network), [...userEnvLines, ...containerState.readEnvFilePaths(runtime.envFiles || []).flatMap(file => file.entries.map(entry => `${entry.key}=${entry.value}`))]);
     const networkManager = createCliNetworkManager(runtime);
+    const networkPolicy = await withEnvEndpoints(await networkManager.resolveRefs(normalizePolicy(runtime.network)), [...userEnvLines, ...containerState.readEnvFilePaths(runtime.envFiles || []).flatMap(file => file.entries.map(entry => `${entry.key}=${entry.value}`))]);
     if (!hasNetworkArg([...(runtime.contModeArgs || []), ...(runtime.containerExtraArgs || [])])) {
         try {
             await networkManager.ensureBridgeNetwork();
@@ -2156,7 +2156,7 @@ async function createNewContainer(runtime) {
         envFiles: runtime.envFiles,
         autostart: runtime.autostart,
         network: networkPolicy,
-        netRequired: networkPolicy.preset !== 'open',
+        netRequired: !isUnrestrictedPolicy(networkPolicy),
         meta: { name: runtime.containerName }
     });
 

package/lib/container-exec.js

@@ -129,4 +129,23 @@ function buildExecArgs(ctx, containerName, options = {}) {
     return { args, cleanup, invalid, containerId };
 }
 
-module.exports = { ID_LABEL, resolveContainerId, composeEnvLines, buildExecArgs };
+/**
+ * 读出一个容器 exec 时会拿到的合并后 env（managed → 环境变量文件 → box/env），只在宿主机上读文件、不进容器。
+ * 旧容器（没有状态目录）返回空对象。调用方只能挑非敏感字段（如 *_MODEL）展示，不要整份下发给前端。
+ * @returns {Record<string, string>}
+ */
+function readMergedEnv(ctx, containerName) {
+    const homeDir = ctx.homeDir || os.homedir();
+    const containerId = resolveContainerId(ctx.dockerExecArgs, containerName);
+    if (!containerId || !state.stateExists(homeDir, containerId)) return {};
+    const p = state.paths(homeDir, containerId);
+    const { lines } = composeEnvLines(readTextOrEmpty(p.managedEnv), readTextOrEmpty(p.env, true), [], state.envFileEntries(homeDir, containerId));
+    const env = {};
+    lines.forEach(line => {
+        const i = line.indexOf('=');
+        if (i > 0) env[line.slice(0, i)] = line.slice(i + 1);
+    });
+    return env;
+}
+
+module.exports = { ID_LABEL, resolveContainerId, composeEnvLines, buildExecArgs, readMergedEnv };

package/lib/container-network.js

@@ -98,6 +98,11 @@ function parseUrlHostPort(value) {
     }
 }
 
+// 指向宿主机的代理（host.*.internal / loopback）要放行到容器里看到的宿主机 IP，而不是在宿主机上解析
+function isHostTarget(host) {
+    return HOST_NAMES.includes(host) || host === 'localhost' || host === '::1' || /^127\./.test(host);
+}
+
 function uniqueBy(items, keyFn) {
     const seen = new Set();
     return items.filter(item => {
@@ -148,7 +153,7 @@ function createNetworkManager(options) {
         });
     }
 
-    // 域名白名单的过滤代理：manyoyo 网络里的 sidecar 容器，按来源 IP 认容器（见 egress-sidecar.js）
+    // 域名规则的过滤代理：manyoyo 网络里的 sidecar 容器，按来源 IP 认容器（见 egress-sidecar.js）
     const sidecar = createSidecarManager({ run, command, homeDir, imageRef: getImageRef, networkName: NETWORK_NAME, ensureNetwork: ensureBridgeNetwork, getUpstream });
 
     // buildExecArgs 只需要同步 inspect 取 id；这里 withEnv:false 不会用到
@@ -180,6 +185,13 @@ function createNetworkManager(options) {
         })).filter(item => state.isValidId(item.id));
     }
 
+    // 把策略里按名称写的 @container:<名称> 换成 id；名称找不到抛错
+    async function resolveRefs(policy) {
+        if (!policyLib.hasNameRefs(policy)) return policy;
+        const byName = new Map((await listManaged()).map(item => [item.name, item.id]));
+        return policyLib.resolveContainerRefs(policy, name => byName.get(name) || '');
+    }
+
     function loadPolicy(id) {
         const raw = state.readNetworkRaw(homeDir, id);
         return policyLib.normalizePolicy(raw || undefined);
@@ -228,6 +240,29 @@ function createNetworkManager(options) {
         return await run(args, { timeout: 30000 });
     }
 
+    // 容器间：别的容器入站规则里允许了本容器（来源写 @containers 或 @container:<本容器>），本容器才能出去到它（派生行）。
+    // 来源写 @any 不派生：别的容器开放自己，不能顺带放宽本容器的出站限制
+    function computeDerived(self, all) {
+        const derived = [];
+        for (const other of all) {
+            if (other.id === self.id || !other.running || !state.stateExists(homeDir, other.id)) continue;
+            let otherPolicy;
+            try { otherPolicy = loadPolicy(other.id); } catch (e) { continue; }
+            const b = safeBridge(other.info);
+            if (!b) continue;
+            otherPolicy.inbound.filter(rule => rule.enabled && rule.action === 'allow' && (rule.source === '@containers' || rule.source === `@container:${self.id}`)).forEach(rule => {
+                derived.push({ id: other.id, name: other.name, ip: b.ip, ports: rule.ports, proto: rule.proto });
+            });
+        }
+        return derived;
+    }
+
+    async function derivedOf(name) {
+        const all = await listManaged();
+        const self = all.find(item => item.name === name);
+        return self ? computeDerived(self, all) : [];
+    }
+
     // 下发时现算：容器看到的宿主机 IP / DNS / 代理 / 镜像源 / peer 的当前 IP
     async function resolveEndpoints(self, policy, all) {
         const hostsText = await readRuntimeNetworkFacts(self.info);
@@ -239,10 +274,10 @@ function createNetworkManager(options) {
         const allow = [];
         const addHost = (ports, proto) => hostIps.forEach(ip => allow.push({ ip, ports: String(ports), proto }));
 
-        // 必需端点：上游代理、过滤代理、Playwright、镜像源
+        // 必需端点（@manyoyo）：上游代理、过滤代理、Playwright、镜像源
         const env = envMapOf(self.info);
         const proxyTargets = [];
-        // allowlist 下容器只能经过滤代理出网，上游代理不能直连放行（否则绕过域名白名单）
+        // allowlist 下容器只能经过滤代理出网，上游代理不能直连放行（否则绕过域名规则）
         if (policy.preset !== 'allowlist') {
             Object.keys(env).filter(key => PROXY_ENV_KEYS.has(key)).forEach(key => {
                 const parsed = env[key] && parseUrlHostPort(env[key]);
@@ -254,15 +289,20 @@ function createNetworkManager(options) {
             if (parsed) proxyTargets.push(parsed);
         });
         for (const target of uniqueBy(proxyTargets, t => `${t.host}:${t.port}`)) {
+            if (isHostTarget(target.host)) {
+                addHost(target.port, 'tcp');
+                continue;
+            }
             for (const ip of await resolveHostToIps(target.host)) allow.push({ ip, ports: String(target.port), proto: 'tcp' });
         }
-        // 过滤代理（sidecar 容器）：allowlist 容器经它出网，只放行到它的 IP:端口；
+        // 过滤代理（sidecar 容器）：有启用的域名规则时，容器的 HTTP(S) 经它出网，只放行到它的 IP:端口；
         // 容器发往它的包来源必须是自己的 IP（第二道保险：识别身份靠的就是来源 IP）
         let managedEnv = [];
         const antiSpoof = [];
-        if (policy.preset === 'allowlist' && policy.egress.domains.length) {
+        const proxied = policyLib.usesProxy(policy);
+        if (proxied) {
             const selfBridge = safeBridge(self.info);
-            if (!selfBridge) throw new Error('域名白名单需要容器在 manyoyo 网络里，这个容器的网络不支持');
+            if (!selfBridge) throw new Error('域名规则需要容器在 manyoyo 网络里，这个容器的网络不支持');
             const proxy = await sidecar.ensure();
             allow.push({ ip: proxy.ip, ports: String(proxy.port), proto: 'tcp' });
             antiSpoof.push({ daddr: proxy.ip, saddr: selfBridge.ip });
@@ -270,50 +310,55 @@ function createNetworkManager(options) {
             managedEnv = ['HTTP_PROXY', 'HTTPS_PROXY', 'http_proxy', 'https_proxy'].map(key => `${key}=${url}`);
         }
         playwrightHostPorts().forEach(port => addHost(port, 'tcp'));
-        policy.host.forEach(entry => addHost(entry.ports, entry.proto));
-
-        // 容器间：我的 peers.inbound 里的容器能进来；别人的 inbound 列了我，我才能出去
-        const peerIn = [];
-        const byId = new Map(all.map(item => [item.id, item]));
-        policy.peers.inbound.forEach(entry => {
-            const peer = byId.get(entry.from);
-            const b = peer && peer.running ? safeBridge(peer.info) : null;
-            if (b) peerIn.push({ ip: b.ip, ports: entry.ports, proto: entry.proto });
+
+        const containers = {};
+        all.forEach(item => {
+            const b = item.running ? safeBridge(item.info) : null;
+            if (b) containers[item.id] = b.ip;
         });
-        for (const other of all) {
-            if (other.id === self.id || !other.running || !state.stateExists(homeDir, other.id)) continue;
-            let otherPolicy;
-            try { otherPolicy = loadPolicy(other.id); } catch (e) { continue; }
-            const b = safeBridge(other.info);
-            if (!b) continue;
-            otherPolicy.peers.inbound.filter(entry => entry.from === self.id).forEach(entry => {
-                allow.push({ ip: b.ip, ports: entry.ports, proto: entry.proto });
-            });
-        }
-        return {
+        const derived = computeDerived(self, all);
+        derived.forEach(item => allow.push({ ip: item.ip, ports: item.ports, proto: item.proto }));
+        const bridge = bridgeOf(self.info);
+        const endpoints = {
             managedEnv,
             antiSpoof,
             dns: dnsServers,
             allow: uniqueBy(allow, a => `${a.ip}|${a.ports}|${a.proto}`),
-            peerIn,
-            bridge: bridgeOf(self.info) ? { subnet: bridgeOf(self.info).subnet, gateway: bridgeOf(self.info).gateway } : null
+            derived: uniqueBy(derived, d => `${d.id}|${d.ports}|${d.proto}`),
+            hostIps,
+            containers,
+            bridge: bridge ? { subnet: bridge.subnet, gateway: bridge.gateway } : null
         };
+        endpoints.proxyPolicy = proxied ? policyLib.compileProxyPolicy(policy, endpoints) : null;
+        return endpoints;
     }
 
     function safeBridge(info) {
         try { return bridgeOf(info); } catch (e) { return null; }
     }
 
-    // 过滤代理的「来源 IP → 容器 id + 策略」：所有运行中、属于本 HOME、策略是 allowlist 的容器
+    // 过滤代理的「来源 IP → 容器 id + 编译好的规则」：所有运行中、属于本 HOME、出站有域名规则的容器。
+    // 规则在容器自己下发时编译并缓存；缓存没有（serve 刚重启、CLI 新进程）就沿用 clients.json 里同 id 同 IP 的旧项
+    const clientCache = new Map();
+    function clientEntryOf(item, previous) {
+        const bridge = safeBridge(item.info);
+        if (!bridge) return null;
+        const cached = clientCache.get(item.id);
+        if (cached && cached.ip === bridge.ip) return { ip: bridge.ip, entry: cached.entry };
+        const old = previous[bridge.ip];
+        return old && old.id === item.id ? { ip: bridge.ip, entry: old } : null;
+    }
+
     function syncEgressClients(all) {
+        const previous = sidecar.readClients();
         const clients = {};
         for (const item of all) {
             if (!item.running || !state.stateExists(homeDir, item.id)) continue;
             let policy;
             try { policy = loadPolicy(item.id); } catch (e) { continue; }
-            if (policy.preset !== 'allowlist') continue;
-            const bridge = safeBridge(item.info);
-            if (bridge) clients[bridge.ip] = { id: item.id, preset: policy.preset, domains: policy.egress.domains, rules: policy.egress.rules };
+            if (!policyLib.usesProxy(policy)) continue;
+            const found = clientEntryOf(item, previous);
+            if (found) clients[found.ip] = found.entry;
         }
         sidecar.writeClients(clients);
     }
@@ -366,10 +411,13 @@ function createNetworkManager(options) {
                 state.writeNetStatus(homeDir, self.id, status);
                 return { ...status, id: self.id };
             }
-            state.setNetRequired(homeDir, self.id, policy.preset !== 'open');
+            state.setNetRequired(homeDir, self.id, !policyLib.isUnrestricted(policy));
             const endpoints = await resolveEndpoints(self, policy, all);
             state.syncFilesEnv(homeDir, self.id); // 环境变量文件的最新快照（供自启动脚本用）
             state.writeManagedEnv(homeDir, self.id, endpoints.managedEnv);
+            const selfBridge = safeBridge(self.info);
+            if (endpoints.proxyPolicy && selfBridge) clientCache.set(self.id, { ip: selfBridge.ip, entry: { id: self.id, ...endpoints.proxyPolicy } });
+            else clientCache.delete(self.id);
             syncEgressClients(all); // 先让代理认得这个容器，再放行门闩
             await sendRuleset(name, policyLib.buildNftRuleset(policy, endpoints));
             await execInContainer(name, ['/bin/sh', '-c', `mkdir -p ${path.posix.dirname(GATE_READY)} && : > ${GATE_READY}`]);
@@ -378,7 +426,7 @@ function createNetworkManager(options) {
                 status: 'applied',
                 startedAt,
                 policyHash: policyHashOf(policy),
-                warning: privileged && policy.preset !== 'open' ? '特权容器（dind / sock 模式）里的进程自带 NET_ADMIN，可以改动这些规则，网络限制没有约束力' : '',
+                warning: privileged && !policyLib.isUnrestricted(policy) ? '特权容器（dind / sock 模式）里的进程自带 NET_ADMIN，可以改动这些规则，网络限制没有约束力' : '',
                 at: new Date().toISOString()
             };
             state.writeNetStatus(homeDir, self.id, status);
@@ -386,7 +434,7 @@ function createNetworkManager(options) {
         } catch (e) {
             const message = `网络规则下发失败: ${e.message}`;
             try { state.writeNetStatus(homeDir, self.id, { status: 'error', message, startedAt, at: new Date().toISOString() }); } catch (err) { /* 状态目录可能已被删 */ }
-            // 旧规则可能还在（比如 open → allowlist 失败）：清掉门闩，让 manyoyo 的 exec 与自启动都按“未下发”处理
+            // 旧规则可能还在（比如不限制 → 收紧失败）：清掉门闩，让 manyoyo 的 exec 与自启动都按“未下发”处理
             await clearGate(name);
             const error = new Error(message);
             error.cause = e;
@@ -420,7 +468,7 @@ function createNetworkManager(options) {
         } catch (e) {
             policy = null; // 策略文件损坏：按收紧处理，下发时会报错
         }
-        if (policy && policy.preset === 'open') return { status: 'open' };
+        if (policy && policyLib.isUnrestricted(policy)) return { status: 'unrestricted' };
         // 判断依据在宿主机侧（net-status.json：同一次启动 + 同一份策略 + 下发成功），不依赖容器里的任何文件或命令
         const status = state.readNetStatus(homeDir, id);
         const startedAt = String((info.State && info.State.StartedAt) || '');
@@ -428,20 +476,25 @@ function createNetworkManager(options) {
         if (sameRun && status.status === 'unsupported') return { status: 'unsupported' };
         if (policy && sameRun && status.status === 'applied' && status.policyHash === policyHashOf(policy)) {
             // 规则还在，但过滤代理可能意外退了（容器出网此时是失败即关闭）：顺手拉起，失败不拦 exec
-            if (policy.preset === 'allowlist' && policy.egress.domains.length) {
+            if (policyLib.usesProxy(policy)) {
                 try {
                     if (!await sidecar.isHealthy()) {
                         await sidecar.ensure();
                         syncEgressClients(await listManaged());
                     }
-                } catch (e) { warn(`域名白名单代理恢复失败: ${e.message}`); }
+                } catch (e) { warn(`域名规则代理恢复失败: ${e.message}`); }
+                // 代理不认识这个容器（规则没缓存、clients.json 里也没有）：重新下发一次
+                if (!clientEntryOf({ id, info }, sidecar.readClients())) return await apply(name, { expectId: id });
             }
             return { status: 'applied' };
         }
         return await apply(name, { expectId: id });
     }
 
-    // 与 `name` 有 peers 关系的其他运行中容器（本容器重启后 IP 变化时要重算它们）
+    // 与 `name` 有容器间规则关系的其他运行中容器（本容器重启后 IP 变化时要重算它们）
+    const rulesOf = policy => [...policy.outbound, ...policy.inbound].filter(rule => rule.enabled);
+    const refersTo = (policy, id) => rulesOf(policy).some(rule => (rule.target || rule.source) === `@container:${id}`);
+    const opensToContainers = policy => policy.inbound.some(rule => rule.enabled && rule.action === 'allow' && rule.source === '@containers');
     async function relatedContainers(name) {
         const all = await listManaged();
         const self = all.find(item => item.name === name);
@@ -452,7 +505,7 @@ function createNetworkManager(options) {
             let p;
             let mine;
             try { p = loadPolicy(other.id); mine = loadPolicy(self.id); } catch (e) { continue; }
-            if (p.peers.inbound.some(e => e.from === self.id) || mine.peers.inbound.some(e => e.from === other.id)) related.push(other.name);
+            if (refersTo(p, self.id) || refersTo(mine, other.id) || opensToContainers(p) || opensToContainers(mine)) related.push(other.name);
         }
         return related;
     }
@@ -468,22 +521,20 @@ function createNetworkManager(options) {
             }
         }
         // 没有容器需要重新下发规则时，过滤代理也要在（运行时重启后它同样是停着的）
-        await healSidecar().catch(e => warn(`域名白名单代理恢复失败: ${e.message}`));
+        await healSidecar().catch(e => warn(`域名规则代理恢复失败: ${e.message}`));
     }
 
-    // 订阅容器 start 事件：容器被外部重启（podman restart、machine 重启后手动 start）后 netns 重建、规则丢失，
-    // 事件到来就重新下发，并重算与它有 peers 关系的容器（它的 IP 可能变了）。
-    async function needsSidecar(all) {
+        async function needsSidecar(all) {
         return all.some(item => {
             if (!state.stateExists(homeDir, item.id)) return false;
             try {
                 const policy = loadPolicy(item.id);
-                return policy.preset === 'allowlist' && policy.egress.domains.length > 0;
+                return policyLib.usesProxy(policy);
             } catch (e) { return false; }
         });
     }
 
-    // 过滤代理容器自己退出 / 被删：有 allowlist 容器就拉起来，并重写映射
+    // 过滤代理容器自己退出 / 被删：有用到它的容器就拉起来，并重写映射
     let lastHealAt = 0;
     let healTimer = null;
     async function healSidecar() {
@@ -494,7 +545,7 @@ function createNetworkManager(options) {
             if (!healTimer) {
                 healTimer = setTimeout(() => {
                     healTimer = null;
-                    healSidecar().catch(e => warn(`域名白名单代理恢复失败: ${e.message}`));
+                    healSidecar().catch(e => warn(`域名规则代理恢复失败: ${e.message}`));
                 }, wait + 50);
                 if (healTimer.unref) healTimer.unref();
             }
@@ -601,7 +652,7 @@ function createNetworkManager(options) {
         };
     }
 
-    return { NETWORK_NAME, sidecar, run, listManaged, loadPolicy, ensureBridgeNetwork, apply, ensureReady, relatedContainers, resolveEndpoints, reconcileAll, watchStarts };
+    return { NETWORK_NAME, sidecar, run, listManaged, loadPolicy, resolveRefs, derivedOf, ensureBridgeNetwork, apply, ensureReady, relatedContainers, resolveEndpoints, reconcileAll, watchStarts };
 }
 
 module.exports = {
@@ -611,5 +662,6 @@ module.exports = {
     bridgeOf,
     parseHostsAndResolv,
     parseUrlHostPort,
+    isHostTarget,
     createNetworkManager
 };

package/lib/container-run.js

@@ -27,7 +27,7 @@ function buildContainerRunArgs(options) {
         '--name', options.containerName,
         '--entrypoint', `${SYS_MOUNT}/init.sh`,
         // docker 默认带 NET_RAW（podman 默认不带）：有它的容器能发原始包 / 伪造 ARP，冒充别的容器的来源 IP，
-        // 域名白名单的过滤代理就是按来源 IP 认容器的，所以统一去掉
+        // 域名规则的过滤代理就是按来源 IP 认容器的，所以统一去掉
         '--cap-drop', 'NET_RAW',
         ...(options.contModeArgs || []),
         ...(options.containerExtraArgs || []),