spawnfile 0.1.13 → 0.1.17

package/dist/compiler/containerEntrypointRender.js

@@ -1,17 +1,34 @@
 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";
+import { MOLTNET_READINESS_DIRECTORY } from "./containerReadinessPaths.js";
+import { createRuntimeReadinessWait } from "./containerRuntimeReadinessRender.js";
+import { createBackedMountGuard } from "./containerBackedMountRender.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 +43,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") {
@@ -45,32 +62,36 @@ const resolveStartCommand = (plan) => plan.meta.startCommand
     .map((token) => token
     .replaceAll("<config-path>", plan.instancePaths.configPath)
     .replaceAll("<home-path>", plan.instancePaths.homePath ?? "")
+    .replaceAll("<instance-root>", plan.instancePaths.instanceRoot ?? "")
     .replaceAll("<runtime-root>", plan.runtimeRoot)
     .replaceAll("<workspace-path>", plan.instancePaths.workspacePath)
     .replaceAll("<port>", plan.port ? String(plan.port) : ""))
     .filter((token) => token.length > 0);
-const createRuntimeReadinessWait = (plan) => {
-    if (!["openclaw", "pi"].includes(plan.runtimeName) || !plan.port) {
-        return [];
-    }
-    return [
-        "attempts=0",
-        `until curl -sf ${shellQuote(`http://127.0.0.1:${plan.port}/healthz`)} >/dev/null; do`,
-        "  attempts=$((attempts + 1))",
-        '  if [ "$attempts" -ge 180 ]; then',
-        `    echo ${shellQuote(`Timed out waiting for ${plan.runtimeName} on port ${plan.port}`)} >&2`,
-        "    exit 1",
-        "  fi",
-        "  sleep 1",
-        "done",
-        ""
-    ];
-};
 export const renderEntrypoint = (runtimePlans, requiredSecrets, options = {}) => {
+    const usesDaimonRuntime = runtimePlans.some((plan) => plan.runtimeName === "daimon");
+    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",
+        ...(usesDaimonRuntime ? [
+            'if [ "$#" -ne 3 ] || [ "$1" != "--spawnfile-runtime-identity" ]; then echo "Missing trusted Daimon runtime identity" >&2; exit 1; fi',
+            'volume_bootstrap_uid="$2"',
+            'volume_bootstrap_gid="$3"',
+            'if ! [[ "$volume_bootstrap_uid" =~ ^[1-9][0-9]{0,9}$ ]] || [ "$volume_bootstrap_uid" -gt 2147483647 ]; then echo "Invalid trusted Daimon runtime UID" >&2; exit 1; fi',
+            'if ! [[ "$volume_bootstrap_gid" =~ ^[1-9][0-9]{0,9}$ ]] || [ "$volume_bootstrap_gid" -gt 2147483647 ]; then echo "Invalid trusted Daimon runtime GID" >&2; exit 1; fi',
+            "shift 3"
+        ] : [
+            "volume_bootstrap_uid=1001",
+            "volume_bootstrap_gid=1001"
+        ]),
         "",
+        ...createBackedMountGuard(options.persistentMounts ?? []),
         "require_env() {",
         '  local name=\"$1\"',
         '  if [ -z \"${!name:-}\" ]; then',
@@ -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,13 @@ 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", "");
+    for (const receiptDirectory of [...new Set(moltnetNodePlans.flatMap((plan) => plan.receiptStorePath ? [path.posix.dirname(plan.receiptStorePath)] : []))].sort()) {
+        lines.push(`install -d -m 700 ${shellQuote(receiptDirectory)}`);
+    }
+    if (moltnetNodePlans.some((plan) => plan.receiptStorePath))
+        lines.push("");
+    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,9 +163,30 @@ 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 start --config ${shellQuote(serverPlan.configPath)} &`, 'moltnet_server_pid="$!"', 'PIDS+=("$moltnet_server_pid")');
         if (serverPlan.port) {
-            serverLines.push(`until curl -sf ${shellQuote(`http://127.0.0.1:${serverPlan.port}/healthz`)} >/dev/null; do sleep 1; done`);
+            serverLines.push(`until curl -sf ${shellQuote(`http://127.0.0.1:${serverPlan.port}/healthz`)} >/dev/null; do if ! kill -0 "$moltnet_server_pid" 2>/dev/null; then wait "$moltnet_server_pid" || true; echo ${shellQuote(`Moltnet exited before readiness on port ${serverPlan.port}`)} >&2; exit 1; fi; 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", "");
@@ -185,14 +194,15 @@ export const renderEntrypoint = (runtimePlans, requiredSecrets, options = {}) =>
     for (const plan of runtimePlans) {
         const commandTokens = resolveStartCommand(plan);
         const envAssignments = createEnvironmentAssignments(plan);
-        lines.push(`mkdir -p ${shellQuote(plan.instancePaths.workspacePath)}`, ...createWorkspaceResourceCommands(plan), `require_file ${shellQuote(plan.instancePaths.configPath)}`, ...createEnvFileWrites(plan), ...createConfigEnvWrites(plan), `${envAssignments.join(" ")} ${commandTokens.map(shellQuote).join(" ")} &`, 'PIDS+=("$!")', "", ...createRuntimeReadinessWait(plan));
+        lines.push(`mkdir -p ${shellQuote(plan.instancePaths.workspacePath)}`, ...createWorkspaceResourceCommands(plan), `require_file ${shellQuote(plan.instancePaths.configPath)}`, ...createEnvFileWrites(plan), ...createConfigEnvWrites(plan), `${envAssignments.join(" ")} ${commandTokens.map(shellQuote).join(" ")} &`, 'runtime_pid="$!"', 'PIDS+=("$runtime_pid")', "", ...createRuntimeReadinessWait(plan, "runtime_pid"));
     }
     for (const nodePlan of moltnetNodePlans) {
         const urlEnv = networkUrlEnvName(nodePlan.networkId);
+        const receiptPath = `${MOLTNET_READINESS_DIRECTORY}/${nodePlan.networkId}-${nodePlan.memberId}.json`;
         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", `install -d -m 700 ${shellQuote(path.posix.dirname(receiptPath))}`, `rm -f ${shellQuote(receiptPath)}`, `MOLTNET_NODE_READINESS_RECEIPT=${shellQuote(receiptPath)} ${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"');
+    lines.push('if [ "${#PIDS[@]}" -eq 0 ]; then', '  echo "No runtime targets were generated for this compile output" >&2', "  exit 1", "fi", "", "# Every child is critical. Exit on the first child termination so Docker", "# can restart the complete, mutually consistent organization unit.", "set +e", 'wait -n "${PIDS[@]}"', "status=$?", "set -e", "terminate_children", 'for pid in "${PIDS[@]}"; do wait "$pid" 2>/dev/null || true; done', 'if [ "$status" -eq 0 ]; then status=1; fi', '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>;

package/dist/compiler/containerPackageOverrides.js

@@ -0,0 +1,63 @@
+import { execFile as execFileCallback } from "node:child_process";
+import path from "node:path";
+import { promisify } from "node:util";
+import { ensureDirectory } from "../filesystem/index.js";
+import { VENDOR_BUILD_CONTEXT_DIR } from "../runtime/index.js";
+import { SpawnfileError } from "../shared/index.js";
+const execFile = promisify(execFileCallback);
+const packOverride = async (packageName, packageDirectory, vendorDirectory) => {
+    try {
+        const { stdout } = await execFile("npm", [
+            "pack",
+            "--json",
+            // Every caller (assertRuntimePackageOverrideDistsBuilt in
+            // src/e2e/runtimePackageOverrides.ts) already asserts the
+            // override directory's dist is built before packing, so a `prepack`
+            // lifecycle script here would only redundantly rebuild it — and, since
+            // several packages' own `prepack` runs `rm -rf dist && tsc`, doing so
+            // is actively unsafe when two compiles pack the same shared source
+            // directory concurrently (one's `rm -rf` can race another's dist read).
+            "--ignore-scripts",
+            "--pack-destination",
+            vendorDirectory,
+            packageDirectory
+        ]);
+        const entries = JSON.parse(stdout);
+        const filename = entries[0]?.filename;
+        if (!filename) {
+            throw new Error("npm pack did not report a packed filename");
+        }
+        return { filename };
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new SpawnfileError("compile_error", `Unable to pack local override for ${packageName} from ${packageDirectory}: ${reason}`);
+    }
+};
+/**
+ * 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 const stageRuntimePackageOverrides = async (outputDirectory, overrides) => {
+    if (!overrides || Object.keys(overrides).length === 0) {
+        return undefined;
+    }
+    const vendorDirectory = path.join(outputDirectory, VENDOR_BUILD_CONTEXT_DIR);
+    await ensureDirectory(vendorDirectory);
+    const resolved = {};
+    for (const [packageName, packageDirectory] of Object.entries(overrides)) {
+        resolved[packageName] = await packOverride(packageName, packageDirectory, vendorDirectory);
+    }
+    return resolved;
+};

package/dist/compiler/containerPersistentMounts.d.ts

@@ -0,0 +1,30 @@
+import type { ContainerPersistentMountReport } from "../report/types.js";
+/**
+ * Merges every durable-mount source into one report list.
+ *
+ * Sources are independent (memory banks, workspace `kind: volume` resources,
+ * Daimon telemetry, runtime-declared mounts, Moltnet stores and token
+ * directories) and may legitimately name the same mount twice; two sources
+ * describing one id DIFFERENTLY is a compile error, as is two ids claiming one
+ * host volume name.
+ */
+export declare const mergePersistentMounts: (candidates: readonly ContainerPersistentMountReport[]) => ContainerPersistentMountReport[];
+/**
+ * Durable mount names come from four independent sources — memory banks
+ * (`memoryArtifacts.ts`), workspace `kind: volume` resources
+ * (`containerTargetResources.ts`), Moltnet stores and token directories
+ * (`moltnetArtifacts.ts`), and runtime-declared mounts (`runtimePlans`) —
+ * and each source only ever checked itself.
+ *
+ * Author-declared names cross those boundaries. A resource with
+ * `name: X` and a managed Moltnet store with `persistence.name: X` used to
+ * compile to two mounts at two different paths carrying one `volume_name`, so
+ * `spawnfile run` mounted a single host volume at both. A sqlite store and a
+ * team's edition state then shared one directory, where their bootstrap-marker
+ * and replacement-sentinel protocols contradict each other.
+ *
+ * There is no safe interpretation of that declaration, so it fails at compile
+ * naming both sides. (Two mounts legitimately SHARE a name only when they are
+ * the same mount, which the id-keyed merge upstream has already collapsed.)
+ */
+export declare const assertPersistentMountVolumeNamesAreUnique: (mounts: readonly ContainerPersistentMountReport[]) => void;

package/dist/compiler/containerPersistentMounts.js

@@ -0,0 +1,66 @@
+import { SpawnfileError } from "../shared/index.js";
+/**
+ * Merges every durable-mount source into one report list.
+ *
+ * Sources are independent (memory banks, workspace `kind: volume` resources,
+ * Daimon telemetry, runtime-declared mounts, Moltnet stores and token
+ * directories) and may legitimately name the same mount twice; two sources
+ * describing one id DIFFERENTLY is a compile error, as is two ids claiming one
+ * host volume name.
+ */
+export const mergePersistentMounts = (candidates) => {
+    const byId = new Map();
+    const merged = [...candidates]
+        .sort((left, right) => left.id.localeCompare(right.id))
+        .filter((mount) => {
+        const existing = byId.get(mount.id);
+        if (!existing) {
+            byId.set(mount.id, mount);
+            return true;
+        }
+        if (existing.mount_path !== mount.mount_path ||
+            existing.volume_name !== mount.volume_name ||
+            existing.reason !== mount.reason ||
+            existing.lifecycle !== mount.lifecycle) {
+            throw new SpawnfileError("validation_error", `Container persistent mount ${mount.id} resolves to conflicting targets`);
+        }
+        // Deliberately kept, not deduplicated: two sources describing one mount
+        // identically was already reported twice before this merge was extracted,
+        // and silently changing that is not this fix's business.
+        return true;
+    });
+    assertPersistentMountVolumeNamesAreUnique(merged);
+    return merged;
+};
+/**
+ * Durable mount names come from four independent sources — memory banks
+ * (`memoryArtifacts.ts`), workspace `kind: volume` resources
+ * (`containerTargetResources.ts`), Moltnet stores and token directories
+ * (`moltnetArtifacts.ts`), and runtime-declared mounts (`runtimePlans`) —
+ * and each source only ever checked itself.
+ *
+ * Author-declared names cross those boundaries. A resource with
+ * `name: X` and a managed Moltnet store with `persistence.name: X` used to
+ * compile to two mounts at two different paths carrying one `volume_name`, so
+ * `spawnfile run` mounted a single host volume at both. A sqlite store and a
+ * team's edition state then shared one directory, where their bootstrap-marker
+ * and replacement-sentinel protocols contradict each other.
+ *
+ * There is no safe interpretation of that declaration, so it fails at compile
+ * naming both sides. (Two mounts legitimately SHARE a name only when they are
+ * the same mount, which the id-keyed merge upstream has already collapsed.)
+ */
+export const assertPersistentMountVolumeNamesAreUnique = (mounts) => {
+    const byVolumeName = new Map();
+    for (const mount of mounts) {
+        const existing = byVolumeName.get(mount.volume_name);
+        if (existing && existing.mount_path !== mount.mount_path) {
+            throw new SpawnfileError("validation_error", `Durable volume name "${mount.volume_name}" is claimed by two different mounts: `
+                + `${existing.id} (${existing.reason}) at ${existing.mount_path}, and `
+                + `${mount.id} (${mount.reason}) at ${mount.mount_path}. `
+                + "One host volume cannot back two container paths; give each declaration its own name.");
+        }
+        if (!existing)
+            byVolumeName.set(mount.volume_name, mount);
+    }
+};

package/dist/compiler/containerReadinessPaths.d.ts

@@ -0,0 +1 @@
+export declare const MOLTNET_READINESS_DIRECTORY = "/run/spawnfile/moltnet-readiness";

package/dist/compiler/containerReadinessPaths.js

@@ -0,0 +1 @@
+export const MOLTNET_READINESS_DIRECTORY = "/run/spawnfile/moltnet-readiness";

package/dist/compiler/containerRuntimeLinkMaterializer.d.ts

@@ -0,0 +1,2 @@
+export declare const RUNTIME_LINK_MATERIALIZER_PATH = "/opt/spawnfile/materialize-runtime-links.cjs";
+export declare const renderRuntimeLinkMaterializer: () => string;

package/dist/compiler/containerRuntimeLinkMaterializer.js

@@ -0,0 +1,12 @@
+export const RUNTIME_LINK_MATERIALIZER_PATH = "/opt/spawnfile/materialize-runtime-links.cjs";
+export const renderRuntimeLinkMaterializer = () => `"use strict";
+const fs=require("node:fs"),path=require("node:path"),root=path.resolve(process.argv[2]||"");
+if(!root.startsWith("/opt/spawnfile/runtime-installs/"))throw Error("unsafe root");
+const rootInfo=fs.lstatSync(root),links=[];
+if(!rootInfo.isDirectory()||rootInfo.isSymbolicLink()||rootInfo.uid||rootInfo.gid)throw Error("unsafe root identity");
+const walk=d=>{for(const n of fs.readdirSync(d).sort()){const p=path.join(d,n),s=fs.lstatSync(p);if(s.isSymbolicLink())links.push(p);else if(s.isDirectory())walk(p);else if(!s.isFile())throw Error("unsupported entry");}};
+const inside=p=>p.startsWith(root+path.sep);
+const resolve=p=>{let hops=0;for(;;){const rel=path.relative(root,p);if(!rel||rel.startsWith("..")||path.isAbsolute(rel))throw Error("link escape");const parts=rel.split(path.sep);let q=root,again=false;for(let i=0;i<parts.length;i++){q=path.join(q,parts[i]);const s=fs.lstatSync(q);if(!s.isSymbolicLink())continue;if(++hops>16||s.uid||s.gid)throw Error("unsafe link chain");const l=fs.readlinkSync(q);if(path.isAbsolute(l))throw Error("absolute link");p=path.resolve(path.dirname(q),l,...parts.slice(i+1));if(!inside(p))throw Error("link escape");again=true;break;}if(!again)return p;}};
+walk(root);
+for(const link of links){const s=fs.lstatSync(link);if(!s.isSymbolicLink()||s.uid||s.gid)throw Error("link changed");const target=resolve(link),t=fs.lstatSync(target);if(!t.isFile()||t.isSymbolicLink()||t.uid||t.gid||t.dev!==rootInfo.dev||t.nlink<1)throw Error("unsafe target");const b=fs.readFileSync(target);if(b.length>67108864)throw Error("target too large");const tmp=link+".spawnfile-materialize",fd=fs.openSync(tmp,fs.constants.O_CREAT|fs.constants.O_EXCL|fs.constants.O_WRONLY|fs.constants.O_NOFOLLOW,t.mode&0o111?0o555:0o444);try{fs.writeFileSync(fd,b);fs.fsyncSync(fd);}finally{fs.closeSync(fd);}fs.renameSync(tmp,link);}
+`;

package/dist/compiler/containerRuntimeReadinessRender.d.ts

@@ -0,0 +1,7 @@
+import type { RuntimeTargetPlan } from "./containerArtifactsTypes.js";
+/**
+ * Blocks until a runtime with an HTTP port answers /healthz, failing fast if
+ * the child dies first. Split out of containerEntrypointRender.ts to keep that
+ * module under the repository's 400-line ceiling.
+ */
+export declare const createRuntimeReadinessWait: (plan: RuntimeTargetPlan, pidVariable: string) => string[];

package/dist/compiler/containerRuntimeReadinessRender.js

@@ -0,0 +1,40 @@
+import { shellQuote } from "./containerEntrypointShell.js";
+/**
+ * Blocks until a runtime with an HTTP port answers /healthz, failing fast if
+ * the child dies first. Split out of containerEntrypointRender.ts to keep that
+ * module under the repository's 400-line ceiling.
+ */
+export const createRuntimeReadinessWait = (plan, pidVariable) => {
+    if (!plan.port)
+        return [];
+    if (plan.runtimeName === "daimon") {
+        return [
+            "attempts=0",
+            `until curl -sf ${shellQuote(`http://127.0.0.1:${plan.port}/healthz`)} >/dev/null; do`,
+            `  if ! kill -0 "$${pidVariable}" 2>/dev/null; then wait "$${pidVariable}" || true; echo ${shellQuote(`Daimon exited before readiness on port ${plan.port}`)} >&2; exit 1; fi`,
+            "  attempts=$((attempts + 1))",
+            '  if [ "$attempts" -ge 180 ]; then',
+            `    echo ${shellQuote(`Timed out waiting for daimon on port ${plan.port}`)} >&2`,
+            "    exit 1",
+            "  fi",
+            "  sleep 1",
+            "done",
+            ""
+        ];
+    }
+    if (!["openclaw", "pi"].includes(plan.runtimeName))
+        return [];
+    return [
+        "attempts=0",
+        `until curl -sf ${shellQuote(`http://127.0.0.1:${plan.port}/healthz`)} >/dev/null; do`,
+        `  if ! kill -0 "$${pidVariable}" 2>/dev/null; then wait "$${pidVariable}" || true; echo ${shellQuote(`${plan.runtimeName} exited before readiness on port ${plan.port}`)} >&2; exit 1; fi`,
+        "  attempts=$((attempts + 1))",
+        '  if [ "$attempts" -ge 180 ]; then',
+        `    echo ${shellQuote(`Timed out waiting for ${plan.runtimeName} on port ${plan.port}`)} >&2`,
+        "    exit 1",
+        "  fi",
+        "  sleep 1",
+        "done",
+        ""
+    ];
+};

package/dist/compiler/containerStateOwnershipRender.d.ts

@@ -0,0 +1,4 @@
+import type { RuntimeTargetPlan } from "./containerArtifactsTypes.js";
+import type { EntrypointOptions } from "./containerEntrypointRender.js";
+export { VOLUME_BOOTSTRAP_MARKER, VOLUME_BOOTSTRAP_MARKER_CONTENT } from "./containerVolumeBootstrap.js";
+export declare const createStateOwnershipCommand: (runtimePlans: RuntimeTargetPlan[], persistentMountPaths?: string[], moltnet?: EntrypointOptions["moltnet"]) => string;

package/dist/compiler/containerStateOwnershipRender.js

@@ -0,0 +1,75 @@
+import path from "node:path";
+import { SpawnfileError } from "../shared/index.js";
+import { DAIMON_RUNTIME_UID, resolveDaimonUidEntrypointStateRoots } from "./containerDaimonUidEntrypointRender.js";
+import { VOLUME_BOOTSTRAP_MARKER, VOLUME_BOOTSTRAP_MARKER_CONTENT } from "./containerVolumeBootstrap.js";
+export { VOLUME_BOOTSTRAP_MARKER, VOLUME_BOOTSTRAP_MARKER_CONTENT } from "./containerVolumeBootstrap.js";
+const SPAWNFILE_STATE_ROOT = "/var/lib/spawnfile";
+const MOLTNET_STATE_ROOT = `${SPAWNFILE_STATE_ROOT}/moltnet`;
+const shellQuote = (value) => `'${value.replace(/'/g, `'\"'\"'`)}'`;
+const privateDirectoriesThrough = (target) => {
+    const relative = path.posix.relative(SPAWNFILE_STATE_ROOT, target);
+    if (relative.startsWith("../") || path.posix.isAbsolute(relative)) {
+        throw new SpawnfileError("compile_error", `Generated Moltnet state path escapes ${SPAWNFILE_STATE_ROOT}: ${target}`);
+    }
+    const segments = relative === "" ? [] : relative.split("/");
+    return [
+        SPAWNFILE_STATE_ROOT,
+        ...segments.map((_, index) => path.posix.join(SPAWNFILE_STATE_ROOT, ...segments.slice(0, index + 1)))
+    ];
+};
+const createMoltnetPrivacyCommands = (runtimePlans, persistentMountPaths, moltnet) => {
+    if (!runtimePlans.some((plan) => plan.runtimeName === "daimon") || !moltnet)
+        return [];
+    const configPaths = [
+        ...moltnet.serverPlans.flatMap((plan) => plan.mode === "managed" && plan.configPath ? [plan.configPath] : []),
+        ...moltnet.nodePlans.map((plan) => plan.configPath)
+    ].sort();
+    const receiptDirectories = moltnet.nodePlans.flatMap((plan) => plan.receiptStorePath ? [path.posix.dirname(plan.receiptStorePath)] : []);
+    if (configPaths.length === 0)
+        return [];
+    if (configPaths.some((configPath) => !configPath.startsWith(`${MOLTNET_STATE_ROOT}/`))) {
+        throw new SpawnfileError("compile_error", "Generated Moltnet config paths must stay beneath the private Moltnet state root");
+    }
+    const moltnetMountPaths = persistentMountPaths
+        .filter((mountPath) => mountPath.startsWith(`${MOLTNET_STATE_ROOT}/`));
+    const privateDirectories = [
+        ...new Set([
+            ...configPaths.flatMap((configPath) => privateDirectoriesThrough(path.posix.dirname(configPath))),
+            ...receiptDirectories.flatMap(privateDirectoriesThrough),
+            ...moltnetMountPaths.flatMap(privateDirectoriesThrough)
+        ])
+    ].filter((directory) => directory !== SPAWNFILE_STATE_ROOT).sort();
+    const ownership = `${DAIMON_RUNTIME_UID}:${DAIMON_RUNTIME_UID}`;
+    return [
+        `install -d -o ${DAIMON_RUNTIME_UID} -g ${DAIMON_RUNTIME_UID} -m 700 ${privateDirectories.map(shellQuote).join(" ")}`,
+        `chown root:root ${configPaths.map(shellQuote).join(" ")}`,
+        `chmod 600 ${configPaths.map(shellQuote).join(" ")}`,
+        `chown ${ownership} ${configPaths.map(shellQuote).join(" ")}`
+    ];
+};
+export const createStateOwnershipCommand = (runtimePlans, persistentMountPaths = [], moltnet) => {
+    const mountPaths = [...new Set(persistentMountPaths)].sort();
+    const wrapperStateRoots = runtimePlans.some((plan) => plan.runtimeName === "daimon")
+        ? resolveDaimonUidEntrypointStateRoots(runtimePlans)
+        : [];
+    const mkdirPaths = [...new Set([SPAWNFILE_STATE_ROOT, ...mountPaths])].sort();
+    const markerCommands = mountPaths.map((mountPath) => `printf '%s\\n' ${shellQuote(VOLUME_BOOTSTRAP_MARKER_CONTENT)} > ${shellQuote(path.posix.join(mountPath, VOLUME_BOOTSTRAP_MARKER))} && chmod 600 ${shellQuote(path.posix.join(mountPath, VOLUME_BOOTSTRAP_MARKER))}`);
+    const chownPaths = [
+        ...new Set([
+            ...(runtimePlans.some((plan) => plan.runtimeName === "daimon") ? [] : [SPAWNFILE_STATE_ROOT]),
+            ...mountPaths.filter((mountPath) => !mountPath.startsWith(`${SPAWNFILE_STATE_ROOT}/`))
+        ])
+    ].sort();
+    return [
+        `mkdir -p ${mkdirPaths.map(shellQuote).join(" ")}`,
+        ...markerCommands,
+        ...(chownPaths.length > 0
+            ? [`chown -R spawnfile:spawnfile ${chownPaths.map(shellQuote).join(" ")}`]
+            : []),
+        ...(runtimePlans.some((plan) => plan.runtimeName === "daimon")
+            ? [`chown root:root ${shellQuote(SPAWNFILE_STATE_ROOT)} && chmod 711 ${shellQuote(SPAWNFILE_STATE_ROOT)}`]
+            : []),
+        ...wrapperStateRoots.map((stateRoot) => `install -d -o root -g root -m 700 ${shellQuote(stateRoot)}`),
+        ...createMoltnetPrivacyCommands(runtimePlans, mountPaths, moltnet)
+    ].join(" && ");
+};