@moinulmoin/eden 0.5.0 → 0.7.0

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

@@ -1,14 +1,6 @@
 import { type EveNodeImage, type EvePackagingCheck, type EvePackagingCode, type EveProjectBuildCandidate, type EveProjectOutput } from "./eve-packaging.js";
-import type { EveRuntimeInjection } from "./eve-runtime-config.js";
-declare const START_COMMAND: readonly ["./node_modules/.bin/eve", "start", "--host", "0.0.0.0", "--port", "8080"];
+import { EVE_HOST_ENVIRONMENT as HOST_ENVIRONMENT, EVE_START_COMMAND as START_COMMAND, type EveRuntimeInjection } from "./eve-runtime-config.js";
 declare const HEALTH_PATH: "/eve/v1/health";
-declare const HOST_ENVIRONMENT: {
-    readonly HOST: "0.0.0.0";
-    readonly NITRO_HOST: "0.0.0.0";
-    readonly PORT: "8080";
-    readonly NITRO_PORT: "8080";
-    readonly NODE_ENV: "production";
-};
 export interface EveHostRequirements {
     readonly architecture: string;
     readonly world: "supported" | "unsupported" | "unknown";
@@ -39,6 +31,17 @@ export interface EveRuntimeClosure {
     readonly nativeModules: readonly EveRuntimeNativeModule[];
     readonly eveStartClosureRetained: true;
     readonly builderOnlyMaterialExcluded: true;
+    /**
+     * The prepared sandbox-template tree shipped at
+     * `/workspace/.eve/sandbox-cache`. Present only when this Eve build
+     * prepared a sandbox template; without it Eve's sandbox tools fail on the
+     * deployed agent.
+     */
+    readonly sandboxTemplate?: {
+        readonly root: "/workspace/.eve/sandbox-cache";
+        readonly digest: string;
+        readonly files: readonly EveRuntimeClosureFile[];
+    };
 }
 export interface EveRuntimeImage extends EveRuntimeImageMetadata {
     readonly runtimeClosure: EveRuntimeClosure;

package/dist/eve-runtime-image.js

@@ -1,22 +1,12 @@
-import { createHash, } from "node:crypto";
 import { execFile, } from "node:child_process";
 import { cp, lstat, mkdir, readFile, readlink, readdir, realpath, rm, symlink, writeFile, } from "node:fs/promises";
 import { dirname, join, relative, resolve, } from "node:path";
 import { promisify, } from "node:util";
-import { EvePackagingError, eveSnapshotSourceEntries, } from "./eve-packaging.js";
+import { EvePackagingError, EVE_SANDBOX_CACHE_ROOT, eveSnapshotSourceEntries, imageReference as packagingImageReference, IMAGE_ID_PATTERN, isWithin, jsonBytes, safeError as errorRecord, safeRelativePath, sha256, } from "./eve-packaging.js";
+import { EVE_HOST_ENVIRONMENT as HOST_ENVIRONMENT, EVE_START_COMMAND as START_COMMAND, } from "./eve-runtime-config.js";
 const execFileAsync = promisify(execFile);
-const START_COMMAND = [
-    "./node_modules/.bin/eve",
-    "start",
-    "--host",
-    "0.0.0.0",
-    "--port",
-    "8080",
-];
 const HEALTH_PATH = "/eve/v1/health";
 const INTERNAL_PORT = 8080;
-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;
 const FORBIDDEN_RUNTIME_NAMES = new Set([
     ".env",
     ".env.local",
@@ -29,26 +19,6 @@ const FORBIDDEN_RUNTIME_NAMES = new Set([
     "credentials.json",
     "service-account.json",
 ]);
-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) {
-    return createHash("sha256").update(value).digest("hex");
-}
-function jsonBytes(value) {
-    return Buffer.from(`${JSON.stringify(value)}\n`, "utf8");
-}
-function isWithin(root, candidate) {
-    const normalizedRoot = root.endsWith("/") ? root.slice(0, -1) : root;
-    return candidate === normalizedRoot || candidate.startsWith(`${normalizedRoot}/`);
-}
-function safeRelativePath(root, candidate) {
-    return relative(root, candidate).split("\\").join("/");
-}
 async function assertFreshOwnedFilePath(path, root, subject) {
     const canonicalRoot = await realpath(root).catch(() => undefined);
     const canonicalParent = await realpath(dirname(path)).catch(() => undefined);
@@ -77,16 +47,7 @@ async function verifyOwnedFilePath(path, root, expectedParent, subject) {
     }
 }
 function imageReference(nodeImage) {
-    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: "The runtime image requires an immutable Linux/amd64 Node 24 image.",
-            remediation: "Supply the verified Node 24 image reference and sha256 digest.",
-        });
-    }
-    return `${nodeImage.reference}@${nodeImage.digest}`;
+    return packagingImageReference(nodeImage, "The runtime image requires an immutable Linux/amd64 Node 24 image.", "Supply the verified Node 24 image reference and sha256 digest.");
 }
 function packagingError(code, subject, reason, remediation) {
     return new EvePackagingError({
@@ -331,6 +292,34 @@ async function validateCandidateClosure(candidate) {
         captureRuntimeTree(outputRoot, snapshotRoot, "output"),
         captureRuntimeTree(dependenciesRoot, snapshotRoot, "dependencies"),
     ]);
+    const sandboxCacheRoot = join(snapshotRoot, EVE_SANDBOX_CACHE_ROOT);
+    const sandboxCacheDetails = await lstat(sandboxCacheRoot).catch(() => undefined);
+    let sandbox;
+    if (candidate.sandboxCache?.present === true) {
+        if (sandboxCacheDetails === undefined ||
+            !sandboxCacheDetails.isDirectory() ||
+            sandboxCacheDetails.isSymbolicLink()) {
+            throw packagingError("RUNTIME_CLOSURE_INCOMPLETE", EVE_SANDBOX_CACHE_ROOT, "The candidate records a prepared sandbox template but its tree is missing or not a regular directory.", "Regenerate the candidate so the isolated builder extracts .eve/sandbox-cache into the immutable snapshot.");
+        }
+        const capturedSandbox = await captureRuntimeTree(sandboxCacheRoot, snapshotRoot, "sandbox-template");
+        const sandboxEvidence = capturedSandbox.files.map((file) => ({
+            relativePath: file.path,
+            sha256: file.sha256,
+            byteLength: file.byteLength,
+        }));
+        const sandboxTotalBytes = capturedSandbox.files
+            .filter((file) => !file.symbolicLink)
+            .reduce((sum, file) => sum + file.byteLength, 0);
+        if (capturedSandbox.files.length !== candidate.sandboxCache.fileCount ||
+            sandboxTotalBytes !== candidate.sandboxCache.totalBytes ||
+            sha256(jsonBytes(sandboxEvidence)) !== candidate.sandboxCache.outputDigest) {
+            throw packagingError("SOURCE_RACE", EVE_SANDBOX_CACHE_ROOT, "The prepared sandbox template no longer matches the immutable candidate evidence.", "Discard the mixed-generation runtime candidate and rebuild from a quiescent snapshot.");
+        }
+        sandbox = { digest: capturedSandbox.digest, files: capturedSandbox.files };
+    }
+    else if (sandboxCacheDetails !== undefined) {
+        throw packagingError("SOURCE_RACE", EVE_SANDBOX_CACHE_ROOT, "The candidate records no prepared sandbox template but the immutable snapshot contains one.", "Discard the mixed-generation runtime candidate and rebuild from a quiescent snapshot.");
+    }
     const entrypointBytes = await readRegularFile(entrypoint, snapshotRoot);
     const candidateOutputDigest = sha256(jsonBytes(output.files.map((file) => ({
         relativePath: file.path,
@@ -351,6 +340,7 @@ async function validateCandidateClosure(candidate) {
             outputDigest: output.digest,
             dependencyDigest: dependencies.digest,
         })),
+        ...(sandbox === undefined ? {} : { sandbox }),
     };
 }
 export async function revalidateEveRuntimeCandidate(candidate) {
@@ -364,6 +354,15 @@ export async function revalidateEveRuntimeCandidate(candidate) {
         nativeModules: closure.nativeModules,
         eveStartClosureRetained: true,
         builderOnlyMaterialExcluded: true,
+        ...(closure.sandbox === undefined
+            ? {}
+            : {
+                sandboxTemplate: {
+                    root: "/workspace/.eve/sandbox-cache",
+                    digest: closure.sandbox.digest,
+                    files: closure.sandbox.files,
+                },
+            }),
     };
 }
 /**
@@ -420,6 +419,12 @@ async function writeRuntimeContext(candidate, nodeImage, closure) {
     try {
         await cp(join(candidate.snapshotRoot, ".output"), join(runtimeContextPath, ".output"), { recursive: true });
         await cp(join(candidate.snapshotRoot, "node_modules"), join(runtimeContextPath, "node_modules"), { recursive: true });
+        const sandboxCacheSource = join(candidate.snapshotRoot, EVE_SANDBOX_CACHE_ROOT);
+        const sandboxCacheContext = join(runtimeContextPath, EVE_SANDBOX_CACHE_ROOT);
+        if (closure.sandbox !== undefined) {
+            await cp(sandboxCacheSource, sandboxCacheContext, { recursive: true });
+            await rewriteContextLinks(sandboxCacheSource, sandboxCacheContext);
+        }
         const sourceEntries = await eveSnapshotSourceEntries(candidate.snapshotRoot);
         for (const entry of sourceEntries) {
             await cp(join(candidate.snapshotRoot, entry), join(runtimeContextPath, entry), { recursive: true });
@@ -428,10 +433,20 @@ async function writeRuntimeContext(candidate, nodeImage, closure) {
         await rewriteContextLinks(join(candidate.snapshotRoot, ".output"), join(runtimeContextPath, ".output"));
         const copiedOutput = await captureRuntimeTree(join(runtimeContextPath, ".output"), runtimeContextPath, "output");
         const copiedDependencies = await captureRuntimeTree(join(runtimeContextPath, "node_modules"), runtimeContextPath, "dependencies");
+        const copiedSandbox = closure.sandbox === undefined
+            ? undefined
+            : await captureRuntimeTree(sandboxCacheContext, runtimeContextPath, "sandbox-template");
         if (copiedOutput.digest !== closure.outputDigest ||
-            copiedDependencies.digest !== closure.dependencyDigest) {
+            copiedDependencies.digest !== closure.dependencyDigest ||
+            (closure.sandbox !== undefined && copiedSandbox?.digest !== closure.sandbox.digest)) {
             throw packagingError("SOURCE_RACE", "runtime context", "The copied runtime context does not match the validated immutable closure.", "Discard the mixed-generation runtime context and rebuild from a quiescent candidate.");
         }
+        const sandboxContextCopy = closure.sandbox === undefined
+            ? ""
+            : `COPY ${JSON.stringify([EVE_SANDBOX_CACHE_ROOT, `/candidate/${EVE_SANDBOX_CACHE_ROOT}`])}\n`;
+        const sandboxImageCopy = closure.sandbox === undefined
+            ? ""
+            : `COPY --from=candidate ${JSON.stringify([`/candidate/${EVE_SANDBOX_CACHE_ROOT}`, `/workspace/${EVE_SANDBOX_CACHE_ROOT}`])}\n`;
         const sourceCopyLines = sourceEntries
             .map((entry) => `COPY --from=candidate ${JSON.stringify([`/candidate/${entry}`, `/workspace/${entry}`])}`)
             .join("\n");
@@ -440,7 +455,7 @@ FROM --platform=linux/amd64 ${imageReference(nodeImage)} AS candidate
 WORKDIR /candidate
 COPY .output /candidate/.output
 COPY node_modules /candidate/node_modules
-${sourceEntries.map((entry) => `COPY ${JSON.stringify([entry, `/candidate/${entry}`])}`).join("\n")}
+${sandboxContextCopy}${sourceEntries.map((entry) => `COPY ${JSON.stringify([entry, `/candidate/${entry}`])}`).join("\n")}
 
 FROM --platform=linux/amd64 ${imageReference(nodeImage)} AS runtime
 WORKDIR /workspace
@@ -452,7 +467,7 @@ ENV HOST=0.0.0.0 \\
     CBOR_NATIVE_ACCELERATION_DISABLED=true
 COPY --from=candidate /candidate/.output /workspace/.output
 COPY --from=candidate /candidate/node_modules /workspace/node_modules
-${sourceCopyLines}
+${sandboxImageCopy}${sourceCopyLines}
 EXPOSE 8080
 ENTRYPOINT ["./node_modules/.bin/eve", "start", "--host", "0.0.0.0", "--port", "8080"]
 `;
@@ -572,6 +587,55 @@ function runtimeContainerEnvironment(request) {
             : {}),
     };
 }
+/**
+ * Absolute `/workspace` sandbox-template paths recorded by `eve build` in the
+ * compiled `sandbox-prepared-artifacts.json` manifest. The boot probe asserts
+ * each recorded template exists inside the built image. Paths outside the
+ * sandbox cache, or containing anything unsafe to interpolate into a single
+ *-quoted shell word, are skipped (packaging validation already bounded the
+ * tree; this is an end-to-end existence proof).
+ */
+async function eveSandboxTemplateBootPaths(candidate) {
+    if (candidate.sandboxCache?.present !== true)
+        return [];
+    const bootPrefix = `/workspace/${EVE_SANDBOX_CACHE_ROOT}/`;
+    const paths = new Set();
+    let parsed;
+    try {
+        parsed = JSON.parse(await readFile(join(candidate.snapshotRoot, ".output/.eve/compile/sandbox-prepared-artifacts.json"), "utf8"));
+    }
+    catch {
+        return [];
+    }
+    if (typeof parsed !== "object" || parsed === null || !("entries" in parsed)) {
+        return [];
+    }
+    const entries = parsed.entries;
+    if (!Array.isArray(entries))
+        return [];
+    for (const entry of entries) {
+        if (typeof entry !== "object" || entry === null || !("artifact" in entry)) {
+            continue;
+        }
+        const artifact = entry.artifact;
+        if (typeof artifact !== "object" ||
+            artifact === null ||
+            !("templateRootPath" in artifact) ||
+            typeof artifact.templateRootPath !== "string") {
+            continue;
+        }
+        const templateRootPath = artifact.templateRootPath;
+        if (!templateRootPath.startsWith(bootPrefix) ||
+            templateRootPath.slice(bootPrefix.length).length === 0 ||
+            templateRootPath.slice(bootPrefix.length).split("/").includes("..") ||
+            templateRootPath.includes("'") ||
+            templateRootPath.includes("\\")) {
+            continue;
+        }
+        paths.add(templateRootPath);
+    }
+    return [...paths].sort();
+}
 function validateHealthPort(port) {
     if (!Number.isInteger(port) || port < 4310 || port > 4399) {
         throw packagingError("DOCKER_PLATFORM_BLOCKED", "health port", "The local Eve health probe must use a task-owned host port in 4310-4399.", "Choose an unused task-owned host port between 4310 and 4399.");
@@ -822,14 +886,6 @@ async function pollEveHealth(port, timeoutMs, pollIntervalMs, fetchHealth) {
     }
     throw packagingError("EVE_HEALTH_FAILED", HEALTH_PATH, `The real Eve health route did not report ready before the bounded deadline (last status: ${lastStatus}).`, "Inspect the project-local eve start supervisor, Nitro child, sandbox prewarm, and Workflow World startup without replacing them with a synthetic listener.");
 }
-function errorRecord(error) {
-    return {
-        code: error.code,
-        subject: error.subject,
-        reason: error.message,
-        remediation: error.remediation,
-    };
-}
 function blockedResult(candidate, error, cleanup, writtenPaths) {
     return {
         schemaVersion: 1,
@@ -905,8 +961,12 @@ export async function buildEveRuntimeImage(request) {
         ]);
         const postBuildOutput = await captureRuntimeTree(join(context.runtimeContextPath, ".output"), context.runtimeContextPath, "output");
         const postBuildDependencies = await captureRuntimeTree(join(context.runtimeContextPath, "node_modules"), context.runtimeContextPath, "dependencies");
+        const postBuildSandbox = closure.sandbox === undefined
+            ? undefined
+            : await captureRuntimeTree(join(context.runtimeContextPath, EVE_SANDBOX_CACHE_ROOT), context.runtimeContextPath, "sandbox-template");
         if (postBuildOutput.digest !== closure.outputDigest ||
-            postBuildDependencies.digest !== closure.dependencyDigest) {
+            postBuildDependencies.digest !== closure.dependencyDigest ||
+            (closure.sandbox !== undefined && postBuildSandbox?.digest !== closure.sandbox.digest)) {
             throw packagingError("SOURCE_RACE", "runtime context", "The runtime context changed while the immutable Linux/amd64 image was being built.", "Discard the mixed-generation runtime image and rebuild from a quiescent candidate.");
         }
         state.imageId = await recoverImageIdentity(state);
@@ -970,6 +1030,16 @@ export async function buildEveRuntimeImage(request) {
             "-ceu",
             "test -f /workspace/.output/server/index.mjs && test -x /workspace/node_modules/.bin/eve",
         ]);
+        const sandboxTemplatePaths = await eveSandboxTemplateBootPaths(request.candidate);
+        if (sandboxTemplatePaths.length > 0) {
+            await docker(state, [
+                "exec",
+                state.containerId,
+                "sh",
+                "-ceu",
+                sandboxTemplatePaths.map((path) => `test -d '${path}'`).join(" && "),
+            ]);
+        }
         await docker(state, [
             "exec",
             state.containerId,
@@ -1012,15 +1082,15 @@ export async function buildEveRuntimeImage(request) {
             "-ceu",
             "awk '$2 ~ /^00000000:1F90/ { found=1 } END { exit found ? 0 : 1 }' /proc/net/tcp /proc/net/tcp6",
         ]);
-        await docker(state, [
-            "exec",
-            state.containerId,
-            "sh",
-            "-ceu",
-            "test -z \"$(find /app -type f \\( -name '.env*' -o -name '.npmrc' -o -name '.pnpmrc' -o -name '*.pem' -o -name '*.key' -o -name 'credentials.json' -o -name 'service-account.json' \\) -print -quit)\"",
-        ]);
         imageRetained = retainImage;
         state.imageRetained = retainImage;
+        const sandboxTemplate = closure.sandbox === undefined
+            ? undefined
+            : {
+                root: "/workspace/.eve/sandbox-cache",
+                digest: closure.sandbox.digest,
+                files: closure.sandbox.files,
+            };
         containerRemoved = await removeOwnedContainer(state);
         state.containerId = undefined;
         cleanupVerified = containerRemoved;
@@ -1050,7 +1120,14 @@ export async function buildEveRuntimeImage(request) {
                 ? {}
                 : { publicOrigin: request.publicOrigin }),
             applicationArtifact: request.candidate.generatedOutput.entrypointPath,
-            runtimeClosure: closure,
+            runtimeClosure: {
+                files: closure.files,
+                nativeModules: closure.nativeModules,
+                outputDigest: closure.outputDigest,
+                dependencyDigest: closure.dependencyDigest,
+                digest: closure.digest,
+                ...(sandboxTemplate === undefined ? {} : { sandboxTemplate }),
+            },
             health: {
                 method: "GET",
                 path: HEALTH_PATH,
@@ -1085,6 +1162,7 @@ export async function buildEveRuntimeImage(request) {
                 nativeModules: closure.nativeModules,
                 eveStartClosureRetained: true,
                 builderOnlyMaterialExcluded: true,
+                ...(sandboxTemplate === undefined ? {} : { sandboxTemplate }),
             },
         };
         return {

package/dist/eve.d.ts

@@ -34,7 +34,6 @@ export interface EveCliExecutionRequest {
     /** When true the command prints the machine-readable result object. */
     readonly json?: boolean;
 }
-export type EveCliRunner = (request: EveCliExecutionRequest) => void | Promise<void>;
 export interface EveCliDiagnostic {
     readonly code: string;
     readonly message: string;
@@ -51,7 +50,7 @@ export declare class EveCliError extends Error {
         readonly diagnostics?: readonly EveCliDiagnostic[];
     });
 }
-export declare const EVE_USAGE = "Usage: eden <preflight|deploy|destroy> [options]\n\nEden Deploy commands:\n  preflight  Build and inspect a local Eve candidate without remote mutation\n  deploy     Deploy the selected Eve project to the exact named target\n  destroy    Remove the exact owned Eve target\n\nWithout flags, preflight and deploy use the current directory, the preview\nenvironment, and a Worker name derived from the project's package.json name.\n--env accepts only preview or production; production and destroy always\nrequire an explicit --name. --env-file is accepted only by preflight and deploy.\nAll three commands print a human summary by default; --json prints the\nmachine-readable result object for scripts and CI.\n\nOptions:\n  --help  Show this help\n";
+export declare const EVE_NAME_PATTERN: RegExp;
 export declare function eveHelpText(scope: EveCliHelp["scope"]): string;
 export declare function parseEveArguments(args: readonly string[]): ParsedEveInvocation;
 /**

package/dist/eve.js

@@ -16,24 +16,7 @@ export class EveCliError extends Error {
         this.diagnostics = options.diagnostics ?? [];
     }
 }
-const EVE_NAME_PATTERN = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/u;
-export const EVE_USAGE = `Usage: eden <preflight|deploy|destroy> [options]
-
-Eden Deploy commands:
-  preflight  Build and inspect a local Eve candidate without remote mutation
-  deploy     Deploy the selected Eve project to the exact named target
-  destroy    Remove the exact owned Eve target
-
-Without flags, preflight and deploy use the current directory, the preview
-environment, and a Worker name derived from the project's package.json name.
---env accepts only preview or production; production and destroy always
-require an explicit --name. --env-file is accepted only by preflight and deploy.
-All three commands print a human summary by default; --json prints the
-machine-readable result object for scripts and CI.
-
-Options:
-  --help  Show this help
-`;
+export const EVE_NAME_PATTERN = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/u;
 const EVE_COMMAND_USAGE = {
     preflight: `Usage: eden preflight [--project <path>] [--env <preview|production>] [--name <name>] [--env-file <path>] [--json]
 

package/dist/index.d.ts

@@ -1,18 +1,16 @@
 #!/usr/bin/env -S node --
 import { type EveCliExecutionRequest } from "./eve.js";
 import { type EvePreflightOptions } from "./eve-control-plane.js";
-export { EVE_CLI_COMMANDS, EVE_USAGE, EveCliError, deriveEveTargetName, eveHelpText, parseEveArguments, } from "./eve.js";
+export { EVE_CLI_COMMANDS, EveCliError, deriveEveTargetName, eveHelpText, parseEveArguments, } from "./eve.js";
 export { EvePackagingError, buildEveProjectSnapshot, createDockerEveProjectBuilder, revalidateEveProjectCandidateInputs, } from "./eve-packaging.js";
-export { EVE_RESERVED_HOST_VARIABLES, EVE_START_COMMAND, EveRuntimeConfig, EveRuntimeConfigError, loadEveRuntimeConfig, parseEveRuntimeConfig, prepareEveRuntimeInjection, readEveRuntimeConfig, redactEveRuntimeOutput, } from "./eve-runtime-config.js";
+export { EVE_RESERVED_HOST_VARIABLES, EVE_START_COMMAND, EveRuntimeConfig, EveRuntimeConfigError, prepareEveRuntimeInjection, readEveRuntimeConfig, redactEveRuntimeOutput, } from "./eve-runtime-config.js";
 export type { EveReservedHostVariable, EveRuntimeConfigErrorCode, EveRuntimeInjection, EveRuntimeInjectionMode, EveRuntimeInjectionOptions, EveRuntimeInputIdentity, EveRuntimeProtectedPutRequest, EveRuntimeProtectedPutResult, EveRuntimeProtectedStore, EveStartProcessRequest, RedactedRuntimeConfigSeam, } from "./eve-runtime-config.js";
 export { buildEveRuntimeImage, discardEveRuntimeImage, revalidateEveRuntimeCandidate, validateEveHostRequirements, } from "./eve-runtime-image.js";
-export type { EveCliCommand, EveCliEnvironment, EveCliExecutionRequest, EveCliHelp, EveCliInvocation, EveCliRunner, ParsedEveInvocation, } from "./eve.js";
-export type { EveNodeImage, EvePackagingCheck, EvePackagingCode, EveProjectBuilder, EveProjectBuilderRequest, EveProjectBuilderResult, EveProjectBuildCandidate, EveProjectFile, EveProjectImage, EveProjectInputManifest, EveProjectOutput, EveProjectPackagingResult, EveProjectRuntime, EveProjectSnapshot, EveProjectSnapshotOptions, EveProjectToolchain, EveRuntimeConfigExclusion, } from "./eve-packaging.js";
+export type { EveCliCommand, EveCliEnvironment, EveCliExecutionRequest, EveCliHelp, EveCliInvocation, ParsedEveInvocation, } from "./eve.js";
+export type { EveNodeImage, EvePackagingCheck, EvePackagingCode, EveProjectBuilder, EveProjectBuilderRequest, EveProjectBuilderResult, EveProjectBuildCandidate, EveProjectFile, EveProjectImage, EveProjectInputManifest, EveProjectOutput, EveProjectPackagingResult, EveProjectSnapshot, EveProjectSnapshotOptions, EveProjectToolchain, EveRuntimeConfigExclusion, EveSandboxResumePatchStatus, } from "./eve-packaging.js";
 export type { EveHostRequirements, EveRuntimeClosure, EveRuntimeClosureFile, EveRuntimeCleanup, EveRuntimeImage, EveRuntimeImageDiscardRequest, EveRuntimeImageMetadata, EveRuntimeImageRequest, EveRuntimeImageResult, EveRuntimeNativeModule, EveRuntimeStatus, } from "./eve-runtime-image.js";
 export { DEFAULT_EVE_HOST_REQUIREMENTS, DEFAULT_EVE_NODE_IMAGE, runEveControlPlane, runEveDestroy, } from "./eve-control-plane.js";
-export type { EveCloudflareReadRequest, EveCloudflareReadResult, EveCloudflareReadRunner, EveCloudflareTargetState, EveContainerDeleteRunner, EveDeploymentCompensationRequest, EveDeploymentCompensationRunner, EveDeploymentHealthRequest, EveDeploymentHealthResult, EveDeploymentHealthRunner, EveDeploymentIdentity, EveDeploymentIdentityProof, EveDeploymentMetadata, EveDeploymentPublicationRequest, EveDeploymentPublicationResult, EveDeploymentPublicationRunner, EveDeploymentStatus, EveDestroyCloudflareReadRequest, EveDestroyCloudflareReadRunner, EveDestroyOutcome, EveDestroyTargetRead, EveImagePublicationRequest, EveImagePublicationResult, EveImagePublicationRunner, EvePreflightCandidate, EvePreflightResult, EvePreflightRuntimeEvidence, EvePreflightWarning, EvePreflightRuntimeRunner, EvePreflightRuntimeRunnerRequest, EveRegistryImageDeleteRunner, EveRuntimeConfigLoader, EveRuntimeImageDiscardRunner, EveWorkerDeleteRunner, } from "./eve-control-plane.js";
-export declare const EDEN_CLI_COMMANDS: readonly ["preflight", "deploy", "destroy"];
-export type EdenCliCommand = (typeof EDEN_CLI_COMMANDS)[number];
+export type { EveCloudflareReadRequest, EveCloudflareReadResult, EveCloudflareReadRunner, EveCloudflareTargetState, EveContainerDeleteRunner, EveDeploymentCompensationRequest, EveDeploymentCompensationRunner, EveDeploymentHealthRequest, EveDeploymentHealthResult, EveDeploymentHealthRunner, EveDeploymentIdentity, EveDeploymentIdentityProof, EveDeploymentMetadata, EveDeploymentPublicationRequest, EveDeploymentPublicationResult, EveDeploymentPublicationRunner, EveDeploymentStatus, EveDestroyCloudflareReadRequest, EveDestroyCloudflareReadRunner, EveDestroyOutcome, EveDestroyTargetRead, EveImagePublicationRequest, EveImagePublicationResult, EveImagePublicationRunner, EvePreflightCandidate, EvePreflightResult, EvePreflightRuntimeEvidence, EvePreflightWarning, EvePreflightRuntimeRunner, EvePreflightRuntimeRunnerRequest, EveRegistryRepositoryDeleteRunner, EveRuntimeConfigLoader, EveRuntimeImageDiscardRunner, EveWorkerDeleteRunner, } from "./eve-control-plane.js";
 export interface EdenCliRunOptions {
     readonly cwd?: string;
     readonly stdout?: (line: string) => void;
@@ -30,5 +28,4 @@ export interface EdenCliRunOptions {
 }
 export declare function runEdenCli(args: readonly string[], options?: EdenCliRunOptions): Promise<number>;
 export declare function main(args?: readonly string[]): Promise<number>;
-export declare function isEdenCliCommand(value: string): value is EdenCliCommand;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -6,16 +6,11 @@ import { fileURLToPath, } from "url";
 import { EVE_CLI_COMMANDS, EveCliError, deriveEveTargetName, eveHelpText, parseEveArguments, } from "./eve.js";
 import { EveRuntimeConfigError, readEveRuntimeConfig, redactEveRuntimeOutput, } from "./eve-runtime-config.js";
 import { DEFAULT_EVE_HOST_REQUIREMENTS, runEveControlPlane, runEveDestroy, } from "./eve-control-plane.js";
-export { EVE_CLI_COMMANDS, EVE_USAGE, EveCliError, deriveEveTargetName, eveHelpText, parseEveArguments, } from "./eve.js";
+export { EVE_CLI_COMMANDS, EveCliError, deriveEveTargetName, eveHelpText, parseEveArguments, } from "./eve.js";
 export { EvePackagingError, buildEveProjectSnapshot, createDockerEveProjectBuilder, revalidateEveProjectCandidateInputs, } from "./eve-packaging.js";
-export { EVE_RESERVED_HOST_VARIABLES, EVE_START_COMMAND, EveRuntimeConfig, EveRuntimeConfigError, loadEveRuntimeConfig, parseEveRuntimeConfig, prepareEveRuntimeInjection, readEveRuntimeConfig, redactEveRuntimeOutput, } from "./eve-runtime-config.js";
+export { EVE_RESERVED_HOST_VARIABLES, EVE_START_COMMAND, EveRuntimeConfig, EveRuntimeConfigError, prepareEveRuntimeInjection, readEveRuntimeConfig, redactEveRuntimeOutput, } from "./eve-runtime-config.js";
 export { buildEveRuntimeImage, discardEveRuntimeImage, revalidateEveRuntimeCandidate, validateEveHostRequirements, } from "./eve-runtime-image.js";
 export { DEFAULT_EVE_HOST_REQUIREMENTS, DEFAULT_EVE_NODE_IMAGE, runEveControlPlane, runEveDestroy, } from "./eve-control-plane.js";
-export const EDEN_CLI_COMMANDS = [
-    "preflight",
-    "deploy",
-    "destroy",
-];
 const USAGE = `Usage: eden <command> [options]
 
 Commands:
@@ -193,9 +188,6 @@ export async function runEdenCli(args, options = {}) {
 export async function main(args = process.argv.slice(2)) {
     return runEdenCli(args);
 }
-export function isEdenCliCommand(value) {
-    return EDEN_CLI_COMMANDS.includes(value);
-}
 if (process.argv[1] !== undefined &&
     realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url))) {
     void main().then((exitCode) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moinulmoin/eden",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "Deploy existing Eve projects to your own Cloudflare account.",
   "keywords": [
     "ai",
@@ -31,8 +31,8 @@
     "NOTICE"
   ],
   "dependencies": {
-    "@moinulmoin/eden-runtime-cloudflare": "0.5.0",
-    "wrangler": "4.120.0"
+    "@moinulmoin/eden-runtime-cloudflare": "0.7.0",
+    "wrangler": "4.147.0"
   },
   "devDependencies": {
     "@types/node": "24.0.0"