Skip to content

armgit / eve

Public Imported from GitHub
0

The Open Framework for Building Agents

fix(eve): repair optional sandbox auto-installation (#3641)

OwenKephart867a6adf213c
diff --git a/.changeset/fix-just-bash-auto-install-policy.md b/.changeset/fix-just-bash-auto-install-policy.md
new file mode 100644
index 000000000..74b5bb8bf
--- /dev/null
+++ b/.changeset/fix-just-bash-auto-install-policy.md
@@ -0,0 +1,5 @@
+---
+"eve": patch
+---
+
+Prepare pnpm's optional-dependency policy before automatically installing just-bash during development, avoiding startup failures on unapproved native codec builds. Existing package-specific build decisions are preserved.
diff --git a/.changeset/fix-microsandbox-auto-install.md b/.changeset/fix-microsandbox-auto-install.md
new file mode 100644
index 000000000..223f1e1ae
--- /dev/null
+++ b/.changeset/fix-microsandbox-auto-install.md
@@ -0,0 +1,5 @@
+---
+"eve": patch
+---
+
+Pin automatic microsandbox installs and manual installation guidance to the supported version so a new development server does not install an incompatible release.
diff --git a/.changeset/serialize-optional-engine-installations.md b/.changeset/serialize-optional-engine-installations.md
new file mode 100644
index 000000000..62684e1ca
--- /dev/null
+++ b/.changeset/serialize-optional-engine-installations.md
@@ -0,0 +1,5 @@
+---
+"eve": patch
+---
+
+Serialize automatic sandbox dependency installations that share a package-manager root, preventing concurrent providers or workspace apps from racing on dependency files. Waiting installations recheck their own package and can proceed after another installation fails.
diff --git a/docs/sandbox/just-bash.mdx b/docs/sandbox/just-bash.mdx
index 63210443e..e49d1e1e8 100644
--- a/docs/sandbox/just-bash.mdx
+++ b/docs/sandbox/just-bash.mdx
@@ -15,4 +15,10 @@ export default defineSandbox(() => environment.open());
just-bash can prepare and persist its virtual filesystem. It cannot use OCI images or Dockerfiles, does not run native processes, and provides no network isolation. The session does not expose `setNetworkPolicy()`.
+## Automatic installation
+
+When an environment uses just-bash during `eve dev`, eve installs the package into your application if it is missing, unless you set `autoInstall: false` in the environment options. `DefaultSandbox` selects only one provider, but another environment, such as local self-modification, can use just-bash independently. Other environments require you to install the package yourself.
+
+For pnpm projects, automatic installation adds `@mongodb-js/zstd` and `node-liblzma` to `ignoredOptionalDependencies` in the owning `pnpm-workspace.yaml` when they have no explicit package policy. These optional native codecs are not needed for basic shell and filesystem operations. Commands that require those codecs may be unavailable without them. eve preserves existing package-specific build decisions and does not automatically approve build scripts.
+
See the [sandbox overview](/docs/sandbox) for managed workspace, skills, parent inheritance, and custom providers.
diff --git a/packages/eve/src/cli/commands/registry-pnpm-build-policy-flow.ts b/packages/eve/src/cli/commands/registry-pnpm-build-policy-flow.ts
index e69d0731f..9f0dafeed 100644
--- a/packages/eve/src/cli/commands/registry-pnpm-build-policy-flow.ts
+++ b/packages/eve/src/cli/commands/registry-pnpm-build-policy-flow.ts
@@ -1,14 +1,14 @@
import { detectPackageManager } from "#setup/package-manager.js";
import { createPrompter, type Prompter } from "#setup/prompter.js";
import { WizardCancelledError } from "#setup/step.js";
-
-import type { RegistryCommandLogger } from "./registry-recovery.js";
import {
applyPnpmBuildPolicy,
inspectPnpmBuildPolicy,
type PnpmBuildPolicyAction,
type PnpmBuildPolicyContext,
-} from "./registry-pnpm-build-policy.js";
+} from "#setup/primitives/pm/pnpm-build-policy.js";
+
+import type { RegistryCommandLogger } from "./registry-recovery.js";
import { headlessSetupContinuation, serializeHeadlessSetupEvent } from "./setup-headless.js";
const PNPM_BUILD_POLICY_ANSWER_KEY = "install.pnpm.buildScripts";
diff --git a/packages/eve/src/cli/commands/registry-pnpm-build-policy.test.ts b/packages/eve/src/cli/commands/registry-pnpm-build-policy.test.ts
deleted file mode 100644
index ea18eb8a1..000000000
--- a/packages/eve/src/cli/commands/registry-pnpm-build-policy.test.ts
+++ /dev/null
@@ -1,47 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { withPnpmBuildPolicy } from "./registry-pnpm-build-policy.js";
-
-describe("pnpm registry build policy", () => {
- it("adds exact optional dependencies to the ignored list", () => {
- expect(
- withPnpmBuildPolicy(
- "packages:\n - apps/*\n\nallowBuilds:\n sharp: false\n",
- ["node-liblzma", "@mongodb-js/zstd"],
- "ignore-optional",
- ),
- ).toBe(
- 'packages:\n - apps/*\n\nallowBuilds:\n sharp: false\n\nignoredOptionalDependencies:\n - "@mongodb-js/zstd"\n - "node-liblzma"\n',
- );
- });
-
- it("replaces an ignored decision when build scripts are allowed", () => {
- expect(
- withPnpmBuildPolicy(
- 'ignoredOptionalDependencies:\n - "@mongodb-js/zstd"\n - cbor-extract\n - node-liblzma\n',
- ["node-liblzma", "@mongodb-js/zstd"],
- "allow-builds",
- ),
- ).toBe(
- 'ignoredOptionalDependencies:\n - cbor-extract\n\nallowBuilds:\n "@mongodb-js/zstd": true\n "node-liblzma": true\n',
- );
- });
-
- it("replaces an allowed decision when optional packages are ignored", () => {
- expect(
- withPnpmBuildPolicy(
- 'allowBuilds:\n "@mongodb-js/zstd": true\n esbuild: true\n node-liblzma: false\n',
- ["node-liblzma", "@mongodb-js/zstd"],
- "ignore-optional",
- ),
- ).toBe(
- 'allowBuilds:\n esbuild: true\n\nignoredOptionalDependencies:\n - "@mongodb-js/zstd"\n - "node-liblzma"\n',
- );
- });
-
- it("refuses inline policy structures instead of corrupting them", () => {
- expect(() =>
- withPnpmBuildPolicy("allowBuilds: { esbuild: true }\n", ["node-liblzma"], "ignore-optional"),
- ).toThrow("does not use block-style YAML");
- });
-});
diff --git a/packages/eve/src/execution/sandbox/bindings/just-bash-runtime.ts b/packages/eve/src/execution/sandbox/bindings/just-bash-runtime.ts
index bfed0ee71..9ae0cb9d9 100644
--- a/packages/eve/src/execution/sandbox/bindings/just-bash-runtime.ts
+++ b/packages/eve/src/execution/sandbox/bindings/just-bash-runtime.ts
@@ -69,6 +69,7 @@ async function loadJustBashModule(input: {
"with eve. Install it in your application (for example `pnpm add -D just-bash`), or use " +
"DockerSandbox or DefaultSandbox instead.",
packageName: JUST_BASH_PACKAGE_NAME,
+ ignoredOptionalDependencies: ["@mongodb-js/zstd", "node-liblzma"],
})
.catch((error: unknown) => {
justBashModulePromise = undefined;
diff --git a/packages/eve/src/execution/sandbox/bindings/microsandbox-runtime.test.ts b/packages/eve/src/execution/sandbox/bindings/microsandbox-runtime.test.ts
index 0331b3ae0..02f18ee90 100644
--- a/packages/eve/src/execution/sandbox/bindings/microsandbox-runtime.test.ts
+++ b/packages/eve/src/execution/sandbox/bindings/microsandbox-runtime.test.ts
@@ -4,6 +4,7 @@ import type { MicrosandboxSessionMetadata } from "#execution/sandbox/bindings/mi
import {
connectMicrosandbox,
createPreparedMicrosandbox,
+ loadMicrosandboxModule,
MicrosandboxVm,
} from "#execution/sandbox/bindings/microsandbox-runtime.js";
import {
@@ -13,6 +14,35 @@ import {
import { streamToBuffer } from "#execution/sandbox/stream-utils.js";
import { EVE_DEV_ENV_FLAG } from "#internal/application/optional-package-install.js";
+vi.mock("#execution/sandbox/bindings/microsandbox-platform.js", async (importOriginal) => ({
+ ...(await importOriginal<
+ typeof import("#execution/sandbox/bindings/microsandbox-platform.js")
+ >()),
+ assertMicrosandboxPlatformCandidate: vi.fn(async () => {}),
+}));
+
+describe("microsandbox package installation guidance", () => {
+ it("uses the supported install specifier for both automatic and manual installation", async () => {
+ const loadOptionalPackage = vi.fn(async (input: { readonly missingMessage: string }) => {
+ throw new Error(input.missingMessage);
+ });
+ await expect(
+ loadMicrosandboxModule({
+ host: { loadOptionalPackage, resolveProjectPath: (path) => path },
+ options: resolveMicrosandboxOptions({ setup: { autoInstall: false } }),
+ }),
+ ).rejects.toThrow("pnpm add -D [email protected]");
+ expect(loadOptionalPackage).toHaveBeenCalledWith(
+ expect.objectContaining({
+ autoInstall: false,
+ packageName: "microsandbox",
+ installPackageName: "[email protected]",
+ missingMessage: expect.stringContaining("`pnpm add -D [email protected]`"),
+ }),
+ );
+ });
+});
+
const metadataState = vi.hoisted(() => ({
writeSessionMetadata: vi.fn(),
}));
diff --git a/packages/eve/src/execution/sandbox/bindings/microsandbox-runtime.ts b/packages/eve/src/execution/sandbox/bindings/microsandbox-runtime.ts
index 9c668643d..eaff8d4f0 100644
--- a/packages/eve/src/execution/sandbox/bindings/microsandbox-runtime.ts
+++ b/packages/eve/src/execution/sandbox/bindings/microsandbox-runtime.ts
@@ -56,6 +56,8 @@ export {
export type MicrosandboxModule = typeof import("microsandbox");
const MICROSANDBOX_PACKAGE_NAME = "microsandbox";
+const MICROSANDBOX_PACKAGE_VERSION = "0.5.5";
+const MICROSANDBOX_INSTALL_SPECIFIER = `${MICROSANDBOX_PACKAGE_NAME}@${MICROSANDBOX_PACKAGE_VERSION}`;
const MICROSANDBOX_CONNECT_TIMEOUT_MS = 10_000;
const MICROSANDBOX_STOP_TIMEOUT_MS = 10_000;
@@ -467,7 +469,7 @@ async function restoreMicrosandboxSessionSnapshot(input: {
const MICROSANDBOX_MISSING_PACKAGE_MESSAGE =
"The microsandbox sandbox provider requires the `microsandbox` package, which is not bundled " +
- "with eve. Install it in your application (for example `pnpm add -D microsandbox`), or use " +
+ `with eve. Install it in your application (for example \`pnpm add -D ${MICROSANDBOX_INSTALL_SPECIFIER}\`), or use ` +
"DockerSandbox or VercelSandbox instead.";
/**
@@ -490,6 +492,7 @@ export async function loadMicrosandboxModule(input: {
input.host.loadOptionalPackage<MicrosandboxModule>({
autoInstall: input.options.setup.autoInstall,
importModule: async () => await import("microsandbox"),
+ installPackageName: MICROSANDBOX_INSTALL_SPECIFIER,
missingMessage: MICROSANDBOX_MISSING_PACKAGE_MESSAGE,
packageName: MICROSANDBOX_PACKAGE_NAME,
}),
diff --git a/packages/eve/src/internal/application/optional-package-install.scenario.test.ts b/packages/eve/src/internal/application/optional-package-install.scenario.test.ts
new file mode 100644
index 000000000..3d04b6a51
--- /dev/null
+++ b/packages/eve/src/internal/application/optional-package-install.scenario.test.ts
@@ -0,0 +1,76 @@
+import { execFile } from "node:child_process";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { promisify } from "node:util";
+
+import { describe, expect, it } from "vitest";
+
+import { useTemporaryDirectories } from "#internal/testing/use-temporary-app-roots.js";
+
+const createScratchDirectory = useTemporaryDirectories();
+const run = promisify(execFile);
+
+describe("optional package installation locking", () => {
+ it("installs different packages from concurrent processes into one workspace", async () => {
+ const root = await createScratchDirectory("eve-optional-install-race-");
+ await writeFile(
+ join(root, "package.json"),
+ JSON.stringify({ name: "workspace", private: true }),
+ );
+ await writeFile(
+ join(root, "pnpm-workspace.yaml"),
+ "packages:\n - apps/*\nminimumReleaseAge: 0\n",
+ );
+ for (const name of ["one", "two"]) {
+ await mkdir(join(root, "apps", name), { recursive: true });
+ await writeFile(
+ join(root, "apps", name, "package.json"),
+ JSON.stringify({ name, private: true }),
+ );
+ await mkdir(join(root, "deps", name), { recursive: true });
+ await writeFile(
+ join(root, "deps", name, "package.json"),
+ JSON.stringify({ name: `engine-${name}`, version: "1.0.0", main: "index.js" }),
+ );
+ await writeFile(
+ join(root, "deps", name, "index.js"),
+ `module.exports = ${JSON.stringify(name)};`,
+ );
+ }
+ const installer = new URL(
+ "../../../dist/src/internal/application/optional-package-install.js",
+ import.meta.url,
+ ).href;
+ const outputs = await Promise.all(
+ ["one", "two"].map((name) =>
+ run(
+ process.execPath,
+ [
+ "--input-type=module",
+ "-e",
+ `
+ import { createRequire } from 'node:module';
+ import { loadOptionalEnginePackage } from ${JSON.stringify(installer)};
+ const require = createRequire(process.cwd() + '/package.json');
+ const result = await loadOptionalEnginePackage({
+ appRoot: process.cwd(), autoInstall: true,
+ packageName: ${JSON.stringify(`engine-${name}`)},
+ installPackageName: ${JSON.stringify(`engine-${name}@file:../../deps/${name}`)},
+ missingMessage: 'missing engine',
+ importModule: async () => { throw new Error('missing'); },
+ importInstalledModule: async () => require(${JSON.stringify(`engine-${name}`)}),
+ });
+ console.log('loaded:' + result);
+ `,
+ ],
+ { cwd: join(root, "apps", name), env: { ...process.env, EVE_DEV: "1" }, timeout: 60_000 },
+ ),
+ ),
+ );
+ expect(outputs[0]!.stdout).toContain("loaded:one");
+ expect(outputs[1]!.stdout).toContain("loaded:two");
+ const lockfile = await readFile(join(root, "pnpm-lock.yaml"), "utf8");
+ expect(lockfile).toContain("engine-one");
+ expect(lockfile).toContain("engine-two");
+ });
+});
diff --git a/packages/eve/src/internal/application/optional-package-install.test.ts b/packages/eve/src/internal/application/optional-package-install.test.ts
index c37d7025d..570faaea8 100644
--- a/packages/eve/src/internal/application/optional-package-install.test.ts
+++ b/packages/eve/src/internal/application/optional-package-install.test.ts
@@ -1,16 +1,22 @@
import { ChildProcess, spawn } from "node:child_process";
import { existsSync } from "node:fs";
-import { readFile } from "node:fs/promises";
+import { mkdir, readFile } from "node:fs/promises";
import { PassThrough } from "node:stream";
import { Worker } from "node:worker_threads";
import { beforeEach, describe, expect, it, vi } from "vitest";
+import { ensurePnpmOptionalDependencyDefaults } from "#setup/primitives/pm/pnpm-build-policy.js";
+
import {
EVE_DEV_ENV_FLAG,
installPackageIntoProject,
loadOptionalEnginePackage,
} from "#internal/application/optional-package-install.js";
+vi.mock("#setup/primitives/pm/pnpm-build-policy.js", () => ({
+ ensurePnpmOptionalDependencyDefaults: vi.fn(async () => {}),
+}));
+
vi.mock("node:child_process", async (importOriginal) => ({
...(await importOriginal<typeof import("node:child_process")>()),
spawn: vi.fn(),
@@ -159,6 +165,44 @@ describe("loadOptionalEnginePackage", () => {
expect(importInstalledModule).toHaveBeenCalledTimes(2);
});
+ it("installs a versioned specifier while loading by package name", async () => {
+ vi.stubEnv(EVE_DEV_ENV_FLAG, "1");
+ const importModule = vi.fn(async () => {
+ throw new Error("Cannot find module 'microsandbox'");
+ });
+ const installedModule = { ok: true };
+ let installed = false;
+ mockedSpawn.mockImplementationOnce(() => {
+ const child = createMockChildProcess();
+ queueMicrotask(() => {
+ installed = true;
+ child.emit("close", 0);
+ });
+ return child;
+ });
+
+ await expect(
+ loadOptionalEnginePackage({
+ appRoot: "/repo/versioned-app",
+ autoInstall: true,
+ importInstalledModule: vi.fn(async () => {
+ if (!installed) throw new Error("Cannot find module 'microsandbox'");
+ return installedModule;
+ }),
+ importModule,
+ installPackageName: "[email protected]",
+ missingMessage: "missing microsandbox",
+ packageName: "microsandbox",
+ }),
+ ).resolves.toBe(installedModule);
+
+ expect(mockedSpawn).toHaveBeenCalledWith(
+ "npm",
+ ["install", "--save-dev", "[email protected]"],
+ expect.objectContaining({ cwd: "/repo/versioned-app" }),
+ );
+ });
+
it("coalesces concurrent auto-installs for the same project package", async () => {
const appRoot = "/repo/concurrent-app";
vi.stubEnv(EVE_DEV_ENV_FLAG, "1");
@@ -204,6 +248,89 @@ describe("loadOptionalEnginePackage", () => {
expect(mockedSpawn).toHaveBeenCalledTimes(1);
});
+ it.each([false, true])(
+ "serializes different packages across a shared workspace (first fails: %s)",
+ async (firstFails) => {
+ vi.stubEnv(EVE_DEV_ENV_FLAG, "1");
+ mockedExistsSync.mockImplementation((path) => path === "/workspace/pnpm-lock.yaml");
+ const children: ReturnType<typeof createMockChildProcess>[] = [];
+ const installed = new Set<string>();
+ mockedSpawn.mockImplementation(() => {
+ const child = createMockChildProcess();
+ children.push(child);
+ return child;
+ });
+ const load = (appRoot: string, packageName: string) =>
+ loadOptionalEnginePackage({
+ appRoot,
+ packageName,
+ autoInstall: true,
+ ignoredOptionalDependencies: packageName === "just-bash" ? ["node-liblzma"] : undefined,
+ missingMessage: `missing ${packageName}`,
+ importModule: async () => {
+ throw new Error("missing");
+ },
+ importInstalledModule: async () => {
+ if (!installed.has(packageName)) throw new Error("missing");
+ return packageName;
+ },
+ });
+ const first = load("/workspace/apps/one", "microsandbox").catch((error: unknown) => error);
+ await vi.waitFor(() => expect(children).toHaveLength(1));
+ const second = load("/workspace/apps/two", "just-bash");
+ await flushMicrotasks();
+ expect(children).toHaveLength(1);
+ expect(ensurePnpmOptionalDependencyDefaults).not.toHaveBeenCalled();
+ installed.add("microsandbox");
+ children[0]!.emit("close", firstFails ? 1 : 0);
+ await vi.waitFor(() => expect(children).toHaveLength(2));
+ installed.add("just-bash");
+ children[1]!.emit("close", 0);
+ if (firstFails) expect(await first).toBeInstanceOf(Error);
+ else expect(await first).toBe("microsandbox");
+ await expect(second).resolves.toBe("just-bash");
+ expect(
+ vi
+ .mocked(mkdir)
+ .mock.calls.filter(([path]) => String(path).endsWith(".lock"))
+ .map(([path]) => path),
+ ).toEqual([
+ "/workspace/.eve/optional-package-install.lock",
+ "/workspace/.eve/optional-package-install.lock",
+ ]);
+ },
+ );
+
+ it("allows installations in independent projects to run concurrently", async () => {
+ vi.stubEnv(EVE_DEV_ENV_FLAG, "1");
+ const children: ReturnType<typeof createMockChildProcess>[] = [];
+ let installed = false;
+ mockedSpawn.mockImplementation(() => {
+ const child = createMockChildProcess();
+ children.push(child);
+ return child;
+ });
+ const loads = ["/independent-one", "/independent-two"].map((appRoot) =>
+ loadOptionalEnginePackage({
+ appRoot,
+ packageName: "just-bash",
+ autoInstall: true,
+ missingMessage: "missing",
+ importModule: async () => {
+ throw new Error("missing");
+ },
+ importInstalledModule: async () => {
+ if (!installed) throw new Error("missing");
+ return true;
+ },
+ }),
+ );
+ await vi.waitFor(() => expect(children).toHaveLength(2));
+ installed = true;
+ children.forEach((child) => child.emit("close", 0));
+ await expect(Promise.all(loads)).resolves.toEqual([true, true]);
+ });
+
it("wraps a post-install load failure with an actionable diagnostic", async () => {
const appRoot = "/repo/misconfigured-app";
vi.stubEnv(EVE_DEV_ENV_FLAG, "1");
@@ -308,12 +435,66 @@ describe("loadOptionalEnginePackage", () => {
});
async function flushMicrotasks(): Promise<void> {
- for (let i = 0; i < 5; i += 1) {
+ for (let i = 0; i < 20; i += 1) {
await Promise.resolve();
}
}
describe("installPackageIntoProject", () => {
+ it("prepares declared pnpm defaults before installation", async () => {
+ mockedExistsSync.mockImplementation((path) => path === "/repo/pnpm-lock.yaml");
+ const packages = ["@mongodb-js/zstd", "node-liblzma"];
+ await installPackageIntoProject({
+ appRoot: "/repo/app",
+ packageName: "just-bash",
+ ignoredOptionalDependencies: packages,
+ });
+ expect(ensurePnpmOptionalDependencyDefaults).toHaveBeenCalledWith("/repo/app", packages);
+ expect(
+ vi.mocked(ensurePnpmOptionalDependencyDefaults).mock.invocationCallOrder[0],
+ ).toBeLessThan(mockedSpawn.mock.invocationCallOrder[0]!);
+ });
+
+ it("does not write pnpm configuration for another package manager", async () => {
+ await installPackageIntoProject({
+ appRoot: "/repo/app",
+ packageName: "just-bash",
+ ignoredOptionalDependencies: ["node-liblzma"],
+ });
+ expect(ensurePnpmOptionalDependencyDefaults).not.toHaveBeenCalled();
+ });
+
+ it("does not install if policy preparation fails", async () => {
+ mockedExistsSync.mockImplementation((path) => path === "/repo/pnpm-lock.yaml");
+ vi.mocked(ensurePnpmOptionalDependencyDefaults).mockRejectedValueOnce(
+ new Error("Unsupported policy"),
+ );
+ await expect(
+ installPackageIntoProject({
+ appRoot: "/repo/app",
+ packageName: "just-bash",
+ ignoredOptionalDependencies: ["node-liblzma"],
+ }),
+ ).rejects.toThrow("Unsupported policy");
+ expect(mockedSpawn).not.toHaveBeenCalled();
+ });
+
+ it("keeps package-manager failures fatal after preparing defaults", async () => {
+ mockedExistsSync.mockImplementation((path) => path === "/repo/pnpm-lock.yaml");
+ mockedSpawn.mockImplementationOnce(() => {
+ const child = createMockChildProcess();
+ queueMicrotask(() => child.emit("close", 1));
+ return child;
+ });
+ await expect(
+ installPackageIntoProject({
+ appRoot: "/repo/app",
+ packageName: "just-bash",
+ ignoredOptionalDependencies: ["node-liblzma"],
+ }),
+ ).rejects.toThrow("exit 1");
+ });
+
it("uses the project's package manager", async () => {
mockedExistsSync.mockImplementation((path) => path === "/repo/pnpm-lock.yaml");
diff --git a/packages/eve/src/internal/application/optional-package-install.ts b/packages/eve/src/internal/application/optional-package-install.ts
index 91442143e..af0df0753 100644
--- a/packages/eve/src/internal/application/optional-package-install.ts
+++ b/packages/eve/src/internal/application/optional-package-install.ts
@@ -1,10 +1,12 @@
import { spawn } from "node:child_process";
-import { existsSync } from "node:fs";
+import { existsSync, realpathSync } from "node:fs";
import { mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
+import { dirname, join, resolve } from "node:path";
import { pathToFileURL } from "node:url";
import { Worker } from "node:worker_threads";
+import { ensurePnpmOptionalDependencyDefaults } from "#setup/primitives/pm/pnpm-build-policy.js";
+
import { EVE_DEV_ENV_FLAG, isEveDevEnvironment } from "#internal/application/dev-environment.js";
export { EVE_DEV_ENV_FLAG, isEveDevEnvironment };
@@ -17,27 +19,40 @@ export type ProjectPackageManager = "bun" | "npm" | "pnpm" | "yarn";
* manager. Defaults to npm when no lockfile is found.
*/
export function detectProjectPackageManager(appRoot: string): ProjectPackageManager {
- let current = appRoot;
+ return resolveProjectInstallation(appRoot).packageManager;
+}
+
+function resolveProjectInstallation(appRoot: string): {
+ readonly root: string;
+ readonly packageManager: ProjectPackageManager;
+} {
+ let current = resolve(appRoot);
+ try {
+ current = realpathSync.native(current);
+ } catch {
+ // A not-yet-materialized project still needs a stable absolute lock identity.
+ }
+ const projectRoot = current;
for (;;) {
if (
existsSync(join(current, "pnpm-lock.yaml")) ||
existsSync(join(current, "pnpm-workspace.yaml"))
) {
- return "pnpm";
+ return { root: current, packageManager: "pnpm" };
}
if (existsSync(join(current, "yarn.lock"))) {
- return "yarn";
+ return { root: current, packageManager: "yarn" };
}
if (existsSync(join(current, "bun.lock")) || existsSync(join(current, "bun.lockb"))) {
- return "bun";
+ return { root: current, packageManager: "bun" };
}
if (existsSync(join(current, "package-lock.json"))) {
- return "npm";
+ return { root: current, packageManager: "npm" };
}
const parent = dirname(current);
if (parent === current) {
- return "npm";
+ return { root: projectRoot, packageManager: "npm" };
}
current = parent;
}
@@ -64,8 +79,12 @@ const pendingOptionalPackageInstalls = new Map<string, Promise<void>>();
export async function installPackageIntoProject(input: {
readonly appRoot: string;
readonly packageName: string;
+ readonly ignoredOptionalDependencies?: readonly string[];
}): Promise<void> {
const packageManager = detectProjectPackageManager(input.appRoot);
+ if (packageManager === "pnpm" && input.ignoredOptionalDependencies?.length) {
+ await ensurePnpmOptionalDependencyDefaults(input.appRoot, input.ignoredOptionalDependencies);
+ }
const args = [...INSTALL_ARGUMENTS[packageManager], input.packageName];
console.info(
@@ -109,6 +128,8 @@ export async function loadOptionalEnginePackage<T>(input: {
readonly autoInstall: boolean;
readonly importInstalledModule?: () => Promise<T>;
readonly importModule: () => Promise<T>;
+ readonly installPackageName?: string;
+ readonly ignoredOptionalDependencies?: readonly string[];
readonly missingMessage: string;
readonly packageName: string;
}): Promise<T> {
@@ -146,7 +167,8 @@ export async function loadOptionalEnginePackage<T>(input: {
await installPackageIntoProject({
appRoot: input.appRoot,
- packageName: input.packageName,
+ packageName: input.installPackageName ?? input.packageName,
+ ignoredOptionalDependencies: input.ignoredOptionalDependencies,
});
});
} catch (installError) {
@@ -351,30 +373,28 @@ async function withOptionalPackageInstallLock(
input: { readonly appRoot: string; readonly packageName: string },
callback: () => Promise<void>,
): Promise<void> {
- const lockKey = `${input.appRoot}:${input.packageName}`;
- const pending = pendingOptionalPackageInstalls.get(lockKey);
- if (pending !== undefined) {
- await pending;
- return;
+ const lockRoot = resolveProjectInstallation(input.appRoot).root;
+ const pending = pendingOptionalPackageInstalls.get(lockRoot) ?? Promise.resolve();
+ // Different packages and workspace members mutate the same dependency tree.
+ // Queue every callback so each caller rechecks its own package under the lock.
+ const promise = pending
+ .catch(() => {})
+ .then(() => withOptionalPackageInstallFileLock(lockRoot, callback));
+ pendingOptionalPackageInstalls.set(lockRoot, promise);
+ try {
+ await promise;
+ } finally {
+ if (pendingOptionalPackageInstalls.get(lockRoot) === promise) {
+ pendingOptionalPackageInstalls.delete(lockRoot);
+ }
}
-
- const promise = withOptionalPackageInstallFileLock(input, callback).finally(() => {
- pendingOptionalPackageInstalls.delete(lockKey);
- });
- pendingOptionalPackageInstalls.set(lockKey, promise);
- await promise;
}
async function withOptionalPackageInstallFileLock(
- input: { readonly appRoot: string; readonly packageName: string },
+ lockRoot: string,
callback: () => Promise<void>,
): Promise<void> {
- const lockPath = join(
- input.appRoot,
- ".eve",
- "optional-package-locks",
- `${sanitizeLockName(input.packageName)}.lock`,
- );
+ const lockPath = join(lockRoot, ".eve", "optional-package-install.lock");
await acquireLock(lockPath);
try {
await callback();
@@ -428,10 +448,6 @@ async function waitForExistingLock(lockPath: string, startedAt: number): Promise
await new Promise((resolve) => setTimeout(resolve, OPTIONAL_PACKAGE_LOCK_POLL_MS));
}
-function sanitizeLockName(value: string): string {
- return value.replaceAll(/[^a-zA-Z0-9._-]+/g, "-");
-}
-
/**
* Windows package manager shims are commonly `.cmd` files, which plain
* `spawn` does not resolve reliably without shell execution.
diff --git a/packages/eve/src/setup/primitives/pm/pnpm-build-policy.scenario.test.ts b/packages/eve/src/setup/primitives/pm/pnpm-build-policy.scenario.test.ts
new file mode 100644
index 000000000..2321d2d2c
--- /dev/null
+++ b/packages/eve/src/setup/primitives/pm/pnpm-build-policy.scenario.test.ts
@@ -0,0 +1,40 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+import { describe, expect, it } from "vitest";
+
+import { useTemporaryDirectories } from "#internal/testing/use-temporary-app-roots.js";
+import { pathExists } from "#setup/path-exists.js";
+import { ensurePnpmOptionalDependencyDefaults } from "./pnpm-build-policy.js";
+
+const createScratchDirectory = useTemporaryDirectories();
+const packages = ["@mongodb-js/zstd", "node-liblzma"];
+
+describe("pnpm optional dependency policy ownership", () => {
+ it("creates standalone defaults and leaves them unchanged on repeat preparation", async () => {
+ const root = await createScratchDirectory("eve-optional-policy-");
+ await ensurePnpmOptionalDependencyDefaults(root, packages);
+ const file = join(root, "pnpm-workspace.yaml");
+ const policy = await readFile(file, "utf8");
+ expect(policy).toContain(' - "node-liblzma"');
+ await ensurePnpmOptionalDependencyDefaults(root, packages);
+ expect(await readFile(file, "utf8")).toBe(policy);
+ });
+
+ it("updates the owning workspace and preserves existing build decisions", async () => {
+ const root = await createScratchDirectory("eve-optional-workspace-policy-");
+ const member = join(root, "apps", "agent");
+ await mkdir(member, { recursive: true });
+ const file = join(root, "pnpm-workspace.yaml");
+ await writeFile(
+ file,
+ 'packages:\n - apps/*\nallowBuilds:\n "@mongodb-js/zstd": false\n esbuild: true\n',
+ );
+ await ensurePnpmOptionalDependencyDefaults(member, packages);
+ const policy = await readFile(file, "utf8");
+ expect(policy).toContain(' "@mongodb-js/zstd": false');
+ expect(policy).toContain(' - "node-liblzma"');
+ expect(policy).toContain(" esbuild: true");
+ expect(await pathExists(join(member, "pnpm-workspace.yaml"))).toBe(false);
+ });
+});
diff --git a/packages/eve/src/setup/primitives/pm/pnpm-build-policy.test.ts b/packages/eve/src/setup/primitives/pm/pnpm-build-policy.test.ts
new file mode 100644
index 000000000..ee6da4122
--- /dev/null
+++ b/packages/eve/src/setup/primitives/pm/pnpm-build-policy.test.ts
@@ -0,0 +1,85 @@
+import { describe, expect, it } from "vitest";
+
+import { withPnpmBuildPolicy, withPnpmOptionalDependencyDefaults } from "./pnpm-build-policy.js";
+
+describe("pnpm optional dependency defaults", () => {
+ const packages = ["@mongodb-js/zstd", "node-liblzma"];
+
+ it("adds defaults to a fresh workspace and is idempotent", () => {
+ const next = withPnpmOptionalDependencyDefaults("", packages);
+ expect(next).toBe('ignoredOptionalDependencies:\n - "@mongodb-js/zstd"\n - "node-liblzma"\n');
+ expect(withPnpmOptionalDependencyDefaults(next, packages)).toBe(next);
+ });
+
+ it.each(["true", "false"])(
+ "preserves an explicit %s build decision while defaulting only missing packages",
+ (decision) => {
+ const source = `packages:\n - apps/*\nallowBuilds:\n "@mongodb-js/zstd": ${decision}\n esbuild: true\n`;
+ expect(withPnpmOptionalDependencyDefaults(source, packages)).toBe(
+ `${source}\nignoredOptionalDependencies:\n - "node-liblzma"\n`,
+ );
+ },
+ );
+
+ it("preserves mixed existing decisions without rewriting the file", () => {
+ const source =
+ 'allowBuilds:\n "@mongodb-js/zstd": false\nignoredOptionalDependencies:\n - node-liblzma\n - cbor-extract\n';
+ expect(withPnpmOptionalDependencyDefaults(source, packages)).toBe(source);
+ });
+
+ it("preserves explicit decisions in older pnpm policy lists", () => {
+ const source =
+ 'onlyBuiltDependencies:\n - "@mongodb-js/zstd"\nignoredBuiltDependencies:\n - node-liblzma\n';
+ expect(withPnpmOptionalDependencyDefaults(source, packages)).toBe(source);
+ });
+
+ it("fails safely on unsupported policy syntax", () => {
+ expect(() =>
+ withPnpmOptionalDependencyDefaults("allowBuilds: { esbuild: true }\n", packages),
+ ).toThrow("does not use block-style YAML");
+ });
+});
+
+describe("pnpm registry build policy", () => {
+ it("adds exact optional dependencies to the ignored list", () => {
+ expect(
+ withPnpmBuildPolicy(
+ "packages:\n - apps/*\n\nallowBuilds:\n sharp: false\n",
+ ["node-liblzma", "@mongodb-js/zstd"],
+ "ignore-optional",
+ ),
+ ).toBe(
+ 'packages:\n - apps/*\n\nallowBuilds:\n sharp: false\n\nignoredOptionalDependencies:\n - "@mongodb-js/zstd"\n - "node-liblzma"\n',
+ );
+ });
+
+ it("replaces an ignored decision when build scripts are allowed", () => {
+ expect(
+ withPnpmBuildPolicy(
+ 'ignoredOptionalDependencies:\n - "@mongodb-js/zstd"\n - cbor-extract\n - node-liblzma\n',
+ ["node-liblzma", "@mongodb-js/zstd"],
+ "allow-builds",
+ ),
+ ).toBe(
+ 'ignoredOptionalDependencies:\n - cbor-extract\n\nallowBuilds:\n "@mongodb-js/zstd": true\n "node-liblzma": true\n',
+ );
+ });
+
+ it("replaces an allowed decision when optional packages are ignored", () => {
+ expect(
+ withPnpmBuildPolicy(
+ 'allowBuilds:\n "@mongodb-js/zstd": true\n esbuild: true\n node-liblzma: false\n',
+ ["node-liblzma", "@mongodb-js/zstd"],
+ "ignore-optional",
+ ),
+ ).toBe(
+ 'allowBuilds:\n esbuild: true\n\nignoredOptionalDependencies:\n - "@mongodb-js/zstd"\n - "node-liblzma"\n',
+ );
+ });
+
+ it("refuses inline policy structures instead of corrupting them", () => {
+ expect(() =>
+ withPnpmBuildPolicy("allowBuilds: { esbuild: true }\n", ["node-liblzma"], "ignore-optional"),
+ ).toThrow("does not use block-style YAML");
+ });
+});
diff --git a/packages/eve/src/cli/commands/registry-pnpm-build-policy.ts b/packages/eve/src/setup/primitives/pm/pnpm-build-policy.ts
similarity index 82%
rename from packages/eve/src/cli/commands/registry-pnpm-build-policy.ts
rename to packages/eve/src/setup/primitives/pm/pnpm-build-policy.ts
index cbcf97555..cdcc9ad7b 100644
--- a/packages/eve/src/cli/commands/registry-pnpm-build-policy.ts
+++ b/packages/eve/src/setup/primitives/pm/pnpm-build-policy.ts
@@ -1,10 +1,7 @@
import { access, readFile, writeFile } from "node:fs/promises";
import { join } from "node:path";
-import {
- findClaimingAncestorPnpmWorkspaceRoot,
- PNPM_WORKSPACE_PATH,
-} from "#setup/primitives/pm/pnpm.js";
+import { findClaimingAncestorPnpmWorkspaceRoot, PNPM_WORKSPACE_PATH } from "./pnpm.js";
export type PnpmBuildPolicyAction = "ignore-optional" | "allow-builds";
@@ -152,6 +149,35 @@ export function withPnpmBuildPolicy(
return `${lines.join("\n")}\n`;
}
+/** Adds optional-package defaults without replacing the application's explicit decisions. */
+export function withPnpmOptionalDependencyDefaults(
+ source: string,
+ packages: readonly string[],
+): string {
+ const lines = source.replace(/\r\n/gu, "\n").split("\n");
+ const decisions = [
+ policyEntries(lines, "allowBuilds", "mapping"),
+ policyEntries(lines, "ignoredOptionalDependencies", "sequence"),
+ policyEntries(lines, "onlyBuiltDependencies", "sequence"),
+ policyEntries(lines, "ignoredBuiltDependencies", "sequence"),
+ ];
+ const missing = packages.filter((name) => !decisions.some((entries) => entries.has(name)));
+ return missing.length === 0 ? source : withPnpmBuildPolicy(source, missing, "ignore-optional");
+}
+
+/** Prepares defaults in the owning workspace before installing an optional engine. */
+export async function ensurePnpmOptionalDependencyDefaults(
+ appRoot: string,
+ packages: readonly string[],
+): Promise<void> {
+ const filePath = join(await owningPnpmWorkspaceRoot(appRoot), PNPM_WORKSPACE_PATH);
+ const source = await readWorkspacePolicy(filePath);
+ const next = withPnpmOptionalDependencyDefaults(source, packages);
+ if (next === source) return;
+ await writeFile(filePath, next, "utf8");
+ console.info(`[eve:dev] updated optional dependency defaults in "${filePath}".`);
+}
+
async function readWorkspacePolicy(filePath: string): Promise<string> {
try {
return await readFile(filePath, "utf8");
diff --git a/packages/eve/src/shared/sandbox-provider.ts b/packages/eve/src/shared/sandbox-provider.ts
index d52187566..20a5d77e1 100644
--- a/packages/eve/src/shared/sandbox-provider.ts
+++ b/packages/eve/src/shared/sandbox-provider.ts
@@ -98,6 +98,8 @@ export interface SandboxProviderHost {
loadOptionalPackage<T>(input: {
readonly autoInstall: boolean;
readonly importModule: () => Promise<T>;
+ readonly installPackageName?: string;
+ readonly ignoredOptionalDependencies?: readonly string[];
readonly missingMessage: string;
readonly packageName: string;
}): Promise<T>;
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
new file mode 100644
index 000000000..b4835c7ac
--- /dev/null
+++ b/packages/eve/test/scenarios/just-bash-auto-install.scenario.test.ts
@@ -0,0 +1,51 @@
+import { existsSync } from "node:fs";
+import { readFile } 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";
+
+const scenarioApp = useScenarioApp();
+
+describe("just-bash automatic installation", () => {
+ it("boots a fresh pnpm app without approving optional native codec builds", async () => {
+ const app = await scenarioApp({
+ name: "just-bash-auto-install",
+ installDependencies: true,
+ 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/sandbox/sandbox.ts": [
+ 'import { defineSandbox } from "eve/sandbox";',
+ 'import { JustBashSandbox } from "eve/sandbox/just-bash";',
+ "export const environment = JustBashSandbox.environment({",
+ " prepare: async (sandbox) => {",
+ ' const result = await sandbox.run({ command: "echo ready" });',
+ ' if (result.stdout.trim() !== "ready") throw new Error("Shell preparation failed");',
+ " },",
+ "});",
+ "export default defineSandbox(() => environment.open());",
+ ].join("\n"),
+ },
+ });
+ expect(existsSync(join(app.appRoot, "node_modules", "just-bash"))).toBe(false);
+
+ const server = await startEveDev(app.appRoot);
+ try {
+ expect((await fetch(new URL("/eve/v1/health", server.url))).status).toBe(200);
+ const policy = await readFile(join(app.appRoot, "pnpm-workspace.yaml"), "utf8");
+ expect(policy).toContain("ignoredOptionalDependencies:");
+ expect(policy).toContain('"@mongodb-js/zstd"');
+ expect(policy).toContain('"node-liblzma"');
+ expect(policy).toContain("esbuild: true");
+ const manifest = JSON.parse(await readFile(join(app.appRoot, "package.json"), "utf8"));
+ expect(manifest.devDependencies["just-bash"]).toBeTruthy();
+ } finally {
+ await server.stop();
+ }
+ });
+});