@loucompanion/forge-bridge 0.1.3-dev.c24058d57ab3 → 0.1.3-dev.c28767e94230

package/dist/bridge/bridge.service.d.ts

@@ -76,5 +76,9 @@ export declare class SignalRBridgeConnection implements BridgeConnection {
 }
 export declare function defaultBridgeServiceConfig(overrides?: Partial<BridgeServiceConfig>): BridgeServiceConfig;
 export declare function resolveBridgeRunnerHubUrl(serverUrl: string): URL;
+export declare function canReapManagedSandboxes(preflight: {
+    readonly healthy: boolean;
+    readonly unavailableCode?: string | null;
+}): boolean;
 export type SandboxResourceVector = DispatchSandboxResourceRequest;
 export declare function canReserveSandboxResources(used: SandboxResourceVector, requested: SandboxResourceVector, capacity: SandboxResourceVector): boolean;

package/dist/bridge/bridge.service.js

@@ -9,7 +9,7 @@ import { redactSecrets, redactText } from "../shared/redaction/redaction.js";
 import { BridgeSessionService } from "../session/session.service.js";
 import { failureResult, parseRunOnceDispatchPacket } from "../session/session.types.js";
 import { forgeBridgeVersion } from "../version.js";
-import { DockerPreflight } from "../sandbox/preflight.js";
+import { canRunDockerMaintenance, DockerPreflight } from "../sandbox/preflight.js";
 import { DockerSandboxRuntime } from "../sandbox/runtime.js";
 import { codexSandboxProviderAuthAdapter, sandboxProviderAuthAdapterFor, sandboxProviderAuthUnavailableMessage } from "../sandbox/provider-auth/codex.js";
 export class ForgeBridgeService {
@@ -1001,8 +1001,8 @@ function abortPromise(signal) {
     }
     return new Promise((resolve) => signal.addEventListener("abort", () => resolve(), { once: true }));
 }
