Skip to content

armgit / eve

Public Imported from GitHub
0

The Open Framework for Building Agents

fix(eve): defer development sandbox preparation until first access (#3649)

OwenKephart070525eeb18d
diff --git a/.changeset/lazy-development-sandbox-preparation.md b/.changeset/lazy-development-sandbox-preparation.md
new file mode 100644
index 000000000..5317c7793
--- /dev/null
+++ b/.changeset/lazy-development-sandbox-preparation.md
@@ -0,0 +1,5 @@
+---
+"eve": patch
+---
+
+Defer sandbox environment preparation during development until the first sandbox access, so startup and rebuilds no longer wait for optional engine installation. First access prepares all environments in that compiled generation, with heartbeat-backed coordination that recovers after a development worker crash; production builds still prepare eagerly.
diff --git a/docs/sandbox/index.mdx b/docs/sandbox/index.mdx
index 0fd2fd5dd..7b856d372 100644
--- a/docs/sandbox/index.mdx
+++ b/docs/sandbox/index.mdx
@@ -80,7 +80,9 @@ export default defineSandbox(() => environment.open());
eve runs `prepare` while creating a reusable provider artifact, not once for each live session sandbox. Vercel captures a snapshot; Docker captures an image; microsandbox captures a VM snapshot; and just-bash captures a filesystem template.
-At runtime, eve passes the recorded artifact directly to the provider when it creates a live sandbox. Runtime does not rebuild or repair a missing artifact. A missing image, snapshot, or template fails with rebuild or redeploy guidance.
+During `eve dev`, startup and authored-source rebuilds do not prepare sandbox environments. The first sandbox access prepares all environments in that compiled generation before opening the requested sandbox. This includes environments declared by subagents and extensions, even if they use different providers. Concurrent requests share the preparation work; a failed preparation can be retried on a later access. Optional provider installation and setup can make that first access slow.
+
+`eve build` still prepares environments eagerly. In production, eve passes the recorded artifact directly to the provider when it creates a live sandbox. Production runtime does not rebuild or repair a missing artifact. A missing image, snapshot, or template fails with rebuild or redeploy guidance.
### Reuse native resources across sessions
diff --git a/packages/eve/src/cli/dev/tui/runner.ts b/packages/eve/src/cli/dev/tui/runner.ts
index 42c934f92..692aba656 100644
--- a/packages/eve/src/cli/dev/tui/runner.ts
+++ b/packages/eve/src/cli/dev/tui/runner.ts
@@ -26,7 +26,6 @@ import { renderApplicationInfo } from "#cli/commands/info.js";
import type { EveCliSetupStepEvent, EveCliSetupTerminalEvent } from "#cli/telemetry/index.js";
import type { OnboardingScreenEvent } from "./setup-commands.js";
import { loadDevelopmentEnvironmentFiles } from "#cli/dev/environment.js";
-import { subscribeDevelopmentSandboxPrewarmLogs } from "#execution/sandbox/development-prewarm.js";
import { createEventDeduper } from "#protocol/event-dedupe.js";
import { isCurrentTurnBoundaryEvent } from "#protocol/message.js";
import {
@@ -279,7 +278,6 @@ export type AgentTUIRenderer = {
* Commits one development sandbox lifecycle line to the transcript.
* Optional so non-terminal renderers can ignore local prewarm progress.
*/
- renderSandboxLog?(text: string): void;
renderSetupWarning?(text: string): void;
/** Clears the setup attention line once its issue is resolved. */
clearSetupWarning?(): void;
@@ -612,7 +610,6 @@ export class EveTUIRunner {
* only if it is still current, so a stale failure from A cannot replace B.
*/
#failedSession?: ClientSession;
- #unsubscribeDevelopmentSandboxLogs?: () => void;
readonly #lifecycle?: CommandLifecycle;
constructor(options: EveTUIRunnerOptions) {
@@ -768,8 +765,6 @@ export class EveTUIRunner {
this.#authProbeAbort.abort();
this.#subagentPump.abortAll();
// Restore captured stdout/stderr before a fatal error reaches the CLI.
- this.#unsubscribeDevelopmentSandboxLogs?.();
- this.#unsubscribeDevelopmentSandboxLogs = undefined;
this.#renderer.shutdown?.();
// Drops any in-flight link probe so a late resolution cannot paint
// into a torn-down terminal.
@@ -788,7 +783,6 @@ export class EveTUIRunner {
let streamWithoutPrompt = false;
this.#renderer.setStartupPhase?.("starting");
await this.#loadInitialAgentInfo();
- this.#subscribeDevelopmentSandboxLogs();
// Fire-and-forget: the link identity is network-bound to resolve, and the
// first prompt must not wait on it. The segment appears when it lands.
this.#vercelStatus?.refreshIdentity();
@@ -1745,20 +1739,6 @@ export class EveTUIRunner {
}
}
- #subscribeDevelopmentSandboxLogs(): void {
- if (this.#appRoot === undefined || this.#renderer.renderSandboxLog === undefined) {
- return;
- }
- if (this.#unsubscribeDevelopmentSandboxLogs !== undefined) {
- return;
- }
-
- this.#unsubscribeDevelopmentSandboxLogs = subscribeDevelopmentSandboxPrewarmLogs({
- appRoot: this.#appRoot,
- log: (message) => this.#renderer.renderSandboxLog?.(message),
- });
- }
-
#renderCommandOutcome(text: string | undefined, tone?: "success" | "error"): void {
if (text === undefined) return;
if (this.#renderer.renderCommandResult !== undefined) {
diff --git a/packages/eve/src/cli/dev/tui/terminal-renderer.test.ts b/packages/eve/src/cli/dev/tui/terminal-renderer.test.ts
index d5d1b474d..95d47ddf6 100644
--- a/packages/eve/src/cli/dev/tui/terminal-renderer.test.ts
+++ b/packages/eve/src/cli/dev/tui/terminal-renderer.test.ts
@@ -3462,22 +3462,26 @@ describe("TerminalRenderer (inline scrollback)", () => {
renderer.shutdown();
});
- it("records sandbox log lines in the diagnostic log", () => {
+ it("records captured sandbox log lines in the diagnostic log", () => {
const screen = new MockScreen({ columns: 80, rows: 30 });
const input = new MockUserInput();
const stub = stubDiagnostics();
- const append = stub.append;
const renderer = new TerminalRenderer({
input,
output: screen,
- captureForeignOutput: false,
+ captureForeignOutput: true,
unicode: true,
diagnostics: stub.diagnostics,
});
-
- renderer.renderSandboxLog('eve: sandbox template "root" (microsandbox): apt-get update');
- expect(append).toHaveBeenCalledWith({ source: "sandbox", detail: expect.any(String) });
+ renderer.renderAgentHeader({ name: "Weather Agent", serverUrl: "http://localhost:3000" });
+ process.stdout.write('eve: sandbox template "root" (microsandbox): apt-get update\n');
renderer.shutdown();
+ expect(stub.append).toHaveBeenCalledWith(
+ expect.objectContaining({
+ source: "stdout",
+ detail: expect.stringContaining("apt-get update"),
+ }),
+ );
});
it("shows delayed build progress and immediate completion when logs are hidden", () => {
@@ -3660,22 +3664,22 @@ describe("TerminalRenderer (inline scrollback)", () => {
expect(snapshot).toContain("ordinary stdout log");
});
- it("renders subscribed sandbox logs under the sandbox log level", () => {
+ it("renders captured lazy preparation logs under the sandbox log level", () => {
const screen = new MockScreen({ columns: 100, rows: 30 });
const input = new MockUserInput();
const renderer = new TerminalRenderer({
input,
output: screen,
- captureForeignOutput: false,
+ captureForeignOutput: true,
logs: "sandbox",
unicode: true,
});
renderer.renderAgentHeader({ name: "Weather Agent", serverUrl: "http://localhost:3000" });
- renderer.renderSandboxLog?.('eve: sandbox template "root" (docker): checking Docker daemon');
- renderer.renderSandboxLog?.("eve: initializing 3 sandbox templates...");
- renderer.renderSandboxLog?.('eve: built sandbox template "root" on backend "docker".');
- renderer.renderSandboxLog?.("ordinary stdout log");
+ process.stdout.write('eve: sandbox template "root" (docker): checking Docker daemon\n');
+ process.stdout.write("eve: initializing 3 sandbox templates...\n");
+ process.stdout.write('eve: built sandbox template "root" on backend "docker".\n');
+ process.stdout.write("ordinary stdout log\n");
renderer.shutdown();
const snapshot = screen.snapshot();
diff --git a/packages/eve/src/cli/dev/tui/terminal-renderer.ts b/packages/eve/src/cli/dev/tui/terminal-renderer.ts
index 1b6c9a4da..b66d73986 100644
--- a/packages/eve/src/cli/dev/tui/terminal-renderer.ts
+++ b/packages/eve/src/cli/dev/tui/terminal-renderer.ts
@@ -1841,16 +1841,6 @@ export class TerminalRenderer implements AgentTUIRenderer {
this.#paint();
}
- renderSandboxLog(text: string): void {
- const content = stripTerminalControls(text);
- const sandboxMessage = parseSandboxLogLine(content);
- if (sandboxMessage === undefined) return;
- this.#diagnostics?.append({ source: "sandbox", detail: sandboxMessage });
- this.#start();
- this.#pushBlock({ kind: "sandbox", body: sandboxMessage, live: false });
- this.#paint();
- }
-
/**
* Sets the setup attention line (yellow `⚠`, commands blue) as a live footer
* element above the prompt. Unlike committed scrollback, it can be cleared:
diff --git a/packages/eve/src/execution/sandbox/development-lazy-prewarm.scenario.test.ts b/packages/eve/src/execution/sandbox/development-lazy-prewarm.scenario.test.ts
new file mode 100644
index 000000000..00eb0f3e8
--- /dev/null
+++ b/packages/eve/src/execution/sandbox/development-lazy-prewarm.scenario.test.ts
@@ -0,0 +1,163 @@
+import { mkdir, utimes } from "node:fs/promises";
+import { once } from "node:events";
+import { Worker } from "node:worker_threads";
+import { resolvePackageSourceFilePath } from "#internal/application/package.js";
+import { pathToFileURL } from "node:url";
+import { join } from "node:path";
+
+import { describe, expect, it, vi } from "vitest";
+
+import { useTemporaryDirectories } from "#internal/testing/use-temporary-app-roots.js";
+import { createDiskRuntimeCompiledArtifactsSource } from "#runtime/compiled-artifacts-source.js";
+import { writeSandboxPreparedArtifactsManifest } from "#runtime/sandbox/prepared-artifacts.js";
+import { prewarmAppSandboxes } from "./prewarm.js";
+import { ensureDevelopmentSandboxesPrepared } from "./development-lazy-prewarm.js";
+
+vi.mock("./prewarm.js", () => ({ prewarmAppSandboxes: vi.fn() }));
+const scratch = useTemporaryDirectories();
+
+async function fixture() {
+ const appRoot = await scratch("eve-lazy-preparation-");
+ const compileDirectoryPath = join(appRoot, ".eve", "compile");
+ await mkdir(compileDirectoryPath, { recursive: true });
+ return {
+ input: {
+ compiledArtifactsSource: createDiskRuntimeCompiledArtifactsSource(appRoot),
+ nodeId: "__root__",
+ providerName: "test",
+ },
+ async publish() {
+ await writeSandboxPreparedArtifactsManifest({
+ compileDirectoryPath,
+ entries: [{ nodeId: "__root__", providerName: "test", artifact: null }],
+ });
+ },
+ };
+}
+
+describe("lazy development preparation", () => {
+ it("deduplicates concurrent first access and reuses published artifacts", async () => {
+ const app = await fixture();
+ vi.mocked(prewarmAppSandboxes)
+ .mockReset()
+ .mockImplementation(async () => {
+ await new Promise((resolve) => setTimeout(resolve, 30));
+ await app.publish();
+ });
+ await Promise.all([
+ ensureDevelopmentSandboxesPrepared(app.input),
+ ensureDevelopmentSandboxesPrepared(app.input),
+ ]);
+ await ensureDevelopmentSandboxesPrepared(app.input);
+ expect(prewarmAppSandboxes).toHaveBeenCalledTimes(1);
+ });
+
+ it("keeps a live preparation lease beyond the stale-owner interval", async () => {
+ const app = await fixture();
+ vi.mocked(prewarmAppSandboxes)
+ .mockReset()
+ .mockImplementation(async () => {
+ await new Promise((resolve) => setTimeout(resolve, 16_000));
+ await app.publish();
+ });
+ await Promise.all([
+ ensureDevelopmentSandboxesPrepared(app.input),
+ ensureDevelopmentSandboxesPrepared(app.input),
+ ]);
+ expect(prewarmAppSandboxes).toHaveBeenCalledTimes(1);
+ });
+
+ it("recovers after a worker terminates while its parent pid stays alive", async () => {
+ const app = await fixture();
+ const lockPath = join(
+ app.input.compiledArtifactsSource.appRoot,
+ ".eve",
+ "compile",
+ "sandbox-preparation.lock",
+ );
+ const moduleUrl = pathToFileURL(
+ resolvePackageSourceFilePath("src/internal/application/output-publication-lock.ts"),
+ ).href;
+ const worker = new Worker(
+ `
+ const { parentPort, workerData } = require('node:worker_threads');
+ (async () => {
+ const { acquireRecoveryLease, startPublicationJournalHeartbeat } = await import(workerData.moduleUrl);
+ const lease = await acquireRecoveryLease(workerData.lockPath, 'crashed-worker');
+ if (!lease) throw new Error('could not acquire preparation lock');
+ startPublicationJournalHeartbeat(require('node:path').join(workerData.lockPath, 'lease'));
+ parentPort.postMessage({ pid: process.pid });
+ setInterval(() => {}, 1000);
+ })();
+ `,
+ { eval: true, workerData: { moduleUrl, lockPath } },
+ );
+ try {
+ const [owner] = await once(worker, "message");
+ expect(owner.pid).toBe(process.pid);
+ } finally {
+ await worker.terminate();
+ }
+ vi.mocked(prewarmAppSandboxes).mockReset().mockImplementation(app.publish);
+ await Promise.all([
+ ensureDevelopmentSandboxesPrepared(app.input),
+ ensureDevelopmentSandboxesPrepared(app.input),
+ ]);
+ expect(prewarmAppSandboxes).toHaveBeenCalledTimes(1);
+ });
+
+ it("recovers an abandoned lock with no owner journal", async () => {
+ const app = await fixture();
+ const leasePath = join(
+ app.input.compiledArtifactsSource.appRoot,
+ ".eve",
+ "compile",
+ "sandbox-preparation.lock",
+ "lease",
+ );
+ await mkdir(leasePath, { recursive: true });
+ const old = new Date(Date.now() - 60_000);
+ await utimes(leasePath, old, old);
+ vi.mocked(prewarmAppSandboxes).mockReset().mockImplementation(app.publish);
+ await ensureDevelopmentSandboxesPrepared(app.input);
+ expect(prewarmAppSandboxes).toHaveBeenCalledTimes(1);
+ });
+
+ it("releases the lock after failure and retries on next access", async () => {
+ const app = await fixture();
+ vi.mocked(prewarmAppSandboxes)
+ .mockReset()
+ .mockRejectedValueOnce(new Error("setup failed"))
+ .mockImplementationOnce(app.publish);
+ await expect(ensureDevelopmentSandboxesPrepared(app.input)).rejects.toThrow("setup failed");
+ await expect(ensureDevelopmentSandboxesPrepared(app.input)).resolves.toBeUndefined();
+ expect(prewarmAppSandboxes).toHaveBeenCalledTimes(2);
+ });
+
+ it("does not coalesce different generations sharing the same authored app", async () => {
+ const one = await fixture();
+ const two = await fixture();
+ vi.mocked(prewarmAppSandboxes)
+ .mockReset()
+ .mockImplementation(async (input) => {
+ if (
+ input.compiledArtifactsSource?.kind === "disk" &&
+ input.compiledArtifactsSource.appRoot === one.input.compiledArtifactsSource.appRoot
+ )
+ await one.publish();
+ else await two.publish();
+ });
+ await Promise.all(
+ [one, two].map((app) =>
+ ensureDevelopmentSandboxesPrepared({
+ ...app.input,
+ compiledArtifactsSource: {
+ ...app.input.compiledArtifactsSource,
+ sandboxAppRoot: "/same-authored-app",
+ },
+ }),
+ ),
+ );
+ expect(prewarmAppSandboxes).toHaveBeenCalledTimes(2);
+ });
+});
diff --git a/packages/eve/src/execution/sandbox/development-lazy-prewarm.ts b/packages/eve/src/execution/sandbox/development-lazy-prewarm.ts
new file mode 100644
index 000000000..b65b8f6ec
--- /dev/null
+++ b/packages/eve/src/execution/sandbox/development-lazy-prewarm.ts
@@ -0,0 +1,49 @@
+import { randomUUID } from "node:crypto";
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
+
+import {
+ acquireRecoveryLease,
+ startPublicationJournalHeartbeat,
+} from "#internal/application/output-publication-lock.js";
+import type { RuntimeDiskCompiledArtifactsSource } from "#runtime/compiled-artifacts-source.js";
+import { loadSandboxPreparedArtifact } from "#runtime/sandbox/prepared-artifacts.js";
+import { resolveRuntimeCompilerArtifactPaths } from "#runtime/loaders/artifact-paths.js";
+import { prewarmAppSandboxes } from "./prewarm.js";
+
+const PREPARATION_WAIT_TIMEOUT_MS = 10 * 60 * 1000;
+
+/** Serializes whole-generation preparation across dev workers, rechecking artifacts under the lock. */
+export async function ensureDevelopmentSandboxesPrepared(input: {
+ readonly compiledArtifactsSource: RuntimeDiskCompiledArtifactsSource;
+ readonly nodeId: string;
+ readonly providerName: string;
+}): Promise<void> {
+ if ((await loadSandboxPreparedArtifact(input)) !== undefined) return;
+ const source = input.compiledArtifactsSource;
+ const { compileDirectoryPath } = resolveRuntimeCompilerArtifactPaths(source.appRoot);
+ const lockPath = join(compileDirectoryPath, "sandbox-preparation.lock");
+ const deadline = Date.now() + PREPARATION_WAIT_TIMEOUT_MS;
+ await mkdir(compileDirectoryPath, { recursive: true });
+ const token = randomUUID();
+ let lease;
+ while ((lease = await acquireRecoveryLease(lockPath, token)) === undefined) {
+ if (Date.now() >= deadline) {
+ throw new Error("Timed out waiting for development sandbox preparation.");
+ }
+ await new Promise((resolve) => setTimeout(resolve, 250));
+ }
+ // Workers share the parent's pid: heartbeat expiry, not pid alone, detects a crashed worker.
+ const stopHeartbeat = startPublicationJournalHeartbeat(join(lockPath, "lease"));
+ try {
+ if ((await loadSandboxPreparedArtifact(input)) !== undefined) return;
+ await prewarmAppSandboxes({
+ appRoot: source.sandboxAppRoot ?? source.appRoot,
+ compiledArtifactsSource: source,
+ log: (message) => console.info(message),
+ });
+ } finally {
+ stopHeartbeat();
+ await lease.complete();
+ }
+}
diff --git a/packages/eve/src/execution/sandbox/development-prewarm.test.ts b/packages/eve/src/execution/sandbox/development-prewarm.test.ts
deleted file mode 100644
index 82e8386fa..000000000
--- a/packages/eve/src/execution/sandbox/development-prewarm.test.ts
+++ /dev/null
@@ -1,202 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-import {
- startDevelopmentSandboxPrewarmInBackground,
- subscribeDevelopmentSandboxPrewarmLogs,
- waitForDevelopmentSandboxPrewarm,
-} from "#execution/sandbox/development-prewarm.js";
-import { createDiskRuntimeCompiledArtifactsSource } from "#runtime/compiled-artifacts-source.js";
-
-const mocks = vi.hoisted(() => ({
- prewarmAppSandboxes:
- vi.fn<(input: { readonly log?: (message: string) => void }) => Promise<void>>(),
-}));
-
-vi.mock("#execution/sandbox/prewarm.js", () => ({
- prewarmAppSandboxes: mocks.prewarmAppSandboxes,
-}));
-
-describe("development sandbox prewarm coordination", () => {
- beforeEach(() => {
- mocks.prewarmAppSandboxes.mockReset();
- });
-
- it("waits for an in-flight prewarm by authored app root or compiled snapshot root", async () => {
- const prewarm = createDeferred<void>();
- mocks.prewarmAppSandboxes.mockReturnValueOnce(prewarm.promise);
- const appRoot = "/tmp/eve-app";
- const snapshotRoot = "/tmp/eve-app/.eve/dev-runtime/snapshots/current";
- const compiledArtifactsSource = createDiskRuntimeCompiledArtifactsSource(snapshotRoot);
-
- startDevelopmentSandboxPrewarmInBackground({
- appRoot,
- compiledArtifactsSource,
- });
-
- let authoredWaitResolved = false;
- let snapshotWaitResolved = false;
- const authoredWait = waitForDevelopmentSandboxPrewarm({
- appRoot,
- compiledArtifactsSource: createDiskRuntimeCompiledArtifactsSource(appRoot),
- }).then(() => {
- authoredWaitResolved = true;
- });
- const snapshotWait = waitForDevelopmentSandboxPrewarm({
- appRoot: snapshotRoot,
- compiledArtifactsSource,
- }).then(() => {
- snapshotWaitResolved = true;
- });
-
- await Promise.resolve();
- expect(authoredWaitResolved).toBe(false);
- expect(snapshotWaitResolved).toBe(false);
-
- prewarm.resolve();
- await Promise.all([authoredWait, snapshotWait]);
-
- expect(authoredWaitResolved).toBe(true);
- expect(snapshotWaitResolved).toBe(true);
- });
-
- it("waits for an in-flight prewarm by the stable sandbox app root", async () => {
- const prewarm = createDeferred<void>();
- mocks.prewarmAppSandboxes.mockReturnValueOnce(prewarm.promise);
- const appRoot = "/tmp/eve-app";
- const snapshotRoot = "/tmp/eve-app/.eve/dev-runtime/snapshots/current/app";
- const compiledArtifactsSource = createDiskRuntimeCompiledArtifactsSource(snapshotRoot, {
- moduleMapLoaderPath: "/tmp/eve-package/authored-module-map-loader.ts",
- sandboxAppRoot: appRoot,
- });
-
- startDevelopmentSandboxPrewarmInBackground({
- appRoot: snapshotRoot,
- compiledArtifactsSource,
- });
-
- let sandboxRootWaitResolved = false;
- const sandboxRootWait = waitForDevelopmentSandboxPrewarm({
- appRoot,
- compiledArtifactsSource,
- }).then(() => {
- sandboxRootWaitResolved = true;
- });
-
- await Promise.resolve();
- expect(sandboxRootWaitResolved).toBe(false);
-
- prewarm.resolve();
- await sandboxRootWait;
-
- expect(sandboxRootWaitResolved).toBe(true);
- });
-
- it("replays and forwards prewarm progress logs to waiters", async () => {
- const prewarm = createDeferred<void>();
- let prewarmLog: ((message: string) => void) | undefined;
- mocks.prewarmAppSandboxes.mockImplementationOnce(async (input) => {
- prewarmLog = input.log;
- return await prewarm.promise;
- });
- const appRoot = "/tmp/eve-app";
- const compiledArtifactsSource = createDiskRuntimeCompiledArtifactsSource(appRoot);
-
- startDevelopmentSandboxPrewarmInBackground({
- appRoot,
- compiledArtifactsSource,
- });
- prewarmLog?.('eve: sandbox template "root" (microsandbox): preparing base runtime inside VM');
-
- const logs: string[] = [];
- const wait = waitForDevelopmentSandboxPrewarm({
- appRoot,
- compiledArtifactsSource,
- log: (message) => logs.push(message),
- });
- await Promise.resolve();
- prewarmLog?.('eve: sandbox template "root" (microsandbox): apt-get update');
-
- prewarm.resolve();
- await wait;
-
- expect(logs).toEqual(
- expect.arrayContaining([
- 'eve: sandbox template "root" (microsandbox): preparing base runtime inside VM',
- 'eve: sandbox template "root" (microsandbox): apt-get update',
- ]),
- );
- });
-
- it("replays retained logs and forwards future logs to subscribers", async () => {
- const prewarm = createDeferred<void>();
- let prewarmLog: ((message: string) => void) | undefined;
- mocks.prewarmAppSandboxes.mockImplementationOnce(async (input) => {
- prewarmLog = input.log;
- return await prewarm.promise;
- });
- const appRoot = "/tmp/eve-app";
- const compiledArtifactsSource = createDiskRuntimeCompiledArtifactsSource(appRoot);
-
- startDevelopmentSandboxPrewarmInBackground({
- appRoot,
- compiledArtifactsSource,
- });
- prewarmLog?.('eve: built sandbox template "root" on provider "docker".');
-
- const logs: string[] = [];
- const unsubscribe = subscribeDevelopmentSandboxPrewarmLogs({
- appRoot,
- log: (message) => logs.push(message),
- });
- prewarmLog?.('eve: sandbox template "root" (docker): apt-get update');
-
- unsubscribe();
- prewarmLog?.('eve: sandbox template "root" (docker): apt-get install curl');
- prewarm.resolve();
- await prewarm.promise;
-
- expect(logs).toEqual([
- 'eve: built sandbox template "root" on provider "docker".',
- 'eve: sandbox template "root" (docker): apt-get update',
- ]);
- });
-
- it("keeps completed background prewarm logs for one TUI subscription", async () => {
- const appRoot = "/tmp/eve-completed-app";
- const compiledArtifactsSource = createDiskRuntimeCompiledArtifactsSource(appRoot);
- mocks.prewarmAppSandboxes.mockImplementationOnce(async (input) => {
- input.log?.('eve: built sandbox template "root" on provider "docker".');
- });
-
- startDevelopmentSandboxPrewarmInBackground({
- appRoot,
- compiledArtifactsSource,
- });
- await Promise.resolve();
- await Promise.resolve();
-
- const firstLogs: string[] = [];
- subscribeDevelopmentSandboxPrewarmLogs({
- appRoot,
- log: (message) => firstLogs.push(message),
- });
- const secondLogs: string[] = [];
- subscribeDevelopmentSandboxPrewarmLogs({
- appRoot,
- log: (message) => secondLogs.push(message),
- });
-
- expect(firstLogs).toEqual(['eve: built sandbox template "root" on provider "docker".']);
- expect(secondLogs).toEqual([]);
- });
-});
-
-function createDeferred<T>() {
- let resolve!: (value: T | PromiseLike<T>) => void;
- let reject!: (reason?: unknown) => void;
- const promise = new Promise<T>((res, rej) => {
- resolve = res;
- reject = rej;
- });
- return { promise, reject, resolve };
-}
diff --git a/packages/eve/src/execution/sandbox/development-prewarm.ts b/packages/eve/src/execution/sandbox/development-prewarm.ts
deleted file mode 100644
index 44cb1562f..000000000
--- a/packages/eve/src/execution/sandbox/development-prewarm.ts
+++ /dev/null
@@ -1,202 +0,0 @@
-import {
- getRuntimeCompiledArtifactsAppRoot,
- getRuntimeCompiledArtifactsSandboxAppRoot,
- type RuntimeCompiledArtifactsSource,
-} from "#runtime/compiled-artifacts-source.js";
-import { toErrorMessage } from "#shared/errors.js";
-
-import { prewarmAppSandboxes } from "./prewarm.js";
-
-const MAX_RETAINED_PREWARM_LOGS = 50;
-
-interface DevelopmentPrewarmRecord {
- readonly logs: string[];
- promise: Promise<void>;
- readonly subscribers: Set<(message: string) => void>;
-}
-
-const pendingDevelopmentPrewarms = new Map<string, DevelopmentPrewarmRecord>();
-const retainedDevelopmentPrewarmLogs = new Map<string, readonly string[]>();
-
-export async function prewarmDevelopmentSandboxes(input: {
- readonly appRoot: string;
- readonly compiledArtifactsSource: RuntimeCompiledArtifactsSource;
- readonly log?: (message: string) => void;
-}): Promise<void> {
- startDevelopmentSandboxPrewarmInBackground(input);
- await waitForDevelopmentSandboxPrewarm(input);
-}
-
-export function startDevelopmentSandboxPrewarmInBackground(input: {
- readonly appRoot: string;
- readonly compiledArtifactsSource: RuntimeCompiledArtifactsSource;
- readonly log?: (message: string) => void;
-}): void {
- const keys = resolvePrewarmKeys(input);
- const existing = findPendingPrewarm(keys);
- if (existing !== undefined) {
- registerPrewarmAliases(keys, existing);
- return;
- }
-
- const record: DevelopmentPrewarmRecord = {
- logs: [],
- promise: Promise.resolve(),
- subscribers: new Set(),
- };
- for (const key of keys) {
- retainedDevelopmentPrewarmLogs.delete(key);
- }
- const promise = prewarmAppSandboxes({
- appRoot: input.appRoot,
- compiledArtifactsSource: input.compiledArtifactsSource,
- log: (message) => recordPrewarmLog(record, message, input.log),
- });
- record.promise = promise;
- registerPrewarmAliases(keys, record);
-
- void promise
- .catch((error) => {
- recordPrewarmLog(
- record,
- `eve: failed to initialize sandbox templates in the background: ${toErrorMessage(error)}`,
- input.log,
- );
- })
- .finally(() => {
- for (const key of keys) {
- if (pendingDevelopmentPrewarms.get(key) === record) {
- pendingDevelopmentPrewarms.delete(key);
- }
- if (record.subscribers.size === 0 && record.logs.length > 0) {
- retainedDevelopmentPrewarmLogs.set(key, [...record.logs]);
- }
- }
- });
-}
-
-export function subscribeDevelopmentSandboxPrewarmLogs(input: {
- readonly appRoot: string;
- readonly log: (message: string) => void;
-}): () => void {
- const pending = findPendingPrewarm([input.appRoot]);
- if (pending !== undefined) {
- for (const message of pending.logs) {
- input.log(message);
- }
- pending.subscribers.add(input.log);
- return () => pending.subscribers.delete(input.log);
- }
-
- const retainedLogs = retainedDevelopmentPrewarmLogs.get(input.appRoot);
- if (retainedLogs === undefined) {
- return () => {};
- }
-
- retainedDevelopmentPrewarmLogs.delete(input.appRoot);
- for (const message of retainedLogs) {
- input.log(message);
- }
- return () => {};
-}
-
-export async function waitForDevelopmentSandboxPrewarm(input: {
- readonly appRoot: string;
- readonly compiledArtifactsSource: RuntimeCompiledArtifactsSource;
- readonly log?: (message: string) => void;
-}): Promise<void> {
- const pending = findPendingPrewarm(resolvePrewarmKeys(input));
- if (pending === undefined) {
- return;
- }
-
- let unsubscribe: (() => void) | undefined;
- if (input.log !== undefined) {
- for (const message of pending.logs) {
- input.log(message);
- }
- const subscriber = (message: string) => input.log?.(message);
- pending.subscribers.add(subscriber);
- unsubscribe = () => pending.subscribers.delete(subscriber);
- }
-
- try {
- await withProgressHeartbeat(
- "waiting for background sandbox template prewarm",
- input.log,
- () => pending.promise,
- );
- } finally {
- unsubscribe?.();
- }
-}
-
-function resolvePrewarmKeys(input: {
- readonly appRoot: string;
- readonly compiledArtifactsSource: RuntimeCompiledArtifactsSource;
-}): readonly string[] {
- const keys = new Set<string>([input.appRoot]);
- const compiledAppRoot = getRuntimeCompiledArtifactsAppRoot(input.compiledArtifactsSource);
- if (compiledAppRoot !== undefined) {
- keys.add(compiledAppRoot);
- }
- const sandboxAppRoot = getRuntimeCompiledArtifactsSandboxAppRoot(input.compiledArtifactsSource);
- if (sandboxAppRoot !== undefined) {
- keys.add(sandboxAppRoot);
- }
- return [...keys];
-}
-
-function findPendingPrewarm(keys: readonly string[]): DevelopmentPrewarmRecord | undefined {
- for (const key of keys) {
- const record = pendingDevelopmentPrewarms.get(key);
- if (record !== undefined) {
- return record;
- }
- }
- return undefined;
-}
-
-function registerPrewarmAliases(keys: readonly string[], record: DevelopmentPrewarmRecord): void {
- for (const key of keys) {
- pendingDevelopmentPrewarms.set(key, record);
- }
-}
-
-function recordPrewarmLog(
- record: DevelopmentPrewarmRecord,
- message: string,
- log: ((message: string) => void) | undefined,
-): void {
- record.logs.push(message);
- if (record.logs.length > MAX_RETAINED_PREWARM_LOGS) {
- record.logs.splice(0, record.logs.length - MAX_RETAINED_PREWARM_LOGS);
- }
- log?.(message);
- for (const subscriber of record.subscribers) {
- subscriber(message);
- }
-}
-
-async function withProgressHeartbeat<T>(
- message: string,
- log: ((message: string) => void) | undefined,
- callback: () => Promise<T>,
-): Promise<T> {
- if (log === undefined) {
- return await callback();
- }
-
- const startedAt = Date.now();
- const timer = setInterval(() => {
- const elapsedSeconds = Math.round((Date.now() - startedAt) / 1000);
- log(`${message} (${elapsedSeconds}s elapsed)`);
- }, 10_000);
- timer.unref?.();
-
- try {
- return await callback();
- } finally {
- clearInterval(timer);
- }
-}
diff --git a/packages/eve/src/execution/sandbox/ensure.test.ts b/packages/eve/src/execution/sandbox/ensure.test.ts
index 72c44413a..21f4abdb8 100644
--- a/packages/eve/src/execution/sandbox/ensure.test.ts
+++ b/packages/eve/src/execution/sandbox/ensure.test.ts
@@ -11,6 +11,7 @@ import { defineParentSandbox, defineSandbox } from "#public/definitions/sandbox.
import { defineSandboxProvider } from "#shared/sandbox-provider.js";
import { createBundledRuntimeCompiledArtifactsSource } from "#runtime/compiled-artifacts-source.js";
import type { RuntimeSandboxRegistry } from "#runtime/sandbox/registry.js";
+import { loadSandboxPreparedArtifact } from "#runtime/sandbox/prepared-artifacts.js";
vi.mock("#runtime/sandbox/prepared-artifacts.js", () => ({
loadSandboxPreparedArtifact: vi.fn(async () => null),
@@ -93,6 +94,25 @@ async function open(
afterEach(() => clearActiveSandboxHandlesForTest());
describe("ensureSandboxAccess", () => {
+ it("does not prepare or start anything until the sandbox is requested", async () => {
+ const value = fixture();
+ await ensureSandboxAccess({
+ compiledArtifactsSource: createBundledRuntimeCompiledArtifactsSource(),
+ nodeId: "__root__",
+ registry: value.registry,
+ sessionId: "unused",
+ state: null,
+ });
+ expect(value.create).not.toHaveBeenCalled();
+ });
+
+ it("keeps missing production artifacts fatal without starting a sandbox", async () => {
+ vi.mocked(loadSandboxPreparedArtifact).mockResolvedValueOnce(undefined);
+ const value = fixture();
+ await expect(open(value.registry)).rejects.toThrow();
+ expect(value.create).not.toHaveBeenCalled();
+ });
+
it("creates and returns a real sandbox", async () => {
const value = fixture();
expect((await open(value.registry)).sandbox).toBeTruthy();
diff --git a/packages/eve/src/execution/sandbox/ensure.ts b/packages/eve/src/execution/sandbox/ensure.ts
index f1e7c8a4f..0cf3f514d 100644
--- a/packages/eve/src/execution/sandbox/ensure.ts
+++ b/packages/eve/src/execution/sandbox/ensure.ts
@@ -1,3 +1,5 @@
+import { ensureDevelopmentSandboxesPrepared } from "#execution/sandbox/development-lazy-prewarm.js";
+import { isEveDevEnvironment } from "#internal/application/dev-environment.js";
import { contextStorage } from "#context/container.js";
import {
buildCallbackContext,
@@ -191,6 +193,14 @@ export async function ensureSandboxAccess(input: EnsureSandboxAccessInput): Prom
if (definition.kind !== "independent")
throw new Error(`Sandbox "${definition.logicalPath}" has no resolved parent.`);
+ if (isEveDevEnvironment() && input.compiledArtifactsSource.kind === "disk") {
+ await ensureDevelopmentSandboxesPrepared({
+ compiledArtifactsSource: input.compiledArtifactsSource,
+ nodeId: inherited?.nodeId ?? input.nodeId,
+ providerName: getSandboxEnvironmentRuntime(definition.environment).providerName,
+ });
+ }
+
const activeSession =
contextStorage.getStore() === undefined
? {
diff --git a/packages/eve/src/execution/sandbox/prewarm.test.ts b/packages/eve/src/execution/sandbox/prewarm.test.ts
index d176f5362..fb6613a7e 100644
--- a/packages/eve/src/execution/sandbox/prewarm.test.ts
+++ b/packages/eve/src/execution/sandbox/prewarm.test.ts
@@ -72,6 +72,36 @@ describe("prewarmAppSandboxes", () => {
expect(secondInputs[0]?.sourceRevision).toBe("sandbox-source-hash");
});
+ it("waits for other providers to finish before reporting a preparation failure", async () => {
+ const graph = createGraph();
+ const child = { ...graph.root, nodeId: "child" };
+ const nodesByNodeId = new Map(graph.nodesByNodeId);
+ nodesByNodeId.set("child", child);
+ let finish!: () => void;
+ const slow = new Promise<void>((resolve) => {
+ finish = resolve;
+ });
+ let calls = 0;
+ let settled = false;
+ const preparation = prewarmAppSandboxes({
+ appRoot: process.cwd(),
+ loadAgentGraph: async () => ({ ...graph, nodesByNodeId }),
+ dispatch: async () => {
+ if (++calls === 1) throw new Error("first provider failed");
+ await slow;
+ return null;
+ },
+ preparedArtifactStore: createMemoryArtifactStore(),
+ }).catch((error: unknown) => {
+ settled = true;
+ return error;
+ });
+ await vi.waitFor(() => expect(calls).toBe(2));
+ expect(settled).toBe(false);
+ finish();
+ expect(await preparation).toMatchObject({ message: "first provider failed" });
+ });
+
it.each(["docker", "microsandbox"])(
"explains that %s is unavailable during Vercel prewarm",
async (providerName) => {
diff --git a/packages/eve/src/execution/sandbox/prewarm.ts b/packages/eve/src/execution/sandbox/prewarm.ts
index 08ee688c5..e6a377847 100644
--- a/packages/eve/src/execution/sandbox/prewarm.ts
+++ b/packages/eve/src/execution/sandbox/prewarm.ts
@@ -103,7 +103,7 @@ export async function prewarmSandboxes(input: PrewarmSandboxesInput): Promise<vo
input.log?.(`eve: initializing ${formatSandboxTemplateCount(targets.length)}...`);
- const results = await Promise.all(
+ const results = await Promise.allSettled(
targets.map(async ({ context, label, nodeId, provider }) => {
const logProviderProgress = (message: string) => {
if (!shouldLogSandboxPrewarmProgress(message)) return;
@@ -130,11 +130,20 @@ export async function prewarmSandboxes(input: PrewarmSandboxesInput): Promise<vo
}
}),
);
- const entries = results.map(({ nodeId, provider, result }) => ({
- artifact: result,
- nodeId,
- providerName: provider.providerName,
- }));
+ // A failed provider must not release the preparation lock while others still write templates.
+ const failure = results.find((result) => result.status === "rejected");
+ if (failure?.status === "rejected") throw failure.reason;
+ const entries = results.flatMap((result) =>
+ result.status === "fulfilled"
+ ? [
+ {
+ artifact: result.value.result,
+ nodeId: result.value.nodeId,
+ providerName: result.value.provider.providerName,
+ },
+ ]
+ : [],
+ );
await preparedArtifactStore.write({ compileDirectoryPath: input.compileDirectoryPath, entries });
input.log?.(`eve: initialized ${formatSandboxTemplateCount(targets.length)}.`);
}
diff --git a/packages/eve/src/internal/application/output-publication-lock.ts b/packages/eve/src/internal/application/output-publication-lock.ts
index c92f5c663..b7b1f31e8 100644
--- a/packages/eve/src/internal/application/output-publication-lock.ts
+++ b/packages/eve/src/internal/application/output-publication-lock.ts
@@ -173,7 +173,7 @@ async function recoverStalePublication(
}
}
-async function acquireRecoveryLease(
+export async function acquireRecoveryLease(
recoveryPath: string,
token: string,
): Promise<RecoveryLease | undefined> {
diff --git a/packages/eve/src/internal/nitro/host/create-application-nitro.ts b/packages/eve/src/internal/nitro/host/create-application-nitro.ts
index 224617fd9..f6ae709f6 100644
--- a/packages/eve/src/internal/nitro/host/create-application-nitro.ts
+++ b/packages/eve/src/internal/nitro/host/create-application-nitro.ts
@@ -18,6 +18,7 @@ import {
} from "#internal/application/cache-metadata.js";
import { createProductionNitroArtifactsConfig } from "#internal/nitro/host/artifacts-config.js";
import { createCompiledSandboxProviderPrunePlugin } from "#internal/nitro/host/compiled-sandbox-provider-prune-plugin.js";
+import { createDevelopmentRuntimePrunePlugin } from "#internal/nitro/host/development-runtime-prune-plugin.js";
import { createExtensionScopePlugin } from "#internal/bundler/extension-scope-plugin.js";
import {
createExtensionExternalDependencyPlugin,
@@ -591,6 +592,7 @@ function createApplicationNitroBundlerConfiguration(
...preparedHost.compileResult.manifest.subagents.map((subagent) => subagent.agent),
].flatMap((node) => node.extensionMounts);
const nitroBundlerPlugins = [
+ preset === "vercel" ? createDevelopmentRuntimePrunePlugin() : null,
compiledSandboxProviderPrunePlugin,
createOptionalEngineDependencyPlugin(unconfiguredOptionalEnginePackages),
createExtensionExternalDependencyPlugin(extensionMounts),
diff --git a/packages/eve/src/internal/nitro/host/dev-authored-rebuild-coordinator.test.ts b/packages/eve/src/internal/nitro/host/dev-authored-rebuild-coordinator.test.ts
index 6a9beb861..af9cc77b8 100644
--- a/packages/eve/src/internal/nitro/host/dev-authored-rebuild-coordinator.test.ts
+++ b/packages/eve/src/internal/nitro/host/dev-authored-rebuild-coordinator.test.ts
@@ -53,9 +53,6 @@ vi.mock("#internal/nitro/development-generation.js", () => ({
vi.mock("#internal/nitro/host/artifacts-config.js", () => ({
createDevelopmentGenerationArtifactsSource: () => ({ kind: "disk" }),
}));
-vi.mock("#execution/sandbox/development-prewarm.js", () => ({
- prewarmDevelopmentSandboxes: vi.fn(async () => {}),
-}));
function createHost(
id: string,
diff --git a/packages/eve/src/internal/nitro/host/dev-authored-rebuild-coordinator.ts b/packages/eve/src/internal/nitro/host/dev-authored-rebuild-coordinator.ts
index e6231cc3d..be4e5e9c7 100644
--- a/packages/eve/src/internal/nitro/host/dev-authored-rebuild-coordinator.ts
+++ b/packages/eve/src/internal/nitro/host/dev-authored-rebuild-coordinator.ts
@@ -1,6 +1,4 @@
import { stageDevelopmentEnvironmentFiles } from "#cli/dev/environment.js";
-import { prewarmDevelopmentSandboxes } from "#execution/sandbox/development-prewarm.js";
-import { createDevelopmentGenerationArtifactsSource } from "#internal/nitro/host/artifacts-config.js";
import { createDevelopmentApplicationNitro } from "#internal/nitro/host/create-application-nitro.js";
import { buildDevelopmentHostCandidate } from "#internal/nitro/host/dev-host-candidate.js";
import { computeDevelopmentHostFingerprint } from "#internal/nitro/host/dev-host-fingerprint.js";
@@ -121,7 +119,6 @@ class TransactionalDevelopmentAuthoredRebuildCoordinator implements DevelopmentA
) {
throw new DevelopmentWorkflowWorldChangeRequiresRestartError();
}
- await prewarmDevelopmentHost(nextHost);
const nextHostFingerprint = await computeDevelopmentHostFingerprint(nextHost);
const nextRuntimeFingerprint = nextHost.generation.fingerprint;
const hasStructuralChange = nextHostFingerprint !== this.#currentHostFingerprint;
@@ -262,18 +259,6 @@ function retainActiveHostWorkspace(
};
}
-async function prewarmDevelopmentHost(host: PreparedDevelopmentApplicationHost): Promise<void> {
- await prewarmDevelopmentSandboxes({
- appRoot: host.appRoot,
- compiledArtifactsSource: createDevelopmentGenerationArtifactsSource({
- appRoot: host.appRoot,
- configuredWorld: host.compileResult.manifest.config.experimental?.workflow?.world,
- runtimeAppRoot: host.generation.runtimeAppRoot,
- }),
- log: (message) => console.log(message),
- });
-}
-
async function discardPreparedHost(host: PreparedDevelopmentApplicationHost): Promise<void> {
const cleanup = await Promise.allSettled([
discardDevelopmentGeneration(host.generation),
diff --git a/packages/eve/src/internal/nitro/host/development-runtime-prune-plugin.test.ts b/packages/eve/src/internal/nitro/host/development-runtime-prune-plugin.test.ts
new file mode 100644
index 000000000..7d8c5fc34
--- /dev/null
+++ b/packages/eve/src/internal/nitro/host/development-runtime-prune-plugin.test.ts
@@ -0,0 +1,20 @@
+import { describe, expect, it } from "vitest";
+
+import { createDevelopmentRuntimePrunePlugin } from "./development-runtime-prune-plugin.js";
+
+describe("createDevelopmentRuntimePrunePlugin", () => {
+ it("prunes lazy preparation from hosted JavaScript and TypeScript graphs", () => {
+ const plugin = createDevelopmentRuntimePrunePlugin();
+ for (const path of [
+ "/repo/packages/eve/dist/src/execution/sandbox/development-lazy-prewarm.js",
+ "/repo/packages/eve/src/execution/sandbox/development-lazy-prewarm.ts?query",
+ "#execution/sandbox/development-lazy-prewarm.js",
+ ]) {
+ const id = plugin.resolveId?.(path);
+ if (id === null || id === undefined) throw new Error("Expected a pruned module id.");
+ expect(plugin.load?.(id)).toBe(
+ "export async function ensureDevelopmentSandboxesPrepared() {}\n",
+ );
+ }
+ });
+});
diff --git a/packages/eve/src/internal/nitro/host/development-runtime-prune-plugin.ts b/packages/eve/src/internal/nitro/host/development-runtime-prune-plugin.ts
new file mode 100644
index 000000000..3bcdb3062
--- /dev/null
+++ b/packages/eve/src/internal/nitro/host/development-runtime-prune-plugin.ts
@@ -0,0 +1,28 @@
+const PRUNED_DEVELOPMENT_LAZY_PREWARM_MODULE_ID = "\0eve-pruned-development-lazy-prewarm";
+const DEVELOPMENT_LAZY_PREWARM_SOURCE_RE =
+ /(?:^|[/\\#])execution[/\\]sandbox[/\\]development-lazy-prewarm\.(?:js|ts)(?:[?#].*)?$/;
+
+interface BundlerPluginShape {
+ readonly enforce: "pre";
+ readonly name: string;
+ load?(id: string): string | null;
+ resolveId?(source: string): string | null;
+}
+
+/** Removes development-only lazy sandbox preparation from every hosted runtime bundle. */
+export function createDevelopmentRuntimePrunePlugin(): BundlerPluginShape {
+ return {
+ enforce: "pre",
+ name: "eve-hosted-development-runtime-prune",
+ load(id) {
+ return id === PRUNED_DEVELOPMENT_LAZY_PREWARM_MODULE_ID
+ ? "export async function ensureDevelopmentSandboxesPrepared() {}\n"
+ : null;
+ },
+ resolveId(source) {
+ return DEVELOPMENT_LAZY_PREWARM_SOURCE_RE.test(source)
+ ? PRUNED_DEVELOPMENT_LAZY_PREWARM_MODULE_ID
+ : null;
+ },
+ };
+}
diff --git a/packages/eve/src/internal/nitro/host/start-development-server.test.ts b/packages/eve/src/internal/nitro/host/start-development-server.test.ts
index f85213930..dca85ed04 100644
--- a/packages/eve/src/internal/nitro/host/start-development-server.test.ts
+++ b/packages/eve/src/internal/nitro/host/start-development-server.test.ts
@@ -125,7 +125,6 @@ const mocks = vi.hoisted(() => {
rm: vi.fn(async (path: string) => {
files.delete(path);
}),
- startDevelopmentSandboxPrewarmInBackground: vi.fn(() => undefined),
pruneLocalSandboxTemplatesInBackground: vi.fn(() => undefined),
stopDevelopmentSandboxResources: vi.fn(async () => undefined),
resolveDiscoveryProject: vi.fn(async () => ({
@@ -203,10 +202,6 @@ vi.mock("#internal/nitro/host/artifacts-config.js", () => ({
createDevelopmentGenerationArtifactsSource: () => mocks.resolveNitroCompiledArtifactsSource(),
}));
-vi.mock("#execution/sandbox/development-prewarm.js", () => ({
- prewarmDevelopmentSandboxes: mocks.startDevelopmentSandboxPrewarmInBackground,
-}));
-
vi.mock("#execution/sandbox/bindings/local.js", () => ({
pruneLocalSandboxTemplatesInBackground: mocks.pruneLocalSandboxTemplatesInBackground,
stopDevelopmentSandboxResources: mocks.stopDevelopmentSandboxResources,
@@ -393,14 +388,6 @@ describe("createDevelopmentServer", () => {
const server = await startDevelopmentServer("/tmp/eve-test");
expect(mocks.prepareDevelopmentApplicationHost).toHaveBeenCalledWith("/tmp/eve-test");
- expect(mocks.startDevelopmentSandboxPrewarmInBackground).toHaveBeenCalledWith({
- appRoot: "/tmp/eve-test",
- compiledArtifactsSource: {
- appRoot: "/tmp/eve-test/.eve/dev-runtime-test",
- kind: "disk",
- moduleMapLoaderPath: "/tmp/eve-package/authored-module-map-loader.ts",
- },
- });
expect(mocks.pruneLocalSandboxTemplatesInBackground).toHaveBeenCalledWith("/tmp/eve-test");
expect(mocks.createParentDevelopmentWorkflowWorld).toHaveBeenCalledWith(
expect.objectContaining({ agentName: "test-agent", appRoot: "/tmp/eve-test" }),
diff --git a/packages/eve/src/internal/nitro/host/start-development-server.ts b/packages/eve/src/internal/nitro/host/start-development-server.ts
index a8e366fc7..022df1b3b 100644
--- a/packages/eve/src/internal/nitro/host/start-development-server.ts
+++ b/packages/eve/src/internal/nitro/host/start-development-server.ts
@@ -5,7 +5,6 @@ import type { Nitro } from "nitro/types";
import { createDevelopmentApplicationNitro } from "#internal/nitro/host/create-application-nitro.js";
import { DrainedNitroDevServer } from "#internal/nitro/host/drained-nitro-dev-server.js";
-import { createDevelopmentGenerationArtifactsSource } from "#internal/nitro/host/artifacts-config.js";
import type { AuthoredSourceWatcherHandle } from "#internal/nitro/host/dev-authored-source-watcher.js";
import { prepareDevelopmentApplicationHost } from "#internal/nitro/host/prepare-application-host.js";
import { buildDevelopmentHostCandidate } from "#internal/nitro/host/dev-host-candidate.js";
@@ -27,7 +26,6 @@ import {
pruneLocalSandboxTemplatesInBackground,
stopDevelopmentSandboxResources,
} from "#execution/sandbox/bindings/local.js";
-import { prewarmDevelopmentSandboxes } from "#execution/sandbox/development-prewarm.js";
import {
createDevelopmentSandboxRunId,
EVE_DEVELOPMENT_SANDBOX_RUN_ID_ENV,
@@ -435,20 +433,6 @@ async function startNitroDevelopmentServer(
options.onBootProgress,
);
preparedDevelopmentHost = preparedHost;
- await devBootPhase(
- "preparing sandbox templates",
- () =>
- prewarmDevelopmentSandboxes({
- appRoot: preparedHost.appRoot,
- compiledArtifactsSource: createDevelopmentGenerationArtifactsSource({
- appRoot: preparedHost.appRoot,
- configuredWorld:
- preparedHost.compileResult.manifest.config.experimental?.workflow?.world,
- runtimeAppRoot: preparedHost.generation.runtimeAppRoot,
- }),
- }),
- options.onBootProgress,
- );
pruneLocalSandboxTemplatesInBackground(preparedHost.appRoot);
const activeNitro = await devBootPhase(
"creating dev server",
diff --git a/packages/eve/src/runtime/sandbox/prepared-artifacts.ts b/packages/eve/src/runtime/sandbox/prepared-artifacts.ts
index 2676eec89..a729e6a16 100644
--- a/packages/eve/src/runtime/sandbox/prepared-artifacts.ts
+++ b/packages/eve/src/runtime/sandbox/prepared-artifacts.ts
@@ -1,4 +1,5 @@
-import { readFile, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { readFile, rename, rm, writeFile } from "node:fs/promises";
import type { RuntimeCompiledArtifactsSource } from "#runtime/compiled-artifacts-source.js";
import { readBundledCompiledArtifacts } from "#runtime/loaders/bundled-artifacts.js";
@@ -27,10 +28,17 @@ export async function writeSandboxPreparedArtifactsManifest(input: {
}
const entries = new Map(existing?.entries.map((entry) => [entry.nodeId, entry]));
for (const entry of input.entries) entries.set(entry.nodeId, entry);
- await writeFile(
- path,
- `${JSON.stringify(createSandboxPreparedArtifactsManifest([...entries.values()]), null, 2)}\n`,
- );
+ const temporaryPath = `${path}.${randomUUID()}.tmp`;
+ try {
+ await writeFile(
+ temporaryPath,
+ `${JSON.stringify(createSandboxPreparedArtifactsManifest([...entries.values()]), null, 2)}\n`,
+ );
+ // Dev workers may read while another worker publishes the prepared generation.
+ await rename(temporaryPath, path);
+ } finally {
+ await rm(temporaryPath, { force: true });
+ }
}
export async function loadSandboxPreparedArtifact(input: {
diff --git a/packages/eve/test/scenarios/just-bash-auto-install.scenario.test.ts b/packages/eve/test/scenarios/just-bash-auto-install.scenario.test.ts
index b4835c7ac..f350c5188 100644
--- a/packages/eve/test/scenarios/just-bash-auto-install.scenario.test.ts
+++ b/packages/eve/test/scenarios/just-bash-auto-install.scenario.test.ts
@@ -1,24 +1,34 @@
import { existsSync } from "node:fs";
-import { readFile } from "node:fs/promises";
+import { readFile, writeFile } from "node:fs/promises";
import { join } from "node:path";
import { describe, expect, it } from "vitest";
import { useScenarioApp } from "../../src/internal/testing/scenario-app.js";
-import { startEveDev } from "./dev-server-harness.js";
+import { readDevelopmentRevision, startEveDev, waitForCondition } from "./dev-server-harness.js";
+import { sendDevelopmentMessage } from "../dev-client-harness/send-message.js";
+import { createDevelopmentSessionState } from "../dev-client-harness/session.js";
const scenarioApp = useScenarioApp();
describe("just-bash automatic installation", () => {
- it("boots a fresh pnpm app without approving optional native codec builds", async () => {
+ it("defers installation until sandbox access without approving optional native codec builds", async () => {
const app = await scenarioApp({
name: "just-bash-auto-install",
installDependencies: true,
+ dependencies: { zod: "4.5.4" },
files: {
"pnpm-workspace.yaml":
"minimumReleaseAge: 0\nstrictDepBuilds: true\nallowBuilds:\n esbuild: true\n",
"agent/agent.ts": 'export default { model: "openai/gpt-5.4-mini" };\n',
"agent/instructions.md": "Help with everyday tasks.\n",
+ "agent/tools/check_shell.ts": [
+ 'import { defineTool } from "eve/tools";',
+ 'import { z } from "zod";',
+ 'export default defineTool({ description: "Check the shell", inputSchema: z.object({}),',
+ ' async execute(_input, ctx) { const sandbox = await ctx.getSandbox(); return await sandbox.run({ command: "echo lazy-ready" }); },',
+ "});",
+ ].join("\n"),
"agent/sandbox/sandbox.ts": [
'import { defineSandbox } from "eve/sandbox";',
'import { JustBashSandbox } from "eve/sandbox/just-bash";',
@@ -37,6 +47,26 @@ describe("just-bash automatic installation", () => {
const server = await startEveDev(app.appRoot);
try {
expect((await fetch(new URL("/eve/v1/health", server.url))).status).toBe(200);
+ expect(existsSync(join(app.appRoot, "node_modules", "just-bash"))).toBe(false);
+ expect(existsSync(join(app.appRoot, "node_modules", "microsandbox"))).toBe(false);
+ expect(await readFile(join(app.appRoot, "pnpm-workspace.yaml"), "utf8")).not.toContain(
+ "ignoredOptionalDependencies:",
+ );
+ const sessions = [createDevelopmentSessionState(), createDevelopmentSessionState()];
+ const results = await Promise.all(
+ sessions.map((session) =>
+ sendDevelopmentMessage({
+ message: "Run check_shell",
+ session,
+ serverUrl: server.url,
+ }),
+ ),
+ );
+ for (const result of results) {
+ expect(JSON.stringify(result.events), `${server.stdout()}\n${server.stderr()}`).toContain(
+ "lazy-ready",
+ );
+ }
const policy = await readFile(join(app.appRoot, "pnpm-workspace.yaml"), "utf8");
expect(policy).toContain("ignoredOptionalDependencies:");
expect(policy).toContain('"@mongodb-js/zstd"');
@@ -44,6 +74,24 @@ describe("just-bash automatic installation", () => {
expect(policy).toContain("esbuild: true");
const manifest = JSON.parse(await readFile(join(app.appRoot, "package.json"), "utf8"));
expect(manifest.devDependencies["just-bash"]).toBeTruthy();
+
+ const initialRevision = await readDevelopmentRevision(server.url);
+ await writeFile(
+ join(app.appRoot, "agent", "instructions.md"),
+ "Help with everyday tasks and check the shell when asked.\n",
+ );
+ await waitForCondition(
+ async () => (await readDevelopmentRevision(server.url)) !== initialRevision,
+ () => `Expected authored rebuild.\n${server.stdout()}\n${server.stderr()}`,
+ );
+ const resumed = await sendDevelopmentMessage({
+ message: "Run check_shell",
+ session: sessions[0]!,
+ serverUrl: server.url,
+ });
+ expect(JSON.stringify(resumed.events), `${server.stdout()}\n${server.stderr()}`).toContain(
+ "lazy-ready",
+ );
} finally {
await server.stop();
}