@moinulmoin/eden 0.6.0 → 0.7.0

package/dist/eve-packaging.js

@@ -1,9 +1,12 @@
 import { createHash, } from "node:crypto";
 import { execFile, } from "node:child_process";
-import { chmod, lstat, mkdir, readFile, readlink, readdir, realpath, writeFile, } from "node:fs/promises";
+import { chmod, lstat, mkdir, readFile, readlink, readdir, realpath, rm, writeFile, } from "node:fs/promises";
 import { promisify, } from "node:util";
+import { EVE_HOST_ENVIRONMENT as HOST_ENVIRONMENT, EVE_START_COMMAND as START_COMMAND, } from "./eve-runtime-config.js";
 import { basename, dirname, isAbsolute, join, relative, resolve, } from "node:path";
 const execFileAsync = promisify(execFile);
+/** Snapshot-relative root of Eve's prepared sandbox templates. */
+export const EVE_SANDBOX_CACHE_ROOT = ".eve/sandbox-cache";
 export class EvePackagingError extends Error {
     code;
     subject;
@@ -27,6 +30,121 @@ export class EvePackagingError extends Error {
 // exempt from the ldd check, and the runtime stage sets
 // CBOR_NATIVE_ACCELERATION_DISABLED.
 const IGNORED_BUILDS_GUARD = `node -e 'const m=JSON.parse(require("fs").readFileSync("node_modules/.modules.yaml","utf8"));const b=(m.ignoredBuilds||[]).filter((p)=>!p.startsWith("cbor-extract@"));if(b.length){console.error("ERR_PNPM_IGNORED_BUILDS Ignored build scripts: "+b.join(", "));process.exit(1)}'`;
+/**
+ * Eden's temporary fix for upstream https://github.com/vercel/eve/issues/4440
+ * (repro: https://github.com/moinulmoin/eve-justbash-resume-repro).
+ * Eve's just-bash provider permanently refuses to resume a conversation once
+ * the sandbox template changes (skills, `agent/sandbox/workspace/`, or the
+ * sandbox definition) and never falls back, so one `eden deploy` update would
+ * break every existing conversation's sandbox forever. The isolated builder
+ * rewrites one file in the installed Eve copy so an existing session reopens
+ * against the current template instead of throwing; user files under
+ * `/workspace` always win over the template. The patch applies only when the
+ * target file's sha256 equals `EVE_SANDBOX_RESUME_PATCH_KNOWN_SHA256`, and it
+ * is removed entirely once upstream ships the fix.
+ */
+export const EVE_SANDBOX_RESUME_PATCH_KNOWN_SHA256 = "0ba0ac3a237c99af2f67a6028f1675bf7c04b22454b4ebfb4cd9d19e5bf5aaf8";
+/** Marker the patched binding always contains; proves the patch shipped. */
+export const EVE_SANDBOX_RESUME_PATCH_SIGNATURE = "edenRefreshJustBashSessionSkills";
+/** Path of the just-bash binding inside the resolved Eve package root. */
+const EVE_JUST_BASH_BINDING_PATH = "dist/src/execution/sandbox/bindings/just-bash.js";
+/** The exact `resume()` implementation in eve 0.68.0, 0.71.2, and 0.72.1. */
+export const EVE_JUST_BASH_RESUME_ORIGINAL = `async resume(e,n,r){let i=requirePreparedJustBashArtifact(n),a=requireJustBashSessionState(r),o=createSandboxProviderIdentity({artifact:i,version:1}),s=sessionRootPath(e,i);if(a.generation!==o||a.rootPath!==s)throw Error(\`just-bash session state is incompatible with this environment.\`);if(!await pathExists(a.rootPath))throw Error(\`just-bash session root "\${a.rootPath}" no longer exists.\`);return await openHandle(e,a.rootPath,t)}`;
+/**
+ * The replacement `resume()`: a session whose template generation moved is
+ * contained to the same sessions directory and reopened with its authored
+ * skills refreshed from the current template. A session folder that is gone
+ * (for example a deploy that could not carry it) is recreated from the
+ * current template instead of failing every later sandbox call.
+ */
+export const EVE_SANDBOX_RESUME_PATCHED = `async resume(e,n,r){let i=requirePreparedJustBashArtifact(n),a=requireJustBashSessionState(r),o=createSandboxProviderIdentity({artifact:i,version:1}),s=sessionRootPath(e,i);if((a.generation!==o||a.rootPath!==s)&&dirname(a.rootPath)!==dirname(s))throw Error(\`just-bash session state is incompatible with this environment.\`);await ensureSessionRoot(i,a.rootPath);if(a.generation!==o)await edenRefreshJustBashSessionSkills(i.templateRootPath,a.rootPath);return await openHandle(e,a.rootPath,t)}`;
+/**
+ * Helpers appended to the patched binding. They use only identifiers the
+ * module already imports (`readdir`, `rm`, `join`, `pathExists`,
+ * `copyDirectoryAtomically`). Skills live at `$HOME/.agents/skills` inside a
+ * just-bash root, so the session keeps the same path relative to its `fs`
+ * directory as the template; the template's `fs` is scanned because `$HOME`
+ * is only known inside the sandbox.
+ */
+export const EVE_SANDBOX_RESUME_PATCH_HELPERS = `async function edenRefreshJustBashSessionSkills(e,t){let n=await edenFindTemplateSkillsRelativePath(join(e,"fs"));if(n===void 0)return;let r=join(t,"fs",n);await rm(r,{force:!0,recursive:!0}),await copyDirectoryAtomically(join(e,"fs",n),r)}
+async function edenFindTemplateSkillsRelativePath(e){let t=[["",0]];for(;t.length>0;){let n=t.shift(),r=n[0],i=n[1];if(i>3)continue;let a=[];try{a=await readdir(join(e,r),{withFileTypes:!0})}catch{a=[]}for(let o of a){if(!o.isDirectory())continue;let s=r===""?o.name:r+"/"+o.name;if(o.name===".agents")return await pathExists(join(e,s,"skills"))?s+"/skills":void 0;t.push([s,i+1])}}return void 0}
+`;
+/**
+ * The CommonJS patcher the isolated builder runs between the frozen install
+ * and `eve build` (and again for the production reinstall). It never touches
+ * project files, applies only against the known sha256, verifies the
+ * replacement matched exactly once, validates the result with `node --check`,
+ * and breaks hardlinks by writing a temp file and renaming it into place.
+ */
+export const EVE_SANDBOX_RESUME_PATCH_SCRIPT = `// Eden temporary fix for https://github.com/vercel/eve/issues/4440: Eve's
+// just-bash provider permanently refuses to resume a conversation after the
+// sandbox template changes (skills, agent/sandbox/workspace/, sandbox
+// definition) and never falls back. This rewrites one file in the installed
+// Eve copy so an existing session reopens against the current template. It
+// runs only against the sha256 Eden knows and is removed once upstream
+// ships the fix.
+const fs = require("node:fs");
+const path = require("node:path");
+const crypto = require("node:crypto");
+const { spawnSync } = require("node:child_process");
+const KNOWN_SHA256 = ${JSON.stringify(EVE_SANDBOX_RESUME_PATCH_KNOWN_SHA256)};
+const SIGNATURE = ${JSON.stringify(EVE_SANDBOX_RESUME_PATCH_SIGNATURE)};
+const BINDING_PATH = ${JSON.stringify(EVE_JUST_BASH_BINDING_PATH)};
+const ORIGINAL = ${JSON.stringify(EVE_JUST_BASH_RESUME_ORIGINAL)};
+const PATCHED_RESUME = ${JSON.stringify(EVE_SANDBOX_RESUME_PATCHED)};
+const HELPERS = ${JSON.stringify(EVE_SANDBOX_RESUME_PATCH_HELPERS)};
+function finish(outcome, detail) {
+  console.log("eden-eve-sandbox-resume-patch: " + outcome + " (" + detail + ")");
+}
+let packageJsonPath;
+try {
+  packageJsonPath = fs.realpathSync("node_modules/eve/package.json");
+} catch {
+  finish("absent", "no project-local eve package to patch");
+  process.exit(0);
+}
+const binding = path.join(path.dirname(packageJsonPath), BINDING_PATH);
+let source;
+try {
+  source = fs.readFileSync(binding, "utf8");
+} catch {
+  finish("absent", "this eve build has no just-bash binding");
+  process.exit(0);
+}
+if (source.includes(SIGNATURE)) {
+  finish("applied", "already patched");
+  process.exit(0);
+}
+const digest = crypto.createHash("sha256").update(source).digest("hex");
+if (digest !== KNOWN_SHA256) {
+  finish("skipped", "sha256 " + digest + " is not a version Eden knows (eve#4440)");
+  process.exit(0);
+}
+const first = source.indexOf(ORIGINAL);
+if (first === -1 || source.indexOf(ORIGINAL, first + 1) !== -1) {
+  console.error("eden-eve-sandbox-resume-patch: the known resume implementation did not match exactly once; refusing to patch");
+  process.exit(1);
+}
+const patched = source.slice(0, first) + PATCHED_RESUME +
+  source.slice(first + ORIGINAL.length) + "\\n" + HELPERS + "\\n";
+const temporary = binding + ".tmp.js";
+fs.rmSync(temporary, { force: true });
+fs.writeFileSync(temporary, patched);
+const parsed = spawnSync(process.execPath, ["--check", temporary], { encoding: "utf8" });
+if (parsed.status !== 0) {
+  fs.rmSync(temporary, { force: true });
+  console.error("eden-eve-sandbox-resume-patch: the patched file failed node --check; refusing to install it" + (typeof parsed.stderr === "string" ? "\\n" + parsed.stderr : ""));
+  process.exit(1);
+}
+// Rename (not write) so any hardlink to the original inode is broken.
+fs.renameSync(temporary, binding);
+finish("applied", "temporary eve#4440 fix written into the isolated builder image");
+`;
+/** The heredoc COPY + RUN inserted after each frozen install in the builder. */
+const EVE_SANDBOX_RESUME_PATCH_DOCKERFILE_STEP = `COPY <<'EDEN_EVE_PATCH_EOF' /tmp/eden-eve-sandbox-resume-patch.cjs
+${EVE_SANDBOX_RESUME_PATCH_SCRIPT}EDEN_EVE_PATCH_EOF
+RUN node /tmp/eden-eve-sandbox-resume-patch.cjs
+`;
 const INSTALL_COMMAND = [
     "corepack",
     "pnpm",
@@ -34,14 +152,6 @@ const INSTALL_COMMAND = [
     "--frozen-lockfile",
 ];
 const BUILD_COMMAND = ["./node_modules/.bin/eve", "build"];
-const START_COMMAND = [
-    "./node_modules/.bin/eve",
-    "start",
-    "--host",
-    "0.0.0.0",
-    "--port",
-    "8080",
-];
 const EVE_ENTRYPOINT = ".output/server/index.mjs";
 const EVE_EXCLUDED_DIRECTORY_NAMES = new Set([
     ".eden",
@@ -78,27 +188,45 @@ const EVE_COMPETING_LOCKFILES = new Set([
     "package-lock.json",
     "yarn.lock",
 ]);
-const HOST_ENVIRONMENT = {
-    HOST: "0.0.0.0",
-    NITRO_HOST: "0.0.0.0",
-    PORT: "8080",
-    NITRO_PORT: "8080",
-    NODE_ENV: "production",
-};
-function sha256(value) {
+export function sha256(value) {
     return createHash("sha256").update(value).digest("hex");
 }
-function jsonBytes(value) {
+export function jsonBytes(value) {
     return Buffer.from(`${JSON.stringify(value)}\n`, "utf8");
 }
-function isWithin(root, candidate) {
+export function isWithin(root, candidate) {
     const normalizedRoot = root.endsWith("/") ? root.slice(0, -1) : root;
     return candidate === normalizedRoot ||
         candidate.startsWith(`${normalizedRoot}/`);
 }
-function safeRelativePath(root, candidate) {
+export function safeRelativePath(root, candidate) {
     return relative(root, candidate).split("\\").join("/");
 }
+export const IMAGE_ID_PATTERN = /^sha256:[0-9a-f]{64}$/u;
+const NODE_IMAGE_PATTERN = /^node:24\.17\.0(?:-[a-z0-9][a-z0-9._-]*)?$/u;
+export function imageReference(nodeImage, reason, remediation) {
+    if (!NODE_IMAGE_PATTERN.test(nodeImage.reference) ||
+        !IMAGE_ID_PATTERN.test(nodeImage.digest)) {
+        throw new EvePackagingError({
+            code: "DOCKER_PLATFORM_BLOCKED",
+            subject: "node-24-image",
+            reason,
+            remediation,
+        });
+    }
+    return `${nodeImage.reference}@${nodeImage.digest}`;
+}
+function safeDockerEnvironment() {
+    return {
+        PATH: process.env.PATH,
+        HOME: process.env.HOME,
+        TMPDIR: process.env.TMPDIR,
+        LANG: process.env.LANG,
+        LC_ALL: process.env.LC_ALL,
+        DOCKER_HOST: process.env.DOCKER_HOST,
+        DOCKER_CONTEXT: process.env.DOCKER_CONTEXT,
+    };
+}
 function isAllowedSystemAlias(path) {
     const normalized = resolve(path);
     return normalized === "/var" || normalized === "/tmp";
@@ -770,6 +898,10 @@ async function verifySnapshotInputs(snapshotRoot, inputs) {
             if (firstSegment !== undefined && generatedRoots.has(firstSegment)) {
                 continue;
             }
+            if (relativePath === EVE_SANDBOX_CACHE_ROOT ||
+                relativePath.startsWith(`${EVE_SANDBOX_CACHE_ROOT}/`)) {
+                continue;
+            }
             const candidate = join(directory, entry.name);
             if (entry.isSymbolicLink() || !entry.isDirectory()) {
                 if (!entry.isFile() || entry.isSymbolicLink()) {
@@ -928,16 +1060,7 @@ export async function eveSnapshotSourceEntries(snapshotRoot) {
     return names;
 }
 async function writeDockerBuildFiles(options) {
-    if (!/^sha256:[0-9a-f]{64}$/u.test(options.nodeImage.digest) ||
-        !/^node:24\.17\.0(?:-[a-z0-9][a-z0-9._-]*)?$/u.test(options.nodeImage.reference)) {
-        throw new EvePackagingError({
-            code: "DOCKER_PLATFORM_BLOCKED",
-            subject: "node-24-image",
-            reason: "The Linux/amd64 builder requires an immutable Node 24 image digest.",
-            remediation: "Supply a verified Node 24 image reference and sha256 digest.",
-        });
-    }
-    const image = `${options.nodeImage.reference}@${options.nodeImage.digest}`;
+    const image = imageReference(options.nodeImage, "The Linux/amd64 builder requires an immutable Node 24 image digest.", "Supply a verified Node 24 image reference and sha256 digest.");
     const installSources = ["package.json", "pnpm-lock.yaml"];
     if ((await lstat(join(options.snapshotRoot, "pnpm-workspace.yaml"))
         .catch(() => undefined))?.isFile() === true) {
@@ -956,16 +1079,18 @@ RUN corepack enable \\
   && test "$(sha256sum pnpm-lock.yaml | cut -d ' ' -f1)" = "${options.lockfileSha256}" \\
   && corepack pnpm install --frozen-lockfile --config.node-linker=hoisted --config.strict-dep-builds=false \\
   && ${IGNORED_BUILDS_GUARD}
-RUN test "$(sha256sum pnpm-lock.yaml | cut -d ' ' -f1)" = "${options.lockfileSha256}"
+${EVE_SANDBOX_RESUME_PATCH_DOCKERFILE_STEP}RUN test "$(sha256sum pnpm-lock.yaml | cut -d ' ' -f1)" = "${options.lockfileSha256}"
 COPY . ./
 RUN test -x ./node_modules/.bin/eve \\
-  && ./node_modules/.bin/eve build
+  && ./node_modules/.bin/eve build \\
+  && mkdir -p .eve/sandbox-cache
 
 FROM builder AS runtime-deps
 RUN rm -rf node_modules \\
   && corepack pnpm install --frozen-lockfile --prod --config.node-linker=hoisted --config.strict-dep-builds=false \\
   && ${IGNORED_BUILDS_GUARD} \\
   && for l in node_modules/.bin/*; do t=$(readlink "$l") || continue; case "$t" in /*) ln -sfn "$(realpath --relative-to=node_modules/.bin "$t")" "$l" ;; esac; done
+${EVE_SANDBOX_RESUME_PATCH_DOCKERFILE_STEP}
 
 FROM --platform=linux/amd64 ${image} AS runtime
 WORKDIR /app
@@ -975,6 +1100,12 @@ ENV HOST=0.0.0.0 \\
     NITRO_PORT=8080 \\
     NODE_ENV=production
 COPY --from=builder /workspace/.output /app/.output
+# Eve's prepared just-bash sandbox template: the builder stage's eve build
+# prewarm wrote it under /workspace/.eve/sandbox-cache, and the runtime sandbox
+# resolves it at /app/.eve/sandbox-cache (bash/read_file/write_file fail
+# without it). The mkdir in the build step guarantees the source exists even
+# when this Eve build prepared no template.
+COPY --from=builder /workspace/.eve/sandbox-cache /app/.eve/sandbox-cache
 ${runtimeSourceCopies}
 COPY --from=runtime-deps /workspace/node_modules /app/node_modules
 EXPOSE 8080
@@ -1221,10 +1352,123 @@ async function scanGeneratedOutput(snapshotRoot) {
         fileCount: files.length,
     };
 }
+/**
+ * A generous sanity bound for the prepared sandbox-template tree (templates
+ * carry the sandbox filesystem seeds and authored skills; the minimal Eve
+ * fixture produces ~1 KiB). Anything larger means the builder extracted more
+ * than Eve's build-time prewarm could have written.
+ */
+const EVE_SANDBOX_CACHE_MAX_BYTES = 64 * 1024 * 1024;
+/**
+ * Validates the prepared sandbox-template tree the builder extracted into
+ * `<snapshot>/.eve/sandbox-cache` with the same rigor as `.output`: regular
+ * files and directories only, no symbolic links, no special files, stable
+ * reads inside the immutable snapshot, and a total-size sanity bound.
+ * Returns `null` when this Eve build prepared no sandbox template.
+ */
+async function scanGeneratedSandboxCache(snapshotRoot) {
+    const cacheRoot = join(snapshotRoot, EVE_SANDBOX_CACHE_ROOT);
+    const rootDetails = await lstat(cacheRoot).catch(() => undefined);
+    if (rootDetails === undefined)
+        return null;
+    const rootCanonical = await realpath(cacheRoot).catch(() => undefined);
+    if (!rootDetails.isDirectory() ||
+        rootDetails.isSymbolicLink() ||
+        rootCanonical === undefined ||
+        !isWithin(snapshotRoot, resolve(rootCanonical))) {
+        throw new EvePackagingError({
+            code: "UNSUPPORTED_EVE_OUTPUT",
+            subject: EVE_SANDBOX_CACHE_ROOT,
+            reason: "The prepared sandbox template root is missing, a symbolic link, or escapes the immutable snapshot.",
+            remediation: "Rebuild the candidate so the isolated builder extracts a regular .eve/sandbox-cache directory.",
+        });
+    }
+    const files = [];
+    let totalBytes = 0;
+    const visit = async (directory, relativeDirectory) => {
+        const directoryDetails = await lstat(directory).catch(() => undefined);
+        const directoryCanonical = await realpath(directory).catch(() => undefined);
+        if (directoryDetails === undefined ||
+            !directoryDetails.isDirectory() ||
+            directoryDetails.isSymbolicLink() ||
+            directoryCanonical === undefined ||
+            !isWithin(snapshotRoot, resolve(directoryCanonical))) {
+            throw new EvePackagingError({
+                code: "UNSUPPORTED_EVE_OUTPUT",
+                subject: relativeDirectory,
+                reason: "The prepared sandbox template tree escaped or changed during validation.",
+                remediation: "Rebuild the candidate so the isolated builder extracts regular template files.",
+            });
+        }
+        const entries = await readdir(directory, { withFileTypes: true });
+        entries.sort((left, right) => left.name.localeCompare(right.name));
+        for (const entry of entries) {
+            const relativePath = relativeDirectory.length === 0
+                ? entry.name
+                : `${relativeDirectory}/${entry.name}`;
+            const candidate = join(directory, entry.name);
+            if (entry.isSymbolicLink()) {
+                throw new EvePackagingError({
+                    code: "UNSUPPORTED_EVE_OUTPUT",
+                    subject: `${EVE_SANDBOX_CACHE_ROOT}/${relativePath}`,
+                    reason: "The prepared sandbox template tree contains a symbolic link.",
+                    remediation: "Rebuild the candidate so the isolated builder extracts regular template files only.",
+                });
+            }
+            if (entry.isDirectory()) {
+                await visit(candidate, relativePath);
+                continue;
+            }
+            if (!entry.isFile()) {
+                throw new EvePackagingError({
+                    code: "UNSUPPORTED_EVE_OUTPUT",
+                    subject: `${EVE_SANDBOX_CACHE_ROOT}/${relativePath}`,
+                    reason: "The prepared sandbox template tree contains a device, socket, FIFO, or other unsupported file.",
+                    remediation: "Rebuild the candidate so the isolated builder extracts regular template files only.",
+                });
+            }
+            let stable;
+            try {
+                stable = await readStableFile(candidate, snapshotRoot);
+            }
+            catch {
+                throw new EvePackagingError({
+                    code: "UNSUPPORTED_EVE_OUTPUT",
+                    subject: `${EVE_SANDBOX_CACHE_ROOT}/${relativePath}`,
+                    reason: "The prepared sandbox template file is unreadable or changed during validation.",
+                    remediation: "Rebuild the candidate so the isolated builder extracts a stable template tree.",
+                });
+            }
+            totalBytes += stable.bytes.byteLength;
+            if (totalBytes > EVE_SANDBOX_CACHE_MAX_BYTES) {
+                throw new EvePackagingError({
+                    code: "UNSUPPORTED_EVE_OUTPUT",
+                    subject: EVE_SANDBOX_CACHE_ROOT,
+                    reason: `The prepared sandbox template tree exceeds the ${EVE_SANDBOX_CACHE_MAX_BYTES}-byte sanity bound.`,
+                    remediation: "Rebuild the candidate; the extracted template tree must contain only Eve's prepared templates.",
+                });
+            }
+            files.push({
+                relativePath: `${EVE_SANDBOX_CACHE_ROOT}/${relativePath}`,
+                sha256: stable.sha256,
+                byteLength: stable.bytes.byteLength,
+            });
+        }
+    };
+    await visit(cacheRoot, "");
+    return {
+        present: true,
+        root: EVE_SANDBOX_CACHE_ROOT,
+        outputDigest: sha256(jsonBytes(files)),
+        fileCount: files.length,
+        totalBytes,
+    };
+}
 async function assertGeneratedTreesExcludeSecrets(snapshotRoot) {
     const roots = [
         join(snapshotRoot, "node_modules"),
         join(snapshotRoot, ".output"),
+        join(snapshotRoot, EVE_SANDBOX_CACHE_ROOT),
     ];
     const visit = async (directory, relativeDirectory) => {
         const directoryDetails = await lstat(directory).catch(() => undefined);
@@ -1301,7 +1545,7 @@ async function assertGeneratedTreesExcludeSecrets(snapshotRoot) {
         }
     }
 }
-function safeError(error) {
+export function safeError(error) {
     return {
         code: error.code,
         subject: error.subject,
@@ -1447,12 +1691,11 @@ function blockedResult(error, extra = {}) {
         status: "blocked",
         returnCode: error.code,
         deployable: false,
-        project: extra.project ?? null,
+        project: null,
         candidate: null,
         snapshot: null,
         toolchain: null,
         image: null,
-        runtime: null,
         secrets: {
             runtimeVariableNames: [],
             valuesRecorded: false,
@@ -1464,19 +1707,39 @@ function blockedResult(error, extra = {}) {
             excludedFromManifestsAndLogs: true,
             redactionRegisteredBeforeChildren: false,
         },
-        checks: extra.checks ?? [{
+        checks: [{
                 id: error.code,
                 status: "blocked",
                 subject: error.subject,
                 reason: error.message,
                 remediation: error.remediation,
             }],
+        sandboxResumePatch: "absent",
         candidateImageId: null,
         candidateImageRetainedLocally: false,
         writtenPaths: extra.writtenPaths ?? [],
         error: safeError(error),
     };
 }
+/**
+ * Decides the sandbox-resume patch outcome from the `node_modules` the
+ * builder copied out of the finished image: the shipped just-bash binding is
+ * the single source of truth and stays correct under Docker layer caching
+ * (a cached patch step still ships the patched file). Reading never throws —
+ * an unreadable tree counts as `absent`.
+ */
+async function detectEveSandboxResumePatch(snapshotRoot) {
+    try {
+        const packageJsonPath = await realpath(join(snapshotRoot, "node_modules/eve/package.json"));
+        const binding = await readFile(join(dirname(packageJsonPath), EVE_JUST_BASH_BINDING_PATH), "utf8");
+        return binding.includes(EVE_SANDBOX_RESUME_PATCH_SIGNATURE)
+            ? "applied"
+            : "skipped";
+    }
+    catch {
+        return "absent";
+    }
+}
 async function currentInputIdentity(runtimeConfig) {
     const token = (value) => {
         if (typeof value === "string")
@@ -1743,7 +2006,9 @@ export async function buildEveProjectSnapshot(options) {
             return blockedResult(cleanupError ?? dependencyError, { writtenPaths });
         }
         const eve = await resolveProjectLocalEve(snapshotRoot);
+        const sandboxResumePatch = await detectEveSandboxResumePatch(snapshotRoot);
         const output = await scanGeneratedOutput(snapshotRoot);
+        const sandboxCache = await scanGeneratedSandboxCache(snapshotRoot);
         await assertGeneratedTreesExcludeSecrets(snapshotRoot);
         const snapshotSourceDigest = await snapshotDigest(snapshotRoot);
         const runtimeManifestPath = join(generationRoot, "runtime-manifest.json");
@@ -1758,6 +2023,7 @@ export async function buildEveProjectSnapshot(options) {
             sourceDigest: initialInputs.sourceDigest,
             snapshotDigest: snapshotSourceDigest,
             generatedOutput: output,
+            sandboxCache,
             artifactPath: EVE_ENTRYPOINT,
             platform: "linux/amd64",
             runtimeVariableNames,
@@ -1791,10 +2057,8 @@ export async function buildEveProjectSnapshot(options) {
             excludedCategories: [...new Set(initialInputs.excludedRelativePaths.map((path) => isPathExcluded(path, undefined).category ?? "generated-state"))].sort(),
             sourceRaceChecked: true,
         };
-        if ((buildResult.imageId !== undefined &&
-            !/^sha256:[0-9a-f]{64}$/u.test(buildResult.imageId)) ||
-            (buildResult.imageId !== undefined &&
-                buildResult.imagePlatform !== "linux/amd64")) {
+        if (buildResult.imageId !== undefined &&
+            !IMAGE_ID_PATTERN.test(buildResult.imageId)) {
             const imageError = new EvePackagingError({
                 code: "DOCKER_PLATFORM_BLOCKED",
                 subject: "linux/amd64 image",
@@ -1835,6 +2099,7 @@ export async function buildEveProjectSnapshot(options) {
             sourceDigest: initialInputs.sourceDigest,
             snapshotDigest: snapshotSourceDigest,
             generatedOutput: output,
+            sandboxCache,
             ...(initialRuntimeInputIdentity === undefined
                 ? {}
                 : { runtimeConfigInputIdentity: initialRuntimeInputIdentity }),
@@ -1868,7 +2133,6 @@ export async function buildEveProjectSnapshot(options) {
             },
             image,
             candidate,
-            runtime: null,
             secrets: {
                 runtimeVariableNames,
                 valuesRecorded: false,
@@ -1916,7 +2180,17 @@ export async function buildEveProjectSnapshot(options) {
                     reason: "The resolved Eve executable is inside the isolated project dependency tree.",
                     remediation: null,
                 },
+                ...(sandboxResumePatch === "applied"
+                    ? [{
+                            id: "EVE_SANDBOX_RESUME_PATCH",
+                            status: "pass",
+                            subject: "eve-sandbox-resume",
+                            reason: "applied temporary fix for eve#4440",
+                            remediation: null,
+                        }]
+                    : []),
             ],
+            sandboxResumePatch,
             candidateImageId: buildResult.imageId ?? null,
             candidateImageRetainedLocally: buildResult.imageId !== undefined,
             writtenPaths,
@@ -2049,15 +2323,7 @@ export function createDockerEveProjectBuilder(options) {
                 });
             }
             const imageIdFile = join(request.generationRoot, "image-id");
-            const safeEnv = {
-                PATH: process.env.PATH,
-                HOME: process.env.HOME,
-                TMPDIR: process.env.TMPDIR,
-                LANG: process.env.LANG,
-                LC_ALL: process.env.LC_ALL,
-                DOCKER_HOST: process.env.DOCKER_HOST,
-                DOCKER_CONTEXT: process.env.DOCKER_CONTEXT,
-            };
+            const safeEnv = safeDockerEnvironment();
             let containerId;
             let imageBuilt = false;
             let retainImage = false;
@@ -2100,7 +2366,7 @@ export function createDockerEveProjectBuilder(options) {
                 ], { env: safeEnv, cwd: request.generationRoot, maxBuffer: 1024 * 1024 });
                 imageBuilt = true;
                 builtImageId = (await readFile(imageIdFile, "utf8")).trim();
-                if (!/^sha256:[0-9a-f]{64}$/u.test(builtImageId)) {
+                if (!IMAGE_ID_PATTERN.test(builtImageId)) {
                     throw new EvePackagingError({
                         code: "DOCKER_PLATFORM_BLOCKED",
                         subject: "image identity",
@@ -2139,6 +2405,30 @@ export function createDockerEveProjectBuilder(options) {
                 }
                 await execFileAsync(dockerCommand, ["cp", `${containerId}:/app/.output`, join(request.snapshotRoot, ".output")], { env: safeEnv, cwd: request.generationRoot });
                 await execFileAsync(dockerCommand, ["cp", `${containerId}:/app/node_modules`, join(request.snapshotRoot, "node_modules")], { env: safeEnv, cwd: request.generationRoot });
+                // The builder stage's `eve build` prewarm writes the just-bash sandbox
+                // template under its workdir; the runtime stage copies it to
+                // /app/.eve/sandbox-cache (the mkdir in the Dockerfile guarantees the
+                // path exists). Extract exactly that subtree so runtime sandboxes can
+                // resolve their template; never the rest of `.eve` (sessions, locks,
+                // builds). Treated as absent when the container has no such path.
+                const sandboxCacheTarget = join(request.snapshotRoot, EVE_SANDBOX_CACHE_ROOT);
+                await ensureSnapshotDirectory(request.snapshotRoot, dirname(sandboxCacheTarget));
+                try {
+                    await execFileAsync(dockerCommand, ["cp", `${containerId}:/app/${EVE_SANDBOX_CACHE_ROOT}`, sandboxCacheTarget], { env: safeEnv, cwd: request.generationRoot });
+                }
+                catch (error) {
+                    const stderr = typeof error === "object" &&
+                        error !== null &&
+                        "stderr" in error &&
+                        typeof error.stderr === "string"
+                        ? error.stderr
+                        : "";
+                    if (!/(?:could not find|no such|not found|does not exist)/iu.test(stderr)) {
+                        throw error;
+                    }
+                    // Absent: remove the `.eve` parent this extraction created.
+                    await rm(dirname(sandboxCacheTarget), { recursive: true, force: true }).catch(() => undefined);
+                }
                 const result = {
                     imageId: builtImageId,
                     imagePlatform: "linux/amd64",
@@ -2174,15 +2464,7 @@ export function createDockerEveProjectBuilder(options) {
             const imageReference = result.imageReference;
             if (imageReference === undefined)
                 return;
-            const safeEnv = {
-                PATH: process.env.PATH,
-                HOME: process.env.HOME,
-                TMPDIR: process.env.TMPDIR,
-                LANG: process.env.LANG,
-                LC_ALL: process.env.LC_ALL,
-                DOCKER_HOST: process.env.DOCKER_HOST,
-                DOCKER_CONTEXT: process.env.DOCKER_CONTEXT,
-            };
+            const safeEnv = safeDockerEnvironment();
             await execFileAsync(dockerCommand, ["image", "rm", "--force", imageReference], { env: safeEnv });
             const remainingImage = await execFileAsync(dockerCommand, ["image", "inspect", imageReference, "--format", "{{.Id}}"], { env: safeEnv }).catch(() => undefined);
             if (remainingImage !== undefined && remainingImage.stdout.trim().length > 0) {

package/dist/eve-runtime-config.d.ts

@@ -1,6 +1,13 @@
 export declare const EVE_RESERVED_HOST_VARIABLES: readonly ["HOST", "NITRO_HOST", "PORT", "NITRO_PORT", "NODE_ENV", "NODE_EXTRA_CA_CERTS", "WORKFLOW_LOCAL_BASE_URL", "EDEN_WORLD_URL", "EDEN_EVE_DEPLOYMENT_ID", "EDEN_EVE_GENERATION_ID"];
 export type EveReservedHostVariable = (typeof EVE_RESERVED_HOST_VARIABLES)[number];
 export declare const EVE_START_COMMAND: readonly ["./node_modules/.bin/eve", "start", "--host", "0.0.0.0", "--port", "8080"];
+export declare const EVE_HOST_ENVIRONMENT: Readonly<{
+    readonly HOST: "0.0.0.0";
+    readonly NITRO_HOST: "0.0.0.0";
+    readonly PORT: "8080";
+    readonly NITRO_PORT: "8080";
+    readonly NODE_ENV: "production";
+}>;
 type EveRuntimeValueMap = Readonly<Record<string, string>>;
 export type EveRuntimeConfigErrorCode = "EVE_ENV_FILE_NOT_FOUND" | "EVE_ENV_FILE_INVALID" | "EVE_ENV_FILE_UNREADABLE" | "EVE_ENV_FILE_ENCODING" | "EVE_ENV_FILE_MALFORMED" | "EVE_ENV_FILE_DUPLICATE" | "EVE_ENV_RESERVED_VARIABLE" | "EVE_ENV_FILE_RACE" | "EVE_RUNTIME_INJECTION_INVALID" | "EVE_RUNTIME_PROTECTED_STORE_UNAVAILABLE" | "EVE_RUNTIME_PROTECTED_UPLOAD_FAILED" | "EVE_RUNTIME_LOCAL_INJECTION_UNSUPPORTED";
 export declare class EveRuntimeConfigError extends Error {
@@ -119,8 +126,6 @@ export declare class EveRuntimeConfig {
 export declare function readEveRuntimeConfig(inputPath: string, options?: {
     readonly cwd?: string;
 }): Promise<EveRuntimeConfig>;
-export declare const parseEveRuntimeConfig: typeof readEveRuntimeConfig;
-export declare const loadEveRuntimeConfig: typeof readEveRuntimeConfig;
 export declare function prepareEveRuntimeInjection(config: EveRuntimeConfig, options: EveRuntimeInjectionOptions): Promise<EveRuntimeInjection>;
 export {};
 //# sourceMappingURL=eve-runtime-config.d.ts.map

package/dist/eve-runtime-config.js

@@ -21,6 +21,13 @@ export const EVE_START_COMMAND = Object.freeze([
     "--port",
     "8080",
 ]);
+export const EVE_HOST_ENVIRONMENT = Object.freeze({
+    HOST: "0.0.0.0",
+    NITRO_HOST: "0.0.0.0",
+    PORT: "8080",
+    NITRO_PORT: "8080",
+    NODE_ENV: "production",
+});
 const EVE_ENVIRONMENT_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/u;
 const EVE_RUNTIME_METADATA_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/u;
 const EVE_ENV_FILE_SOURCE = "--env-file";
@@ -323,8 +330,6 @@ export async function readEveRuntimeConfig(inputPath, options = {}) {
     activeRedactionRegistries.add(redaction);
     return EveRuntimeConfig.from(observation, values, redaction);
 }
-export const parseEveRuntimeConfig = readEveRuntimeConfig;
-export const loadEveRuntimeConfig = readEveRuntimeConfig;
 function validateProtectedPutResult(result) {
     if (typeof result !== "object" ||
         result === null ||