@moinulmoin/eden 0.11.1 → 0.11.3

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.3
 ```
 
 ```sh
-pnpm add --global @moinulmoin/eden@0.11.1
+pnpm add --global @moinulmoin/eden@0.11.3
 ```
 
 ```sh
-bun add --global @moinulmoin/eden@0.11.1
+bun add --global @moinulmoin/eden@0.11.3
 ```
 
 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
@@ -580,14 +583,15 @@ function candidateMetadata(candidate, imageDigest) {
         ...(imageDigest === undefined ? {} : { imageDigest }),
     };
 }
-function safeWranglerEnvironment() {
+function safeWranglerEnvironment(cwd) {
     return {
-        PATH: process.env.PATH,
-        HOME: process.env.HOME,
-        TMPDIR: process.env.TMPDIR,
-        LANG: process.env.LANG,
-        LC_ALL: process.env.LC_ALL,
+        ...safeDockerEnvironment(),
         CLOUDFLARE_API_TOKEN: process.env.CLOUDFLARE_API_TOKEN,
+        CLOUDFLARE_ACCOUNT_ID: process.env.CLOUDFLARE_ACCOUNT_ID,
+        NODE_EXTRA_CA_CERTS: process.env.NODE_EXTRA_CA_CERTS,
+        XDG_CONFIG_HOME: process.env.XDG_CONFIG_HOME,
+        WRANGLER_CACHE_DIR: join(cwd, "cache"),
+        CLOUDFLARE_API_BASE_URL: "https://api.cloudflare.com/client/v4",
         NODE_OPTIONS: undefined,
     };
 }
@@ -600,16 +604,37 @@ function safeDockerEnvironment() {
         LC_ALL: process.env.LC_ALL,
         DOCKER_HOST: process.env.DOCKER_HOST,
         DOCKER_CONTEXT: process.env.DOCKER_CONTEXT,
+        DOCKER_CONFIG: process.env.DOCKER_CONFIG,
+        DOCKER_CERT_PATH: process.env.DOCKER_CERT_PATH,
+        DOCKER_TLS_VERIFY: process.env.DOCKER_TLS_VERIFY,
+        HTTP_PROXY: process.env.HTTP_PROXY,
+        HTTPS_PROXY: process.env.HTTPS_PROXY,
+        NO_PROXY: process.env.NO_PROXY,
+        http_proxy: process.env.http_proxy,
+        https_proxy: process.env.https_proxy,
+        no_proxy: process.env.no_proxy,
     };
 }
+async function withWranglerDirectory(operation) {
+    // An explicit --config and WRANGLER_CACHE_DIR inside this private folder
+    // stop Wrangler from searching its (possibly shared) parent directories.
+    const cwd = await mkdtemp(join(tmpdir(), "eden-wrangler-"));
+    try {
+        await writeFile(join(cwd, "wrangler.json"), "{}\n", { mode: 0o600 });
+        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], {
-            env: safeWranglerEnvironment(),
-            cwd: wranglerCwd,
+        const result = await withWranglerDirectory((cwd) => execFileAsync(process.execPath, [wranglerEntrypoint, ...args, "--config", join(cwd, "wrangler.json")], {
+            env: safeWranglerEnvironment(cwd),
+            cwd,
             maxBuffer: 2 * 1024 * 1024,
             timeout: timeoutMs,
-        });
+        }));
         const parsed = JSON.parse(result.stdout.trim());
         return { value: parsed, failed: false };
     }
@@ -635,7 +660,7 @@ function jsonCollection(value) {
     }
     return undefined;
 }
-function exactContainerEntries(value, name) {
+function exactContainerEntries(value, name, complete = false) {
     const collection = jsonCollection(value);
     if (collection === undefined)
         return undefined;
@@ -655,7 +680,8 @@ function exactContainerEntries(value, name) {
             });
         }
     }
-    if (entries.length === 0 && collection.length >= 100) {
+    // Without proven pagination, a full page that lacks the name proves nothing.
+    if (entries.length === 0 && !complete && collection.length >= 100) {
         return undefined;
     }
     return entries;
@@ -684,16 +710,25 @@ function authenticatedAccountId(value) {
     const account = accounts[0];
     if (typeof account !== "object" ||
         account === null ||
+        !("id" in account) ||
         typeof account.id !== "string") {
         return undefined;
     }
+    const selectedAccount = process.env.CLOUDFLARE_ACCOUNT_ID;
+    if (selectedAccount && selectedAccount !== account.id) {
+        return undefined;
+    }
     return account.id;
 }
 async function readWranglerOAuthToken() {
-    const root = process.env.WRANGLER_HOME ??
+    const legacyRoot = join(homedir(), ".wrangler");
+    const legacyExists = (await lstat(legacyRoot).catch(() => undefined))?.isDirectory();
+    const configHome = process.env.XDG_CONFIG_HOME ??
         (process.platform === "darwin"
-            ? join(homedir(), "Library", "Preferences", ".wrangler")
-            : join(homedir(), ".config", ".wrangler"));
+            ? join(homedir(), "Library", "Preferences")
+            : join(homedir(), ".config"));
+    const root = process.env.WRANGLER_HOME ??
+        (legacyExists ? legacyRoot : join(configHome, ".wrangler"));
     const raw = await readFile(join(root, "config", "default.toml"), "utf8")
         .catch(() => undefined);
     if (raw === undefined)
@@ -743,17 +778,71 @@ async function readWorkersDevSubdomain(accountId) {
 export function exactTargetContainerEntries(value, name) {
     return exactContainerEntries(value, boundedResourceName(name, "container"));
 }
+async function readTargetContainers(name) {
+    const account = await readWranglerJson(["whoami", "--json"]);
+    const accountId = authenticatedAccountId(account.value);
+    const token = process.env.CLOUDFLARE_API_TOKEN || await readWranglerOAuthToken();
+    if (accountId === undefined || !token)
+        return { failed: true };
+    // Unlike `containers list --json`, this endpoint supports an exact name
+    // filter and exposes result_info.next_page_token. No per_page means all.
+    const entries = [];
+    const seenTokens = new Set();
+    let pageToken;
+    try {
+        do {
+            const url = new URL(`https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(accountId)}/containers/applications`);
+            url.searchParams.set("name", name);
+            if (pageToken !== undefined)
+                url.searchParams.set("page_token", pageToken);
+            const response = await fetch(url, {
+                headers: { Authorization: `Bearer ${token}`, Accept: "application/json" },
+                signal: AbortSignal.timeout(30_000),
+            });
+            if (!response.ok)
+                return { failed: true };
+            const body = await response.json();
+            if (typeof body !== "object" || body === null ||
+                !("success" in body) || body.success !== true ||
+                !("result" in body) || !Array.isArray(body.result))
+                return { failed: true };
+            const info = "result_info" in body ? body.result_info : undefined;
+            if (info !== undefined &&
+                (typeof info !== "object" || info === null || Array.isArray(info))) {
+                return { failed: true };
+            }
+            const next = info !== undefined && "next_page_token" in info
+                ? info.next_page_token
+                : undefined;
+            if (next !== undefined && next !== null && typeof next !== "string") {
+                return { failed: true };
+            }
+            // Missing pagination metadata on a full page cannot prove absence.
+            if (info === undefined && body.result.length >= 100)
+                return { failed: true };
+            entries.push(...body.result);
+            pageToken = typeof next === "string" && next.length > 0 ? next : undefined;
+            if (pageToken !== undefined) {
+                if (seenTokens.has(pageToken))
+                    return { failed: true };
+                seenTokens.add(pageToken);
+            }
+        } while (pageToken !== undefined);
+        return { failed: false, value: entries };
+    }
+    catch {
+        return { failed: true };
+    }
+}
 async function readExactTargetInventory(workerName, containerApp) {
-    const containers = await readWranglerJson([
-        "containers", "list", "--json", "--per-page", "100",
-    ]);
+    const containers = await readTargetContainers(containerApp);
     const deployments = await readWranglerJson([
         "deployments", "list", "--name", workerName, "--json",
     ]);
     return {
         containers,
         deployments,
-        containerEntries: exactContainerEntries(containers.value, containerApp),
+        containerEntries: containers.failed ? undefined : exactContainerEntries(containers.value, containerApp, true),
         deploymentEntries: exactDeploymentEntries(deployments.value),
     };
 }
@@ -883,6 +972,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 +995,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 +1021,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 +1053,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,11 +1353,14 @@ 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) => {
-        const child = spawn(process.execPath, [wranglerEntrypoint, ...args], {
+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, ...(args.includes("--config")
+                ? []
+                : ["--config", join(cwd, "wrangler.json")])], {
             cwd,
-            env: safeWranglerEnvironment(),
+            env: safeWranglerEnvironment(cwd),
             stdio: ["pipe", "pipe", "pipe"],
         });
         let stdout = "";
@@ -1298,7 +1402,7 @@ function runWranglerWithInput(args, cwd, input, timeoutMs = WRANGLER_OPERATION_T
             child.stdin.end();
         else
             child.stdin.end(input);
-    });
+    }));
 }
 function defaultProtectedStore(workerName) {
     return {
@@ -1310,7 +1414,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 +1436,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 +1502,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 +1899,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 +2377,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 +3081,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 +3104,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 +3163,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 +3264,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 +3294,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 +3337,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 +3346,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 +3389,7 @@ async function defaultRegistryRepositoryDelete(request) {
             "delete",
             `${request.repository}:${tag}`,
             "--skip-confirmation",
-        ], process.cwd());
+        ]);
         if (result.exitCode === 0) {
             deletedAny = true;
             continue;
@@ -3421,6 +3554,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 +3569,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 +3592,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 +3677,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

@@ -363,8 +363,20 @@ const EVE_EXCLUDED_FILE_NAMES = new Set([
     ".pnpmrc",
     ".pypirc",
     ".bunfig.toml",
+    "bunfig.toml",
     ".yarnrc",
     ".yarnrc.yml",
+    ".dev.vars",
+    ".netrc",
+    ".git-credentials",
+    "id_rsa",
+    "id_ecdsa",
+    "id_ed25519",
+    "id_dsa",
+    "id_ecdsa_sk",
+    "id_ed25519_sk",
+    "id_xmss",
+    "secrets.json",
     "credentials.json",
     "service-account.json",
 ]);
@@ -419,6 +431,24 @@ function isAllowedSystemAlias(path) {
     const normalized = resolve(path);
     return normalized === "/var" || normalized === "/tmp";
 }
+function isEnvironmentFile(name) {
+    const normalizedName = name.toLowerCase();
+    return normalizedName.startsWith(".env") || normalizedName.endsWith(".env");
+}
+function isCredentialPath(relativePath) {
+    const parts = relativePath.split("/");
+    const originalName = parts[parts.length - 1];
+    if (originalName === undefined)
+        return false;
+    const name = originalName.toLowerCase();
+    return (EVE_EXCLUDED_FILE_NAMES.has(originalName) ||
+        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]?.toLowerCase() === ".aws"));
+}
 function isPathExcluded(relativePath, runtimeEnvRelativePath) {
     const parts = relativePath.split("/");
     const name = parts[parts.length - 1];
@@ -437,11 +467,10 @@ function isPathExcluded(relativePath, runtimeEnvRelativePath) {
     if (runtimeEnvRelativePath !== undefined && relativePath === runtimeEnvRelativePath) {
         return { excluded: true, category: "runtime-env" };
     }
-    if (name !== undefined && name.startsWith(".env")) {
+    if (name !== undefined && isEnvironmentFile(name)) {
         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 &&
@@ -1736,10 +1765,8 @@ async function assertGeneratedTreesExcludeSecrets(snapshotRoot) {
                 ? entry.name
                 : `${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")) {
+            if (isEnvironmentFile(entry.name) ||
+                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",
@@ -191,10 +195,14 @@ function parseEnvironmentText(text) {
                 variableName: name,
             });
         }
