youmd 0.7.1 → 0.8.2

package/dist/lib/machine-verify.js

@@ -0,0 +1,684 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MACHINE_SERVER_START_PORT = exports.DEFAULT_MACHINE_CHECK_SCRIPTS = void 0;
+exports.inspectMachineProject = inspectMachineProject;
+exports.buildMachineReadinessReport = buildMachineReadinessReport;
+exports.runMachineProjectChecks = runMachineProjectChecks;
+exports.runMachineDependencyInstalls = runMachineDependencyInstalls;
+exports.runMachineServerProbes = runMachineServerProbes;
+exports.buildMachineRunChecksReport = buildMachineRunChecksReport;
+exports.buildMachineInstallReport = buildMachineInstallReport;
+exports.buildMachineServerProbeReport = buildMachineServerProbeReport;
+exports.buildMachineVerificationProof = buildMachineVerificationProof;
+exports.defaultMachineReportPath = defaultMachineReportPath;
+exports.writeMachineVerificationProof = writeMachineVerificationProof;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const childProcess = __importStar(require("child_process"));
+const http = __importStar(require("http"));
+const os = __importStar(require("os"));
+exports.DEFAULT_MACHINE_CHECK_SCRIPTS = ["typecheck", "lint", "test", "build"];
+exports.DEFAULT_MACHINE_SERVER_START_PORT = 4310;
+function readText(filePath) {
+    try {
+        return fs.readFileSync(filePath, "utf-8");
+    }
+    catch {
+        return "";
+    }
+}
+function readJson(filePath) {
+    try {
+        const raw = fs.readFileSync(filePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function detectRemoteUrl(projectDir) {
+    const config = readText(path.join(projectDir, ".git", "config"));
+    const match = config.match(/\[remote "origin"\][\s\S]*?\n\s*url\s*=\s*(.+)/);
+    return match?.[1]?.trim() || undefined;
+}
+function detectPackageManager(projectDir) {
+    if (fs.existsSync(path.join(projectDir, "pnpm-lock.yaml")))
+        return "pnpm";
+    if (fs.existsSync(path.join(projectDir, "yarn.lock")))
+        return "yarn";
+    if (fs.existsSync(path.join(projectDir, "bun.lockb")) || fs.existsSync(path.join(projectDir, "bun.lock")))
+        return "bun";
+    if (fs.existsSync(path.join(projectDir, "package-lock.json")))
+        return "npm";
+    if (fs.existsSync(path.join(projectDir, "package.json")))
+        return "npm";
+    return undefined;
+}
+function checkCommand(packageManager, script) {
+    if (packageManager === "yarn")
+        return `yarn ${script}`;
+    if (packageManager === "bun")
+        return `bun run ${script}`;
+    return `${packageManager} run ${script}`;
+}
+function checkCommandParts(packageManager, script) {
+    if (packageManager === "yarn")
+        return { command: "yarn", args: [script], display: `yarn ${script}` };
+    if (packageManager === "bun")
+        return { command: "bun", args: ["run", script], display: `bun run ${script}` };
+    return { command: packageManager, args: ["run", script], display: `${packageManager} run ${script}` };
+}
+function installCommandParts(project) {
+    if (!project.packageManager)
+        return null;
+    if (project.packageManager === "npm") {
+        const hasPackageLock = fs.existsSync(path.join(project.projectDir, "package-lock.json"));
+        return hasPackageLock
+            ? { command: "npm", args: ["ci"], display: "npm ci" }
+            : { command: "npm", args: ["install"], display: "npm install" };
+    }
+    if (project.packageManager === "pnpm") {
+        const hasLock = fs.existsSync(path.join(project.projectDir, "pnpm-lock.yaml"));
+        return {
+            command: "pnpm",
+            args: hasLock ? ["install", "--frozen-lockfile"] : ["install"],
+            display: hasLock ? "pnpm install --frozen-lockfile" : "pnpm install",
+        };
+    }
+    if (project.packageManager === "yarn") {
+        const hasLock = fs.existsSync(path.join(project.projectDir, "yarn.lock"));
+        return {
+            command: "yarn",
+            args: hasLock ? ["install", "--frozen-lockfile"] : ["install"],
+            display: hasLock ? "yarn install --frozen-lockfile" : "yarn install",
+        };
+    }
+    const hasLock = fs.existsSync(path.join(project.projectDir, "bun.lockb")) || fs.existsSync(path.join(project.projectDir, "bun.lock"));
+    return {
+        command: "bun",
+        args: hasLock ? ["install", "--frozen-lockfile"] : ["install"],
+        display: hasLock ? "bun install --frozen-lockfile" : "bun install",
+    };
+}
+function packageText(projectDir) {
+    return readText(path.join(projectDir, "package.json")).toLowerCase();
+}
+function devServerCommandParts(project, port) {
+    if (!project.packageManager || !project.scripts.includes("dev"))
+        return null;
+    const text = packageText(project.projectDir);
+    let extraArgs = [];
+    if (text.includes("\"next\"") || text.includes("next dev")) {
+        extraArgs = ["--hostname", "127.0.0.1", "--port", String(port)];
+    }
+    else if (text.includes("\"vite\"") || text.includes("vite ")) {
+        extraArgs = ["--host", "127.0.0.1", "--port", String(port), "--strictPort"];
+    }
+    else if (text.includes("\"astro\"") || text.includes("astro dev")) {
+        extraArgs = ["--host", "127.0.0.1", "--port", String(port)];
+    }
+    const withArgs = extraArgs.length > 0 ? ["--", ...extraArgs] : [];
+    if (project.packageManager === "yarn") {
+        return {
+            command: "yarn",
+            args: ["dev", ...extraArgs],
+            display: ["yarn dev", ...extraArgs].join(" "),
+        };
+    }
+    if (project.packageManager === "bun") {
+        return {
+            command: "bun",
+            args: ["run", "dev", ...withArgs],
+            display: ["bun run dev", ...withArgs].join(" "),
+        };
+    }
+    return {
+        command: project.packageManager,
+        args: ["run", "dev", ...withArgs],
+        display: [`${project.packageManager} run dev`, ...withArgs].join(" "),
+    };
+}
+function redactSensitive(value) {
+    return value
+        .replace(/((?:API|AUTH|ACCESS|REFRESH|SECRET|TOKEN|PASSWORD|PASS|KEY)[A-Z0-9_]*=)[^\s'"`]+/gi, "$1[redacted]")
+        .replace(/\b(?:sk|pk|ghp|gho|ghs|ghu|ghr|xox[baprs]|or)-[A-Za-z0-9_-]{12,}\b/g, "[redacted-token]")
+        .replace(/\b[A-Za-z0-9_./+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g, "[redacted-email]");
+}
+function outputTail(value, maxLength = 1200) {
+    const trimmed = value.trim();
+    const tail = trimmed.length <= maxLength ? trimmed : trimmed.slice(trimmed.length - maxLength);
+    return redactSensitive(tail);
+}
+function classifyMachineFailure(output, fallback) {
+    const normalized = output.toLowerCase();
+    if (normalized.includes("cannot prompt for input in non-interactive terminals") && normalized.includes("convex")) {
+        return "non-interactive Convex setup required before dev server start; restore Convex/env config or run convex dev interactively once";
+    }
+    if (normalized.includes("cannot prompt for input in non-interactive terminals")) {
+        return "non-interactive setup prompt blocked fresh-host run";
+    }
+    return fallback;
+}
+function sanitizeForProof(value) {
+    return JSON.parse(redactSensitive(JSON.stringify(value)));
+}
+function appendBounded(buffer, chunk, maxLength = 12000) {
+    const next = buffer + String(chunk);
+    if (next.length <= maxLength)
+        return next;
+    return next.slice(next.length - maxLength);
+}
+function statusForProject(project) {
+    if (!project.isDirectory)
+        return "empty";
+    if (!project.isGitRepo && !project.packageManager && !project.hasProjectContext && !project.hasAgentDocs)
+        return "empty";
+    if (!project.packageManager && (project.hasAgentDocs || project.hasProjectContext))
+        return "docs-only";
+    if (project.hasEnvExample && !project.hasEnvLocal)
+        return "needs-env";
+    if (project.isGitRepo && project.packageManager)
+        return "ready";
+    return "partial";
+}
+function inspectMachineProject(projectDir) {
+    const dirName = path.basename(projectDir);
+    const isDirectory = fs.existsSync(projectDir) && fs.statSync(projectDir).isDirectory();
+    const isGitRepo = isDirectory && fs.existsSync(path.join(projectDir, ".git"));
+    const hasAgentDocs = isDirectory && (fs.existsSync(path.join(projectDir, "AGENTS.md")) ||
+        fs.existsSync(path.join(projectDir, "CLAUDE.md")) ||
+        fs.existsSync(path.join(projectDir, ".codex", "AGENTS.md")) ||
+        fs.existsSync(path.join(projectDir, ".claude", "CLAUDE.md")));
+    const hasProjectContext = isDirectory && fs.existsSync(path.join(projectDir, "project-context"));
+    const hasEnvLocal = isDirectory && fs.existsSync(path.join(projectDir, ".env.local"));
+    const hasEnvExample = isDirectory && (fs.existsSync(path.join(projectDir, ".env.example")) ||
+        fs.existsSync(path.join(projectDir, ".env.local.example")));
+    const packageJson = isDirectory ? readJson(path.join(projectDir, "package.json")) : null;
+    const scriptsRecord = packageJson && typeof packageJson.scripts === "object" && packageJson.scripts !== null && !Array.isArray(packageJson.scripts)
+        ? packageJson.scripts
+        : {};
+    const scripts = Object.entries(scriptsRecord)
+        .filter(([, value]) => typeof value === "string")
+        .map(([key]) => key)
+        .sort();
+    const packageManager = isDirectory ? detectPackageManager(projectDir) : undefined;
+    const preferredChecks = ["typecheck", "lint", "test", "build", "dev"].filter((script) => scripts.includes(script));
+    const suggestedChecks = packageManager
+        ? preferredChecks.map((script) => checkCommand(packageManager, script))
+        : [];
+    const base = {
+        dirName,
+        projectDir,
+        isDirectory,
+        isGitRepo,
+        remoteUrl: isGitRepo ? detectRemoteUrl(projectDir) : undefined,
+        hasAgentDocs,
+        hasProjectContext,
+        hasEnvLocal,
+        hasEnvExample,
+        packageManager,
+        scripts,
+        suggestedChecks,
+        notes: [
+            hasEnvExample && !hasEnvLocal ? "env restore needed before full local run" : "",
+            !hasAgentDocs ? "agent docs missing or not at root" : "",
+            packageManager && suggestedChecks.length === 0 ? "package scripts found but no standard check scripts" : "",
+        ].filter(Boolean),
+    };
+    return {
+        ...base,
+        status: statusForProject(base),
+    };
+}
+function buildMachineReadinessReport(rootDir, maxProjects = 80) {
+    const entries = fs.existsSync(rootDir)
+        ? fs.readdirSync(rootDir)
+            .filter((entry) => !entry.startsWith("."))
+            .map((entry) => path.join(rootDir, entry))
+            .filter((entryPath) => {
+            try {
+                return fs.statSync(entryPath).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        })
+            .sort((a, b) => path.basename(a).localeCompare(path.basename(b)))
+            .slice(0, Math.max(1, maxProjects))
+        : [];
+    const projects = entries.map(inspectMachineProject);
+    return {
+        rootDir,
+        scanned: projects.length,
+        projects,
+        totals: {
+            gitRepos: projects.filter((project) => project.isGitRepo).length,
+            packageProjects: projects.filter((project) => Boolean(project.packageManager)).length,
+            envLocal: projects.filter((project) => project.hasEnvLocal).length,
+            envExample: projects.filter((project) => project.hasEnvExample).length,
+            agentDocs: projects.filter((project) => project.hasAgentDocs).length,
+            projectContext: projects.filter((project) => project.hasProjectContext).length,
+            ready: projects.filter((project) => project.status === "ready").length,
+            needsEnv: projects.filter((project) => project.status === "needs-env").length,
+            partial: projects.filter((project) => project.status === "partial").length,
+        },
+    };
+}
+function runMachineProjectChecks(projects, options = {}) {
+    const requestedScripts = (options.scripts?.length ? options.scripts : exports.DEFAULT_MACHINE_CHECK_SCRIPTS)
+        .map((script) => script.trim())
+        .filter(Boolean);
+    const timeoutMs = Number.isFinite(options.timeoutMs) && Number(options.timeoutMs) > 0
+        ? Number(options.timeoutMs)
+        : 120000;
+    const maxProjects = Number.isFinite(options.maxProjects) && Number(options.maxProjects) > 0
+        ? Number(options.maxProjects)
+        : 8;
+    const runnableProjects = projects
+        .filter((project) => Boolean(project.packageManager))
+        .slice(0, maxProjects);
+    const results = [];
+    for (const project of runnableProjects) {
+        if (!project.packageManager)
+            continue;
+        const scriptsToRun = requestedScripts.filter((script) => project.scripts.includes(script));
+        if (scriptsToRun.length === 0) {
+            results.push({
+                dirName: project.dirName,
+                projectDir: project.projectDir,
+                script: requestedScripts.join(","),
+                command: requestedScripts.map((script) => checkCommand(project.packageManager, script)).join(" | "),
+                status: "skipped",
+                durationMs: 0,
+                reason: "no requested check scripts found",
+            });
+            continue;
+        }
+        for (const script of scriptsToRun) {
+            const { command, args, display } = checkCommandParts(project.packageManager, script);
+            const startedAt = Date.now();
+            const result = childProcess.spawnSync(command, args, {
+                cwd: project.projectDir,
+                encoding: "utf-8",
+                timeout: timeoutMs,
+                maxBuffer: 1024 * 1024,
+                env: {
+                    ...process.env,
+                    CI: process.env.CI || "1",
+                    NO_COLOR: process.env.NO_COLOR || "1",
+                },
+            });
+            const durationMs = Date.now() - startedAt;
+            const combinedOutput = [result.stdout, result.stderr].filter(Boolean).join("\n");
+            const timedOut = result.error && result.error.message.includes("ETIMEDOUT");
+            results.push({
+                dirName: project.dirName,
+                projectDir: project.projectDir,
+                script,
+                command: display,
+                status: timedOut ? "timeout" : result.status === 0 ? "passed" : "failed",
+                exitCode: result.status,
+                durationMs,
+                outputTail: outputTail(combinedOutput),
+                reason: result.error && !timedOut ? result.error.message : undefined,
+            });
+        }
+    }
+    return results;
+}
+function runMachineDependencyInstalls(projects, options = {}) {
+    const timeoutMs = Number.isFinite(options.timeoutMs) && Number(options.timeoutMs) > 0
+        ? Number(options.timeoutMs)
+        : 180000;
+    const maxProjects = Number.isFinite(options.maxProjects) && Number(options.maxProjects) > 0
+        ? Number(options.maxProjects)
+        : 4;
+    const runnableProjects = projects
+        .filter((project) => Boolean(project.packageManager))
+        .slice(0, maxProjects);
+    const results = [];
+    for (const project of runnableProjects) {
+        const commandParts = installCommandParts(project);
+        if (!commandParts) {
+            results.push({
+                dirName: project.dirName,
+                projectDir: project.projectDir,
+                command: "install",
+                status: "skipped",
+                durationMs: 0,
+                reason: "no package manager detected",
+            });
+            continue;
+        }
+        const startedAt = Date.now();
+        const result = childProcess.spawnSync(commandParts.command, commandParts.args, {
+            cwd: project.projectDir,
+            encoding: "utf-8",
+            timeout: timeoutMs,
+            maxBuffer: 1024 * 1024,
+            env: {
+                ...process.env,
+                CI: process.env.CI || "1",
+                NO_COLOR: process.env.NO_COLOR || "1",
+            },
+        });
+        const durationMs = Date.now() - startedAt;
+        const combinedOutput = [result.stdout, result.stderr].filter(Boolean).join("\n");
+        const timedOut = result.error && result.error.message.includes("ETIMEDOUT");
+        results.push({
+            dirName: project.dirName,
+            projectDir: project.projectDir,
+            command: commandParts.display,
+            status: timedOut ? "timeout" : result.status === 0 ? "passed" : "failed",
+            exitCode: result.status,
+            durationMs,
+            outputTail: outputTail(combinedOutput),
+            reason: result.error && !timedOut ? result.error.message : undefined,
+        });
+    }
+    return results;
+}
+function waitForHttp(url, timeoutMs) {
+    const startedAt = Date.now();
+    return new Promise((resolve) => {
+        let lastError = "";
+        const attempt = () => {
+            const req = http.get(url, { timeout: 1500 }, (res) => {
+                res.resume();
+                resolve({ status: "passed", statusCode: res.statusCode });
+            });
+            req.on("timeout", () => {
+                req.destroy(new Error("probe request timed out"));
+            });
+            req.on("error", (err) => {
+                lastError = err.message;
+                if (Date.now() - startedAt >= timeoutMs) {
+                    resolve({ status: "timeout", reason: lastError || "server did not respond before timeout" });
+                }
+                else {
+                    setTimeout(attempt, 500);
+                }
+            });
+        };
+        attempt();
+    });
+}
+function stopChild(child) {
+    if (child.exitCode !== null || child.killed)
+        return;
+    child.kill("SIGTERM");
+    setTimeout(() => {
+        if (child.exitCode === null && !child.killed) {
+            child.kill("SIGKILL");
+        }
+    }, 1000).unref();
+}
+async function runMachineServerProbes(projects, options = {}) {
+    const timeoutMs = Number.isFinite(options.timeoutMs) && Number(options.timeoutMs) > 0
+        ? Number(options.timeoutMs)
+        : 45000;
+    const maxProjects = Number.isFinite(options.maxProjects) && Number(options.maxProjects) > 0
+        ? Number(options.maxProjects)
+        : 3;
+    const startPort = Number.isFinite(options.startPort) && Number(options.startPort) > 0
+        ? Number(options.startPort)
+        : exports.DEFAULT_MACHINE_SERVER_START_PORT;
+    const runnableProjects = projects
+        .filter((project) => Boolean(project.packageManager) && project.scripts.includes("dev"))
+        .slice(0, maxProjects);
+    const results = [];
+    for (const [index, project] of runnableProjects.entries()) {
+        const port = startPort + index;
+        const commandParts = devServerCommandParts(project, port);
+        const url = `http://127.0.0.1:${port}`;
+        if (!commandParts) {
+            results.push({
+                dirName: project.dirName,
+                projectDir: project.projectDir,
+                command: "dev",
+                url,
+                status: "skipped",
+                durationMs: 0,
+                reason: "no dev server command could be inferred",
+            });
+            continue;
+        }
+        const startedAt = Date.now();
+        let output = "";
+        const child = childProcess.spawn(commandParts.command, commandParts.args, {
+            cwd: project.projectDir,
+            stdio: ["ignore", "pipe", "pipe"],
+            env: {
+                ...process.env,
+                PORT: String(port),
+                HOST: "127.0.0.1",
+                HOSTNAME: "127.0.0.1",
+                BROWSER: "none",
+                CI: "1",
+                NEXT_TELEMETRY_DISABLED: "1",
+                NO_COLOR: process.env.NO_COLOR || "1",
+            },
+        });
+        child.stdout?.on("data", (chunk) => {
+            output = appendBounded(output, chunk);
+        });
+        child.stderr?.on("data", (chunk) => {
+            output = appendBounded(output, chunk);
+        });
+        const earlyExit = new Promise((resolve) => {
+            child.once("error", (err) => resolve({ status: "failed", reason: err.message }));
+            child.once("exit", (code, signal) => {
+                const exitReason = signal || (code ?? "unknown");
+                resolve({ status: "failed", reason: `server exited before probe responded (${exitReason})` });
+            });
+        });
+        const probe = await Promise.race([
+            waitForHttp(url, timeoutMs),
+            earlyExit,
+        ]);
+        const durationMs = Date.now() - startedAt;
+        const tail = outputTail(output);
+        stopChild(child);
+        results.push({
+            dirName: project.dirName,
+            projectDir: project.projectDir,
+            command: commandParts.display,
+            url,
+            status: probe.status,
+            statusCode: "statusCode" in probe ? probe.statusCode : undefined,
+            durationMs,
+            outputTail: tail,
+            reason: classifyMachineFailure(tail, probe.reason),
+        });
+    }
+    return results;
+}
+function buildMachineRunChecksReport(rootDir, options = {}) {
+    const scanLimit = Number.isFinite(options.scanLimit) && Number(options.scanLimit) > 0
+        ? Number(options.scanLimit)
+        : 80;
+    const requestedScripts = (options.scripts?.length ? options.scripts : exports.DEFAULT_MACHINE_CHECK_SCRIPTS)
+        .map((script) => script.trim())
+        .filter(Boolean);
+    const timeoutMs = Number.isFinite(options.timeoutMs) && Number(options.timeoutMs) > 0
+        ? Number(options.timeoutMs)
+        : 120000;
+    const maxProjects = Number.isFinite(options.maxProjects) && Number(options.maxProjects) > 0
+        ? Number(options.maxProjects)
+        : 8;
+    const readiness = buildMachineReadinessReport(rootDir, scanLimit);
+    const results = runMachineProjectChecks(readiness.projects, {
+        scripts: requestedScripts,
+        timeoutMs,
+        maxProjects,
+    });
+    return {
+        rootDir,
+        requestedScripts,
+        timeoutMs,
+        maxProjects,
+        results,
+        totals: {
+            passed: results.filter((result) => result.status === "passed").length,
+            failed: results.filter((result) => result.status === "failed").length,
+            timeout: results.filter((result) => result.status === "timeout").length,
+            skipped: results.filter((result) => result.status === "skipped").length,
+        },
+    };
+}
+function buildMachineInstallReport(rootDir, options = {}) {
+    const scanLimit = Number.isFinite(options.scanLimit) && Number(options.scanLimit) > 0
+        ? Number(options.scanLimit)
+        : 80;
+    const timeoutMs = Number.isFinite(options.timeoutMs) && Number(options.timeoutMs) > 0
+        ? Number(options.timeoutMs)
+        : 180000;
+    const maxProjects = Number.isFinite(options.maxProjects) && Number(options.maxProjects) > 0
+        ? Number(options.maxProjects)
+        : 4;
+    const readiness = buildMachineReadinessReport(rootDir, scanLimit);
+    const results = runMachineDependencyInstalls(readiness.projects, {
+        timeoutMs,
+        maxProjects,
+    });
+    return {
+        rootDir,
+        timeoutMs,
+        maxProjects,
+        results,
+        totals: {
+            passed: results.filter((result) => result.status === "passed").length,
+            failed: results.filter((result) => result.status === "failed").length,
+            timeout: results.filter((result) => result.status === "timeout").length,
+            skipped: results.filter((result) => result.status === "skipped").length,
+        },
+    };
+}
+async function buildMachineServerProbeReport(rootDir, options = {}) {
+    const scanLimit = Number.isFinite(options.scanLimit) && Number(options.scanLimit) > 0
+        ? Number(options.scanLimit)
+        : 80;
+    const timeoutMs = Number.isFinite(options.timeoutMs) && Number(options.timeoutMs) > 0
+        ? Number(options.timeoutMs)
+        : 45000;
+    const maxProjects = Number.isFinite(options.maxProjects) && Number(options.maxProjects) > 0
+        ? Number(options.maxProjects)
+        : 3;
+    const startPort = Number.isFinite(options.startPort) && Number(options.startPort) > 0
+        ? Number(options.startPort)
+        : exports.DEFAULT_MACHINE_SERVER_START_PORT;
+    const readiness = buildMachineReadinessReport(rootDir, scanLimit);
+    const results = await runMachineServerProbes(readiness.projects, {
+        timeoutMs,
+        maxProjects,
+        startPort,
+    });
+    return {
+        rootDir,
+        timeoutMs,
+        maxProjects,
+        startPort,
+        results,
+        totals: {
+            passed: results.filter((result) => result.status === "passed").length,
+            failed: results.filter((result) => result.status === "failed").length,
+            timeout: results.filter((result) => result.status === "timeout").length,
+            skipped: results.filter((result) => result.status === "skipped").length,
+        },
+    };
+}
+function buildMachineVerificationProof(options) {
+    const generatedAt = options.generatedAt ?? new Date().toISOString();
+    const installFailures = (options.installs?.totals.failed ?? 0) + (options.installs?.totals.timeout ?? 0);
+    const checkFailures = (options.checks?.totals.failed ?? 0) + (options.checks?.totals.timeout ?? 0);
+    const serverFailures = (options.servers?.totals.failed ?? 0) + (options.servers?.totals.timeout ?? 0);
+    const failures = installFailures + checkFailures + serverFailures;
+    const warnings = [
+        options.readiness.totals.needsEnv > 0 ? `${options.readiness.totals.needsEnv} projects need env restore` : "",
+        options.readiness.totals.partial > 0 ? `${options.readiness.totals.partial} projects are partial` : "",
+        options.installs && options.installs.results.length === 0 ? "no package projects were available for dependency install" : "",
+        options.checks && options.checks.results.length === 0 ? "no package projects had requested check scripts" : "",
+        options.servers && options.servers.results.length === 0 ? "no package projects had dev servers to probe" : "",
+        ...(options.servers?.results ?? [])
+            .filter((result) => result.status === "failed" || result.status === "timeout")
+            .map((result) => result.reason ? `${result.dirName}: ${result.reason}` : "")
+            .filter(Boolean),
+    ].filter(Boolean);
+    return {
+        schemaVersion: 1,
+        generatedAt,
+        hostName: os.hostname(),
+        platform: `${process.platform} ${os.release()}`,
+        rootDir: options.readiness.rootDir,
+        secretValuesExposed: false,
+        readiness: sanitizeForProof(options.readiness),
+        installs: options.installs ? sanitizeForProof(options.installs) : undefined,
+        checks: options.checks ? sanitizeForProof(options.checks) : undefined,
+        servers: options.servers ? sanitizeForProof(options.servers) : undefined,
+        summary: {
+            status: failures > 0 ? "failed" : warnings.length > 0 ? "warn" : "ready",
+            scanned: options.readiness.scanned,
+            ready: options.readiness.totals.ready,
+            needsEnv: options.readiness.totals.needsEnv,
+            partial: options.readiness.totals.partial,
+            installPassed: options.installs?.totals.passed ?? 0,
+            checksPassed: options.checks?.totals.passed ?? 0,
+            serversPassed: options.servers?.totals.passed ?? 0,
+            failures,
+            warnings: warnings.slice(0, 8),
+        },
+    };
+}
+function defaultMachineReportPath() {
+    return path.join(os.homedir(), ".youmd", "machine-reports", "latest.json");
+}
+function timestampForPath(value) {
+    return value.replace(/[:.]/g, "-");
+}
+function writeMachineVerificationProof(proof, reportPath = defaultMachineReportPath()) {
+    const latestPath = path.resolve(reportPath);
+    const reportDir = path.dirname(latestPath);
+    fs.mkdirSync(reportDir, { recursive: true });
+    const archivedPath = path.join(reportDir, `machine-proof-${timestampForPath(proof.generatedAt)}.json`);
+    const body = `${JSON.stringify(proof, null, 2)}\n`;
+    fs.writeFileSync(latestPath, body, { mode: 0o600 });
+    fs.writeFileSync(archivedPath, body, { mode: 0o600 });
+    return { latestPath, archivedPath };
+}
+//# sourceMappingURL=machine-verify.js.map