spawnfile 0.1.13 → 0.1.14

package/dist/compiler/containerArtifactsPlans.js

@@ -1,69 +1,10 @@
-import path from "node:path";
 import { createRuntimeInstallRecipe, getRuntimeAdapter } from "../runtime/index.js";
-import { SpawnfileError } from "../shared/index.js";
 import { listAgentSurfaceSecretNames } from "./agentSurfaces.js";
-import { listExecutionModelSecretNames, resolveExecutionModelAuthMethods } from "./modelEnv.js";
 import { resolveTargetResources } from "./containerTargetResources.js";
-const CONFIG_FILE_PLACEHOLDER = "<config-file>";
-const INSTANCE_ROOT_PLACEHOLDER = "<instance-root>";
-const createDefaultTargets = (inputs) => inputs.map((input) => ({
-    files: input.emittedFiles,
-    id: `${input.kind}-${input.slug}`,
-    sourceIds: [input.id]
-}));
-const resolveTargetEnvFiles = (configPath, target) => (target.envFiles ?? []).map((binding) => ({
-    envName: binding.envName,
-    filePath: path.posix.join(path.posix.dirname(configPath), binding.relativePath)
-}));
-const resolveTargetConfigEnvBindings = (meta, target) => [...(meta.configEnvBindings ?? []), ...(target.configEnvBindings ?? [])];
-const assertTargetHasConfig = (runtimeName, targetId, meta, files) => {
-    if (!files.some((file) => file.path === meta.configFileName)) {
-        throw new SpawnfileError("runtime_error", `Container target ${targetId} for ${runtimeName} is missing ${meta.configFileName}`);
-    }
-};
-const createPackageIdentity = (pkg) => `${pkg.manager}\u0000${pkg.name}\u0000${pkg.version ?? ""}\u0000${pkg.scope ?? ""}`;
-const createPackageConflictIdentity = (pkg) => `${pkg.manager}\u0000${pkg.name}`;
-const createPackageLabel = (pkg) => `${pkg.manager} package ${pkg.name}`;
-const resolveTargetPackages = (target, inputs) => {
-    const sourceIds = new Set(target.sourceIds ?? []);
-    if (sourceIds.size === 0) {
-        return [];
-    }
-    const byIdentity = new Map();
-    for (const input of inputs) {
-        if (!sourceIds.has(input.id) || input.value.kind !== "agent") {
-            continue;
-        }
-        const candidatePackages = input.value.packages ?? [];
-        for (const currentPackage of candidatePackages) {
-            const conflictIdentity = createPackageConflictIdentity(currentPackage);
-            const existingPackage = byIdentity.get(conflictIdentity);
-            if (!existingPackage) {
-                byIdentity.set(conflictIdentity, currentPackage);
-                continue;
-            }
-            if (createPackageIdentity(existingPackage) !== createPackageIdentity(currentPackage)) {
-                throw new SpawnfileError("validation_error", `Container target ${target.id} declares conflicting package definitions for ${createPackageLabel(currentPackage)}`);
-            }
-        }
-    }
-    return [...byIdentity.values()].sort((left, right) => createPackageIdentity(left).localeCompare(createPackageIdentity(right)));
-};
-const replaceContainerPathTemplate = (template, instanceRoot, configFileName) => template
-    .replaceAll(INSTANCE_ROOT_PLACEHOLDER, instanceRoot)
-    .replaceAll(CONFIG_FILE_PLACEHOLDER, configFileName);
-const resolveInstancePaths = (runtimeName, targetId, meta) => {
-    const instanceRoot = `/var/lib/spawnfile/instances/${runtimeName}/${targetId}`;
-    return {
-        configPath: replaceContainerPathTemplate(meta.instancePaths.configPathTemplate, instanceRoot, meta.configFileName),
-        homePath: meta.instancePaths.homePathTemplate
-            ? replaceContainerPathTemplate(meta.instancePaths.homePathTemplate, instanceRoot, meta.configFileName)
-            : undefined,
-        instanceRoot,
-        workspacePath: replaceContainerPathTemplate(meta.instancePaths.workspacePathTemplate, instanceRoot, meta.configFileName)
-    };
-};
-export const createEnvVariableMap = (compiledNodes, runtimePlans) => {
+import { assertTargetHasConfig, createDefaultTargets, resolveInstancePaths, resolveTargetConfigEnvBindings, resolveTargetEnvFiles, resolveTargetExposure, resolveTargetModelAuthMethods, resolveTargetModelSecrets, resolveTargetPackages } from "./containerTargetPlanResolution.js";
+import { listExecutionModelSecretNames } from "./modelEnv.js";
+import { findWorldBindingForNode } from "./worldBindings.js";
+export const createEnvVariableMap = (compiledNodes, runtimePlans, moltnet) => {
     const variables = new Map();
     const register = (name, required, description, category, generated = false) => {
         const current = variables.get(name);
@@ -89,9 +30,8 @@ export const createEnvVariableMap = (compiledNodes, runtimePlans) => {
     };
     for (const node of compiledNodes) {
         if (node.value.kind === "agent") {
-            for (const secret of node.value.secrets) {
+            for (const secret of node.value.secrets)
                 registerSecret(secret);
-            }
             for (const secretName of listExecutionModelSecretNames(node.value.execution)) {
                 register(secretName, true, `Model provider auth for ${secretName}`, "model");
             }
@@ -100,9 +40,8 @@ export const createEnvVariableMap = (compiledNodes, runtimePlans) => {
             }
             continue;
         }
-        for (const secret of node.value.shared.secrets) {
+        for (const secret of node.value.shared.secrets)
             registerSecret(secret);
-        }
     }
     for (const runtimePlan of runtimePlans) {
         for (const variable of runtimePlan.meta.env ?? []) {
@@ -112,52 +51,14 @@ export const createEnvVariableMap = (compiledNodes, runtimePlans) => {
             register(binding.envName, true, `Injected into ${runtimePlan.runtimeName} runtime config`, "runtime", binding.generated ?? false);
         }
     }
-    return variables;
-};
-const resolveTargetModelSecrets = (target, inputs) => {
-    const sourceIds = new Set(target.sourceIds ?? []);
-    if (sourceIds.size === 0) {
-        return [];
-    }
-    const secretNames = new Set();
-    for (const input of inputs) {
-        if (!sourceIds.has(input.id) || input.value.kind !== "agent") {
-            continue;
-        }
-        for (const secretName of listExecutionModelSecretNames(input.value.execution)) {
-            secretNames.add(secretName);
-        }
-    }
-    return [...secretNames].sort();
-};
-const resolveTargetModelAuthMethods = (target, inputs) => {
-    const sourceIds = new Set(target.sourceIds ?? []);
-    if (sourceIds.size === 0) {
-        return {};
-    }
-    const methods = new Map();
-    for (const input of inputs) {
-        if (!sourceIds.has(input.id) || input.value.kind !== "agent") {
-            continue;
-        }
-        for (const [provider, method] of Object.entries(resolveExecutionModelAuthMethods(input.value.execution))) {
-            const existingMethod = methods.get(provider);
-            if (existingMethod && existingMethod !== method) {
-                throw new SpawnfileError("validation_error", `Container target ${target.id} declares conflicting auth methods for provider ${provider}`);
-            }
-            methods.set(provider, method);
+    for (const serverPlan of moltnet?.serverPlans ?? []) {
+        for (const patch of serverPlan.secretPatches) {
+            register(patch.envName, true, `Managed Moltnet secret for ${serverPlan.networkId}`, "surface");
         }
     }
-    return Object.fromEntries([...methods.entries()].sort(([left], [right]) => left.localeCompare(right)));
-};
-const resolveTargetExposure = (target, inputs) => {
-    const sourceIds = new Set(target.sourceIds ?? []);
-    if (sourceIds.size === 0) {
-        return false;
-    }
-    return inputs.some((input) => sourceIds.has(input.id) && input.value.kind === "agent" && input.value.expose === true);
+    return variables;
 };
-export const createRuntimeTargetPlans = async (plan, compiledNodes) => {
+export const createRuntimeTargetPlans = async (plan, compiledNodes, worldBindings) => {
     const runtimeNames = Object.keys(plan.runtimes).sort();
     const runtimePlans = [];
     for (const runtimeName of runtimeNames) {
@@ -165,13 +66,20 @@ export const createRuntimeTargetPlans = async (plan, compiledNodes) => {
         const recipe = await createRuntimeInstallRecipe(runtimeName);
         const targetInputs = compiledNodes
             .filter((node) => node.runtimeName === runtimeName && node.emittedFiles.length > 0)
-            .map((node) => ({
-            emittedFiles: node.emittedFiles,
-            id: node.id ?? `${node.kind}:${node.slug}`,
-            kind: node.kind,
-            slug: node.slug,
-            value: node.value
-        }));
+            .map((node) => {
+            const id = node.id ?? `${node.kind}:${node.slug}`;
+            const worldBinding = node.kind === "agent"
+                ? findWorldBindingForNode(worldBindings, id)
+                : undefined;
+            return {
+                emittedFiles: node.emittedFiles,
+                id,
+                kind: node.kind,
+                slug: node.slug,
+                value: node.value,
+                ...(worldBinding ? { worldBinding } : {})
+            };
+        });
         const targets = (await adapter.createContainerTargets?.(targetInputs)) ??
             createDefaultTargets(targetInputs);
         targets.forEach((target, index) => {
@@ -180,6 +88,7 @@ export const createRuntimeTargetPlans = async (plan, compiledNodes) => {
             const portStride = adapter.container.portStride ?? 1;
             runtimePlans.push({
                 configEnvBindings: resolveTargetConfigEnvBindings(adapter.container, target) ?? [],
+                ...(target.engineByNodeId ? { engineByNodeId: target.engineByNodeId } : {}),
                 envFiles: resolveTargetEnvFiles(instancePaths.configPath, target),
                 packages: resolveTargetPackages(target, targetInputs),
                 id: target.id,
@@ -191,12 +100,16 @@ export const createRuntimeTargetPlans = async (plan, compiledNodes) => {
                 publishedPort: resolveTargetExposure(target, targetInputs) && adapter.container.port
                     ? adapter.container.port + (index * portStride)
                     : undefined,
+                recipeEnv: recipe.env,
                 resources: resolveTargetResources(target, targetInputs, instancePaths, adapter.container),
                 runtimeName,
                 runtimeRoot: recipe.runtimeRoot,
                 sourceIds: [...(target.sourceIds ?? [])].sort(),
                 targetConfigEnvBindings: target.configEnvBindings,
-                targetFiles: target.files
+                targetFiles: target.files,
+                ...(target.worldTokenEnvNames
+                    ? { worldTokenEnvNames: target.worldTokenEnvNames }
+                    : {})
             });
         });
     }

package/dist/compiler/containerArtifactsRender.d.ts

@@ -1,4 +1,4 @@
-import type { EmittedFile } from "../runtime/index.js";
+import type { EmittedFile, RuntimeContainerPackageOverrides } from "../runtime/index.js";
 import type { ContainerEnvVariable, RuntimeTargetPlan } from "./containerArtifactsTypes.js";
 import type { EntrypointOptions } from "./containerEntrypointRender.js";
 export { renderEntrypoint } from "./containerEntrypointRender.js";
@@ -7,8 +7,10 @@ export declare const renderEnvExample: (variables: ContainerEnvVariable[]) => st
 export interface DockerfileDistributionOptions {
     labels: Record<string, string>;
     reportOutputFile: string;
+    worldBindingsOutputFile?: string;
 }
 export declare const renderDockerfile: (runtimePlans: RuntimeTargetPlan[], options?: EntrypointOptions & {
     distribution?: DockerfileDistributionOptions;
+    runtimePackageOverrides?: RuntimeContainerPackageOverrides;
 }) => Promise<string>;
 export declare const createRootfsFiles: (runtimePlans: RuntimeTargetPlan[]) => EmittedFile[];

package/dist/compiler/containerArtifactsRender.js

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { DISTRIBUTION_REPORT_IMAGE_PATH } from "../distribution/index.js";
+import { DISTRIBUTION_REPORT_IMAGE_PATH, WORLD_BINDINGS_IMAGE_PATH } from "../distribution/index.js";
 import { createRuntimeInstallRecipe } from "../runtime/index.js";
 import { SpawnfileError } from "../shared/index.js";
 export { renderEntrypoint } from "./containerEntrypointRender.js";
@@ -7,8 +7,6 @@ import { MOLTNET_BIN_DIRECTORY, MOLTNET_BINARY_NAMES } from "./moltnetBinaries.j
 import { collectPackagesByManager, createAptPackageInstallItem, createNpmPackageInstallCommand, createNpmPackageInstallItem, createPackageInstallCommand, createPipxPackageInstallCommand, createPipxPackageInstallItem, getNpmInstallItemName } from "./containerPackageRender.js";
 const CONTAINER_ROOTFS_ROOT = "container/rootfs";
 const GATEWAY_PORT_PLACEHOLDER = "<gateway-port>";
-const MOLTNET_INSTALL_SCRIPT_URL = "https://moltnet.dev/install.sh";
-const MOLTNET_RELEASE_METADATA_URL = "https://api.github.com/repos/noopolis/moltnet/releases/latest";
 const WORKSPACE_PLACEHOLDER = "<workspace-path>";
 const RUNTIME_ROOT_PLACEHOLDER = "<runtime-root>";
 const shellQuote = (value) => `'${value.replace(/'/g, `'\"'\"'`)}'`;
@@ -72,19 +70,22 @@ export const renderEnvExample = (variables) => {
     return `${lines.join("\n").trimEnd()}\n`;
 };
 export const renderDockerfile = async (runtimePlans, options = {}) => {
+    if (options.hasMoltnet && !options.hasStagedMoltnetBinaries) {
+        throw new SpawnfileError("compile_error", "Moltnet must be supplied as a pinned, digest-verified, pi-bridge-stamped release; unpinned latest installation is disabled");
+    }
     const runtimeNames = [...new Set(runtimePlans.map((plan) => plan.runtimeName))];
-    const runtimeRecipes = await Promise.all(runtimeNames.map((runtimeName) => createRuntimeInstallRecipe(runtimeName)));
+    const runtimeRecipes = await Promise.all(runtimeNames.map((runtimeName) => createRuntimeInstallRecipe(runtimeName, { packageOverrides: options.runtimePackageOverrides })));
     const recipeByRuntimeName = new Map(runtimeRecipes.map((recipe) => [recipe.runtimeName, recipe]));
     const baseImage = selectBaseImage(runtimePlans, runtimeRecipes);
-    const needsJsonEnvWriter = runtimePlans.some((plan) => (plan.configEnvBindings?.length ?? 0) > 0);
+    const needsJsonEnvWriter = runtimePlans.some((plan) => (plan.configEnvBindings?.length ?? 0) > 0) || (options.moltnet?.nodePlans.length ?? 0) > 0
+        || (options.moltnet?.serverPlans ?? []).some((plan) => plan.mode === "managed"
+            && plan.configPath !== null
+            && plan.secretPatches.length > 0);
     const needsGit = runtimePlans.some((plan) => (plan.resources ?? []).some((resource) => resource.kind === "git"));
     const systemDeps = [
         ...new Set([
             ...runtimePlans.flatMap((plan) => recipeByRuntimeName.get(plan.runtimeName)?.baseImage ? [] : plan.meta.systemDeps),
             ...(needsGit ? ["git"] : []),
-            ...(options.hasMoltnet && !options.hasStagedMoltnetBinaries
-                ? ["ca-certificates", "curl", "tar"]
-                : []),
             ...(needsJsonEnvWriter ? ["python3"] : [])
         ])
     ].sort();
@@ -123,9 +124,6 @@ export const renderDockerfile = async (runtimePlans, options = {}) => {
     if (options.hasMoltnet && options.hasStagedMoltnetBinaries) {
         lines.push(`COPY ${MOLTNET_BIN_DIRECTORY}/ /usr/local/bin/`, `RUN chmod +x ${MOLTNET_BINARY_NAMES.map((binaryName) => `/usr/local/bin/${binaryName}`).join(" ")}`, "");
     }
-    else if (options.hasMoltnet) {
-        lines.push(`ADD ${MOLTNET_RELEASE_METADATA_URL} /tmp/spawnfile-moltnet-release.json`, `RUN MOLTNET_RELEASE="$${"("}sed -n 's/.*\\"tag_name\\": *\\"\\([^\\"]*\\)\\".*/\\1/p' /tmp/spawnfile-moltnet-release.json | head -n 1${")"}" && echo "Installing Moltnet $${"{MOLTNET_RELEASE:-latest}"}" && MOLTNET_INSTALL_DIR=/usr/local/bin sh -c ${shellQuote(`curl -fsSL ${MOLTNET_INSTALL_SCRIPT_URL} | sh`)}`, "");
-    }
     for (const recipe of runtimeRecipes) {
         for (const copyCommand of recipe.copyCommands) {
             lines.push(copyCommand);
@@ -144,7 +142,12 @@ export const renderDockerfile = async (runtimePlans, options = {}) => {
         lines.push(`RUN ${command}`);
     }
     if (options.distribution) {
-        lines.push("", `COPY ${options.distribution.reportOutputFile} ${DISTRIBUTION_REPORT_IMAGE_PATH}`, ...Object.entries(options.distribution.labels)
+        lines.push("", `COPY ${options.distribution.reportOutputFile} ${DISTRIBUTION_REPORT_IMAGE_PATH}`, ...(options.distribution.worldBindingsOutputFile
+            ? [
+                `COPY ${options.distribution.worldBindingsOutputFile} ${WORLD_BINDINGS_IMAGE_PATH}`,
+                `RUN chmod 600 ${WORLD_BINDINGS_IMAGE_PATH} && chown spawnfile:spawnfile ${WORLD_BINDINGS_IMAGE_PATH}`
+            ]
+            : []), ...Object.entries(options.distribution.labels)
             .sort(([left], [right]) => left.localeCompare(right))
             .map(([name, value]) => `LABEL ${name}=${shellQuote(value)}`));
     }

package/dist/compiler/containerArtifactsTypes.d.ts

@@ -14,6 +14,9 @@ export interface ContainerEnvVariable {
 }
 export interface RuntimeTargetPlan {
     configEnvBindings?: RuntimeContainerConfigEnvBinding[];
+    /** Passthrough of `ContainerTarget.engineByNodeId` (see `runtime/types.ts`), for
+     * `containerArtifacts.ts` to stamp onto `ContainerRuntimeInstanceReport.engine_by_node_id`. */
+    engineByNodeId?: Record<string, string>;
     packages?: ResolvedPackage[];
     envFiles: Array<{
         envName: string;
@@ -31,12 +34,21 @@ export interface RuntimeTargetPlan {
     modelSecretsRequired: string[];
     port?: number;
     publishedPort?: number;
+    /**
+     * Per-run container environment carried by this target's
+     * RuntimeInstallRecipe (see src/runtime/container.ts). Sourced only from
+     * the host/compile process environment (e.g. NOOPOLIS_RUN_ID), never
+     * model output. Rendered into the container RUN-time env surface
+     * (entrypoint exec env), never baked into the Dockerfile build layer.
+     */
+    recipeEnv?: Record<string, string>;
     resources?: WorkspaceResourcePlan[];
     runtimeName: string;
     runtimeRoot: string;
     sourceIds?: string[];
     targetConfigEnvBindings?: RuntimeContainerConfigEnvBinding[];
     targetFiles: EmittedFile[];
+    worldTokenEnvNames?: string[];
 }
 export interface CompiledNodeArtifact {
     emittedFiles: EmittedFile[];

package/dist/compiler/containerConfigEnvRender.d.ts

@@ -0,0 +1,3 @@
+import type { RuntimeTargetPlan } from "./containerArtifactsTypes.js";
+export declare const createConfigEnvWrites: (plan: RuntimeTargetPlan) => string[];
+export declare const createConfigEnvMaterializationFunction: () => string[];

package/dist/compiler/containerConfigEnvRender.js

@@ -0,0 +1,54 @@
+const shellQuote = (value) => `'${value.replace(/'/g, `'\"'\"'`)}'`;
+export const createConfigEnvWrites = (plan) => (plan.configEnvBindings ?? []).map((binding) => `apply_json_env_value ${shellQuote(plan.instancePaths.configPath)} ${shellQuote(binding.envName)} ${shellQuote(typeof binding.jsonPath === "string" ? binding.jsonPath : JSON.stringify(binding.jsonPath))}${binding.transform ? ` ${shellQuote(binding.transform)}` : ""}`);
+export const createConfigEnvMaterializationFunction = () => [
+    "apply_json_env_value() {",
+    '  local target="$1"',
+    '  local name="$2"',
+    '  local json_path="$3"',
+    '  local transform="${4:-}"',
+    '  if [ -z "${!name:-}" ]; then',
+    "    return",
+    "  fi",
+    '  python3 - "$target" "$name" "$json_path" "$transform" <<\'PY\'',
+    "import json",
+    "import os",
+    "import sys",
+    "",
+    "target_path = sys.argv[1]",
+    "env_name = sys.argv[2]",
+    "json_path_arg = sys.argv[3]",
+    "json_path = json.loads(json_path_arg) if json_path_arg.startswith('[') else json_path_arg.split('.')",
+    "transform = sys.argv[4] if len(sys.argv) > 4 else ''",
+    "value = os.environ.get(env_name)",
+    "if value is None:",
+    "    raise SystemExit(0)",
+    "if transform == 'bearer':",
+    "    value = f'Bearer {value}'",
+    "elif transform:",
+    "    raise SystemExit(f'Unsupported config env transform: {transform}')",
+    "",
+    "with open(target_path, encoding='utf-8') as handle:",
+    "    data = json.load(handle)",
+    "",
+    "cursor = data",
+    "for part in json_path[:-1]:",
+    "    if isinstance(cursor, list):",
+    "        cursor = cursor[int(part)]",
+    "        continue",
+    "    child = cursor.get(part)",
+    "    if not isinstance(child, (dict, list)):",
+    "        child = {}",
+    "        cursor[part] = child",
+    "    cursor = child",
+    "",
+    "if isinstance(cursor, list):",
+    "    cursor[int(json_path[-1])] = value",
+    "else:",
+    "    cursor[json_path[-1]] = value",
+    "",
+    "with open(target_path, 'w', encoding='utf-8') as handle:",
+    "    json.dump(data, handle, indent=2)",
+    "    handle.write('\\n')",
+    "PY",
+    "}",
+];

package/dist/compiler/containerEntrypointRender.d.ts

@@ -4,6 +4,7 @@ export interface EntrypointOptions {
     hasMoltnet?: boolean;
     hasStagedMoltnetBinaries?: boolean;
     moltnet?: {
+        externalParticipantArtifacts?: NonNullable<MoltnetArtifacts["externalParticipantArtifacts"]>;
         nodePlans: MoltnetArtifacts["nodePlans"];
         serverPlans: MoltnetArtifacts["serverPlans"];
     };

package/dist/compiler/containerEntrypointRender.js

@@ -1,17 +1,31 @@
 import path from "node:path";
-import { resolveMoltnetStorePath } from "./moltnetConfigLowering.js";
+import { createMoltnetCausalEventsPath, resolveMoltnetStorePath } from "./moltnetConfigLowering.js";
 import { networkUrlEnvName } from "./networkBinding.js";
 import { createWorkspaceResourceCommands, createWorkspaceResourceShellFunctions } from "./containerWorkspaceResourceRender.js";
+import { createConfigEnvMaterializationFunction, createConfigEnvWrites } from "./containerConfigEnvRender.js";
+import { CLI_CREDENTIAL_SECRET_NAME, modelAuthMethodNeedsCliCredential } from "./modelEnv.js";
+import { createCliCredentialMaterialization, createRecipeEnvAssignments, mergeRecipeEnv, shellQuote } from "./containerEntrypointShell.js";
 const MOLTNET_SERVER_DATA_DIRECTORY = "/var/lib/spawnfile/moltnet/servers";
-const shellQuote = (value) => `'${value.replace(/'/g, `'\"'\"'`)}'`;
+// moltnet reads this path from MOLTNET_CAUSAL_EVENTS_PATH
+// (internal/app/config_load.go's mergeEnvConfig) and, when set, stamps
+// every message.accepted/message.denied causal event there via
+// internal/observability/causal.go's CausalWriter (nil/no-op otherwise).
+// Always set, independent of the network's own store.kind (a memory-store
+// network — e.g. office-sim's fixture — still gets a causal log). Points
+// into a dedicated `causal/` subdirectory of the server's data directory
+// (see createMoltnetCausalDirectory/createMoltnetCausalEventsPath) that
+// moltnetArtifacts.ts registers as its own persistent mount, so it survives
+// container teardown/restart via a host-backed named docker volume instead
+// of only being recoverable through a live-container `docker cp` (the
+// previous e2e-capture-only precedent).
+const moltnetCausalEventsPath = createMoltnetCausalEventsPath;
 const createEnvironmentAssignments = (plan) => {
     const envAssignments = [];
     if (plan.instancePaths.homePath) {
         envAssignments.push(`HOME=${shellQuote(plan.instancePaths.homePath)}`);
     }
     if (plan.instancePaths.homePath &&
-        plan.runtimeName === "picoclaw" &&
-        plan.modelAuthMethods.openai === "codex") {
+        Object.values(plan.modelAuthMethods).some(modelAuthMethodNeedsCliCredential)) {
         envAssignments.push(`CODEX_HOME=${shellQuote(path.posix.join(plan.instancePaths.homePath, ".codex"))}`);
     }
     if (plan.meta.homeEnv && plan.instancePaths.homePath) {
@@ -26,10 +40,10 @@ const createEnvironmentAssignments = (plan) => {
     for (const [name, value] of Object.entries(plan.meta.staticEnv ?? {}).sort(([left], [right]) => left.localeCompare(right))) {
         envAssignments.push(`${name}=${shellQuote(value)}`);
     }
+    envAssignments.push(...createRecipeEnvAssignments(plan.recipeEnv));
     return envAssignments;
 };
 const createEnvFileWrites = (plan) => plan.envFiles.map((binding) => `write_env_file ${shellQuote(binding.envName)} ${shellQuote(binding.filePath)}`);
-const createConfigEnvWrites = (plan) => (plan.configEnvBindings ?? []).map((binding) => `apply_json_env_value ${shellQuote(plan.instancePaths.configPath)} ${shellQuote(binding.envName)} ${shellQuote(binding.jsonPath)}`);
 const createMoltnetStorePrepareCommands = (serverPlan) => {
     const server = serverPlan.server;
     if (server.mode !== "managed" || server.store.kind === "memory" || server.store.kind === "postgres") {
@@ -67,6 +81,13 @@ const createRuntimeReadinessWait = (plan) => {
     ];
 };
 export const renderEntrypoint = (runtimePlans, requiredSecrets, options = {}) => {
+    const cliCredentialMaterialization = createCliCredentialMaterialization(runtimePlans);
+    const renderedRequiredSecrets = [
+        ...new Set([
+            ...requiredSecrets,
+            ...(cliCredentialMaterialization.length > 0 ? [CLI_CREDENTIAL_SECRET_NAME] : [])
+        ])
+    ];
     const lines = [
         "#!/usr/bin/env bash",
         "set -euo pipefail",
@@ -97,61 +118,21 @@ export const renderEntrypoint = (runtimePlans, requiredSecrets, options = {}) =>
         '  printf %s \"${!name:-}\" > \"$target\"',
         "}",
         "",
-        "apply_json_env_value() {",
-        '  local target=\"$1\"',
-        '  local name=\"$2\"',
-        '  local json_path=\"$3\"',
-        '  if [ -z \"${!name:-}\" ]; then',
-        "    return",
-        "  fi",
-        "  python3 - \"$target\" \"$name\" \"$json_path\" <<'PY'",
-        "import json",
-        "import os",
-        "import sys",
-        "",
-        "target_path = sys.argv[1]",
-        "env_name = sys.argv[2]",
-        "json_path = sys.argv[3].split('.')",
-        "value = os.environ.get(env_name)",
-        "if value is None:",
-        "    raise SystemExit(0)",
-        "",
-        "with open(target_path, encoding='utf-8') as handle:",
-        "    data = json.load(handle)",
-        "",
-        "cursor = data",
-        "for part in json_path[:-1]:",
-        "    if isinstance(cursor, list):",
-        "        cursor = cursor[int(part)]",
-        "        continue",
-        "    child = cursor.get(part)",
-        "    if not isinstance(child, (dict, list)):",
-        "        child = {}",
-        "        cursor[part] = child",
-        "    cursor = child",
-        "",
-        "if isinstance(cursor, list):",
-        "    cursor[int(json_path[-1])] = value",
-        "else:",
-        "    cursor[json_path[-1]] = value",
-        "",
-        "with open(target_path, 'w', encoding='utf-8') as handle:",
-        "    json.dump(data, handle, indent=2)",
-        "    handle.write('\\n')",
-        "PY",
-        "}",
+        ...createConfigEnvMaterializationFunction(),
         "",
         ...createWorkspaceResourceShellFunctions()
     ];
     lines.push('if [ -n "${OPENCLAW_GATEWAY_TOKEN:-}" ] && [ -z "${OPENCLAW_HOOKS_TOKEN:-}" ]; then', '  export OPENCLAW_HOOKS_TOKEN="hooks-${OPENCLAW_GATEWAY_TOKEN}"', "fi", "");
-    for (const secretName of requiredSecrets) {
+    for (const secretName of renderedRequiredSecrets) {
         lines.push(`require_env ${shellQuote(secretName)}`);
     }
-    if (requiredSecrets.length > 0) {
+    if (renderedRequiredSecrets.length > 0) {
         lines.push("");
     }
+    lines.push(...cliCredentialMaterialization);
     const moltnetServerPlans = options.moltnet?.serverPlans ?? [];
     const moltnetNodePlans = options.moltnet?.nodePlans ?? [];
+    const moltnetExternalParticipants = options.moltnet?.externalParticipantArtifacts ?? [];
     if (runtimePlans.length === 1 &&
         moltnetServerPlans.length === 0 &&
         moltnetNodePlans.length === 0) {
@@ -162,6 +143,8 @@ export const renderEntrypoint = (runtimePlans, requiredSecrets, options = {}) =>
         return `${lines.join("\n").trimEnd()}\n`;
     }
     lines.push("PIDS=()", "", "terminate_children() {", '  for pid in "${PIDS[@]:-}"; do', '    kill "$pid" 2>/dev/null || true', "  done", "}", "", "trap terminate_children INT TERM EXIT", "");
+    const recipeEnvAssignments = createRecipeEnvAssignments(mergeRecipeEnv(runtimePlans));
+    const recipeEnvPrefix = recipeEnvAssignments.length > 0 ? `${recipeEnvAssignments.join(" ")} ` : "";
     const managedMoltnetServerPlans = moltnetServerPlans.filter((serverPlan) => serverPlan.mode === "managed");
     if (managedMoltnetServerPlans.length > 0) {
         lines.push(`mkdir -p ${shellQuote(MOLTNET_SERVER_DATA_DIRECTORY)}`, "");
@@ -175,10 +158,31 @@ export const renderEntrypoint = (runtimePlans, requiredSecrets, options = {}) =>
         for (const patch of serverPlan.secretPatches) {
             serverLines.push(`apply_json_env_value ${shellQuote(serverPlan.configPath)} ${shellQuote(patch.envName)} ${shellQuote(patch.jsonPath)}`);
         }
-        serverLines.push(...createMoltnetStorePrepareCommands(serverPlan), `MOLTNET_CONFIG=${shellQuote(serverPlan.configPath)} /usr/local/bin/moltnet &`, 'PIDS+=("$!")');
+        const causalEventsPath = moltnetCausalEventsPath(serverPlan.configPath);
+        serverLines.push(...createMoltnetStorePrepareCommands(serverPlan), `MOLTNET_CONFIG=${shellQuote(serverPlan.configPath)} MOLTNET_CAUSAL_EVENTS_PATH=${shellQuote(causalEventsPath)} ${recipeEnvPrefix}/usr/local/bin/moltnet &`, 'PIDS+=("$!")');
         if (serverPlan.port) {
             serverLines.push(`until curl -sf ${shellQuote(`http://127.0.0.1:${serverPlan.port}/healthz`)} >/dev/null; do sleep 1; done`);
         }
+        const externalParticipants = moltnetExternalParticipants.filter((artifact) => artifact.network.id === serverPlan.networkId);
+        if (externalParticipants.length > 0) {
+            const clientTokenId = serverPlan.server.auth.client?.token_id;
+            const clientToken = serverPlan.server.auth.tokens?.find((token) => token.id === clientTokenId);
+            if (!serverPlan.port || !clientToken?.secret) {
+                throw new Error(`Managed Moltnet external participant topology for ${serverPlan.networkId} requires an operator token and port`);
+            }
+            for (const artifact of externalParticipants) {
+                for (const directMessage of artifact.direct_messages) {
+                    serverLines.push([
+                        "/usr/local/bin/moltnet admin dm ensure",
+                        `--sender ${shellQuote(artifact.participant.member_id)}`,
+                        ...directMessage.members.map((member) => `--member ${shellQuote(member)}`),
+                        `--base-url ${shellQuote(`http://127.0.0.1:${serverPlan.port}`)}`,
+                        `--token-env ${shellQuote(clientToken.secret)}`,
+                        ">/dev/null"
+                    ].join(" "));
+                }
+            }
+        }
         // Suppress the in-image managed server when an external endpoint is bound.
         lines.push(`if [ -z "\${${urlEnv}:-}" ]; then`, ...serverLines.map((line) => `  ${line}`), "fi", "");
     }
@@ -191,7 +195,7 @@ export const renderEntrypoint = (runtimePlans, requiredSecrets, options = {}) =>
         const urlEnv = networkUrlEnvName(nodePlan.networkId);
         lines.push(
         // Rebind the bridge endpoint when an external network URL is provided.
-        `if [ -n "\${${urlEnv}:-}" ]; then`, `  apply_json_env_value ${shellQuote(nodePlan.configPath)} ${shellQuote(urlEnv)} ${shellQuote("moltnet.base_url")}`, "fi", `/usr/local/bin/moltnet node ${shellQuote(nodePlan.configPath)} &`, 'PIDS+=("$!")', "");
+        `if [ -n "\${${urlEnv}:-}" ]; then`, `  apply_json_env_value ${shellQuote(nodePlan.configPath)} ${shellQuote(urlEnv)} ${shellQuote("moltnet.base_url")}`, "fi", `${recipeEnvPrefix}/usr/local/bin/moltnet node ${shellQuote(nodePlan.configPath)} &`, 'PIDS+=("$!")', "");
     }
     lines.push('if [ "${#PIDS[@]}" -eq 0 ]; then', '  echo "No runtime targets were generated for this compile output" >&2', "  exit 1", "fi", "", "status=0", 'for pid in "${PIDS[@]}"; do', '  if ! wait "$pid"; then', "    status=1", "  fi", "done", "", 'exit "$status"');
     return `${lines.join("\n").trimEnd()}\n`;

package/dist/compiler/containerEntrypointShell.d.ts

@@ -0,0 +1,5 @@
+import type { RuntimeTargetPlan } from "./containerArtifactsTypes.js";
+export declare const shellQuote: (value: string) => string;
+export declare const createRecipeEnvAssignments: (recipeEnv: Record<string, string> | undefined) => string[];
+export declare const mergeRecipeEnv: (runtimePlans: RuntimeTargetPlan[]) => Record<string, string>;
+export declare const createCliCredentialMaterialization: (runtimePlans: RuntimeTargetPlan[]) => string[];

package/dist/compiler/containerEntrypointShell.js

@@ -0,0 +1,29 @@
+import path from "node:path";
+import { CLI_CREDENTIAL_SECRET_NAME, modelAuthMethodNeedsCliCredential } from "./modelEnv.js";
+export const shellQuote = (value) => `'${value.replace(/'/g, `'"'"'`)}'`;
+export const createRecipeEnvAssignments = (recipeEnv) => Object.entries(recipeEnv ?? {})
+    .sort(([left], [right]) => left.localeCompare(right))
+    .map(([name, value]) => `${name}=${shellQuote(value)}`);
+export const mergeRecipeEnv = (runtimePlans) => runtimePlans.reduce((merged, plan) => ({ ...merged, ...(plan.recipeEnv ?? {}) }), {});
+export const createCliCredentialMaterialization = (runtimePlans) => {
+    const homePaths = [...new Set(runtimePlans
+            .filter((plan) => plan.instancePaths.homePath &&
+            Object.values(plan.modelAuthMethods).some(modelAuthMethodNeedsCliCredential))
+            .map((plan) => path.posix.join(plan.instancePaths.homePath, ".codex")))];
+    if (homePaths.length === 0)
+        return [];
+    return [
+        "# SPAWNFILE_CLI_AUTH_JSON persists in Config.Env for the container's lifetime.",
+        "# unset removes it from runtime processes' environments but cannot remove it from the container definition.",
+        "# Anyone with docker access on the host can read it, and every docker exec inherits it.",
+        "# This is accepted because the target host is single-user and the container is destroyed each run;",
+        "# a non-env delivery route is the fix if this ever runs anywhere shared.",
+        ...homePaths.flatMap((homePath) => [
+            `mkdir -m 700 -p ${shellQuote(homePath)}`,
+            `printf %s "\${${CLI_CREDENTIAL_SECRET_NAME}}" > ${shellQuote(path.posix.join(homePath, "auth.json"))}`,
+            `chmod 600 ${shellQuote(path.posix.join(homePath, "auth.json"))}`
+        ]),
+        `unset ${CLI_CREDENTIAL_SECRET_NAME}`,
+        ""
+    ];
+};

package/dist/compiler/containerPackageOverrides.d.ts

@@ -0,0 +1,27 @@
+import type { RuntimeContainerPackageOverrides } from "../runtime/index.js";
+/**
+ * Compile-time-only request map: runtime install npm package name (e.g.
+ * "@noopolis/daimon") to the absolute local package directory that should
+ * be packed and installed into the generated container instead of the
+ * pinned registry version. Only opt-in local/E2E compiles set this (see
+ * src/e2e/AGENTS.md); a standard compile passes no overrides and the
+ * generated Dockerfile install line is byte-identical to before this
+ * mechanism existed.
+ */
+export type RuntimePackageOverrideRequest = Record<string, string>;
+/**
+ * Packs each overridden runtime install package's local directory into the
+ * generated container's build context (`<outputDirectory>/container/vendor`)
+ * via `npm pack`, so `renderDockerfile` (containerArtifactsRender.ts) can
+ * COPY the tarball into the image and `createRuntimeInstallRecipe`
+ * (src/runtime/container.ts) can install from it instead of the registry.
+ * Mirrors how `stageMoltnetBinaries` (moltnetBinaries.ts) stages binaries
+ * directly onto disk outside the EmittedFile pipeline — a `.tgz` cannot
+ * round-trip through EmittedFile's string `content`.
+ *
+ * The caller is responsible for ensuring each override's `dist` is already
+ * built (see `assertRuntimePackageOverrideDistsBuilt` in
+ * src/e2e/runtimePackageOverrides.ts) — this function only packs, it never
+ * builds.
+ */
+export declare const stageRuntimePackageOverrides: (outputDirectory: string, overrides: RuntimePackageOverrideRequest | undefined) => Promise<RuntimeContainerPackageOverrides | undefined>;