-        if (EVE_RESERVED_HOST_VARIABLES.includes(name)) {
+        if (EVE_RESERVED_HOST_VARIABLES.includes(name) ||
+            /^(DOCKER_|BUILDKIT_|BUILDX_|COMPOSE_|LD_|DYLD_)/u.test(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

@@ -556,6 +556,15 @@ function safeDockerEnvironment() {
         LC_ALL: process.env.LC_ALL,
         DOCKER_HOST: process.env.DOCKER_HOST,
         DOCKER_CONTEXT: process.env.DOCKER_CONTEXT,
+        DOCKER_CONFIG: process.env.DOCKER_CONFIG,
+        DOCKER_CERT_PATH: process.env.DOCKER_CERT_PATH,
+        DOCKER_TLS_VERIFY: process.env.DOCKER_TLS_VERIFY,
+        HTTP_PROXY: process.env.HTTP_PROXY,
+        HTTPS_PROXY: process.env.HTTPS_PROXY,
+        NO_PROXY: process.env.NO_PROXY,
+        http_proxy: process.env.http_proxy,
+        https_proxy: process.env.https_proxy,
+        no_proxy: process.env.no_proxy,
     };
 }
 /**
@@ -567,7 +576,7 @@ function safeDockerEnvironment() {
  */
 async function docker(state, args, options = {}) {
     return execFileAsync(state.command, [...args], {
-        env: { ...state.env, ...options.environment },
+        env: { ...options.environment, ...state.env },
         cwd: state.generationRoot,
         maxBuffer: options.maxBuffer ?? 4 * 1024 * 1024,
     });
@@ -987,7 +996,8 @@ export async function buildEveRuntimeImage(request) {
                 run: (startRequest) => startRequest.env,
             });
         if (request.runtimeInjection !== undefined) {
-            const collision = Object.keys(runtimeEnvironment).find((name) => DOCKER_CLI_OWNED_VARIABLES.includes(name));
+            const collision = Object.keys(runtimeEnvironment).find((name) => DOCKER_CLI_OWNED_VARIABLES.includes(name) ||
+                /^(DOCKER_|BUILDKIT_|BUILDX_|COMPOSE_|LD_|DYLD_)/u.test(name));
             if (collision !== undefined) {
                 throw packagingError("DOCKER_PLATFORM_BLOCKED", "runtime variable name", `The runtime variable ${collision} would replace the local Docker CLI's own ${collision}.`, `Rename ${collision} in --env-file; ${DOCKER_CLI_OWNED_VARIABLES.join(", ")} are reserved for the local Docker CLI.`);
             }
@@ -1000,7 +1010,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.3",
   "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.3",
     "wrangler": "4.147.0"
   },
   "devDependencies": {