@loucompanion/forge-bridge 0.1.3-dev.f66395c3ac21 → 0.1.3-dev.fbe15023cdfe

package/dist/runtime/attempt-process-supervisor.js

@@ -0,0 +1,350 @@
+import { createHash } from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+const terminalChildStatuses = new Set(["exited", "failed"]);
+const defaultMetadataReadyTimeoutMs = process.platform === "win32" ? 60_000 : 10_000;
+/**
+ * Owns the independently supervised process trees that belong to one host
+ * dispatch attempt. Each named child gets a distinct Windows Job Object or
+ * Unix process group through the existing process runner, while this
+ * coordinator supplies shared fencing, cancellation, and a durable ledger.
+ */
+export class AttemptProcessSupervisor {
+    runner;
+    ledgerPath;
+    identity;
+    metadataReadyTimeoutMs;
+    records = [];
+    currentByName = new Map();
+    attemptController = new AbortController();
+    status = "active";
+    persistTail = Promise.resolve();
+    persistenceFailure;
+    stopOperation = null;
+    constructor(identity, runner, options = {}) {
+        this.runner = runner;
+        this.identity = validateIdentity(identity);
+        this.metadataReadyTimeoutMs = boundedInteger(options.metadataReadyTimeoutMs ?? defaultMetadataReadyTimeoutMs, 100, 120_000, "metadataReadyTimeoutMs");
+        this.ledgerPath = path.join(this.identity.logDirectory, "attempt-process-supervisor.json");
+        if (options.signal?.aborted) {
+            this.status = "stopping";
+            this.attemptController.abort(options.signal.reason);
+        }
+        else {
+            options.signal?.addEventListener("abort", () => {
+                void this.stopAll(this.identity.fencingToken, options.signal?.reason).catch(error => {
+                    this.persistenceFailure ??= error;
+                });
+            }, { once: true });
+        }
+    }
+    async startChild(name, request, handlers = {}, signal) {
+        assertChildName(name);
+        if (this.status !== "active" || this.attemptController.signal.aborted) {
+            throw new Error("attempt_process_supervisor_closed: the attempt no longer accepts child processes.");
+        }
+        if (signal?.aborted)
+            throw cancellationError(signal);
+        const existing = this.currentByName.get(name);
+        if (existing && !terminalChildStatuses.has(existing.status)) {
+            throw new Error(`attempt_process_supervisor_conflict: child '${name}' is already active.`);
+        }
+        const generation = (existing?.generation ?? 0) + 1;
+        const childId = `${name}:${generation}`;
+        const processSupervisorId = childProcessSupervisorId(this.identity.processSupervisorId, childId);
+        const metadataPath = path.join(this.identity.logDirectory, `process-supervisor.${name}.${generation}.json`);
+        const controller = new AbortController();
+        const combinedSignal = signal
+            ? AbortSignal.any([this.attemptController.signal, controller.signal, signal])
+            : AbortSignal.any([this.attemptController.signal, controller.signal]);
+        const childRequest = {
+            ...request,
+            env: {
+                ...request.env,
+                FORGE_RUNTIME_MODE: "host",
+                FORGE_RESOURCE_LEASE_ID: this.identity.executionLeaseId,
+                FORGE_EXECUTION_LEASE_ID: this.identity.executionLeaseId,
+                FORGE_DISPATCH_ATTEMPT_ID: this.identity.dispatchAttemptId,
+                FORGE_FENCING_TOKEN: this.identity.fencingToken,
+                FORGE_LOG_DIR: this.identity.logDirectory,
+                FORGE_PROCESS_SUPERVISOR_ID: processSupervisorId,
+                FORGE_PROCESS_SUPERVISOR_METADATA_PATH: metadataPath,
+                FORGE_PROCESS_CHILD_ID: childId,
+                FORGE_PROCESS_CHILD_NAME: name,
+                FORGE_PROCESS_CHILD_GENERATION: String(generation),
+            },
+        };
+        const startedAt = new Date().toISOString();
+        const record = {
+            name,
+            generation,
+            childId,
+            processSupervisorId,
+            metadataPath,
+            controller,
+            startedAt,
+            status: "starting",
+            result: Promise.resolve({ exitCode: 1, stdout: "", stderr: "not started" }),
+        };
+        this.records.push(record);
+        this.currentByName.set(name, record);
+        const result = this.runner.run(childRequest, handlers, combinedSignal);
+        record.result = result;
+        void result.then(value => this.settleChild(record, "exited", value.exitCode), error => this.settleChild(record, "failed", undefined, error));
+        try {
+            await this.persist();
+        }
+        catch (error) {
+            controller.abort("Attempt process ledger could not be persisted.");
+            await result.catch(() => undefined);
+            throw error;
+        }
+        const ready = this.observeChildReady(record);
+        void ready.catch(() => undefined);
+        return {
+            name,
+            generation,
+            childId,
+            processSupervisorId,
+            metadataPath,
+            ready,
+            result,
+            stop: async (fencingToken) => await this.stopChild(name, generation, fencingToken),
+        };
+    }
+    /**
+     * Starts a child and proves that the OS process tree is supervised before
+     * returning it to the caller. A launch that settles before producing its
+     * provider-ready supervision record is safe to retry: the raw runner only
+     * persists that record after the actual provider child has started, before
+     * Forge announces the provider as active.
+     */
+    async startChildReady(name, request, handlers = {}, signal, options = {}) {
+        const maxStartAttempts = boundedInteger(options.maxStartAttempts ?? 1, 1, 5, "maxStartAttempts");
+        const retryDelayMs = boundedInteger(options.retryDelayMs ?? 100, 0, 5_000, "retryDelayMs");
+        let lastError;
+        for (let attempt = 1; attempt <= maxStartAttempts; attempt += 1) {
+            const child = await this.startChild(name, request, handlers, signal);
+            try {
+                await child.ready;
+                return child;
+            }
+            catch (error) {
+                lastError = error;
+                await child.result.catch(() => undefined);
+                if (!isRetryableStartFailure(error) || attempt === maxStartAttempts)
+                    throw error;
+                if (signal?.aborted)
+                    throw cancellationError(signal);
+                if (retryDelayMs > 0)
+                    await wait(retryDelayMs * attempt);
+            }
+        }
+        throw lastError;
+    }
+    async stopChild(name, generation, fencingToken, reason = "Forge stopped the supervised child.") {
+        this.assertFence(fencingToken);
+        const record = this.currentByName.get(name);
+        if (!record || record.generation !== generation) {
+            throw new Error(`attempt_process_supervisor_stale: child '${name}' generation ${generation} is no longer current.`);
+        }
+        if (!terminalChildStatuses.has(record.status)) {
+            record.status = "stopping";
+            record.controller.abort(reason);
+            await this.persist();
+        }
+        return await record.result;
+    }
+    async stopAll(fencingToken, reason = "Forge stopped the supervised attempt.") {
+        this.assertFence(fencingToken);
+        // The durable terminal ledger is part of the stop operation's contract.
+        // Join an in-flight stop before inspecting terminal state so lease cleanup
+        // cannot remove the log directory underneath its final persistence.
+        if (this.stopOperation)
+            return await this.stopOperation;
+        if (this.status === "stopped")
+            return;
+        const operation = this.performStopAll(reason);
+        this.stopOperation = operation;
+        void operation.catch(() => undefined).finally(() => {
+            if (this.stopOperation === operation && this.status !== "stopped")
+                this.stopOperation = null;
+        });
+        return await this.stopOperation;
+    }
+    async performStopAll(reason) {
+        this.status = "stopping";
+        this.attemptController.abort(reason);
+        const active = [...this.currentByName.values()].filter(record => !terminalChildStatuses.has(record.status));
+        for (const record of active)
+            record.status = "stopping";
+        await this.persist();
+        const results = await Promise.allSettled(active.map(record => record.result));
+        const rejected = results.filter((result) => result.status === "rejected");
+        const terminalStatus = rejected.length > 0 || this.persistenceFailure !== undefined ? "degraded" : "stopped";
+        await this.persist({
+            ...this.snapshot(),
+            status: terminalStatus,
+            updatedAt: new Date().toISOString(),
+        });
+        this.status = terminalStatus;
+        if (rejected.length > 0) {
+            throw new AggregateError(rejected.map(result => result.reason), "attempt_process_supervisor_cleanup_degraded");
+        }
+        if (this.persistenceFailure !== undefined)
+            throw this.persistenceFailure;
+    }
+    snapshot() {
+        return {
+            schemaVersion: 1,
+            attemptSupervisorId: this.identity.processSupervisorId,
+            dispatchAttemptId: this.identity.dispatchAttemptId,
+            executionLeaseId: this.identity.executionLeaseId,
+            status: this.status,
+            updatedAt: new Date().toISOString(),
+            children: this.records.map(record => ({
+                name: record.name,
+                generation: record.generation,
+                childId: record.childId,
+                processSupervisorId: record.processSupervisorId,
+                metadataPath: record.metadataPath,
+                status: record.status,
+                startedAt: record.startedAt,
+                ...(record.settledAt ? { settledAt: record.settledAt } : {}),
+                ...(record.exitCode === undefined ? {} : { exitCode: record.exitCode }),
+                ...(record.failure ? { failure: record.failure } : {}),
+            })),
+        };
+    }
+    async observeChildReady(record) {
+        const deadline = Date.now() + this.metadataReadyTimeoutMs;
+        while (Date.now() <= deadline) {
+            if (await fileExists(record.metadataPath)) {
+                if (record.status === "starting") {
+                    record.status = "running";
+                    await this.persist();
+                }
+                return;
+            }
+            if (terminalChildStatuses.has(record.status)) {
+                const detail = await childStartFailureDetail(record);
+                throw new Error(`attempt_process_supervisor_start_failed: child '${record.childId}' exited before supervision metadata was produced${detail ? `: ${detail}` : "."}`);
+            }
+            await wait(25);
+        }
+        record.controller.abort("Supervised child metadata was not produced before the readiness deadline.");
+        const detail = await childStartFailureDetail(record);
+        throw new Error(`attempt_process_supervisor_start_timeout: child '${record.childId}' did not become supervised${detail ? `: ${detail}` : "."}`);
+    }
+    async settleChild(record, status, exitCode, failure) {
+        record.status = status;
+        record.settledAt = new Date().toISOString();
+        record.exitCode = exitCode;
+        record.failure = failure === undefined ? undefined : boundedFailure(failure);
+        await this.persist().catch(error => {
+            this.persistenceFailure ??= error;
+            this.status = "degraded";
+        });
+    }
+    assertFence(fencingToken) {
+        if (fencingToken !== this.identity.fencingToken) {
+            throw new Error("attempt_process_supervisor_fenced: fencing token does not own this attempt.");
+        }
+    }
+    persist(snapshot = this.snapshot()) {
+        const operation = this.persistTail.then(async () => {
+            await ensurePrivateDirectory(this.identity.logDirectory);
+            const temporary = `${this.ledgerPath}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`;
+            try {
+                const handle = await fs.open(temporary, "wx", 0o600);
+                try {
+                    await handle.writeFile(`${JSON.stringify(snapshot)}\n`);
+                    await handle.sync();
+                }
+                finally {
+                    await handle.close();
+                }
+                await fs.rename(temporary, this.ledgerPath);
+            }
+            catch (error) {
+                await fs.rm(temporary, { force: true }).catch(() => undefined);
+                throw error;
+            }
+        });
+        this.persistTail = operation.catch(() => undefined);
+        return operation;
+    }
+}
+function validateIdentity(identity) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9_.-]{0,127}$/u.test(identity.processSupervisorId)) {
+        throw new Error("attempt_process_supervisor_invalid: process supervisor id is invalid.");
+    }
+    assertUuid(identity.dispatchAttemptId, "dispatch attempt");
+    assertUuid(identity.executionLeaseId, "execution lease");
+    assertUuid(identity.fencingToken, "fencing token");
+    if (!path.isAbsolute(identity.logDirectory)) {
+        throw new Error("attempt_process_supervisor_invalid: log directory must be absolute.");
+    }
+    return { ...identity, logDirectory: path.resolve(identity.logDirectory) };
+}
+function assertChildName(name) {
+    if (!/^[a-z][a-z0-9_-]{0,31}$/u.test(name)) {
+        throw new Error("attempt_process_supervisor_invalid: child name must be a safe lowercase identifier.");
+    }
+}
+function childProcessSupervisorId(attemptSupervisorId, childId) {
+    const digest = createHash("sha256")
+        .update(JSON.stringify([attemptSupervisorId, childId]))
+        .digest("hex")
+        .slice(0, 32);
+    return `host-${digest}`;
+}
+function assertUuid(value, label) {
+    if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu.test(value)) {
+        throw new Error(`attempt_process_supervisor_invalid: ${label} id must be a UUID.`);
+    }
+}
+function boundedInteger(value, minimum, maximum, name) {
+    if (!Number.isSafeInteger(value) || value < minimum || value > maximum) {
+        throw new Error(`attempt_process_supervisor_invalid: ${name} must be between ${minimum} and ${maximum}.`);
+    }
+    return value;
+}
+function boundedFailure(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.replaceAll(/[\r\n\t]+/gu, " ").slice(0, 512);
+}
+async function childStartFailureDetail(record) {
+    try {
+        const result = await record.result;
+        const stderr = boundedDiagnostic(result.stderr);
+        return stderr
+            ? `exit ${result.exitCode}; stderr: ${stderr}`
+            : `exit ${result.exitCode}`;
+    }
+    catch (error) {
+        return boundedFailure(error);
+    }
+}
+function boundedDiagnostic(value) {
+    return value.replaceAll(/[\r\n\t]+/gu, " ").trim().slice(0, 512);
+}
+function isRetryableStartFailure(error) {
+    return error instanceof Error
+        && (error.message.startsWith("attempt_process_supervisor_start_failed:")
+            || error.message.startsWith("attempt_process_supervisor_start_timeout:"));
+}
+function cancellationError(signal) {
+    return new Error(String(signal.reason ?? "Supervised child launch was cancelled."));
+}
+async function ensurePrivateDirectory(directory) {
+    await fs.mkdir(directory, { recursive: true, mode: 0o700 });
+    if (process.platform !== "win32")
+        await fs.chmod(directory, 0o700);
+}
+async function fileExists(target) {
+    return await fs.stat(target).then(() => true, () => false);
+}
+function wait(milliseconds) {
+    return new Promise(resolve => setTimeout(resolve, milliseconds));
+}

