@loucompanion/forge-bridge 0.1.3-dev.f66395c3ac21 → 0.1.4-dev.bfa11ebe98c6

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

@@ -0,0 +1,397 @@
+import { createHash } from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { ForgeFailureError, sanitizeFailureError } from "../session/session.types.js";
+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", () => {
+                // stopAll already persists a degraded terminal snapshot when a child
+                // rejects during cancellation. Do not relabel that process failure as
+                // a persistence failure: doing so poisons every later cleanup retry,
+                // even after all supervised processes have exited.
+                void this.stopAll(this.identity.fencingToken, options.signal?.reason).catch(() => undefined);
+            }, { 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 failureRedactionValues = [...new Set((request.failureRedactionValues ?? []).filter(value => value.length > 0))];
+        const { failureRedactionValues: _failureRedactionValues, ...executableRequest } = request;
+        const childRequest = {
+            ...executableRequest,
+            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,
+            failureRedactionValues,
+            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, undefined, value), 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.flatMap((result, index) => result.status === "rejected"
+            ? [sanitizeFailureError(result.reason, active[index].failureRedactionValues)]
+            : []);
+        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, "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 } : {}),
+                ...(record.peakMemoryBytes === undefined ? {} : { peakMemoryBytes: record.peakMemoryBytes }),
+                ...(record.memorySampleCount === undefined ? {} : { memorySampleCount: record.memorySampleCount }),
+                ...(record.memorySource ? { memorySource: record.memorySource } : {}),
+                ...(record.memoryObservedAt ? { memoryObservedAt: record.memoryObservedAt } : {}),
+            })),
+        };
+    }
+    providerMemoryTelemetry() {
+        const observations = this.records
+            .filter(record => record.name === "provider"
+            && record.peakMemoryBytes !== undefined
+            && record.peakMemoryBytes > 0
+            && record.memorySampleCount !== undefined
+            && record.memorySampleCount > 0
+            && record.memorySource
+            && record.memoryObservedAt);
+        if (observations.length === 0)
+            return null;
+        const peak = observations.reduce((current, candidate) => (candidate.peakMemoryBytes ?? 0) > (current.peakMemoryBytes ?? 0) ? candidate : current);
+        return {
+            peakMemoryBytes: peak.peakMemoryBytes,
+            sampleCount: observations.reduce((total, candidate) => total + (candidate.memorySampleCount ?? 0), 0),
+            source: peak.memorySource,
+            observedAt: peak.memoryObservedAt,
+        };
+    }
+    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 ForgeFailureError("attempt_process_supervisor_start_failed", `attempt_process_supervisor_start_failed: child '${record.childId}' exited before supervision metadata was produced${detail ? `: ${detail}` : "."}`, "bridge");
+            }
+            await wait(25);
+        }
+        record.controller.abort("Supervised child metadata was not produced before the readiness deadline.");
+        const detail = await childStartFailureDetail(record);
+        throw new ForgeFailureError("attempt_process_supervisor_start_timeout", `attempt_process_supervisor_start_timeout: child '${record.childId}' did not become supervised${detail ? `: ${detail}` : "."}`, "bridge");
+    }
+    async settleChild(record, status, exitCode, failure, result) {
+        record.status = status;
+        record.settledAt = new Date().toISOString();
+        record.exitCode = exitCode;
+        record.failure = failure === undefined
+            ? undefined
+            : boundedFailure(failure, record.failureRedactionValues);
+        if (result?.peakMemoryBytes !== undefined
+            && result.peakMemoryBytes > 0
+            && result.memorySampleCount !== undefined
+            && result.memorySampleCount > 0
+            && result.memorySource
+            && result.memoryObservedAt) {
+            record.peakMemoryBytes = result.peakMemoryBytes;
+            record.memorySampleCount = result.memorySampleCount;
+            record.memorySource = result.memorySource;
+            record.memoryObservedAt = result.memoryObservedAt;
+        }
+        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, exactSecrets = []) {
+    const message = sanitizeFailureError(error, exactSecrets).message;
+    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, record.failureRedactionValues);
+        return stderr
+            ? `exit ${result.exitCode}; stderr: ${stderr}`
+            : `exit ${result.exitCode}`;
+    }
+    catch (error) {
+        return boundedFailure(error, record.failureRedactionValues);
+    }
+}
+function boundedDiagnostic(value, exactSecrets = []) {
+    return sanitizeFailureError(value, exactSecrets).message
+        .replaceAll(/[\r\n\t]+/gu, " ")
+        .trim()
+        .slice(0, 512);
+}
+function isRetryableStartFailure(error) {
+    return error instanceof ForgeFailureError
+        && (error.failureCode === "attempt_process_supervisor_start_failed"
+            || error.failureCode === "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/canonical-source-file.d.ts

@@ -0,0 +1,3 @@
+import type { PinnedDirectoryIdentity } from "./pinned-directory-process.js";
+/** Keep the validated source inode open: reopening a checked pathname can follow a replacement. */
+export declare function readCanonicalSourceFile(target: string, maximumBytes: number, expectedIdentity?: PinnedDirectoryIdentity): Promise<Buffer>;

package/dist/runtime/canonical-source-file.js

@@ -0,0 +1,54 @@
+import { constants } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+/** Keep the validated source inode open: reopening a checked pathname can follow a replacement. */
+export async function readCanonicalSourceFile(target, maximumBytes, expectedIdentity) {
+    const resolved = path.resolve(target);
+    const pathBefore = await canonicalStat(resolved);
+    if (expectedIdentity && !sameFile(pathBefore, expectedIdentity)) {
+        throw new Error("host_runtime_source_changed: source identity changed before reading.");
+    }
+    const handle = await fs.open(resolved, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0)
+        | (constants.O_NONBLOCK ?? 0));
+    try {
+        const before = await handle.stat({ bigint: true });
+        if (!before.isFile() || before.nlink !== 1n || !sameFile(pathBefore, before) || before.size > BigInt(maximumBytes)) {
+            throw new Error("host_runtime_source_invalid: source changed or exceeds the byte bound.");
+        }
+        if (!sameFile(before, await canonicalStat(resolved))) {
+            throw new Error("host_runtime_source_changed: source changed before reading.");
+        }
+        const bytes = Buffer.alloc(Number(before.size));
+        let offset = 0;
+        while (offset < bytes.length) {
+            const read = await handle.read(bytes, offset, bytes.length - offset, offset);
+            if (!read.bytesRead)
+                throw new Error("host_runtime_source_changed: incomplete source read.");
+            offset += read.bytesRead;
+        }
+        const after = await handle.stat({ bigint: true });
+        const pathAfter = await canonicalStat(resolved);
+        if (after.nlink !== 1n || !sameFile(before, after) || !sameFile(after, pathAfter) || before.size !== after.size
+            || before.mtimeNs !== after.mtimeNs || before.ctimeNs !== after.ctimeNs) {
+            throw new Error("host_runtime_source_changed: source changed while reading.");
+        }
+        return bytes;
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function canonicalStat(target) {
+    const stat = await fs.lstat(target, { bigint: true });
+    const real = await fs.realpath(target);
+    const realStat = await fs.lstat(real, { bigint: true });
+    const samePath = process.platform === "win32" ? real.toLowerCase() === target.toLowerCase() : real === target;
+    if (!samePath || !stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1n || !realStat.isFile()
+        || realStat.isSymbolicLink() || realStat.nlink !== 1n || !sameFile(stat, realStat)) {
+        throw new Error("host_runtime_source_invalid: source must be a canonical regular file.");
+    }
+    return realStat;
+}
+function sameFile(left, right) {
+    return left.dev === right.dev && left.ino === right.ino;
+}

package/dist/runtime/docker-engine-probe.d.ts

@@ -0,0 +1,90 @@
+import type { CommandRunner } from "../sandbox/sandbox.types.js";
+export interface DockerEngineCapabilitySnapshot {
+    readonly available: boolean;
+    readonly sampledAt: string;
+    readonly runtimeVersion: string | null;
+    readonly operatingSystem: string | null;
+    readonly context: string;
+    readonly unavailableCode: string | null;
+    readonly unavailableReason: string | null;
+}
+export interface DockerEngineProbeOptions {
+    readonly dockerExecutable?: string;
+    readonly dockerContext?: string;
+    readonly recovery?: DockerEngineRecoveryPolicy;
+    readonly recoveryExecutor?: DockerEngineRecoveryExecutor;
+    readonly platform?: NodeJS.Platform;
+    readonly dockerHost?: string;
+    readonly now?: () => number;
+    readonly wait?: (delayMs: number) => Promise<void>;
+    readonly onStatus?: (message: string) => void;
+}
+export interface DockerEngineRecoveryPolicy {
+    readonly enabled: boolean;
+    readonly failureThreshold?: number;
+    readonly confirmationDelayMs?: number;
+    readonly cooldownMs?: number;
+    readonly startupTimeoutMs?: number;
+    readonly pollIntervalMs?: number;
+    readonly canRecover?: () => boolean;
+}
+export interface DockerEngineRecoveryResult {
+    readonly started: boolean;
+    readonly reason?: string;
+}
+export interface DockerEngineRecoveryExecutor {
+    restart(): Promise<DockerEngineRecoveryResult>;
+}
+/**
+ * Probes ordinary Docker-daemon access for host-run Testcontainers and project
+ * services. This is deliberately independent from the stricter Forge sandbox
+ * preflight: a usable Docker Desktop engine may satisfy docker_engine even
+ * when it is not approved to host an agent sandbox.
+ */
+export declare class DockerEngineProbe {
+    private readonly commands;
+    private readonly cacheMs;
+    private cached;
+    private sampledAtMs;
+    private inFlight;
+    private requiredWorkRecoveryInFlight;
+    private consecutiveFailures;
+    private lastRecoveryAttemptAtMs;
+    private readonly docker;
+    private readonly context;
+    private readonly platform;
+    private readonly dockerHost;
+    private readonly now;
+    private readonly wait;
+    private readonly recovery;
+    private readonly recoveryExecutor;
+    private readonly onStatus;
+    constructor(options?: DockerEngineProbeOptions, commands?: CommandRunner, cacheMs?: number);
+    current(): DockerEngineCapabilitySnapshot | null;
+    refresh(force?: boolean): Promise<DockerEngineCapabilitySnapshot>;
+    /**
+     * Establishes a fresh daemon fence for work that declares Docker as a hard
+     * prerequisite. This remains bounded, cooldown protected and single-flight;
+     * it never contacts Docker unless a caller explicitly invokes this method.
+     */
+    ensureAvailableForRequiredWork(): Promise<DockerEngineCapabilitySnapshot>;
+    private inspectSafely;
+    private recoverIfEligible;
+    private isLocalDockerDesktopContext;
+    private inspect;
+}
+/**
+ * Restarts only the local Docker Desktop installation. It never targets a
+ * remote daemon and is used only behind the explicit bridge recovery policy.
+ */
+export declare class WindowsDockerDesktopRecoveryExecutor implements DockerEngineRecoveryExecutor {
+    private readonly platform;
+    private readonly commands;
+    private readonly programFiles;
+    private readonly wait;
+    constructor(platform?: NodeJS.Platform, commands?: CommandRunner, programFiles?: string, wait?: (delayMs: number) => Promise<void>);
+    restart(): Promise<DockerEngineRecoveryResult>;
+    private readProcessState;
+    private cleanupOrphanedCompanions;
+    private startDesktop;
+}