aiakiv 0.2.1 → 0.3.0

package/dist/local/checks.js

@@ -0,0 +1,529 @@
+// `aiakiv local doctor` 의 점검 판정(docs/211 §17.4). 판정 함수는 받은 값만 보고 결과를 낸다.
+// 바깥 세계(실행기, fetch, 환경 변수)는 Ctx 로, Node 판과 OS, 디스크, 포트 묶기는 LocalHost 로만 만난다.
+// 시험은 둘 다 가짜로 넣는다.
+//
+// 문턱값의 GB 는 10^9 바이트다. Docker 가 알리는 MemTotal 은 커널이 잡아 둔 몫을 빼고 나와서, 설정에서
+// 4GB 를 준 컴퓨터가 2^30 기준으로는 4GB 미만으로 보이기 때문이다.
+import { existsSync, promises as fsp } from "node:fs";
+import { createServer } from "node:net";
+import { cpus, networkInterfaces, release, totalmem } from "node:os";
+import { posix, win32 } from "node:path";
+export const GB = 1e9;
+export const pass = (detail) => ({ status: "pass", detail });
+export const warn = (detail, fix = null) => ({ status: "warn", detail, fix });
+export const fail = (detail, fix = null) => ({ status: "fail", detail, fix });
+export const skip = (detail) => ({ status: "skip", detail });
+export const info = (detail, fix = null) => ({ status: "info", detail, fix });
+function bindOnce(port) {
+    return new Promise((resolve) => {
+        const server = createServer();
+        server.once("error", (e) => resolve({ ok: false, code: e.code, message: e.message }));
+        server.listen(port, "127.0.0.1", () => server.close(() => resolve({ ok: true })));
+    });
+}
+export function realHost() {
+    const statfs = fsp.statfs;
+    return {
+        nodeVersion: process.versions.node,
+        arch: process.arch,
+        osRelease: release(),
+        cpus: cpus().length,
+        memBytes: totalmem(),
+        interfaces: () => networkInterfaces(),
+        statfs: typeof statfs === "function" ? (p) => statfs(p) : null,
+        exists: (p) => existsSync(p),
+        tryBind: bindOnce,
+    };
+}
+/** "27.3.1", "v2.29.1-desktop.1", "20.10.24+dfsg1" 에서 [주, 부]. 못 읽으면 null. */
+export function majorMinor(v) {
+    const m = /(\d+)\.(\d+)/.exec(v ?? "");
+    return m ? [Number(m[1]), Number(m[2])] : null;
+}
+const below = (v, major, minor) => v[0] < major || (v[0] === major && v[1] < minor);
+export const gbText = (bytes) => `${(bytes / GB).toFixed(1)}GB`;
+// ---- Node, OS -------------------------------------------------------------------------------
+export function checkNodeVersion(version) {
+    const v = majorMinor(version);
+    if (!v)
+        return fail(`Node 판을 읽지 못했습니다(${version})`, "Node.js LTS 판을 설치하세요(https://nodejs.org).");
+    if (below(v, 18, 3))
+        return fail(`Node ${version} 은 18.3 보다 낮습니다`, "Node.js LTS 판을 설치하세요(https://nodejs.org).");
+    return pass(`Node ${version}`);
+}
+const WINDOWS_22H2_BUILD = 19045;
+const WINDOWS_11_BUILD = 22000;
+export function checkOs(platform, hostArch, osRelease) {
+    const archOk = hostArch === "x64" || hostArch === "arm64";
+    const unsupported = "Linux, macOS, Windows 10 22H2 이상 또는 Windows 11 의 x64, arm64 컴퓨터에서 설치하세요.";
+    if (platform === "linux" || platform === "darwin") {
+        const name = platform === "linux" ? "Linux" : "macOS";
+        if (!archOk)
+            return fail(`${name} ${hostArch} 는 지원하지 않습니다(x64, arm64 만)`, unsupported);
+        return pass(`${name} ${osRelease} ${hostArch}`);
+    }
+    if (platform === "win32") {
+        const m = /^(\d+)\.(\d+)\.(\d+)/.exec(osRelease);
+        if (!m || Number(m[1]) < 10)
+            return fail(`Windows ${osRelease} 는 지원하지 않습니다`, unsupported);
+        if (!archOk)
+            return fail(`Windows ${hostArch} 는 지원하지 않습니다(x64, arm64 만)`, unsupported);
+        const build = Number(m[3]);
+        if (build >= WINDOWS_11_BUILD)
+            return pass(`Windows 11(빌드 ${build}) ${hostArch}`);
+        if (build >= WINDOWS_22H2_BUILD)
+            return pass(`Windows 10 22H2(빌드 ${build}) ${hostArch}`);
+        return warn(`Windows 10 빌드 ${build} 는 22H2(빌드 ${WINDOWS_22H2_BUILD}) 보다 오래됐습니다`, "Windows 업데이트로 Windows 10 22H2 이상으로 올리세요.");
+    }
+    return fail(`${platform} 는 지원하지 않습니다`, unsupported);
+}
+// ---- Docker ---------------------------------------------------------------------------------
+export function dockerInstallUrl(platform) {
+    if (platform === "win32")
+        return "https://docs.docker.com/desktop/setup/install/windows-install/";
+    if (platform === "darwin")
+        return "https://docs.docker.com/desktop/setup/install/mac-install/";
+    return "https://docs.docker.com/engine/install/";
+}
+const str = (v) => (typeof v === "string" && v ? v : undefined);
+const num = (v) => (typeof v === "number" && Number.isFinite(v) ? v : undefined);
+/** `docker info --format "{{json .}}"` 의 출력. 데몬에 닿지 못하면 info 없이 errors 만(ServerErrors 나 JSON 아님). */
+export function parseDockerInfo(stdout) {
+    const line = stdout.split(/\r?\n/).map((l) => l.trim()).find((l) => l.startsWith("{"));
+    if (!line)
+        return { info: null, errors: [] };
+    let raw;
+    try {
+        raw = JSON.parse(line);
+    }
+    catch {
+        return { info: null, errors: [] };
+    }
+    const errors = Array.isArray(raw.ServerErrors) ? raw.ServerErrors.map(String).filter(Boolean) : [];
+    const serverVersion = str(raw.ServerVersion);
+    if (!serverVersion || errors.length)
+        return { info: null, errors };
+    return {
+        info: {
+            serverVersion,
+            osType: str(raw.OSType),
+            architecture: str(raw.Architecture),
+            memTotal: num(raw.MemTotal),
+            ncpu: num(raw.NCPU),
+            operatingSystem: str(raw.OperatingSystem),
+            kernelVersion: str(raw.KernelVersion),
+            dockerRootDir: str(raw.DockerRootDir),
+            httpProxy: str(raw.HttpProxy),
+            httpsProxy: str(raw.HttpsProxy),
+            noProxy: str(raw.NoProxy),
+        },
+        errors,
+    };
+}
+export function isPermissionDenied(text) {
+    return /permission denied/i.test(text);
+}
+export function daemonFix(platform, permissionDenied) {
+    if (platform === "linux" && permissionDenied) {
+        return "지금 사용자를 docker 그룹에 넣고(sudo usermod -aG docker $USER) 로그아웃했다가 다시 로그인하세요.";
+    }
+    if (platform === "linux")
+        return "Docker 를 켜세요(sudo systemctl start docker).";
+    return "Docker Desktop 을 켜고, 고래 아이콘이 움직임을 멈출 때까지 기다린 뒤 다시 점검하세요.";
+}
+export function checkDockerVersion(v) {
+    const mm = majorMinor(v);
+    const fix = "Docker 를 새 판으로 올리세요(Docker Engine 24 이상 또는 최신 Docker Desktop).";
+    if (!mm)
+        return warn(`Docker 서버 판을 읽지 못했습니다(${v})`, fix);
+    if (below(mm, 20, 10))
+        return fail(`Docker 서버 ${v} 는 20.10 보다 낮습니다`, fix);
+    if (mm[0] < 24)
+        return warn(`Docker 서버 ${v} 는 24 보다 낮습니다`, fix);
+    return pass(`Docker 서버 ${v}`);
+}
+/** `docker compose version --short` 결과(실패면 null)와 옛 docker-compose 실행 파일이 있는지. */
+export function checkCompose(short, hasV1, platform) {
+    const fix = platform === "linux"
+        ? "compose 플러그인을 설치하세요(배포판 꾸러미 docker-compose-v2 또는 docker-compose-plugin)."
+        : "Docker Desktop 을 새 판으로 올리세요(compose v2 가 함께 들어 있습니다).";
+    if (short === null) {
+        if (hasV1)
+            return fail("옛 docker-compose(v1) 만 있고 docker compose(v2) 가 없습니다", fix);
+        return fail("docker compose(v2) 가 없습니다", fix);
+    }
+    const v = short.trim().replace(/^v/, "");
+    const mm = majorMinor(v);
+    if (!mm)
+        return warn(`compose 판을 읽지 못했습니다(${short.trim()})`, fix);
+    if (mm[0] < 2)
+        return fail(`compose ${v} 는 v2 가 아닙니다`, fix);
+    if (below(mm, 2, 20))
+        return warn(`compose ${v} 는 2.20 보다 낮습니다`, fix);
+    return pass(`compose ${v}`);
+}
+export function checkDockerOs(osType) {
+    if (osType === "linux")
+        return pass("리눅스 컨테이너 모드");
+    if (osType === "windows") {
+        return fail("Docker 가 Windows 컨테이너 모드입니다", "작업 표시줄의 Docker 아이콘을 오른쪽 클릭해 Switch to Linux containers 를 고르세요.");
+    }
+    return fail(`Docker 컨테이너 종류를 알 수 없습니다(${osType ?? "없음"})`, "리눅스 컨테이너 모드로 바꾸세요.");
+}
+/** Docker 의 Architecture 와 process.arch 를 같은 이름(amd64, arm64)으로. 모르면 null. */
+export function normArch(a) {
+    const v = (a ?? "").toLowerCase();
+    if (v === "x86_64" || v === "amd64" || v === "x64")
+        return "amd64";
+    if (v === "aarch64" || v === "arm64")
+        return "arm64";
+    return null;
+}
+export function checkDockerArch(dockerArch, hostArch) {
+    const d = normArch(dockerArch);
+    if (!d)
+        return fail(`Docker 아키텍처 ${dockerArch ?? "없음"} 는 지원하지 않습니다(amd64, arm64 만)`, "amd64 또는 arm64 컴퓨터에서 설치하세요.");
+    const h = normArch(hostArch);
+    if (h && h !== d) {
+        return warn(`Docker 는 ${d}, 이 컴퓨터는 ${h} 입니다(에뮬레이션이라 임베딩이 느립니다)`, "이 컴퓨터의 아키텍처와 같은 Docker 를 설치하세요.");
+    }
+    return pass(`Docker ${dockerArch}(${d})`);
+}
+export function checkWsl2(kernelVersion, operatingSystem) {
+    const k = kernelVersion ?? "";
+    if (/wsl2/i.test(k))
+        return pass(`WSL2 백엔드(커널 ${k})`);
+    return warn(`WSL2 백엔드가 아닌 것으로 보입니다(커널 ${k || "알 수 없음"}${operatingSystem ? `, ${operatingSystem}` : ""})`, "Docker Desktop 의 Settings > General 에서 Use the WSL 2 based engine 을 켜세요.");
+}
+export function checkDockerMem(memTotal, platform, isDesktop) {
+    if (memTotal === undefined)
+        return warn("Docker 가 쓸 수 있는 메모리를 알 수 없습니다");
+    let fix;
+    if (platform === "win32") {
+        fix =
+            "Docker Desktop 의 Settings > Resources 에서 메모리를 6GB 이상으로 올리세요. WSL2 백엔드면 " +
+                "%UserProfile%\\.wslconfig 의 [wsl2] 아래 memory=6GB 로 적고 wsl --shutdown 뒤 Docker Desktop 을 다시 켜세요.";
+    }
+    else if (isDesktop || platform === "darwin") {
+        fix = "Docker Desktop 의 Settings > Resources > Memory 를 6GB 이상으로 올리세요.";
+    }
+    else {
+        fix = "메모리가 더 많은 컴퓨터를 쓰세요(Docker Engine 은 컴퓨터 메모리를 그대로 씁니다).";
+    }
+    if (memTotal < 4 * GB)
+        return fail(`Docker 메모리 ${gbText(memTotal)} 는 4GB 보다 적습니다`, fix);
+    if (memTotal < 6 * GB)
+        return warn(`Docker 메모리 ${gbText(memTotal)} 는 6GB 보다 적습니다`, fix);
+    return pass(`Docker 메모리 ${gbText(memTotal)}`);
+}
+export function checkDockerCpus(ncpu, isDesktop) {
+    if (ncpu === undefined)
+        return warn("Docker 가 쓸 수 있는 CPU 수를 알 수 없습니다");
+    const fix = isDesktop
+        ? "Docker Desktop 의 Settings > Resources 에서 CPU 를 4개 이상으로 올리세요."
+        : "CPU 가 더 많은 컴퓨터를 쓰세요.";
+    if (ncpu < 2)
+        return fail(`Docker CPU ${ncpu}개는 2개보다 적습니다`, fix);
+    if (ncpu < 4)
+        return warn(`Docker CPU ${ncpu}개는 4개보다 적습니다`, fix);
+    return pass(`Docker CPU ${ncpu}개`);
+}
+export function isDockerDesktop(info) {
+    return /docker desktop/i.test(info?.operatingSystem ?? "");
+}
+export function checkDesktopLicense(d) {
+    if (isDockerDesktop(d)) {
+        return info(`Docker Desktop 입니다(${d.operatingSystem})`, "직원 250명 이상이거나 연매출 1천만 달러 이상인 회사는 Docker 유료 구독이 필요합니다.");
+    }
+    return info(`Docker Desktop 이 아닙니다(${d.operatingSystem ?? "알 수 없음"}). 구독 조건과 관계없습니다`);
+}
+/** 여유 공간을 볼 경로 후보. 앞에서부터 있는 것을 쓴다. 마지막은 늘 홈 폴더(또는 그 드라이브). */
+export function diskCandidates(platform, home, env, info) {
+    if (platform === "win32") {
+        const out = [];
+        const lad = env.LOCALAPPDATA ?? env.LocalAppData;
+        if (lad) {
+            out.push({ path: win32.join(lad, "Docker", "wsl"), label: "Docker Desktop 데이터 폴더" });
+            const drive = /^[A-Za-z]:/.exec(lad)?.[0];
+            if (drive)
+                out.push({ path: `${drive}\\`, label: `Docker Desktop 데이터가 있는 ${drive} 드라이브` });
+        }
+        out.push({ path: home, label: "홈 폴더" });
+        return out;
+    }
+    if (platform === "darwin") {
+        return [
+            { path: posix.join(home, "Library", "Containers", "com.docker.docker", "Data"), label: "Docker Desktop 데이터 폴더" },
+            { path: posix.join(home, ".orbstack"), label: "OrbStack 데이터 폴더" },
+            { path: home, label: "홈 폴더" },
+        ];
+    }
+    const root = info?.dockerRootDir ?? "/var/lib/docker";
+    return [
+        { path: root, label: info?.dockerRootDir ? "Docker 데이터 폴더(DockerRootDir)" : "Docker 기본 데이터 폴더" },
+        { path: home, label: "홈 폴더" },
+    ];
+}
+/** `df -Pk <경로>` 출력에서 쓸 수 있는 바이트(Available 칸, 1K 블록). 못 읽으면 null. */
+export function parseDfAvailable(stdout) {
+    const lines = stdout.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+    for (const l of lines.slice(1).reverse()) {
+        const m = /\s(\d+)\s+(\d+)\s+(\d+)\s+(\d+)%\s+\S.*$/.exec(` ${l}`);
+        if (m)
+            return Number(m[3]) * 1024;
+    }
+    return null;
+}
+/** PowerShell `(Get-PSDrive …).Free` 의 출력(바이트 숫자 한 줄). */
+export function parsePsFree(stdout) {
+    const m = /^\s*(\d+)\s*$/m.exec(stdout);
+    return m ? Number(m[1]) : null;
+}
+export function checkDiskFree(bytes, where) {
+    const fix = "디스크 공간을 비우거나 Docker 데이터 위치를 여유가 있는 디스크로 옮기세요.";
+    if (bytes < 10 * GB)
+        return fail(`${where} 의 여유 공간 ${gbText(bytes)} 는 10GB 보다 적습니다`, fix);
+    if (bytes < 20 * GB)
+        return warn(`${where} 의 여유 공간 ${gbText(bytes)} 는 20GB 보다 적습니다`, fix);
+    return pass(`${where} 의 여유 공간 ${gbText(bytes)}`);
+}
+/** AiAkiv 엔진(k2g-mcp)의 /health 로 보이는가: status 가 글자이고 엔진만 내는 칸이 하나 이상 있다. */
+export function looksLikeEngineHealth(body) {
+    if (!body || typeof body !== "object" || Array.isArray(body))
+        return false;
+    const b = body;
+    return typeof b.status === "string" && ("edition" in b || "engine_version" in b || "first_bootstrap" in b);
+}
+export const FREE_EDITION = "self-hosted-free";
+export function checkEngineHealth(h) {
+    if (h.status === "ok")
+        return pass("엔진 /health 의 status 가 ok 입니다");
+    return fail(`엔진 /health 의 status 가 ${String(h.status)} 입니다`, "엔진 로그를 보세요(~/.aiakiv/engine 에서 docker compose -f aiakiv-compose.yml logs engine).");
+}
+export function checkEngineEdition(h) {
+    if (h.edition === FREE_EDITION)
+        return pass(`판 이름 ${FREE_EDITION}`);
+    return fail(`이 포트의 엔진은 무료 엔진이 아닙니다(edition ${h.edition === undefined ? "없음" : String(h.edition)})`, "이 포트를 쓰는 프로그램을 확인하거나 --port 로 무료 엔진의 포트를 주세요.");
+}
+export function checkEngineVersion(h) {
+    const v = h.engine_version;
+    return info(`엔진 판 ${typeof v === "string" && v ? v : "알 수 없음"}`);
+}
+// ---- 엔진 status 의 vectors 칸 --------------------------------------------------------------
+/**
+ * `aiakiv-admin --json status` 의 결과 문서(K2G src/k2g/selfhost/admin/status.py)에서 `vectors` 칸
+ * (vector_check.status_block: status 는 ok, info, warn, skip, 그리고 detail, fix)을 점검 한 줄로 옮긴다.
+ * 엔진의 detail 과 fix 는 그대로 싣는다. doc 이 null 이면 결과를 읽지 못한 것이고 why 가 이유다.
+ * 이 칸이 없는 옛 엔진 판은 알림으로 둔다.
+ */
+export function checkEngineVectors(doc, why = "") {
+    const logsFix = "엔진 로그(docker logs <엔진 컨테이너>)를 보세요.";
+    if (!doc)
+        return warn(`엔진 상태(aiakiv-admin status)를 읽지 못했습니다${why ? `: ${why}` : ""}`, logsFix);
+    if (doc.ok !== true) {
+        const msg = typeof doc.message === "string" && doc.message ? doc.message : String(doc.error ?? "이유 없음");
+        return warn(`엔진 상태(aiakiv-admin status)가 실패했습니다: ${msg}`, logsFix);
+    }
+    const v = doc.vectors;
+    if (!v || typeof v !== "object" || Array.isArray(v)) {
+        const ver = typeof doc.engine_version === "string" && doc.engine_version ? `, 엔진 판 ${doc.engine_version}` : "";
+        return info(`엔진 판이 벡터 없는 기억 점검을 지원하지 않아 보지 않았습니다(status 에 vectors 칸 없음${ver})`);
+    }
+    const b = v;
+    const detail = typeof b.detail === "string" && b.detail ? b.detail : "벡터 상태 내용 없음";
+    const fix = typeof b.fix === "string" && b.fix ? b.fix : null;
+    switch (b.status) {
+        case "ok":
+            return pass(detail);
+        case "warn":
+            return warn(detail, fix);
+        case "skip":
+            return skip(detail);
+        default:
+            return info(detail, fix);
+    }
+}
+/** `docker ps --format "{{.Image}}\t{{.Names}}\t{{.Ports}}"` 출력. */
+export function parseDockerPs(stdout) {
+    return stdout
+        .split(/\r?\n/)
+        .filter((l) => l.trim())
+        .map((l) => {
+        const [image = "", names = "", ports = ""] = l.split("\t");
+        return { image: image.trim(), names: names.trim(), ports: ports.trim() };
+    });
+}
+export function isEngineContainer(r) {
+    return /(^|\/)aiakiv\/engine(:|@|$)/i.test(r.image);
+}
+/** Ports 칸(`127.0.0.1:7777->7777/tcp, [::]:7777->7777/tcp`)에서 그 호스트 포트가 묶인 주소들. */
+export function hostAddrsForPort(ports, port) {
+    const out = [];
+    for (const piece of ports.split(",").map((p) => p.trim()).filter(Boolean)) {
+        const m = /^(.*):(\d+)(?:-(\d+))?->/.exec(piece);
+        if (!m)
+            continue;
+        const lo = Number(m[2]);
+        const hi = m[3] ? Number(m[3]) : lo;
+        if (port < lo || port > hi)
+            continue;
+        out.push(m[1].replace(/^\[|\]$/g, "") || "::");
+    }
+    return out;
+}
+/** 사설 또는 공인 인터넷에서 닿지 않는 IPv4 대역(사설, 루프백, 링크 로컬, 통신사 공유 대역). */
+export function isPrivateV4(a) {
+    const p = a.split(".").map(Number);
+    if (p.length !== 4 || p.some((n) => !Number.isInteger(n) || n < 0 || n > 255))
+        return false;
+    const [x, y] = p;
+    return (x === 10 || x === 127 || x === 0 ||
+        (x === 172 && y >= 16 && y <= 31) ||
+        (x === 192 && y === 168) ||
+        (x === 169 && y === 254) ||
+        (x === 100 && y >= 64 && y <= 127));
+}
+const isV4 = (a) => /^\d+\.\d+\.\d+\.\d+$/.test(a);
+const isLoopback = (a) => a === "::1" || a === "localhost" || (isV4(a) && a.startsWith("127."));
+/** 이 컴퓨터의 공인 IPv4(내부가 아니고 사설 대역 밖). */
+export function publicIPv4s(ifaces) {
+    const out = [];
+    for (const list of Object.values(ifaces)) {
+        for (const a of list ?? []) {
+            const v4 = a.family === "IPv4" || a.family === 4;
+            if (v4 && !a.internal && !isPrivateV4(a.address) && !out.includes(a.address))
+                out.push(a.address);
+        }
+    }
+    return out;
+}
+export function checkEngineBind(addrs, port, publicV4) {
+    const fixClose = "다른 컴퓨터에서 쓰지 않는다면 ~/.aiakiv/engine/.env 의 AIAKIV_BIND 를 127.0.0.1 로 바꾸고 " +
+        "그 폴더에서 docker compose -f aiakiv-compose.yml up -d 로 다시 올리세요.";
+    if (addrs.every(isLoopback))
+        return pass(`${addrs.join(", ")}:${port} 에만 묶여 있습니다`);
+    const exposed = [];
+    let worst = "warn";
+    for (const a of addrs) {
+        if (isLoopback(a))
+            continue;
+        if (a === "0.0.0.0" || a === "::") {
+            if (publicV4.length) {
+                worst = "fail";
+                exposed.push(`${a}(모든 주소, 이 컴퓨터의 공인 주소 ${publicV4.join(", ")} 포함)`);
+            }
+            else
+                exposed.push(`${a}(모든 주소, 공인 주소는 없음)`);
+        }
+        else if (isV4(a) && !isPrivateV4(a)) {
+            worst = "fail";
+            exposed.push(`${a}(공인 주소)`);
+        }
+        else
+            exposed.push(`${a}(사설 대역)`);
+    }
+    if (worst === "fail") {
+        return fail(`포트 ${port} 가 공인 주소에 열려 있습니다: ${exposed.join(", ")}`, fixClose);
+    }
+    return warn(`포트 ${port} 가 이 컴퓨터 밖(사설망)에 열려 있습니다: ${exposed.join(", ")}`, fixClose);
+}
+// ---- 네트워크 -------------------------------------------------------------------------------
+const PROXY_VARS = ["HTTPS_PROXY", "HTTP_PROXY", "ALL_PROXY", "NO_PROXY"];
+/** 주소의 사용자 이름과 비밀번호를 가린다. */
+export function maskProxy(v) {
+    return v.replace(/\/\/[^@/\s]*@/, "//…@");
+}
+/** 설정된 프록시 환경 변수(대소문자 둘 다). NO_PROXY 는 있는지만 알 때 쓰도록 따로 표시한다. */
+export function envProxies(env) {
+    const out = [];
+    for (const base of PROXY_VARS) {
+        for (const name of [base, base.toLowerCase()]) {
+            const v = env[name];
+            if (v && !out.some((o) => o.name.toUpperCase() === base))
+                out.push({ name, value: maskProxy(v) });
+        }
+    }
+    return out;
+}
+export function hasProxyEnv(env) {
+    return envProxies(env).some((p) => p.name.toUpperCase() !== "NO_PROXY");
+}
+/** Docker Desktop 이 늘 알리는 안쪽 중계(http.docker.internal)는 회사 프록시가 아니다. */
+export function isDesktopInternalProxy(v) {
+    return /(^|\/\/)http\.docker\.internal(:\d+)?\/?$/i.test(v.trim());
+}
+export function checkProxy(env, d) {
+    const envList = envProxies(env);
+    const dockerList = [
+        ["HttpProxy", d?.httpProxy],
+        ["HttpsProxy", d?.httpsProxy],
+        ["NoProxy", d?.noProxy],
+    ].filter((x) => !!x[1]);
+    const dockerReal = dockerList.filter(([k, v]) => k === "NoProxy" || !isDesktopInternalProxy(v));
+    const internal = dockerList.length > 0 && dockerList.some(([k, v]) => k !== "NoProxy" && isDesktopInternalProxy(v));
+    const parts = [];
+    parts.push(envList.length ? `환경 변수 ${envList.map((p) => `${p.name}=${p.value}`).join(", ")}` : "프록시 환경 변수 없음");
+    if (!d)
+        parts.push("Docker 설정은 보지 못함");
+    else if (dockerReal.some(([k]) => k !== "NoProxy")) {
+        parts.push(`Docker ${dockerReal.map(([k, v]) => `${k}=${maskProxy(v)}`).join(", ")}`);
+    }
+    else
+        parts.push(internal ? "Docker 는 Docker Desktop 안쪽 중계(http.docker.internal)만 씀" : "Docker 프록시 없음");
+    const anyProxy = hasProxyEnv(env) || dockerReal.some(([k]) => k !== "NoProxy");
+    return info(parts.join("; "), anyProxy
+        ? "회사 프록시를 쓰면 Docker 에도 같은 프록시를 설정하고, TLS 를 검사하는 프록시면 회사 인증서를 Docker 에 등록하세요."
+        : null);
+}
+export const NET_TARGETS = [
+    {
+        id: "net.docker_registry",
+        url: "https://registry-1.docker.io/v2/",
+        what: "Docker Hub",
+        fix: "Postgres 이미지를 받을 수 없으니 다른 컴퓨터에서 받아 옮기는 오프라인 설치(--image-tar)를 쓰세요.",
+    },
+    {
+        id: "net.aiakiv",
+        url: "https://www.aiakiv.com/",
+        what: "www.aiakiv.com",
+        fix: "로그인과 엔진 내려받기가 안 되니 인터넷이 되는 다른 컴퓨터에서 받아 옮기세요.",
+    },
+    {
+        id: "net.npm",
+        url: "https://registry.npmjs.org/",
+        what: "npm 저장소(registry.npmjs.org)",
+        fix: "npm 패키지를 받을 수 없으니 다른 컴퓨터에서 패키지 tgz 를 받아 옮기세요.",
+    },
+];
+export const NET_TIMEOUT_MS = 10000;
+/** 응답이 오면(상태 코드와 관계없이) 닿은 것. 시간 초과나 연결 실패면 이유 한 줄. */
+export async function reach(doFetch, url, timeoutMs) {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), timeoutMs);
+    try {
+        const res = await doFetch(url, { method: "GET", redirect: "manual", signal: ac.signal });
+        try {
+            await res.body?.cancel();
+        }
+        catch {
+            /* 본문은 읽지 않는다 */
+        }
+        return { ok: true, status: res.status };
+    }
+    catch (e) {
+        const err = e;
+        if (err.name === "AbortError" || ac.signal.aborted) {
+            return { ok: false, reason: `${Math.round(timeoutMs / 1000)}초 안에 응답이 없음` };
+        }
+        return { ok: false, reason: err.cause?.code ?? err.cause?.message ?? err.message };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export function netVerdict(r, what, fix, proxyEnv) {
+    const note = proxyEnv ? " (프록시 환경 변수가 있지만 직접 연결로만 시험함)" : "";
+    if (r.ok)
+        return pass(`${what} 에 닿음(HTTP ${r.status})${note}`);
+    return warn(`${what} 에 닿지 않음: ${r.reason}${note}`, fix);
+}