-function canReapManagedSandboxes(preflight) {
-    return preflight.healthy || preflight.unavailableCode === "docker_disk_low";
+export function canReapManagedSandboxes(preflight) {
+    return canRunDockerMaintenance(preflight);
 }
 function sandboxNetworkPolicyFailure(dispatch) {
     const sandbox = dispatch.sandbox;

package/dist/sandbox/preflight.d.ts

@@ -27,6 +27,10 @@ export declare class DockerPreflight {
     run(force?: boolean): Promise<SandboxPreflightResult>;
     private inspect;
 }
+export declare function canRunDockerMaintenance(preflight: {
+    readonly healthy: boolean;
+    readonly unavailableCode?: string | null;
+}): boolean;
 export declare function evaluateDiskPressure(availableBytes: number, totalBytes: number, minimumAvailableBytes: number, highWatermarkPercent: number, lowWatermarkPercent: number, pressureLatched: boolean): boolean;
 export declare function storagePolicyAvailable(storageQuota: boolean, environment?: NodeJS.ProcessEnv): boolean;
 export declare class DockerContextOwnershipLock {

package/dist/sandbox/preflight.js

@@ -26,7 +26,7 @@ export class DockerPreflight {
     async refresh() {
         await fs.mkdir(this.options.stateRoot ?? path.join(os.homedir(), ".forge", "bridge", "sandboxes"), { recursive: true, mode: 0o700 });
         const result = await this.run(true);
-        if (result.healthy || result.unavailableCode === "docker_disk_low") {
+        if (canRunDockerMaintenance(result)) {
             await this.ownership.acquire(this.options.dockerContext);
         }
         return result;
@@ -108,14 +108,27 @@ export class DockerPreflight {
         const availableMemoryBytes = os.freemem();
         const cpuCount = Math.max(1, os.availableParallelism?.() ?? os.cpus().length);
         const availableCpuMillis = Math.max(0, (cpuCount - 1) * 1000);
-        const memorySlots = Math.max(0, Math.floor((availableMemoryBytes - 2 * 1024 ** 3) / (2 * 1024 ** 3)));
-        const cpuSlots = Math.max(0, Math.floor((cpuCount - 1) / 2));
-        const configuredMax = this.options.maxConcurrentSandboxes ?? positiveInteger(process.env.FORGE_MAX_CONCURRENT_SANDBOXES, 3);
-        const maxConcurrentSandboxes = diskLow ? 0 : Math.max(1, Math.min(3, configuredMax, Math.max(1, cpuSlots), Math.max(1, memorySlots)));
+        const memoryReserveBytes = 2 * 1024 ** 3;
+        const sandboxMemoryBytes = 2 * 1024 ** 3;
+        const sandboxCpuMillis = 2_000;
+        const memorySlots = Math.max(0, Math.floor((availableMemoryBytes - memoryReserveBytes) / sandboxMemoryBytes));
+        const cpuSlots = Math.max(0, Math.floor(availableCpuMillis / sandboxCpuMillis));
+        const configuredMax = positiveInteger(this.options.maxConcurrentSandboxes, positiveInteger(process.env.FORGE_MAX_CONCURRENT_SANDBOXES, 3));
+        const capacityLowCode = !diskLow && memorySlots <= 0 ? "docker_memory_low" : !diskLow && cpuSlots <= 0 ? "docker_cpu_low" : null;
+        const maxConcurrentSandboxes = diskLow || capacityLowCode ? 0 : Math.min(3, configuredMax, cpuSlots, memorySlots);
+        const unavailableCode = diskLow ? "docker_disk_low" : capacityLowCode;
+        const unavailableReason = diskLow
+            ? `Docker workspace has only ${disk.available} bytes available.`
+            : unavailableCode === "docker_memory_low"
+                ? `Docker host has ${availableMemoryBytes} bytes free; at least ${memoryReserveBytes + sandboxMemoryBytes} bytes are needed for one sandbox plus reserve.`
+                : unavailableCode === "docker_cpu_low"
+                    ? `Docker host has ${availableCpuMillis} available CPU millis; at least ${sandboxCpuMillis} are needed for one sandbox.`
+                    : null;
         const features = { rootless, userNamespaces, cgroupV2, seccomp, lsm, storageQuota, storagePolicy, compose, internalNetwork: true, buildkit, imagePolicy, securityProfile, egressProxy };
+        const capacityAvailable = unavailableCode === null;
         return {
-            available: !diskLow,
-            healthy: !diskLow,
+            available: capacityAvailable,
+            healthy: capacityAvailable,
             generation: this.generation,
             runtimeVersion: `docker/${String(info.ServerVersion ?? "unknown")}${rootless ? "-rootless" : "-desktop"}`,
             maxConcurrentSandboxes,
@@ -123,12 +136,16 @@ export class DockerPreflight {
             availableCpuMillis,
             availableWorkspaceBytes: disk.available,
             diskLow,
-            unavailableCode: diskLow ? "docker_disk_low" : null,
-            unavailableReason: diskLow ? `Docker workspace has only ${disk.available} bytes available.` : null,
+            unavailableCode,
+            unavailableReason,
             features,
         };
     }
 }
+const dockerMaintenanceUnavailableCodes = new Set(["docker_disk_low", "docker_memory_low", "docker_cpu_low"]);
+export function canRunDockerMaintenance(preflight) {
+    return preflight.healthy || dockerMaintenanceUnavailableCodes.has(preflight.unavailableCode ?? "");
+}
 export function evaluateDiskPressure(availableBytes, totalBytes, minimumAvailableBytes, highWatermarkPercent, lowWatermarkPercent, pressureLatched) {
     if (availableBytes < minimumAvailableBytes)
         return true;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const forgeBridgeVersion = "0.1.3-dev.c24058d57ab3";
+export declare const forgeBridgeVersion = "0.1.3-dev.c28767e94230";

package/dist/version.js

@@ -1 +1 @@
-export const forgeBridgeVersion = "0.1.3-dev.c24058d57ab3";
+export const forgeBridgeVersion = "0.1.3-dev.c28767e94230";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loucompanion/forge-bridge",
-  "version": "0.1.3-dev.c24058d57ab3",
+  "version": "0.1.3-dev.c28767e94230",
   "description": "Forge runner bridge CLI for connecting local developer machines to Forge dispatch.",
   "license": "UNLICENSED",
   "type": "module",