package/dist/runtime/generated-output-reset.d.ts

@@ -0,0 +1,10 @@
+export interface GeneratedOutputResetResult {
+    readonly quarantineDirectory: string;
+    readonly quarantinedPaths: readonly string[];
+}
+/**
+ * Moves only known, untracked test-output directories out of a worktree before
+ * a managed attempt starts. The quarantine lives in the attempt-owned output
+ * directory, so cleanup is recoverable and cannot cross the attempt boundary.
+ */
+export declare function resetGeneratedOutputs(worktreePath: string, testOutputDirectory: string): Promise<GeneratedOutputResetResult>;

package/dist/runtime/generated-output-reset.js

@@ -0,0 +1,103 @@
+import { createHash, randomUUID } from "node:crypto";
+import { execFile } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+const generatedDirectoryNames = new Set(["TestResults", "test-results", "playwright-report"]);
+const skippedDirectoryNames = new Set([
+    ".git",
+    ".forge",
+    ".idea",
+    ".next",
+    ".pnpm",
+    ".vs",
+    ".vscode",
+    "bin",
+    "build",
+    "coverage",
+    "dist",
+    "node_modules",
+    "obj",
+    "target",
+    "vendor",
+]);
+/**
+ * Moves only known, untracked test-output directories out of a worktree before
+ * a managed attempt starts. The quarantine lives in the attempt-owned output
+ * directory, so cleanup is recoverable and cannot cross the attempt boundary.
+ */
+export async function resetGeneratedOutputs(worktreePath, testOutputDirectory) {
+    const worktreeRoot = await fs.realpath(path.resolve(worktreePath));
+    const outputRoot = await fs.realpath(path.resolve(testOutputDirectory));
+    if (isContainedPath(worktreeRoot, outputRoot)) {
+        throw new Error("generated_output_reset_invalid: attempt output must be outside the source worktree.");
+    }
+    const candidates = await findGeneratedDirectories(worktreeRoot);
+    const quarantineDirectory = path.join(outputRoot, "preflight-reset");
+    const quarantinedPaths = [];
+    for (const candidate of candidates) {
+        const relativePath = path.relative(worktreeRoot, candidate);
+        if (!relativePath || relativePath.startsWith(`..${path.sep}`) || path.isAbsolute(relativePath)) {
+            throw new Error("generated_output_reset_invalid: generated output escaped the source worktree.");
+        }
+        await assertUntrackedGeneratedDirectory(worktreeRoot, relativePath);
+        await fs.mkdir(quarantineDirectory, { recursive: true, mode: 0o700 });
+        const digest = createHash("sha256").update(relativePath).digest("hex").slice(0, 12);
+        const destination = path.join(quarantineDirectory, `${digest}-${randomUUID()}-${path.basename(candidate)}`);
+        try {
+            await fs.rename(candidate, destination);
+        }
+        catch (error) {
+            const code = error.code ?? "unknown";
+            throw new Error(`generated_output_reset_failed: could not quarantine ${relativePath} (${code}).`, { cause: error });
+        }
+        quarantinedPaths.push(relativePath.split(path.sep).join("/"));
+    }
+    if (quarantinedPaths.length > 0) {
+        await fs.writeFile(path.join(quarantineDirectory, "manifest.json"), `${JSON.stringify({ schemaVersion: 1, worktreePath: worktreeRoot, quarantinedPaths }, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+    }
+    return { quarantineDirectory, quarantinedPaths };
+}
+async function findGeneratedDirectories(root) {
+    const candidates = [];
+    const pending = [root];
+    while (pending.length > 0) {
+        const current = pending.pop();
+        const entries = await fs.readdir(current, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.isSymbolicLink())
+                continue;
+            if (skippedDirectoryNames.has(entry.name))
+                continue;
+            const candidate = path.join(current, entry.name);
+            if (generatedDirectoryNames.has(entry.name)) {
+                const realCandidate = await fs.realpath(candidate);
+                if (!isContainedPath(root, realCandidate)) {
+                    throw new Error("generated_output_reset_invalid: generated output resolves outside the source worktree.");
+                }
+                candidates.push(realCandidate);
+                continue;
+            }
+            pending.push(candidate);
+        }
+    }
+    return candidates.sort((left, right) => left.localeCompare(right));
+}
+async function assertUntrackedGeneratedDirectory(worktreeRoot, relativePath) {
+    const pathspec = relativePath.split(path.sep).join("/");
+    let stdout;
+    try {
+        ({ stdout } = await execFileAsync("git", ["-C", worktreeRoot, "ls-files", "-z", "--", pathspec], { encoding: "utf8", windowsHide: true, maxBuffer: 4 * 1024 * 1024 }));
+    }
+    catch (error) {
+        throw new Error(`generated_output_reset_unverified: git could not verify ${pathspec}.`, { cause: error });
+    }
+    if (stdout.length > 0) {
+        throw new Error(`generated_output_reset_unsafe: ${pathspec} contains tracked files and was not changed.`);
+    }
+}
+function isContainedPath(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative.length > 0 && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}

package/dist/runtime/host-listener-inspector.d.ts

@@ -0,0 +1,44 @@
+import type { AttemptProcessChildHandle } from "./attempt-process-supervisor.js";
+import type { HostPortLeaseOwner, HostPortReservation } from "./host-port-broker.js";
+import type { HostListenerOwnership } from "./node-host-runtime-adapter.js";
+export interface HostInspectionCommandResult {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly errorCode?: string;
+}
+export interface HostInspectionCommandRunner {
+    run(command: string, args: readonly string[]): Promise<HostInspectionCommandResult>;
+}
+/** Proves that a loopback listener belongs to one exact supervised child. */
+export declare class HostListenerInspector {
+    private readonly commands;
+    private readonly platform;
+    constructor(commands?: HostInspectionCommandRunner, platform?: NodeJS.Platform);
+    inspect(child: AttemptProcessChildHandle, reservation: HostPortReservation, owner: HostPortLeaseOwner): Promise<HostListenerOwnership>;
+    /** Returns loopback TCP ports opened by one exact supervised child process tree. */
+    inspectOwnedLoopbackListeners(child: AttemptProcessChildHandle, owner: HostPortLeaseOwner): Promise<readonly number[]>;
+    private inspectWindows;
+    private inspectAllWindows;
+    private inspectUnix;
+    private inspectAllUnix;
+}
+export declare function parseWindowsLoopbackListeners(output: string): readonly {
+    pid: number;
+    port: number;
+}[];
+export declare function parseLsofLoopbackListeners(output: string): readonly {
+    pid: number;
+    port: number;
+}[];
+export declare function parseSsLoopbackListeners(output: string): readonly {
+    pid: number;
+    port: number;
+}[];
+export declare class ExecFileInspectionCommandRunner implements HostInspectionCommandRunner {
+    run(command: string, args: readonly string[]): Promise<HostInspectionCommandResult>;
+}
+export declare function parseWindowsListenerPids(output: string, port: number): readonly number[];
+export declare function parseLsofPids(output: string): readonly number[];
+export declare function parseSsPids(output: string, port: number): readonly number[];
+export declare function parseProcessGroups(output: string): ReadonlyMap<number, number>;