@loucompanion/forge-bridge 0.1.3-dev.fbe15023cdfe → 0.1.4-dev.9445952e33ba

package/dist/runtime/aspnet-runtime-prebuild.js

@@ -0,0 +1,341 @@
+import { createHash, randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { ForgeFailureError } from "../session/session.types.js";
+const inFlightPrebuilds = new Map();
+export function createAspNetRuntimePrebuildPlan(options) {
+    if (!isDotnetRun(options.command, options.args))
+        return null;
+    const projectArgument = readOptionValue(options.args, "--project");
+    const projectPath = path.resolve(options.cwd, projectArgument ?? ".");
+    const normalizedWorktree = path.resolve(options.worktreePath);
+    const relativeProject = path.relative(normalizedWorktree, projectPath);
+    if (relativeProject.startsWith("..") || path.isAbsolute(relativeProject)) {
+        throw new Error("host_runtime_build_invalid: the ASP.NET project must remain inside the managed worktree.");
+    }
+    const projectDirectory = projectArgument && path.extname(projectPath).toLowerCase() === ".csproj"
+        ? path.dirname(projectPath)
+        : projectPath;
+    const buildArgs = [
+        "build",
+        ...(projectArgument ? [projectArgument] : []),
+        "--nologo",
+        "--no-restore",
+        "--disable-build-servers",
+        "-p:UseSharedCompilation=false",
+        "-p:DefaultItemExcludesInProjectFolder=TestResults/**",
+        ...forwardBuildOptions(options.args),
+    ];
+    const fingerprint = `sha256:${createHash("sha256").update(JSON.stringify({
+        inputCommitSha: options.inputCommitSha,
+        runtimeContractFingerprint: options.runtimeContractFingerprint,
+        project: relativeProject.replaceAll("\\", "/"),
+        args: buildArgs,
+        environment: buildEnvironmentContract(options.environment ?? {}),
+    })).digest("hex")}`;
+    return {
+        fingerprint,
+        receiptPath: path.join(projectDirectory, "obj", ".forge-runtime-build.json"),
+        command: options.command,
+        args: buildArgs,
+        cwd: options.cwd,
+        environment: options.environment ?? {},
+        projectPath,
+        worktreePath: normalizedWorktree,
+        inputCommitSha: options.inputCommitSha,
+    };
+}
+export async function ensureAspNetRuntimePrebuilt(plan, execute, signal) {
+    const pending = inFlightPrebuilds.get(plan.receiptPath);
+    if (pending)
+        return await pending;
+    const started = ensureAspNetRuntimePrebuiltCore(plan, execute, signal);
+    inFlightPrebuilds.set(plan.receiptPath, started);
+    try {
+        return await started;
+    }
+    finally {
+        if (inFlightPrebuilds.get(plan.receiptPath) === started)
+            inFlightPrebuilds.delete(plan.receiptPath);
+    }
+}
+async function ensureAspNetRuntimePrebuiltCore(plan, execute, signal) {
+    const inputs = await aspNetBuildInputs(plan);
+    const fingerprint = `sha256:${createHash("sha256").update(JSON.stringify({
+        planFingerprint: plan.fingerprint,
+        ...inputs,
+    })).digest("hex")}`;
+    const receipt = await readReceipt(plan.receiptPath);
+    if (receipt?.fingerprint === fingerprint
+        && receipt.planFingerprint === plan.fingerprint
+        && receipt.inputCommitSha === plan.inputCommitSha
+        && await aspNetOutputsMatch(plan, receipt.outputs)) {
+        return { cacheHit: true, receiptPath: plan.receiptPath, fingerprint };
+    }
+    const result = await execute(plan, signal);
+    if (result.exitCode !== 0) {
+        const evidence = [
+            diagnostic("stderr", result.stderrTail),
+            diagnostic("stdout", result.stdoutTail),
+            `stdout log: ${result.stdoutLogPath}`,
+            `stderr log: ${result.stderrLogPath}`,
+        ].filter(Boolean).join("; ");
+        throw new ForgeFailureError("host_runtime_project_start_failed", `host_runtime_project_start_failed: dotnet build exited with code ${result.exitCode}.${evidence ? ` ${evidence}` : ""}`, "bridge");
+    }
+    await fs.mkdir(path.dirname(plan.receiptPath), { recursive: true });
+    const outputs = await collectAspNetBuildOutputs(plan);
+    if (outputs.length === 0) {
+        throw new Error("host_runtime_build_output_missing: dotnet build succeeded without producing a verifiable project output.");
+    }
+    const temporaryReceipt = `${plan.receiptPath}.${randomUUID()}.tmp`;
+    const nextReceipt = {
+        schemaVersion: 2,
+        fingerprint,
+        planFingerprint: plan.fingerprint,
+        inputCommitSha: plan.inputCommitSha,
+        projectPath: plan.projectPath,
+        ...inputs,
+        outputs,
+        completedAt: new Date().toISOString(),
+    };
+    await fs.writeFile(temporaryReceipt, `${JSON.stringify(nextReceipt)}\n`, { encoding: "utf8", mode: 0o600 });
+    try {
+        await fs.rename(temporaryReceipt, plan.receiptPath);
+    }
+    finally {
+        await fs.rm(temporaryReceipt, { force: true }).catch(() => undefined);
+    }
+    return { cacheHit: false, receiptPath: plan.receiptPath, fingerprint };
+}
+export function withAspNetPrebuiltRunArguments(command, args) {
+    if (!isDotnetRun(command, args)) {
+        throw new Error("node_runtime_adapter_invalid: aspnetcore adapter requires a dotnet run command.");
+    }
+    const applicationArguments = args.indexOf("--");
+    const insertionIndex = applicationArguments < 0 ? args.length : applicationArguments;
+    const beforeApplication = args.slice(0, insertionIndex);
+    return [
+        ...beforeApplication,
+        ...(!beforeApplication.includes("--no-build") ? ["--no-build"] : []),
+        ...(!beforeApplication.includes("--no-restore") ? ["--no-restore"] : []),
+        ...args.slice(insertionIndex),
+    ];
+}
+export async function resolveWorktreeCommitSha(worktreePath, supplied) {
+    if (supplied && /^[0-9a-f]{40,64}$/iu.test(supplied))
+        return supplied.toLowerCase();
+    return await new Promise((resolve, reject) => {
+        const child = spawn("git", ["rev-parse", "--verify", "HEAD^{commit}"], {
+            cwd: worktreePath,
+            windowsHide: true,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", chunk => { stdout = `${stdout}${String(chunk)}`.slice(-256); });
+        child.stderr.on("data", chunk => { stderr = `${stderr}${String(chunk)}`.slice(-1_000); });
+        child.once("error", reject);
+        child.once("close", code => {
+            const commit = stdout.trim();
+            if (code === 0 && /^[0-9a-f]{40,64}$/iu.test(commit))
+                resolve(commit.toLowerCase());
+            else
+                reject(new Error(`host_runtime_build_commit_unavailable: git rev-parse failed (${code ?? "unknown"}): ${stderr.trim()}`));
+        });
+    });
+}
+function isDotnetRun(command, args) {
+    const executable = path.basename(command).toLowerCase();
+    return (executable === "dotnet" || executable === "dotnet.exe") && args[0]?.toLowerCase() === "run";
+}
+function readOptionValue(args, option) {
+    const index = args.findIndex(argument => argument === option || argument.startsWith(`${option}=`));
+    if (index < 0)
+        return null;
+    const argument = args[index];
+    return argument.startsWith(`${option}=`) ? argument.slice(option.length + 1) : args[index + 1] ?? null;
+}
+function forwardBuildOptions(args) {
+    const forwarded = [];
+    const optionsWithValues = new Set(["-c", "--configuration", "-f", "--framework", "-r", "--runtime", "--arch", "--os"]);
+    for (let index = 1; index < args.length; index += 1) {
+        const argument = args[index];
+        if (argument === "--")
+            break;
+        if (argument === "--project") {
+            index += 1;
+            continue;
+        }
+        if (argument.startsWith("--project="))
+            continue;
+        if (optionsWithValues.has(argument)) {
+            const value = args[index + 1];
+            if (value !== undefined) {
+                forwarded.push(argument, value);
+                index += 1;
+            }
+            continue;
+        }
+        if ([...optionsWithValues].some(option => argument.startsWith(`${option}=`))
+            || argument.startsWith("-p:")
+            || argument.startsWith("/p:")) {
+            forwarded.push(argument);
+        }
+    }
+    return forwarded;
+}
+async function readReceipt(receiptPath) {
+    try {
+        const parsed = JSON.parse(await fs.readFile(receiptPath, "utf8"));
+        return parsed.schemaVersion === 2
+            && typeof parsed.fingerprint === "string"
+            && typeof parsed.planFingerprint === "string"
+            && typeof parsed.inputCommitSha === "string"
+            && typeof parsed.sourceDigest === "string"
+            && typeof parsed.dependencyDigest === "string"
+            && typeof parsed.sdkVersion === "string"
+            && Array.isArray(parsed.outputs)
+            ? parsed
+            : null;
+    }
+    catch (error) {
+        if (error.code === "ENOENT" || error instanceof SyntaxError)
+            return null;
+        throw error;
+    }
+}
+async function aspNetBuildInputs(plan) {
+    const projectDirectory = path.extname(plan.projectPath).toLowerCase() === ".csproj"
+        ? path.dirname(plan.projectPath)
+        : plan.projectPath;
+    const sourceDigest = await directoryContentDigest(projectDirectory);
+    const dependencyReceipt = path.join(projectDirectory, "obj", ".forge-dependency-preparation.json");
+    const dependencyContent = await fs.readFile(dependencyReceipt).catch(() => null);
+    const globalJson = await findAncestorFile(projectDirectory, plan.worktreePath, "global.json");
+    const globalJsonContent = globalJson ? await fs.readFile(globalJson) : null;
+    return {
+        sourceDigest,
+        dependencyDigest: `sha256:${createHash("sha256")
+            .update(dependencyContent ?? Buffer.alloc(0))
+            .update(globalJsonContent ?? Buffer.alloc(0))
+            .digest("hex")}`,
+        sdkVersion: await dotnetSdkVersion(plan.cwd),
+    };
+}
+async function directoryContentDigest(directory) {
+    const files = [];
+    await collectInputFiles(directory, directory, files);
+    const hash = createHash("sha256");
+    for (const file of files.sort((left, right) => left.localeCompare(right))) {
+        hash.update(path.relative(directory, file).replaceAll("\\", "/"));
+        hash.update("\0");
+        hash.update(await fs.readFile(file));
+        hash.update("\0");
+    }
+    return `sha256:${hash.digest("hex")}`;
+}
+async function collectInputFiles(root, directory, files) {
+    const entries = await fs.readdir(directory, { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+        const absolute = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            if (!["bin", "obj", "node_modules", ".git", "TestResults"].includes(entry.name)) {
+                await collectInputFiles(root, absolute, files);
+            }
+        }
+        else if (entry.isFile()) {
+            files.push(absolute);
+        }
+    }
+}
+async function collectAspNetBuildOutputs(plan) {
+    const projectDirectory = path.extname(plan.projectPath).toLowerCase() === ".csproj"
+        ? path.dirname(plan.projectPath)
+        : plan.projectPath;
+    const outputRoot = path.join(projectDirectory, "bin");
+    const outputs = [];
+    await collectOutputFiles(outputRoot, projectDirectory, outputs);
+    return outputs.sort((left, right) => left.path.localeCompare(right.path));
+}
+async function collectOutputFiles(directory, projectDirectory, outputs) {
+    const entries = await fs.readdir(directory, { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+        const absolute = path.join(directory, entry.name);
+        if (entry.isDirectory())
+            await collectOutputFiles(absolute, projectDirectory, outputs);
+        else if (entry.isFile()) {
+            const stat = await fs.stat(absolute);
+            outputs.push({
+                path: path.relative(projectDirectory, absolute).replaceAll("\\", "/"),
+                size: stat.size,
+                digest: createHash("sha256").update(await fs.readFile(absolute)).digest("hex"),
+            });
+        }
+    }
+}
+async function aspNetOutputsMatch(plan, outputs) {
+    if (outputs.length === 0)
+        return false;
+    const projectDirectory = path.extname(plan.projectPath).toLowerCase() === ".csproj"
+        ? path.dirname(plan.projectPath)
+        : plan.projectPath;
+    for (const output of outputs) {
+        const absolute = path.resolve(projectDirectory, output.path);
+        const relative = path.relative(projectDirectory, absolute);
+        if (relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative))
+            return false;
+        const stat = await fs.stat(absolute).catch(() => null);
+        if (!stat?.isFile() || stat.size !== output.size)
+            return false;
+        const digest = createHash("sha256").update(await fs.readFile(absolute)).digest("hex");
+        if (digest !== output.digest)
+            return false;
+    }
+    return true;
+}
+async function findAncestorFile(directory, root, name) {
+    let current = path.resolve(directory);
+    const resolvedRoot = path.resolve(root);
+    while (true) {
+        const candidate = path.join(current, name);
+        if (await fs.stat(candidate).then(stat => stat.isFile()).catch(() => false))
+            return candidate;
+        if (current === resolvedRoot)
+            return null;
+        const parent = path.dirname(current);
+        if (parent === current || path.relative(resolvedRoot, parent).startsWith(".."))
+            return null;
+        current = parent;
+    }
+}
+async function dotnetSdkVersion(cwd) {
+    return await new Promise(resolve => {
+        const child = spawn("dotnet", ["--version"], { cwd, windowsHide: true, stdio: ["ignore", "pipe", "pipe"] });
+        let output = "";
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", chunk => { output += String(chunk); });
+        child.stderr.on("data", chunk => { output += String(chunk); });
+        child.once("error", () => resolve("unavailable"));
+        child.once("close", code => resolve(code === 0 ? output.trim().slice(0, 256) : `unavailable:${code ?? "unknown"}`));
+    });
+}
+function buildEnvironmentContract(environment) {
+    return {
+        DOTNET_ROOT: environment.DOTNET_ROOT ?? process.env.DOTNET_ROOT ?? null,
+        DOTNET_ROLL_FORWARD: environment.DOTNET_ROLL_FORWARD ?? process.env.DOTNET_ROLL_FORWARD ?? null,
+        DOTNET_MULTILEVEL_LOOKUP: environment.DOTNET_MULTILEVEL_LOOKUP ?? process.env.DOTNET_MULTILEVEL_LOOKUP ?? null,
+        MSBuildSDKsPath: environment.MSBuildSDKsPath ?? process.env.MSBuildSDKsPath ?? null,
+        NUGET_PACKAGES: environment.NUGET_PACKAGES ?? process.env.NUGET_PACKAGES ?? null,
+        FORGE_BUILD_CACHE_EPOCH: createHash("sha256")
+            .update(environment.FORGE_BUILD_CACHE_EPOCH ?? process.env.FORGE_BUILD_CACHE_EPOCH ?? "default")
+            .digest("hex"),
+    };
+}
+function diagnostic(label, value) {
+    const normalized = value.replaceAll(/[\r\n\t]+/gu, " ").trim();
+    return normalized ? `${label} tail: ${normalized.slice(-2_000)}` : "";
+}

package/dist/runtime/attempt-database-broker.d.ts

@@ -0,0 +1,89 @@
+import type { NativeTestPostgresFallback } from "./native-test-postgres-fallback.js";
+/**
+ * The managed host attempt's database capability. The Bridge keeps the test cluster's
+ * administrator credential; an attempt (its agent, its application runtime and its tests)
+ * receives only a login for one database created for it. Forge.Api checks that login before it
+ * migrates (AttemptScopedDatabasePolicy.AssertBrokeredCapabilityAsync), but that check runs in
+ * attempt code: the boundary is what this broker issues and the cluster's pg_hba rules, which
+ * let an attempt role log in only to its own database.
+ */
+export declare const attemptDatabaseCapabilityEnvironment = "FORGE_ATTEMPT_DATABASE_CAPABILITY";
+export interface AttemptDatabaseCapability {
+    readonly databaseName: string;
+    readonly connectionString: string;
+}
+export type AttemptDatabaseReleaseOutcome = "dropped" | "missing" | "retained";
+export interface AttemptDatabaseBroker {
+    provision(dispatchAttemptId: string, fencingToken: string, signal?: AbortSignal): Promise<AttemptDatabaseCapability>;
+    release(dispatchAttemptId: string, fencingToken: string): Promise<AttemptDatabaseReleaseOutcome>;
+    /**
+     * Drops this broker's databases whose attempt is no longer live, asking `isLive` about each one
+     * just before acting on it. Returns the dropped names.
+     */
+    reapOrphans(isLive: (dispatchAttemptId: string) => boolean): Promise<readonly string[]>;
+}
+export declare class AttemptDatabaseBrokerError extends Error {
+    readonly code: string;
+    constructor(code: string, detail: string);
+}
+export interface AttemptDatabaseLogin {
+    readonly database: string;
+    readonly username: string;
+    readonly password: string;
+}
+/**
+ * Runs one psql script and returns its unaligned output: as the cluster administrator against
+ * `postgres`, or, given a login, as that login against its database.
+ */
+export type AttemptDatabaseSqlRunner = (sql: string, signal?: AbortSignal, login?: AttemptDatabaseLogin) => Promise<string>;
+/**
+ * The ownership marker on the attempt's role. Only a role with CREATEROLE can change a role's
+ * comment, so the attempt cannot forge or erase it (it can rewrite its database's comment, which
+ * is therefore informational). Must match AttemptScopedDatabasePolicy.BrokeredRoleMarkerPrefix.
+ */
+export declare function brokeredDatabaseMarker(dispatchAttemptId: string, fencingToken: string, owner: string): string;
+export declare function attemptDatabaseName(dispatchAttemptId: string): string;
+/** Identifies one Bridge's broker on a shared cluster, so it reaps only databases it issued. */
+export declare function attemptDatabaseBrokerOwner(stateRoot: string): string;
+/**
+ * Brokers attempt databases on the dedicated native test cluster that
+ * scripts/setup-native-test-postgres.ps1 provisions. That cluster holds only disposable test
+ * databases, so even a leaked attempt capability cannot reach developer data. Each attempt
+ * gets a login role and a database it owns, cloned from template1 (which carries pgvector,
+ * an extension an unprivileged owner cannot create).
+ */
+export declare class NativeTestClusterDatabaseBroker implements AttemptDatabaseBroker {
+    private readonly admin;
+    private readonly runSql;
+    private readonly owner;
+    private readonly delay;
+    /** Names being provisioned right now; the reaper leaves them alone. */
+    private readonly provisioning;
+    constructor(admin: NativeTestClusterAdmin, runSql: AttemptDatabaseSqlRunner, owner: string, delay?: (milliseconds: number) => Promise<void>);
+    provision(dispatchAttemptId: string, fencingToken: string, signal?: AbortSignal): Promise<AttemptDatabaseCapability>;
+    release(dispatchAttemptId: string, fencingToken: string): Promise<AttemptDatabaseReleaseOutcome>;
+    reapOrphans(isLive: (dispatchAttemptId: string) => boolean): Promise<readonly string[]>;
+    private state;
+    private createDatabase;
+    /** Fails closed unless the cluster lets this login reach its own database and nothing else. */
+    private assertConfinedToOwnDatabase;
+    private drop;
+}
+export interface NativeTestClusterAdmin {
+    readonly host: string;
+    readonly port: number;
+    readonly username: string;
+    readonly password: string;
+}
+export declare function nativeTestClusterAdmin(fallback: NativeTestPostgresFallback): NativeTestClusterAdmin;
+/** Runs SQL through the psql that ships with the PostgreSQL install hosting the native test cluster. */
+export declare function psqlSqlRunner(admin: NativeTestClusterAdmin, psqlPath: string, timeoutMs?: number): AttemptDatabaseSqlRunner;
+/** psql beside the cluster's pg_ctl: FORGE_NATIVE_TEST_POSTGRES_PSQL, a Windows install, or PATH. */
+export declare function resolvePsqlPath(): string | null;
+/**
+ * The broker for this host, or null when no native test cluster is provisioned. Without a
+ * broker, Forge.Api still refuses to start in a managed host attempt; other applications run.
+ */
+export declare function createNativeTestClusterDatabaseBroker(readFallback: () => NativeTestPostgresFallback | null, stateRoot: string): AttemptDatabaseBroker | null;
+/** The exact strings to redact wherever a capability may be printed: the whole value and its password. */
+export declare function attemptDatabaseCapabilitySecrets(capability: string | undefined): readonly string[];