@xcanwin/manyoyo 8.3.3 → 8.5.0

package/lib/egress-sidecar.js

@@ -0,0 +1,276 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const net = require('net');
+const os = require('os');
+const path = require('path');
+const { writeConfigFileSecure } = require('./secure-file');
+
+// 域名白名单的强制执行点：manyoyo 网络里的一个专用小容器（sidecar），里面用镜像自带的 node 跑 egress-proxy。
+// - 容器按“来源 IP”识别：宿主机在每次下发规则时把「容器 IP → 容器 id + 策略」写进 clients.json（只读挂入），
+//   认不出的来源一律 403；宿主机上不监听任何端口，同机其他用户无法占用或冒充。
+// - 固定 IP（--ip）：重启后不变，容器的代理地址与 nft 规则才能稳定。
+// - sidecar 只读挂入程序文件和数据目录，只有拒绝记录目录可写；丢掉全部能力。
+const SIDECAR_PORT = 3128;
+const APP_FILES = ['egress-sidecar-main.js', 'egress-proxy.js', 'egress-denied.js', 'network-policy.js', 'container-id.js'];
+const READY_TIMEOUT_MS = 15000;
+
+function egressDir(homeDir) {
+    return path.join(homeDir, '.manyoyo', 'egress');
+}
+
+function egressPaths(homeDir) {
+    const dir = egressDir(homeDir);
+    return { dir, app: path.join(dir, 'app'), data: path.join(dir, 'data'), denied: path.join(dir, 'denied') };
+}
+
+function homeHash(homeDir) {
+    return crypto.createHash('sha256').update(path.resolve(homeDir)).digest('hex').slice(0, 8);
+}
+
+function sidecarName(homeDir) {
+    return `manyoyo-egress-${homeHash(homeDir)}`;
+}
+
+// 任何 HOME 的过滤代理 sidecar 名字：容器列表（网页 / ls）里要排除，它不是用户的会话容器
+function isSidecarName(name) {
+    return /^manyoyo-egress-[0-9a-f]{8}$/.test(String(name || ''));
+}
+
+function ensureDir(dir) {
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    fs.chmodSync(dir, 0o700); // 只限制宿主机其他用户；容器里的 root（rootless 下就是宿主机用户，rootful 下是真 root）不受影响
+}
+
+function writeAtomic(file, text, mode) {
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, text, { mode });
+    fs.chmodSync(tmp, mode);
+    fs.renameSync(tmp, file);
+}
+
+function ipv4ToInt(ip) {
+    return ip.split('.').reduce((acc, part) => ((acc << 8) | Number(part)) >>> 0, 0);
+}
+
+function intToIpv4(value) {
+    return [24, 16, 8, 0].map(shift => (value >>> shift) & 255).join('.');
+}
+
+/**
+ * 在 manyoyo 网络网段里选 sidecar 的固定地址：网段内偏移 250（/24 即 .250），不同 HOME 的实例在
+ * 250 往下的几个地址里按 HOME 哈希错开；真的撞上了由 `run --ip` 报“地址已占用”，不会随机换。
+ */
+function chooseSidecarIp(subnet, homeDir) {
+    const m = /^(\d+\.\d+\.\d+\.\d+)\/(\d+)$/.exec(String(subnet || ''));
+    if (!m || !net.isIPv4(m[1])) throw new Error(`无法确定 manyoyo 网络的网段: ${subnet}`);
+    const prefix = Number(m[2]);
+    if (prefix < 8 || prefix > 29) throw new Error(`manyoyo 网络网段不适合放过滤代理: ${subnet}`);
+    const size = 2 ** (32 - prefix);
+    const base = (ipv4ToInt(m[1]) & ((0xffffffff << (32 - prefix)) >>> 0)) >>> 0;
+    const slot = parseInt(homeHash(homeDir), 16) % 5;
+    const offset = size > 256 ? 250 - slot : Math.max(2, size - 6 - slot);
+    return intToIpv4((base + offset) >>> 0);
+}
+
+// docker：IPAM.Config[].Subnet；podman 4/5：subnets[].subnet；返回第一个 IPv4 网段
+function subnetOfNetwork(inspectJson) {
+    const parsed = Array.isArray(inspectJson) ? inspectJson[0] : inspectJson;
+    const candidates = [];
+    ((parsed && parsed.IPAM && parsed.IPAM.Config) || []).forEach(c => candidates.push(c.Subnet));
+    ((parsed && (parsed.subnets || parsed.Subnets)) || []).forEach(c => candidates.push(c.subnet || c.Subnet));
+    return candidates.find(s => /^\d+\.\d+\.\d+\.\d+\/\d+$/.test(String(s || ''))) || '';
+}
+
+// 上游代理在宿主机上的地址对 sidecar 容器可能不通：环回地址改写成容器看到的宿主机别名
+function containerSideUpstream(upstream, hostAlias) {
+    if (!upstream) return '';
+    try {
+        const url = new URL(upstream);
+        if (url.protocol !== 'http:') return '';
+        if (/^(localhost|127\.\d+\.\d+\.\d+|\[?::1\]?)$/i.test(url.hostname)) url.hostname = hostAlias;
+        return url.toString().replace(/\/$/, '');
+    } catch (e) {
+        return '';
+    }
+}
+
+// 固定 MAC（同 docker 的 02:42:<IP 四字节> 规则）：重启后 MAC 变了，别的容器里缓存的 ARP 要等一分钟才失效，期间出网不通
+function macForIp(ip) {
+    return `02:42:${ip.split('.').map(part => Number(part).toString(16).padStart(2, '0')).join(':')}`;
+}
+
+function appFileContents() {
+    return APP_FILES.map(name => [name, fs.readFileSync(path.join(__dirname, name), 'utf-8')]);
+}
+
+/**
+ * @param {object} options
+ * @param {(args: string[], opts?: object) => Promise<string>} options.run 运行时命令（容器运行时 CLI）
+ * @param {string} options.command 运行时命令名（docker / podman，用来判断宿主机别名）
+ * @param {string} options.homeDir
+ * @param {() => string} options.imageRef 当前镜像
+ * @param {string} options.networkName manyoyo 网络名
+ * @param {() => Promise<void>} options.ensureNetwork
+ * @param {() => string} [options.getUpstream] 上游代理（宿主机视角）
+ */
+function createSidecarManager(options) {
+    const { run, homeDir, networkName } = options;
+    const getUpstream = options.getUpstream || (() => '');
+    const isDocker = /docker/i.test(path.basename(String(options.command || '')));
+    const hostAlias = isDocker ? 'host.docker.internal' : 'host.containers.internal';
+    const name = sidecarName(homeDir);
+    const hash = homeHash(homeDir);
+    let inflight = null;
+    let lastClients = '';
+
+    async function inspectSidecar() {
+        try {
+            const out = await run(['inspect', '--format', '{{json .}}', name]);
+            const line = out.split('\n').map(l => l.trim()).filter(Boolean)[0];
+            return line ? JSON.parse(line) : null;
+        } catch (e) {
+            if (/no such|not found|no container|does not exist/i.test(String(e.message))) return null;
+            throw e;
+        }
+    }
+
+    function ipOf(info) {
+        const networks = (info.NetworkSettings && info.NetworkSettings.Networks) || {};
+        return (networks[networkName] && networks[networkName].IPAddress) || '';
+    }
+
+    function runningOf(info) {
+        return Boolean(info.State && (info.State.Running === true || info.State.Status === 'running'));
+    }
+
+    function prepareFiles(upstream) {
+        const p = egressPaths(homeDir);
+        ensureDir(path.join(homeDir, '.manyoyo'));
+        ensureDir(p.dir);
+        [p.app, p.data, p.denied].forEach(ensureDir);
+        const contents = appFileContents();
+        contents.forEach(([file, text]) => {
+            const target = path.join(p.app, file);
+            if (!fs.existsSync(target) || fs.readFileSync(target, 'utf-8') !== text) writeAtomic(target, text, 0o644);
+        });
+        const upstreamFile = path.join(p.data, 'upstream.txt');
+        if (upstream) writeConfigFileSecure(upstreamFile, `${upstream}\n`);
+        else fs.rmSync(upstreamFile, { force: true });
+        const rev = crypto.createHash('sha256');
+        contents.forEach(([file, text]) => rev.update(`${file}\0${text}\0`));
+        return { p, rev: rev.digest('hex').slice(0, 16) };
+    }
+
+    // 就绪 = 在 sidecar 里真的连得上代理端口（不能看日志：重启后日志里还留着上一次的“ready”）
+    async function waitReady() {
+        const deadline = Date.now() + READY_TIMEOUT_MS;
+        const probe = `require('net').connect(${SIDECAR_PORT},'127.0.0.1').on('connect',()=>process.exit(0)).on('error',()=>process.exit(1))`;
+        while (Date.now() < deadline) {
+            const info = await inspectSidecar();
+            if (!info || !runningOf(info)) break;
+            try {
+                await run(['exec', name, 'node', '-e', probe], { timeout: 5000 });
+                return;
+            } catch (e) { /* 还没起来 */ }
+            await new Promise(resolve => setTimeout(resolve, 150));
+        }
+        let tail = '';
+        try { tail = await run(['logs', '--tail', '5', name]); } catch (e) { /* 取不到就算了 */ }
+        throw new Error(`域名白名单代理没有起来${tail ? `: ${String(tail).trim().split('\n').slice(-2).join(' ')}` : ''}`);
+    }
+
+    async function doEnsure() {
+        await options.ensureNetwork();
+        const subnet = subnetOfNetwork(JSON.parse((await run(['network', 'inspect', networkName, '--format', '{{json .}}'])).trim().split('\n')[0] || 'null'));
+        const ip = chooseSidecarIp(subnet, homeDir);
+        const upstream = containerSideUpstream(getUpstream(), hostAlias);
+        const { p, rev } = prepareFiles(upstream);
+        let info = await inspectSidecar();
+        const labels = (info && info.Config && info.Config.Labels) || {};
+        const matches = info && labels['manyoyo.egress.rev'] === rev && labels['manyoyo.home'] === hash;
+        if (matches && runningOf(info) && ipOf(info) === ip) return { name, ip, port: SIDECAR_PORT };
+        if (matches && !runningOf(info)) {
+            try {
+                await run(['start', name]);
+                info = await inspectSidecar();
+                if (info && runningOf(info) && ipOf(info) === ip) {
+                    await waitReady();
+                    return { name, ip, port: SIDECAR_PORT };
+                }
+            } catch (e) { /* 起不来就重建 */ }
+        }
+        if (info) await run(['rm', '-f', name]);
+        const args = [
+            'run', '-d', '--name', name,
+            '--network', networkName, '--ip', ip, '--mac-address', macForIp(ip),
+            // 宿主机上这几个目录属于普通用户且是 0700：rootful 运行时里的 root 不带 DAC_OVERRIDE 就进不去（rootless 下 root 就是该用户，不受影响）
+            '--user', 'root', '--cap-drop', 'ALL', '--cap-add', 'DAC_OVERRIDE', '--security-opt', 'no-new-privileges',
+            '--read-only', '--tmpfs', '/tmp', '--pids-limit', '256', '--memory', '256m',
+            '--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}`
+        ];
+        if (isDocker) args.push('--add-host', 'host.docker.internal:host-gateway');
+        args.push('--entrypoint', 'node', options.imageRef(), '/app/egress-sidecar-main.js');
+        try {
+            await run(args, { timeout: 60000 });
+        } catch (e) {
+            const message = String(e.message);
+            // 另一个进程（CLI / serve）刚好同时建好了它：直接用现成的
+            if (/name .*(already in use|is already used)|already in use by container|name is already/i.test(message)) {
+                const other = await inspectSidecar();
+                if (other && runningOf(other) && ipOf(other) === ip) {
+                    await waitReady();
+                    return { name, ip, port: SIDECAR_PORT };
+                }
+            }
+            throw new Error(/address already in use|ip.*(used|allocated)|in use/i.test(message) && !/name/i.test(message)
+                ? `域名白名单代理需要的地址 ${ip} 已被占用（${networkName} 网络里有别的容器用了它）`
+                : `域名白名单代理启动失败: ${message}`);
+        }
+        await waitReady();
+        return { name, ip, port: SIDECAR_PORT };
+    }
+
+    /** 保证 sidecar 在运行，返回 {name, ip, port}；多处同时调用合并成一次。 */
+    function ensure() {
+        if (!inflight) inflight = doEnsure().finally(() => { inflight = null; });
+        return inflight;
+    }
+
+    /** 只读检查：sidecar 现在是否在运行且地址正确（ensureReady 的快速路径用）。 */
+    async function isHealthy() {
+        const info = await inspectSidecar();
+        return Boolean(info && runningOf(info));
+    }
+
+    /** 写入「来源 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;
+    }
+
+    return { name, ensure, isHealthy, writeClients, paths: () => egressPaths(homeDir), isSidecarName: n => n === name };
+}
+
+module.exports = {
+    SIDECAR_PORT,
+    APP_FILES,
+    egressDir,
+    egressPaths,
+    sidecarName,
+    isSidecarName,
+    chooseSidecarIp,
+    macForIp,
+    subnetOfNetwork,
+    containerSideUpstream,
+    createSidecarManager
+};

package/lib/env-text.js

@@ -0,0 +1,62 @@
+'use strict';
+
+// 环境变量的唯一语法（Web「环境变量」文本、容器内 /run/manyoyo/env、环境变量文件、容器内 init 都按它解析；
+// 前端 frontend/src/lib/container-manage.ts 与 lib/container-init.sh 各有一份等价实现，用同一组语料测试）：
+//   - 一行一项 `KEY=VALUE`，空行与 `#` 开头的行忽略；
+//   - 与 docker / podman 的 env-file 一致：不展开变量、不执行命令，值里的空格不需要引号（`KEY=abc 123`）；
+//   - 兼容 shell / dotenv 常见写法：可选的 `export ` 前缀；`=` 两侧的空白；值两端成对的 "…" 或 '…' 会被去掉
+//     （docker 自己会把引号当成值的一部分，这里去掉更符合直觉）。想让值保留首尾的引号，就再包一层引号。
+//   - 写出时（serializeEnvEntries）只在值首尾有空白、或首尾恰好是一对引号时才加引号，其余原样，所以
+//     表格里填的 `abc 123` 在文本里就是 `KEY=abc 123`。
+const ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const LINE_RE = /^(?:export\s+)?([^=\s]+)\s*=\s*(.*)$/;
+
+function unquote(value) {
+    const v = value.trim();
+    if (v.length >= 2 && ((v[0] === '"' && v[v.length - 1] === '"') || (v[0] === "'" && v[v.length - 1] === "'"))) {
+        return v.slice(1, -1);
+    }
+    return v;
+}
+
+/**
+ * @returns {{entries: {key:string,value:string,line:number}[], invalid: {line:number,text:string,reason:string}[]}}
+ */
+function parseEnvText(text) {
+    const entries = [];
+    const invalid = [];
+    String(text || '').split('\n').forEach((raw, index) => {
+        const line = raw.replace(/\r$/, '');
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#')) return;
+        const m = LINE_RE.exec(trimmed);
+        if (!m) {
+            invalid.push({ line: index + 1, text: line, reason: '缺少 KEY=VALUE' });
+            return;
+        }
+        if (!ENV_KEY_RE.test(m[1])) {
+            invalid.push({ line: index + 1, text: line, reason: `key 非法: ${m[1]}` });
+            return;
+        }
+        entries.push({ key: m[1], value: unquote(m[2]), line: index + 1 });
+    });
+    return { entries, invalid };
+}
+
+function needsQuote(value) {
+    return /^\s|\s$/.test(value)
+        || (value.length >= 2 && ((value[0] === '"' && value[value.length - 1] === '"') || (value[0] === "'" && value[value.length - 1] === "'")));
+}
+
+function formatEnvValue(value) {
+    if (!needsQuote(value)) return value;
+    const q = value[0] === '"' ? "'" : '"';
+    return `${q}${value}${q}`;
+}
+
+function serializeEnvEntries(entries) {
+    const lines = entries.filter(entry => String(entry.key).trim()).map(entry => `${String(entry.key).trim()}=${formatEnvValue(entry.value)}`);
+    return lines.length ? `${lines.join('\n')}\n` : '';
+}
+
+module.exports = { ENV_KEY_RE, parseEnvText, serializeEnvEntries, formatEnvValue };

package/lib/json5-text-edit.js

@@ -232,7 +232,7 @@ function applyTextReplacements(text, replacements) {
 }
 
 function formatPropertyKey(key) {
-    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+    return JSON.stringify(key);
 }
 
 // 某个位置所在行的缩进
@@ -246,8 +246,7 @@ function reindent(valueText, indent) {
     return String(valueText).replace(/\n/g, `\n${indent}`);
 }
 
-// 永远只在对象的 '{' 后面插入，不管这个对象原来是空的还是已经有属性——
-// 不用去判断"是不是最后一个属性、要不要补逗号"，语法上总是安全的
+// 永远只在对象的 '{' 后面插入；对象原来已有属性才补逗号，空对象里插入第一个属性不留尾逗号
 function insertObjectProperty(text, objectStartIndex, key, valueText) {
     const objectIndent = lineIndentAt(text, objectStartIndex);
     const childIndent = `${objectIndent}    `;
@@ -256,8 +255,9 @@ function insertObjectProperty(text, objectStartIndex, key, valueText) {
     const lineEnd = text.indexOf('\n', objectStartIndex + 1);
     const tailIsTrivia = lineEnd !== -1 && /^\s*(\/\/.*)?$/.test(text.slice(objectStartIndex + 1, lineEnd));
     // 空对象且 } 紧跟在同一行：闭合的 } 另起一行；} 已在后面的行上就不再补，避免多出空行
-    const closesRightAfter = !tailIsTrivia && text[skipTrivia(text, objectStartIndex + 1)] === '}';
-    const insertion = `${prefix}${reindent(valueText, childIndent)},${closesRightAfter ? `\n${objectIndent}` : ''}`;
+    const nextChar = text[skipTrivia(text, objectStartIndex + 1)];
+    const closesRightAfter = !tailIsTrivia && nextChar === '}';
+    const insertion = `${prefix}${reindent(valueText, childIndent)}${nextChar === '}' ? '' : ','}${closesRightAfter ? `\n${objectIndent}` : ''}`;
     const insertPos = tailIsTrivia ? lineEnd : objectStartIndex + 1;
     const nextText = `${text.slice(0, insertPos)}${insertion}${text.slice(insertPos)}`;
     return { text: nextText, valueStart: insertPos + prefix.length };

package/lib/network-endpoints.js

@@ -0,0 +1,99 @@
+'use strict';
+
+const dns = require('dns').promises;
+const net = require('net');
+const { normalizePolicy, normalizeDomain } = 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，在「容器」页的规则里看得到，也可以删。
+// 代理变量的主机不算“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']);
+
+function urlOf(value) {
+    if (!/^https?:\/\//i.test(value)) return null;
+    try {
+        const url = new URL(value);
+        const port = Number(url.port) || (url.protocol === 'https:' ? 443 : 80);
+        return { host: url.hostname.replace(/^\[|\]$/g, '').toLowerCase(), port };
+    } catch (e) {
+        return null;
+    }
+}
+
+/**
+ * env 里 URL 的域名（排除 IP、宿主机别名、代理变量）：Agent 的模型服务（ANTHROPIC_BASE_URL、OPENAI_BASE_URL…）。
+ * 域名白名单模式下它们必须放行，否则 Agent 一发请求就被过滤代理拒绝（客户端只会看到 ERR_PROXY_TUNNEL）。
+ */
+function envUrlDomains(envLines) {
+    const out = [];
+    for (const line of envLines || []) {
+        const text = String(line);
+        const i = text.indexOf('=');
+        if (i <= 0 || PROXY_KEYS.has(text.slice(0, i))) continue;
+        const target = urlOf(text.slice(i + 1));
+        if (!target || net.isIP(target.host) || HOST_ALIASES.has(target.host)) continue;
+        let domain;
+        try { domain = normalizeDomain(target.host); } catch (e) { continue; }
+        if (!out.includes(domain)) out.push(domain);
+    }
+    return out;
+}
+
+/**
+ * @param {string[]} envLines KEY=VALUE（创建时的用户 env）
+ * @param {(host: string) => Promise<string[]>} [lookup]
+ * @returns {Promise<{host: {ports: string, proto: 'tcp'}[], rules: {cidr: string, ports: string, proto: 'tcp'}[]}>}
+ */
+async function inferEnvEndpoints(envLines, lookup = async host => (await dns.lookup(host, { all: true })).map(r => r.address)) {
+    const host = [];
+    const rules = [];
+    const seen = new Set();
+    for (const line of envLines || []) {
+        const value = String(line).slice(String(line).indexOf('=') + 1);
+        const target = urlOf(value);
+        if (!target) continue;
+        const key = `${target.host}:${target.port}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        if (HOST_ALIASES.has(target.host)) {
+            host.push({ ports: String(target.port), proto: 'tcp' });
+            continue;
+        }
+        let addresses = [];
+        try {
+            addresses = net.isIP(target.host) ? [target.host] : await lookup(target.host);
+        } catch (e) {
+            addresses = [];
+        }
+        addresses.filter(ip => isRestrictedAddress(ip) && !/^127\./.test(ip) && ip !== '::1').forEach(ip => {
+            rules.push({ cidr: ip, ports: String(target.port), proto: 'tcp' });
+        });
+    }
+    return { host, rules, domains: envUrlDomains(envLines) };
+}
+
+/** 把推断出的端点并进（已校验的）策略；open 预设不需要。 */
+async function withEnvEndpoints(policy, envLines, lookup) {
+    if (policy.preset === 'open') 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)))]
+        }
+    });
+}
+
+module.exports = { inferEnvEndpoints, withEnvEndpoints, envUrlDomains };