@loucompanion/forge-bridge 0.1.3-dev.d46a8e73d03d → 0.1.3-dev.e7b62d8fdd33

package/dist/bridge/bridge.types.d.ts

@@ -1,5 +1,8 @@
-import type { ApiKeySecretGrant, RunOnceResultPacket, RunnerDispatchEvent } from "../session/session.types.js";
+import type { ApiKeySecretGrant, DispatchSandboxResourceRequest, RunOnceResultPacket, RunnerDispatchEvent } from "../session/session.types.js";
 import type { SandboxFeatureMatrix } from "../sandbox/sandbox.types.js";
+import type { HostRuntimeCapacitySnapshot } from "../runtime/host-runtime-lease.js";
+import type { MemoryAdmissionDiagnostics } from "../runtime/memory-capacity.js";
+import type { DockerEngineCapabilitySnapshot } from "../runtime/docker-engine-probe.js";
 export interface BridgeServiceConfig {
     readonly serverUrl: string;
     readonly runnerId: string;
@@ -9,14 +12,24 @@ export interface BridgeServiceConfig {
     readonly maxConcurrentSandboxBuilds: number;
     readonly sandboxPidCapacity: number;
     readonly dockerEnabled: boolean;
+    readonly allowOpenPublicSandbox: boolean;
     readonly sandboxPublicationMode?: "bridge_push" | "shared_filesystem";
     readonly dockerExecutable: string;
     readonly dockerContext: string;
+    readonly dockerDesktopRecoveryEnabled: boolean;
+    readonly dockerRecoveryFailureThreshold: number;
+    readonly dockerRecoveryCooldownMs: number;
+    readonly dockerRecoveryStartupTimeoutMs: number;
     readonly sandboxStateRoot: string;
     readonly requireRootlessDocker: boolean;
     readonly diskHighWatermarkPercent: number;
     readonly diskLowWatermarkPercent: number;
     readonly minimumWorkspaceBytes: number;
+    readonly sandboxHostMemoryReserveBytes?: number;
+    readonly defaultSandboxWorkerMemoryLimitBytes: number;
+    readonly defaultSandboxServiceMemoryLimitBytes: number;
+    readonly sandboxRuntimeOverheadBytes: number;
+    readonly sandboxMemorySampleIntervalMs: number;
     readonly imageRetentionCount: number;
     readonly imageRetentionTtlMs: number;
     readonly auditRetentionCount: number;
@@ -42,6 +55,7 @@ export interface BridgeServiceConfig {
     readonly protocolVersion: number;
     readonly minServerVersion?: string | null;
     readonly heartbeatIntervalMs: number;
+    readonly callbackAckTimeoutMs?: number;
     readonly reconnectBackoffMs: readonly number[];
 }
 export interface BridgeRepoMapping {
@@ -56,6 +70,7 @@ export interface QaAppLaunchTarget {
     readonly command?: string | null;
     readonly working_directory?: string | null;
     readonly ready_url?: string | null;
+    readonly managed_runtime_port?: string | null;
     readonly routes?: readonly string[] | null;
     readonly notes?: string | null;
 }
@@ -64,6 +79,20 @@ export interface BridgeProviderStatus {
     readonly version?: string | null;
     readonly models?: readonly string[] | null;
 }
+export interface BridgeToolCapability {
+    readonly available: boolean;
+    readonly executable: string;
+    readonly version?: string | null;
+}
+export interface BridgeToolchainCapabilities {
+    readonly node: BridgeToolCapability;
+    readonly pnpm: BridgeToolCapability;
+    readonly dotnet: BridgeToolCapability;
+    readonly git: BridgeToolCapability;
+    readonly bash: BridgeToolCapability;
+    readonly powershell: BridgeToolCapability;
+    readonly docker?: BridgeToolCapability | null;
+}
 export interface BridgeCapabilities {
     readonly schemaVersion?: number | null;
     readonly activeSessionCount?: number | null;
@@ -75,9 +104,12 @@ export interface BridgeCapabilities {
     readonly sandboxProfiles?: readonly string[] | null;
     readonly runnerInstanceId?: string | null;
     readonly trustDomainId?: string | null;
+    readonly executionFacilities?: readonly string[] | null;
+    readonly dockerEngine?: DockerEngineCapabilitySnapshot | null;
     readonly sandboxRuntimes?: readonly string[] | null;
     readonly sandboxRuntimeVersion?: string | null;
     readonly sandboxFeatures?: SandboxFeatureMatrix | null;
+    readonly allowsOpenPublicSandbox?: boolean | null;
     readonly sandboxPublicationModes?: readonly string[] | null;
     readonly sandboxAuthModes?: Readonly<Record<string, readonly string[]>> | null;
     readonly maxConcurrentSandboxes?: number | null;
@@ -92,6 +124,8 @@ export interface BridgeCapabilities {
     readonly preflightGeneration?: number | null;
     readonly sandboxUnavailableCode?: string | null;
     readonly sandboxUnavailableReason?: string | null;
+    readonly sandboxMemoryCapacity?: SandboxMemoryCapacityDiagnostics | null;
+    readonly hostRuntime?: HostRuntimeCapacitySnapshot | null;
     readonly supportsApiSecretGrant?: boolean | null;
     readonly supportsManagedWorktrees?: boolean | null;
     readonly supportsManagedForgeArtifacts?: boolean | null;
@@ -99,6 +133,23 @@ export interface BridgeCapabilities {
     readonly supportsDraftRunOnce?: boolean | null;
     readonly supportsDraftAttachments?: boolean | null;
     readonly supportsDraftImageAttachments?: boolean | null;
+    readonly toolchains?: BridgeToolchainCapabilities | null;
+    readonly playwrightProjects?: readonly string[] | null;
+    readonly browserLaunch?: boolean | null;
+    readonly providerConnectivity?: Readonly<Record<string, boolean>> | null;
+}
+export interface SandboxMemoryCapacityDiagnostics {
+    readonly defaultWorkerMemoryLimitBytes: number;
+    readonly defaultServiceMemoryLimitBytes: number;
+    readonly runtimeOverheadBytes: number;
+    readonly hostReserveBytes: number;
+    readonly activeReservationBytes: number;
+    readonly daemonTotalBytes: number;
+    readonly daemonAvailableBytes: number;
+    readonly hostAvailableBytes: number;
+    readonly conservativeAvailableBytes: number;
+    readonly availableForAdmissionBytes: number;
+    readonly memoryAdmission: MemoryAdmissionDiagnostics;
 }
 export interface BridgeHelloRequest {
     readonly version: string;
@@ -153,6 +204,8 @@ export interface BridgeOfferDecisionCallback {
     readonly code?: string | null;
     readonly message?: string | null;
     readonly reservedUntil?: string | null;
+    readonly reservedResources?: DispatchSandboxResourceRequest | null;
+    readonly sandboxConfigCommitSha?: string | null;
 }
 export interface BridgeDispatchStartedCallback {
     readonly dispatchAttemptId: string;
@@ -205,3 +258,38 @@ export type BridgeStartHandler = (dispatch: unknown) => Promise<void>;
 export type BridgeLeaseUpdateHandler = (request: BridgeLeaseUpdateRequest) => Promise<void>;
 export type BridgeCancelHandler = (request: BridgeCancelRequest) => Promise<void>;
 export type BridgeReapHandler = (request: BridgeReapRequest) => Promise<void>;
+export type BridgeReadinessProbeHandler = (request: unknown) => Promise<void>;
+export interface BridgeRuntimeReadinessRequest {
+    readonly schemaVersion: 1;
+    readonly requestId: string;
+    readonly fencingToken: string;
+    readonly userId: string;
+    readonly projectId: string;
+    readonly repoId: string;
+    readonly runnerInstanceId: string;
+    readonly attempt: number;
+    readonly repoName: string;
+    readonly remoteUrl: string;
+    readonly defaultBranch: string;
+    readonly cloneOnDemand: boolean;
+    readonly runnerRepoLocalPath: string;
+    readonly revision: string;
+    readonly expiresAt: string;
+}
+export interface BridgeRuntimeReadinessResult {
+    readonly schemaVersion: 1;
+    readonly requestId: string;
+    readonly fencingToken: string;
+    readonly runnerInstanceId: string;
+    readonly status: "parallel_ready" | "serialized" | "failed";
+    readonly runtimeContractFingerprint?: string | null;
+    readonly runtimeContractSource?: string | null;
+    readonly reasonCode?: string | null;
+    readonly reasonMessage?: string | null;
+    readonly qaAppLaunchTarget?: BridgeRuntimeReadinessQaLaunchTarget | null;
+    readonly checkedAt: string;
+}
+export interface BridgeRuntimeReadinessQaLaunchTarget {
+    readonly managedRuntimePort: string;
+    readonly routes: readonly string[];
+}

package/dist/bridge/runner-host-capabilities.d.ts

@@ -0,0 +1,15 @@
+import type { BridgeServiceConfig, BridgeToolchainCapabilities } from "./bridge.types.js";
+export interface RunnerHostCapabilitySnapshot {
+    readonly toolchains: BridgeToolchainCapabilities;
+    readonly playwrightProjects: readonly string[];
+    readonly browserLaunch: boolean;
+    readonly providerConnectivity: Readonly<Record<string, boolean>>;
+}
+export interface RunnerHostCapabilityProbe {
+    detect(config: BridgeServiceConfig): Promise<RunnerHostCapabilitySnapshot>;
+}
+export declare class ProcessRunnerHostCapabilityProbe implements RunnerHostCapabilityProbe {
+    detect(config: BridgeServiceConfig): Promise<RunnerHostCapabilitySnapshot>;
+}
+export declare function isUnavailablePlaywrightConfigError(error: unknown): boolean;
+export declare function emptyRunnerHostCapabilitySnapshot(): RunnerHostCapabilitySnapshot;

package/dist/bridge/runner-host-capabilities.js

@@ -0,0 +1,93 @@
+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);
+export class ProcessRunnerHostCapabilityProbe {
+    async detect(config) {
+        const [pnpm, dotnet, git, bash, pwsh, windowsPowerShell] = await Promise.all([
+            probe("pnpm", ["--version"]),
+            probe("dotnet", ["--version"]),
+            probe("git", ["--version"]),
+            probe("bash", ["--version"]),
+            probe("pwsh", ["-NoProfile", "-Command", "$PSVersionTable.PSVersion.ToString()"]),
+            process.platform === "win32"
+                ? probe("powershell.exe", ["-NoProfile", "-Command", "$PSVersionTable.PSVersion.ToString()"])
+                : Promise.resolve(unavailable("powershell.exe")),
+        ]);
+        const playwrightProjects = await detectPlaywrightProjects(config.repoMappings);
+        const browserLaunch = playwrightProjects.length > 0
+            || config.repoMappings.some(mapping => Boolean(mapping.qaAppLaunchTarget?.url
+                || mapping.qaAppLaunchTarget?.command
+                || mapping.qaAppLaunchTarget?.managed_runtime_port));
+        return {
+            toolchains: {
+                node: { available: true, executable: process.execPath, version: process.version },
+                pnpm,
+                dotnet,
+                git,
+                bash,
+                powershell: pwsh.available ? pwsh : windowsPowerShell,
+            },
+            playwrightProjects,
+            browserLaunch,
+            providerConnectivity: Object.fromEntries(Object.entries(config.providerStatuses)
+                .map(([provider, status]) => [provider, status.signedIn === true])),
+        };
+    }
+}
+async function probe(executable, args) {
+    try {
+        const result = await execFileAsync(executable, [...args], { encoding: "utf8", timeout: 5_000 });
+        const version = `${result.stdout || result.stderr}`.trim().split(/\r?\n/u)[0] ?? "";
+        return { available: true, executable, version };
+    }
+    catch {
+        return unavailable(executable);
+    }
+}
+function unavailable(executable) {
+    return { available: false, executable, version: null };
+}
+async function detectPlaywrightProjects(repoMappings) {
+    const projects = new Set();
+    for (const mapping of repoMappings) {
+        if (!mapping.localPath)
+            continue;
+        const candidates = [
+            "playwright.config.ts", "playwright.config.js", "playwright.config.mjs",
+            "tests/e2e/playwright.config.ts", "tests/e2e/playwright.config.js", "tests/e2e/playwright.config.mjs",
+        ];
+        for (const relative of candidates) {
+            try {
+                const source = await fs.readFile(path.join(mapping.localPath, relative), "utf8");
+                for (const match of source.matchAll(/\bname\s*:\s*["']([^"']+)["']/gu))
+                    projects.add(match[1]);
+            }
+            catch (error) {
+                if (!isUnavailablePlaywrightConfigError(error))
+                    throw error;
+            }
+        }
+    }
+    return [...projects].sort((left, right) => left.localeCompare(right));
+}
+export function isUnavailablePlaywrightConfigError(error) {
+    const code = error?.code;
+    return code === "ENOENT" || code === "EACCES" || code === "EPERM" || code === "ENOTDIR";
+}
+export function emptyRunnerHostCapabilitySnapshot() {
+    return {
+        toolchains: {
+            node: { available: true, executable: process.execPath, version: process.version },
+            pnpm: unavailable("pnpm"),
+            dotnet: unavailable("dotnet"),
+            git: unavailable("git"),
+            bash: unavailable("bash"),
+            powershell: unavailable(process.platform === "win32" ? "powershell.exe" : "pwsh"),
+        },
+        playwrightProjects: [],
+        browserLaunch: false,
+        providerConnectivity: {},
+    };
+}

package/dist/cleanup/cleanup.service.d.ts

@@ -1,5 +1,17 @@
+import { GitClient } from "../shared/git/git.js";
+import type { WorktreeLifecycleCoordinator } from "../worktree/worktree.base.js";
 import type { CleanupService } from "./cleanup.base.js";
 import type { CleanupRequest, CleanupResult } from "./cleanup.types.js";
-export declare class NoopCleanupService implements CleanupService {
-    run(_request: CleanupRequest): Promise<CleanupResult>;
+export declare class ManagedWorktreeCleanupService implements CleanupService {
+    private readonly stateRoot;
+    private readonly git;
+    private readonly coordinator;
+    constructor(stateRoot?: string, git?: GitClient, coordinator?: WorktreeLifecycleCoordinator);
+    run(request: CleanupRequest): Promise<CleanupResult>;
+    private runLocked;
+    private listWorktrees;
+    private staleRuntimeReadinessPaths;
+    private scanManagedCandidates;
+    private readRuntimeLeases;
+    private worktreeMetadataRoot;
 }