@moinulmoin/eden 0.11.1 → 0.11.2

package/README.md

@@ -12,15 +12,15 @@ If you already have an Eve project, start with `eden deploy`.
 Use any one of these package managers:
 
 ```sh
-npm install --global @moinulmoin/eden@0.11.1
+npm install --global @moinulmoin/eden@0.11.2
 ```
 
 ```sh
-pnpm add --global @moinulmoin/eden@0.11.1
+pnpm add --global @moinulmoin/eden@0.11.2
 ```
 
 ```sh
-bun add --global @moinulmoin/eden@0.11.1
+bun add --global @moinulmoin/eden@0.11.2
 ```
 
 Then confirm the CLI is available:

package/dist/SKILL.md

@@ -70,7 +70,10 @@ save a build.
   `agent/channels/eve.ts` (`vercelOidc()`, `localDev()`, `placeholderAuth()`)
   rejects every Cloudflare caller with 401. Replace it with a real
   authenticator, for example a bearer token read from the env file. Keep
-  `localDev()` so `eve dev` still works locally; it is ignored in production:
+  `localDev()` so `eve dev` still works locally. Never set `EVE_DEV`,
+  `VERCEL`, `VERCEL_ENV`, or `VERCEL_TARGET_ENV` in the deployment env file:
+  they switch Eve into development mode and can let unauthenticated callers
+  in. Eden rejects these names with `EVE_ENV_RESERVED_VARIABLE`:
 
   ```ts
   import { localDev, type AuthFn } from "eve/channels/auth";

package/dist/eve-control-plane.d.ts

@@ -88,16 +88,17 @@ export interface EveCloudflareReadResult {
          * Provider-backed facts about the live target, read through the
          * Cloudflare API (not self-asserted response headers, which any Worker
          * can forge): the Container application's Durable Object namespace and
-         * the `EDEN_EVE_DEPLOYMENT_ID` plain-text var Eden stamps into every
-         * Worker it publishes. `settingsReadable` tells the ownership resolver
-         * whether a missing var is evidence of a foreign Worker or just an
-         * unreadable settings call.
+         * the `EDEN_EVE_DEPLOYMENT_ID` and `EDEN_EVE_RELEASE_ID` plain-text vars
+         * Eden stamps into every Worker it publishes. `settingsReadable` tells
+         * the ownership resolver whether a missing var is evidence of a foreign
+         * Worker or just an unreadable settings call.
          */
         readonly providerEvidence?: {
             readonly containerApplicationId?: string;
             readonly containerSchedulingPolicy?: string;
             readonly containerNamespaceId?: string;
             readonly workerDeploymentId?: string;
+            readonly workerReleaseId?: string;
             readonly workerContainerNamespaceId?: string;
             readonly settingsReadable?: boolean;
         };
@@ -284,6 +285,8 @@ export interface EvePreflightOptions {
 }
 export interface EveDestroyTargetRead {
     readonly workerExists: boolean;
+    readonly inventoryComplete?: boolean;
+    readonly providerEvidence?: EveCloudflareReadResult["target"]["providerEvidence"];
     readonly containerApplicationId?: string;
     readonly accountId?: string;
     /**

package/dist/eve-control-plane.js

@@ -2,8 +2,8 @@ import { setTimeout as waitForActivation } from "node:timers/promises";
 import { createRequire, } from "node:module";
 import { createHash, randomUUID, } from "node:crypto";
 import { join, dirname, relative, } from "node:path";
-import { lstat, mkdir, readFile, readdir, realpath, rename, rm, symlink, writeFile, } from "node:fs/promises";
-import { homedir, } from "node:os";
+import { lstat, mkdir, mkdtemp, readFile, readdir, realpath, rename, rm, symlink, writeFile, } from "node:fs/promises";
+import { homedir, tmpdir, } from "node:os";
 import { createServer, } from "node:net";
 import { execFile, spawn, } from "node:child_process";
 import { fileURLToPath, } from "node:url";
@@ -26,7 +26,6 @@ export const DEFAULT_EVE_HOST_REQUIREMENTS = Object.freeze({
     network: "supported",
     durableLocalFilesystem: false,
 });
-const wranglerCwd = dirname(wranglerEntrypoint);
 export const DEFAULT_EVE_NODE_IMAGE = Object.freeze({
     reference: "node:24.17.0-bookworm-slim",
     digest: "sha256:862263c612aa437e3037674b85419622a9d93bff80aa1eee5398dfe686375532",
@@ -223,11 +222,15 @@ async function checkEveWorldPairing(candidate, world) {
         return undefined;
     const eveManifest = await readInstalledManifest(candidate.snapshotRoot, "eve");
     const worldManifest = await readInstalledManifest(candidate.snapshotRoot, world);
+    if (world === "@moinulmoin/eden-world-cloudflare" &&
+        worldManifest?.eden?.capabilities?.worldRpcAuth !== true) {
+        return check("EVE_WORLD_PAIRING", "failed", "The installed Cloudflare World lets the agent's sandbox read and change every session's workflow state.", "Install @moinulmoin/eden-world-cloudflare@0.11.2 or later; see docs/troubleshooting.md.");
+    }
     if (world === "@moinulmoin/eden-world-cloudflare" &&
         worldManifest !== undefined &&
         eveRequiresAtomicStartHook(eveManifest?.version) &&
         worldManifest.eden?.capabilities?.atomicStartHook !== true) {
-        return check("EVE_WORLD_PAIRING", "failed", `Eve ${eveManifest?.version} needs a World with atomic start hooks, and the installed ${world} ${worldManifest.version ?? "(unknown version)"} does not have them; every new session would fail with HTTP 500.`, `Install ${world}@0.11.1 or later; see docs/troubleshooting.md.`);
+        return check("EVE_WORLD_PAIRING", "failed", `Eve ${eveManifest?.version} needs a World with atomic start hooks, and the installed ${world} ${worldManifest.version ?? "(unknown version)"} does not have them; every new session would fail with HTTP 500.`, `Install ${world}@0.11.2 or later; see docs/troubleshooting.md.`);
     }
     const expectedRange = eveManifest === undefined
         ? undefined
@@ -588,6 +591,7 @@ function safeWranglerEnvironment() {
         LANG: process.env.LANG,
         LC_ALL: process.env.LC_ALL,
         CLOUDFLARE_API_TOKEN: process.env.CLOUDFLARE_API_TOKEN,
+        CLOUDFLARE_API_BASE_URL: "https://api.cloudflare.com/client/v4",
         NODE_OPTIONS: undefined,
     };
 }
@@ -602,14 +606,23 @@ function safeDockerEnvironment() {
         DOCKER_CONTEXT: process.env.DOCKER_CONTEXT,
     };
 }
+async function withWranglerDirectory(operation) {
+    const cwd = await mkdtemp(join(tmpdir(), "eden-wrangler-"));
+    try {
+        return await operation(cwd);
+    }
+    finally {
+        await rm(cwd, { recursive: true, force: true });
+    }
+}
 async function readWranglerJson(args, timeoutMs = 30_000) {
     try {
-        const result = await execFileAsync(process.execPath, [wranglerEntrypoint, ...args], {
+        const result = await withWranglerDirectory((cwd) => execFileAsync(process.execPath, [wranglerEntrypoint, ...args], {
             env: safeWranglerEnvironment(),
-            cwd: wranglerCwd,
+            cwd,
             maxBuffer: 2 * 1024 * 1024,
             timeout: timeoutMs,
-        });
+        }));
         const parsed = JSON.parse(result.stdout.trim());
         return { value: parsed, failed: false };
     }
@@ -744,6 +757,8 @@ export function exactTargetContainerEntries(value, name) {
     return exactContainerEntries(value, boundedResourceName(name, "container"));
 }
 async function readExactTargetInventory(workerName, containerApp) {
+    // Wrangler's JSON output does not expose a pagination cursor. A full page
+    // without the exact name remains indeterminate in exactContainerEntries.
     const containers = await readWranglerJson([
         "containers", "list", "--json", "--per-page", "100",
     ]);
@@ -753,7 +768,7 @@ async function readExactTargetInventory(workerName, containerApp) {
     return {
         containers,
         deployments,
-        containerEntries: exactContainerEntries(containers.value, containerApp),
+        containerEntries: containers.failed ? undefined : exactContainerEntries(containers.value, containerApp),
         deploymentEntries: exactDeploymentEntries(deployments.value),
     };
 }
@@ -883,6 +898,11 @@ async function readProviderEvidence(workerName, accountId, workerPresent, contai
                     if (typeof deploymentBinding?.text === "string") {
                         evidence.workerDeploymentId = deploymentBinding.text;
                     }
+                    const releaseBinding = bindings.find((value) => value.type === "plain_text" &&
+                        value.name === "EDEN_EVE_RELEASE_ID");
+                    if (typeof releaseBinding?.text === "string") {
+                        evidence.workerReleaseId = releaseBinding.text;
+                    }
                     const containerBinding = bindings.find((value) => value.type === "durable_object_namespace" &&
                         value.name === "EVE_CONTAINER");
                     if (typeof containerBinding?.namespace_id === "string") {
@@ -901,12 +921,9 @@ async function readProviderEvidence(workerName, accountId, workerPresent, contai
     return evidence;
 }
 /**
- * Resolves `unowned` reads against Eden's immutable deployment records AND
- * the live remote target. The local record proves Eden once created the
- * target; the remote Worker's stamped identity proves it is still the one
- * Eden deployed — a same-name Worker recreated by something else after the
- * target was destroyed (or a forged local record) must never be upgraded to
- * `owned`.
+ * Resolves local deployment history against authenticated provider state.
+ * This detects name reuse and stale records, but deployment IDs are public:
+ * a malicious forged local record is not an independent ownership proof.
  */
 async function resolveEveTargetOwnership(request, result) {
     if (result.target.state !== "unowned")
@@ -930,10 +947,18 @@ async function resolveEveTargetOwnership(request, result) {
     // its own settings: unreadable settings fail closed.
     const evidence = result.target.providerEvidence;
     const recordedDeploymentIds = new Set(record.deploymentIds);
+    // Every Eden project on the same Eve version publishes the same affinity
+    // deployment ID, so the per-publish release ID is what tells a same-name
+    // Worker from another project apart. Workers from before release IDs
+    // existed used the release ID as their deployment ID.
+    const recordedReleaseIds = new Set(record.releaseIds);
+    const workerReleaseId = evidence?.workerReleaseId ?? evidence?.workerDeploymentId;
     const workerProven = result.target.observed?.worker !== true ||
         (evidence?.settingsReadable === true &&
             evidence.workerDeploymentId !== undefined &&
-            recordedDeploymentIds.has(evidence.workerDeploymentId));
+            recordedDeploymentIds.has(evidence.workerDeploymentId) &&
+            workerReleaseId !== undefined &&
+            recordedReleaseIds.has(workerReleaseId));
     // The Container proof is the application running the durable_object
     // scheduling policy with a namespace that matches the Worker binding's
     // namespace; anything else fails closed.
@@ -954,6 +979,8 @@ async function resolveEveTargetOwnership(request, result) {
                 failures.push("Worker deployment stamp absent");
             else if (!recordedDeploymentIds.has(evidence.workerDeploymentId))
                 failures.push("Worker deployment stamp differs from recorded identities");
+            else if (workerReleaseId === undefined || !recordedReleaseIds.has(workerReleaseId))
+                failures.push("Worker release stamp differs from recorded releases");
         }
         if (result.target.observed?.container === true) {
             if (evidence?.containerSchedulingPolicy !== "durable_object")
@@ -1252,8 +1279,9 @@ async function writeEveDeploymentArtifacts(candidate, hostConfig, workerSource)
 const WRANGLER_OPERATION_TIMEOUT_MS = 120_000;
 /** Deadline for `wrangler deploy`, whose Container image preparation alone can approach two minutes. */
 const WRANGLER_PUBLICATION_TIMEOUT_MS = 600_000;
-function runWranglerWithInput(args, cwd, input, timeoutMs = WRANGLER_OPERATION_TIMEOUT_MS) {
-    return new Promise((resolveResult) => {
+async function runWranglerWithInput(args, input, timeoutMs = WRANGLER_OPERATION_TIMEOUT_MS) {
+    // The project's TypeScript lib predates Promise.withResolvers.
+    return withWranglerDirectory((cwd) => new Promise((resolveResult) => {
         const child = spawn(process.execPath, [wranglerEntrypoint, ...args], {
             cwd,
             env: safeWranglerEnvironment(),
@@ -1298,7 +1326,7 @@ function runWranglerWithInput(args, cwd, input, timeoutMs = WRANGLER_OPERATION_T
             child.stdin.end();
         else
             child.stdin.end(input);
-    });
+    }));
 }
 function defaultProtectedStore(workerName) {
     return {
@@ -1310,7 +1338,7 @@ function defaultProtectedStore(workerName) {
                     name,
                     "--name",
                     workerName,
-                ], process.cwd(), request.values[name] === undefined ? "" : `${request.values[name]}\n`);
+                ], request.values[name] === undefined ? "" : `${request.values[name]}\n`);
                 if (result.exitCode !== 0) {
                     throw new EveRuntimeConfigError({
                         code: "EVE_RUNTIME_PROTECTED_UPLOAD_FAILED",
@@ -1332,7 +1360,7 @@ async function defaultImagePublicationRunner(request) {
             cwd: request.generationRoot,
             maxBuffer: 512 * 1024,
         });
-        const pushed = await runWranglerWithInput(["containers", "push", request.localImageTag], request.generationRoot);
+        const pushed = await runWranglerWithInput(["containers", "push", request.localImageTag]);
         if (pushed.exitCode !== 0) {
             return {
                 status: "indeterminate",
@@ -1398,7 +1426,7 @@ function defaultPublicationRunner() {
             "--env",
             request.identity.environment,
             "--strict",
-        ], dirname(request.wranglerConfigPath), undefined, WRANGLER_PUBLICATION_TIMEOUT_MS);
+        ], undefined, WRANGLER_PUBLICATION_TIMEOUT_MS);
         if (result.exitCode !== 0) {
             return {
                 status: "indeterminate",
@@ -1795,15 +1823,32 @@ async function runEveDeployment(request, options, collected) {
             ...(priorIdentity.runtimeRevisionHandle === undefined ? {} : { runtimeRevisionHandle: priorIdentity.runtimeRevisionHandle }),
         };
     }
-    const matchingDeployment = Object.entries(retainedDeployments).find(([, entry]) => entry.eveVersion === candidate.eveVersion && entry.affinityContract === EDEN_AFFINITY_CONTRACT)?.[0];
+    const matchingDeployment = Object.entries(retainedDeployments).find(([, entry]) => entry.worldRpcAuth === true && entry.eveVersion === candidate.eveVersion && entry.affinityContract === EDEN_AFFINITY_CONTRACT)?.[0];
+    const affinityDeploymentId = `eden-affinity-${createHash("sha256").update(`${candidate.eveVersion}:${EDEN_AFFINITY_CONTRACT}`).digest("hex").slice(0, 24)}`;
     const deploymentId = !affinityEnabled ? releaseId : matchingDeployment ??
-        `eden-affinity-${createHash("sha256").update(`${candidate.eveVersion}:${EDEN_AFFINITY_CONTRACT}`).digest("hex").slice(0, 24)}`;
+        (affinityDeploymentId in retainedDeployments ? `${affinityDeploymentId}-${randomUUID().slice(0, 8)}` : affinityDeploymentId);
     const retiringDeployments = { ...priorIdentity?.pendingRetirements };
     delete retiringDeployments[deploymentId];
     if (priorIdentity?.deploymentId !== undefined)
         delete retiringDeployments[priorIdentity.deploymentId];
     for (const id of prior?.protectedDeploymentIds ?? [])
         delete retiringDeployments[id];
+    // Old containers can access every session's World without authentication.
+    // Drop their routes even when live sessions or transfers would prevent drain.
+    const insecureRetirements = affinityEnabled
+        ? Object.entries(retainedDeployments).filter(([id, entry]) => id !== deploymentId && entry.worldRpcAuth !== true)
+        : [];
+    for (const [id, entry] of insecureRetirements) {
+        retiringDeployments[id] = entry;
+        delete retainedDeployments[id];
+    }
+    if (insecureRetirements.length > 0) {
+        resultWarnings.push({
+            id: "EVE_UNAUTHENTICATED_VERSIONS_RETIRED",
+            message: `${insecureRetirements.length} kept version${insecureRetirements.length === 1 ? " was" : "s were"} retired because World RPC was unauthenticated; their sessions ended.`,
+            remediation: 'Old sessions now fail; Eve may report "Failed to send the session message." Start new sessions on the current deployment.',
+        });
+    }
     const hasRetainedNoncurrentDeployments = priorIdentity?.retainedDeployments !== undefined &&
         Object.keys(retainedDeployments).some((id) => id !== priorIdentity.deploymentId);
     const controlToken = `${randomUUID()}${randomUUID()}`;
@@ -2256,10 +2301,11 @@ async function runEveDeployment(request, options, collected) {
                 }
                 completedRetirements.push(id);
             }
-            supersededImageCleanup = check("VAL-LIFE-007", "passed", "Drained deployment instances and their owned registry repositories were retired.");
+            supersededImageCleanup = check("VAL-LIFE-007", "passed", "Retired deployment instances and their owned registry repositories were removed.");
         }
-        catch {
-            supersededImageCleanup = check("VAL-LIFE-007", "failed", "The deployment is healthy, but drained resource retirement was not proven; exact pending retirement records were retained for retry.", "Retry deploy to finish only recorded drained resource cleanup.");
+        catch (error) {
+            const reason = error instanceof Error ? safeText(error.message) : "Unknown retirement failure.";
+            supersededImageCleanup = check("VAL-LIFE-007", "failed", `The deployment is healthy, but resource retirement was not proven: ${reason} Exact pending retirement records were retained for retry.`, "Retry deploy to finish only recorded retired resource cleanup.");
         }
         if (completedRetirements.length > 0) {
             // Keep the immutable deployment record as evidence, but exclude proven
@@ -2959,6 +3005,7 @@ async function readEveDeploymentRecord(projectRoot, environment, name, accountId
     const entries = await readdir(generationsRoot).catch(() => []);
     const scanned = [];
     const deploymentIds = new Set();
+    const releaseIds = new Set();
     for (const entry of entries) {
         const generationRoot = join(generationsRoot, entry);
         const recordPath = await deploymentRecordPath(generationRoot);
@@ -2981,6 +3028,9 @@ async function readEveDeploymentRecord(projectRoot, environment, name, accountId
             const deploymentId = parsed.deploymentId;
             if (deploymentId !== undefined)
                 deploymentIds.add(deploymentId);
+            const releaseId = parsed.identity.releaseId ?? deploymentId;
+            if (releaseId !== undefined)
+                releaseIds.add(releaseId);
         }
     }
     scanned.sort((left, right) => right.modifiedAt - left.modifiedAt);
@@ -3037,6 +3087,7 @@ async function readEveDeploymentRecord(projectRoot, environment, name, accountId
         protectedDeploymentIds: [...protectedDeploymentIds],
         status: live.record.status,
         deploymentIds: [...deploymentIds],
+        releaseIds: [...releaseIds],
         worldCloudflare: live.record.worldCloudflare,
         durableObjects: historySource?.record.durableObjects,
     };
@@ -3137,10 +3188,12 @@ async function parseEveDeploymentRecord(recordPath, environment, name) {
 }
 async function defaultDestroyTargetRead(request) {
     const account = await readWranglerJson(["whoami", "--json"]);
-    const { deployments, containerEntries: entries, deploymentEntries } = await readExactTargetInventory(request.workerName, request.containerApplicationName);
+    const { containers, deployments, containerEntries: entries, deploymentEntries: listedDeployments } = await readExactTargetInventory(request.workerName, request.containerApplicationName);
     const accountId = authenticatedAccountId(account.value);
-    const workerExists = !deployments.failed &&
-        (deploymentEntries?.length ?? 0) > 0;
+    const deploymentEntries = deployments.failed &&
+        /(?:does not exist|not found|10007)/iu.test(deployments.stderr ?? "")
+        ? [] : deployments.failed ? undefined : listedDeployments;
+    const workerExists = (deploymentEntries?.length ?? 0) > 0;
     const firstContainer = entries === undefined ? undefined : entries[0];
     const ownedRepositories = request.registryRepositories;
     let registryTagsPresent;
@@ -3165,6 +3218,10 @@ async function defaultDestroyTargetRead(request) {
     }
     return {
         workerExists,
+        inventoryComplete: !account.failed && accountId !== undefined &&
+            !containers.failed && entries !== undefined && entries.length <= 1 &&
+            deploymentEntries !== undefined,
+        providerEvidence: await readProviderEvidence(request.workerName, accountId, workerExists, firstContainer),
         ...(firstContainer === undefined
             ? {}
             : { containerApplicationId: firstContainer.id }),
@@ -3204,7 +3261,7 @@ function registryTagsByRepository(value) {
     return tagsByRepository;
 }
 async function defaultWorkerDelete(request) {
-    const result = await runWranglerWithInput(["delete", "--name", request.name, "--force"], process.cwd(), "y\n");
+    const result = await runWranglerWithInput(["delete", "--name", request.name, "--force"], "y\n");
     if (result.exitCode === 0)
         return "deleted";
     if (/(?:does not exist|not found|10007)/iu.test(result.stderr)) {
@@ -3213,7 +3270,7 @@ async function defaultWorkerDelete(request) {
     return "indeterminate";
 }
 async function defaultContainerDelete(request) {
-    const result = await runWranglerWithInput(["containers", "delete", request.applicationId], process.cwd());
+    const result = await runWranglerWithInput(["containers", "delete", request.applicationId]);
     if (result.exitCode === 0)
         return "deleted";
     if (/(?:does not exist|not found|not supported|10007)/iu.test(result.stderr)) {
@@ -3256,7 +3313,7 @@ async function defaultRegistryRepositoryDelete(request) {
             "delete",
             `${request.repository}:${tag}`,
             "--skip-confirmation",
-        ], process.cwd());
+        ]);
         if (result.exitCode === 0) {
             deletedAny = true;
             continue;
@@ -3421,6 +3478,7 @@ async function runEveDestroyLocked(request, options, checks, emit, fail) {
     const expectedWorker = record.identity.workerName;
     const expectedContainer = record.identity.containerApplicationName;
     if (expectedWorker !== request.name ||
+        expectedContainer !== boundedResourceName(request.name, "container") ||
         typeof record.identity.accountId !== "string") {
         fail("EVE_DESTROY_RECORD_MISMATCH", "The immutable deployment record does not match the selected target.");
     }
@@ -3435,6 +3493,9 @@ async function runEveDestroyLocked(request, options, checks, emit, fail) {
     const reader = options.destroyCloudflareRead ?? defaultDestroyTargetRead;
     eveProgress(options, "reading the exact remote inventory");
     const before = await readTarget();
+    if (before.inventoryComplete === false) {
+        fail("EVE_DESTROY_INDETERMINATE", "The exact remote inventory could not be read completely; nothing was deleted. Retry the read. If Wrangler returned a full Container page without the exact target, inspect and delete only the named Container application in the Cloudflare dashboard, then retry destroy.");
+    }
     if (before.accountId !== record.identity.accountId) {
         fail("EVE_DESTROY_OWNERSHIP_UNPROVEN", "The authenticated account does not own the recorded deployment account.");
     }
@@ -3455,6 +3516,27 @@ async function runEveDestroyLocked(request, options, checks, emit, fail) {
         });
         return;
     }
+    if (before.workerExists) {
+        const ownership = await resolveEveTargetOwnership({
+            projectRoot: request.projectRoot,
+            environment: request.environment,
+            name: request.name,
+            projectId: record.identity.projectId ?? "unknown-project",
+            sourceDigest: "unknown",
+        }, {
+            accountAccess: "available",
+            containerAccess: "available",
+            accountId: before.accountId,
+            target: {
+                state: "unowned",
+                observed: { worker: true, container: before.containerApplicationId !== undefined },
+                ...(before.providerEvidence === undefined ? {} : { providerEvidence: before.providerEvidence }),
+            },
+        });
+        if (ownership.target.state !== "owned") {
+            fail("EVE_DESTROY_OWNERSHIP_UNPROVEN", "Live provider settings do not match the recorded Worker and Container identity; nothing was deleted.");
+        }
+    }
     const deleteWorker = options.deleteWorker ?? defaultWorkerDelete;
     if (before.workerExists) {
         eveProgress(options, `deleting Worker ${expectedWorker}`);
@@ -3519,6 +3601,9 @@ async function runEveDestroyLocked(request, options, checks, emit, fail) {
     }
     eveProgress(options, "verifying the exact target is absent");
     const after = await readTarget();
+    if (after.inventoryComplete === false) {
+        fail("EVE_DESTROY_INDETERMINATE", "The exact remote inventory could not be read completely after deletion; absence is unproven.");
+    }
     if (after.workerExists || after.containerApplicationId !== undefined) {
         emit({
             ok: false,

package/dist/eve-packaging.js

@@ -365,6 +365,14 @@ const EVE_EXCLUDED_FILE_NAMES = new Set([
     ".bunfig.toml",
     ".yarnrc",
     ".yarnrc.yml",
+    ".dev.vars",
+    ".netrc",
+    ".git-credentials",
+    "id_rsa",
+    "id_ecdsa",
+    "id_ed25519",
+    "id_dsa",
+    "secrets.json",
     "credentials.json",
     "service-account.json",
 ]);
@@ -419,6 +427,16 @@ function isAllowedSystemAlias(path) {
     const normalized = resolve(path);
     return normalized === "/var" || normalized === "/tmp";
 }
+function isCredentialPath(relativePath) {
+    const parts = relativePath.split("/");
+    const name = parts[parts.length - 1];
+    return name !== undefined && (EVE_EXCLUDED_FILE_NAMES.has(name) ||
+        name.startsWith(".dev.vars.") ||
+        name.endsWith(".pem") || name.endsWith(".key") ||
+        name.endsWith(".p12") || name.endsWith(".pfx") ||
+        name.endsWith(".tfvars") ||
+        (name === "credentials" && parts[parts.length - 2] === ".aws"));
+}
 function isPathExcluded(relativePath, runtimeEnvRelativePath) {
     const parts = relativePath.split("/");
     const name = parts[parts.length - 1];
@@ -440,8 +458,7 @@ function isPathExcluded(relativePath, runtimeEnvRelativePath) {
     if (name !== undefined && name.startsWith(".env")) {
         return { excluded: true, category: "runtime-env" };
     }
-    if ((name !== undefined && EVE_EXCLUDED_FILE_NAMES.has(name)) ||
-        (name !== undefined && (name.endsWith(".pem") || name.endsWith(".key")))) {
+    if (isCredentialPath(relativePath)) {
         return { excluded: true, category: "credentials" };
     }
     if (name !== undefined &&
@@ -1737,9 +1754,7 @@ async function assertGeneratedTreesExcludeSecrets(snapshotRoot) {
                 : `${relativeDirectory}/${entry.name}`;
             const candidate = join(directory, entry.name);
             if (entry.name.startsWith(".env") ||
-                EVE_EXCLUDED_FILE_NAMES.has(entry.name) ||
-                entry.name.endsWith(".pem") ||
-                entry.name.endsWith(".key")) {
+                isCredentialPath(relativePath)) {
                 throw new EvePackagingError({
                     code: "SECRET_EXCLUSION_FAILED",
                     subject: relativePath,

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

@@ -1,4 +1,4 @@
-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_WORLD_TOKEN", "EDEN_EVE_WORLD_RPC_AUTH", "EDEN_EVE_DEPLOYMENT_ID", "EDEN_EVE_GENERATION_ID", "EDEN_EVE_RELEASE_ID", "EDEN_EVE_DEPLOYMENTS", "EDEN_AFFINITY_CONTRACT", "EVE_SCHEDULES_DISABLED", "EDEN_EVE_CONTROL_TOKEN"];
+export declare const EVE_RESERVED_HOST_VARIABLES: readonly ["HOST", "NITRO_HOST", "PORT", "NITRO_PORT", "NODE_ENV", "EVE_DEV", "VERCEL", "VERCEL_ENV", "VERCEL_TARGET_ENV", "NODE_EXTRA_CA_CERTS", "WORKFLOW_LOCAL_BASE_URL", "EDEN_WORLD_URL", "EDEN_WORLD_TOKEN", "EDEN_EVE_WORLD_RPC_AUTH", "EDEN_EVE_DEPLOYMENT_ID", "EDEN_EVE_GENERATION_ID", "EDEN_EVE_RELEASE_ID", "EDEN_EVE_DEPLOYMENTS", "EDEN_AFFINITY_CONTRACT", "EVE_SCHEDULES_DISABLED", "EDEN_EVE_CONTROL_TOKEN"];
 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<{

package/dist/eve-runtime-config.js

@@ -7,6 +7,10 @@ export const EVE_RESERVED_HOST_VARIABLES = Object.freeze([
     "PORT",
     "NITRO_PORT",
     "NODE_ENV",
+    "EVE_DEV",
+    "VERCEL",
+    "VERCEL_ENV",
+    "VERCEL_TARGET_ENV",
     "NODE_EXTRA_CA_CERTS",
     "WORKFLOW_LOCAL_BASE_URL",
     "EDEN_WORLD_URL",
@@ -194,7 +198,10 @@ function parseEnvironmentText(text) {
         if (EVE_RESERVED_HOST_VARIABLES.includes(name)) {
             throw new EveRuntimeConfigError({
                 code: "EVE_ENV_RESERVED_VARIABLE",
-                message: `The explicit Eve environment file attempts to override reserved host variable ${name}.`,
+                message: `The explicit Eve environment file attempts to override reserved host variable ${name}.` +
+                    (["EVE_DEV", "VERCEL", "VERCEL_ENV", "VERCEL_TARGET_ENV"].includes(name)
+                        ? " Remove it: Eve development-mode variables can let unauthenticated callers in."
+                        : ""),
                 source: EVE_ENV_FILE_SOURCE,
                 variableName: name,
             });

package/dist/eve-runtime-image.js

@@ -1000,7 +1000,7 @@ export async function buildEveRuntimeImage(request) {
             "--label",
             state.imageLabel,
             "--publish",
-            `${healthPort}:${INTERNAL_PORT}`,
+            `127.0.0.1:${healthPort}:${INTERNAL_PORT}`,
             ...(request.runtimeInjection === undefined
                 ? Object.entries(runtimeEnvironment).flatMap(([name, value]) => [
                     "--env",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moinulmoin/eden",
-  "version": "0.11.1",
+  "version": "0.11.2",
   "description": "Deploy existing Eve projects to your own Cloudflare account.",
   "keywords": [
     "ai",
@@ -32,7 +32,7 @@
     "NOTICE"
   ],
   "dependencies": {
-    "@moinulmoin/eden-runtime-cloudflare": "0.11.1",
+    "@moinulmoin/eden-runtime-cloudflare": "0.11.2",
     "wrangler": "4.147.0"
   },
   "devDependencies": {