spawnfile 0.1.12 → 0.1.13

package/dist/compiler/containerArtifactsRender.js

@@ -4,16 +4,15 @@ import { createRuntimeInstallRecipe } from "../runtime/index.js";
 import { SpawnfileError } from "../shared/index.js";
 export { renderEntrypoint } from "./containerEntrypointRender.js";
 import { MOLTNET_BIN_DIRECTORY, MOLTNET_BINARY_NAMES } from "./moltnetBinaries.js";
+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, `'\"'\"'`)}'`;
 const extractNodeMajorVersion = (image) => Number(image.match(/^node:(\d+)/)?.[1] ?? "0");
-const createPackageInstallCommand = (packages) => `RUN apt-get update && apt-get install -y --no-install-recommends ${packages.join(" ")} && rm -rf /var/lib/apt/lists/*`;
-const createNpmPackageInstallCommand = (packages) => `RUN npm install -g --omit=dev --no-fund --no-audit ${packages.join(" ")}`;
-const createPipxPackageInstallCommand = (packages) => `RUN PIPX_HOME=/opt/pipx PIPX_BIN_DIR=/usr/local/bin pipx install ${packages.join(" ")}`;
 const createStateOwnershipCommand = (persistentMountPaths = []) => {
     const mountPaths = [...new Set(persistentMountPaths)].sort();
     const mkdirPaths = [...new Set(["/var/lib/spawnfile", ...mountPaths])].sort();
@@ -21,7 +20,6 @@ const createStateOwnershipCommand = (persistentMountPaths = []) => {
     const chownPaths = [
         ...new Set([
             "/var/lib/spawnfile",
-            "/opt/spawnfile",
             ...mountPaths.filter((mountPath) => !mountPath.startsWith("/var/lib/spawnfile/"))
         ])
     ].sort();
@@ -31,70 +29,13 @@ const createStateOwnershipCommand = (persistentMountPaths = []) => {
         `chown -R spawnfile:spawnfile ${chownPaths.map(shellQuote).join(" ")}`
     ].join(" && ");
 };
-const dedupePackages = (packages) => {
-    const seen = new Map();
-    for (const currentPackage of packages) {
-        seen.set(`${currentPackage.manager}\u0000${currentPackage.name}\u0000${currentPackage.version ?? ""}\u0000${currentPackage.scope ?? ""}`, currentPackage);
-    }
-    return [...seen.values()].sort((left, right) => `${left.manager}\u0000${left.name}\u0000${left.version ?? ""}\u0000${left.scope ?? ""}`.localeCompare(`${right.manager}\u0000${right.name}\u0000${right.version ?? ""}\u0000${right.scope ?? ""}`));
-};
-const createPackageIdentity = (pkg) => `${pkg.manager}\u0000${pkg.name}\u0000${pkg.version ?? ""}\u0000${pkg.scope ?? ""}`;
-const createPackageConflictIdentity = (pkg) => `${pkg.manager}\u0000${pkg.name}`;
-const assertImagePackageCompatibility = (packages) => {
-    const byName = new Map();
-    for (const currentPackage of packages) {
-        const conflictIdentity = createPackageConflictIdentity(currentPackage);
-        const existingPackage = byName.get(conflictIdentity);
-        if (!existingPackage) {
-            byName.set(conflictIdentity, currentPackage);
-            continue;
-        }
-        if (createPackageIdentity(existingPackage) !== createPackageIdentity(currentPackage)) {
-            throw new SpawnfileError("validation_error", `Generated container declares conflicting package definitions for ${currentPackage.manager} package ${currentPackage.name}`);
-        }
-    }
-};
-const createAptPackageInstallItem = (pkg) => pkg.version ? `${pkg.name}=${pkg.version}` : pkg.name;
-const createNpmPackageInstallItem = (pkg) => pkg.version ? `${pkg.name}@${pkg.version}` : pkg.name;
-const createPipxPackageInstallItem = (pkg) => pkg.version ? `${pkg.name}==${pkg.version}` : pkg.name;
-const getNpmInstallItemName = (item) => {
-    if (!item.startsWith("@")) {
-        const versionMarker = item.indexOf("@");
-        return versionMarker === -1 ? item : item.slice(0, versionMarker);
-    }
-    const slashIndex = item.indexOf("/");
-    if (slashIndex === -1) {
-        return item;
-    }
-    const versionMarker = item.indexOf("@", slashIndex);
-    return versionMarker === -1 ? item : item.slice(0, versionMarker);
-};
-const collectPackagesByManager = (runtimePlans) => {
-    const packagesByManager = {
-        apt: [],
-        npm: [],
-        pipx: []
-    };
-    const imagePackages = runtimePlans.flatMap((plan) => plan.packages ?? []);
-    assertImagePackageCompatibility(imagePackages);
-    const resolvedPackages = dedupePackages(imagePackages);
-    for (const packageConfig of resolvedPackages) {
-        if (packageConfig.manager === "apt") {
-            packagesByManager.apt.push(packageConfig);
-            continue;
-        }
-        if (packageConfig.manager === "npm") {
-            packagesByManager.npm.push(packageConfig);
-            continue;
-        }
-        if (packageConfig.manager === "pipx") {
-            packagesByManager.pipx.push(packageConfig);
-            continue;
-        }
+const selectBaseImage = (runtimePlans, runtimeRecipes) => {
+    const recipeBaseImages = [
+        ...new Set(runtimeRecipes.flatMap((recipe) => recipe.baseImage ? [recipe.baseImage] : []))
+    ];
+    if (recipeBaseImages.length === 1 && runtimePlans.length === runtimeRecipes.length) {
+        return recipeBaseImages[0];
     }
-    return packagesByManager;
-};
-const selectBaseImage = (runtimePlans) => {
     const firstRuntimeMeta = runtimePlans[0]?.meta;
     if (runtimePlans.length <= 1) {
         return firstRuntimeMeta?.standaloneBaseImage ?? "debian:bookworm-slim";
@@ -133,12 +74,13 @@ export const renderEnvExample = (variables) => {
 export const renderDockerfile = async (runtimePlans, options = {}) => {
     const runtimeNames = [...new Set(runtimePlans.map((plan) => plan.runtimeName))];
     const runtimeRecipes = await Promise.all(runtimeNames.map((runtimeName) => createRuntimeInstallRecipe(runtimeName)));
-    const baseImage = selectBaseImage(runtimePlans);
+    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 needsGit = runtimePlans.some((plan) => (plan.resources ?? []).some((resource) => resource.kind === "git"));
     const systemDeps = [
         ...new Set([
-            ...runtimePlans.flatMap((plan) => plan.meta.systemDeps),
+            ...runtimePlans.flatMap((plan) => recipeByRuntimeName.get(plan.runtimeName)?.baseImage ? [] : plan.meta.systemDeps),
             ...(needsGit ? ["git"] : []),
             ...(options.hasMoltnet && !options.hasStagedMoltnetBinaries
                 ? ["ca-certificates", "curl", "tar"]
@@ -195,6 +137,12 @@ export const renderDockerfile = async (runtimePlans, options = {}) => {
     }
     lines.push('RUN if ! id -u spawnfile >/dev/null 2>&1; then useradd --create-home --home-dir /home/spawnfile --shell /bin/bash spawnfile; fi', "");
     lines.push("COPY container/rootfs/ /", "COPY .env.example /opt/spawnfile/.env.example", 'COPY entrypoint.sh /opt/spawnfile/entrypoint.sh', "RUN chmod +x /opt/spawnfile/entrypoint.sh");
+    const postRootfsCommands = [
+        ...new Set(runtimePlans.flatMap((plan) => plan.meta.postRootfsCommands ?? []))
+    ];
+    for (const command of postRootfsCommands) {
+        lines.push(`RUN ${command}`);
+    }
     if (options.distribution) {
         lines.push("", `COPY ${options.distribution.reportOutputFile} ${DISTRIBUTION_REPORT_IMAGE_PATH}`, ...Object.entries(options.distribution.labels)
             .sort(([left], [right]) => left.localeCompare(right))
@@ -213,11 +161,19 @@ export const createRootfsFiles = (runtimePlans) => runtimePlans.flatMap((plan) =
         return {
             content: file.content
                 .replaceAll(WORKSPACE_PLACEHOLDER, plan.instancePaths.workspacePath)
+                .replaceAll(RUNTIME_ROOT_PLACEHOLDER, plan.runtimeRoot)
                 .replaceAll(`"${GATEWAY_PORT_PLACEHOLDER}"`, plan.port ? String(plan.port) : "0")
                 .replaceAll(GATEWAY_PORT_PLACEHOLDER, plan.port ? String(plan.port) : ""),
             path: `${CONTAINER_ROOTFS_ROOT}${plan.instancePaths.configPath}`
         };
     }
+    if (file.path.startsWith("runtime/")) {
+        const relativeRuntimePath = file.path.slice("runtime/".length);
+        return {
+            content: file.content,
+            path: `${CONTAINER_ROOTFS_ROOT}${path.posix.join(plan.runtimeRoot, relativeRuntimePath)}`
+        };
+    }
     if (file.path.startsWith("workspace/")) {
         const relativeWorkspacePath = file.path.slice("workspace/".length);
         return {

package/dist/compiler/containerEntrypointRender.js

@@ -43,11 +43,14 @@ const createMoltnetStorePrepareCommands = (serverPlan) => {
 };
 const resolveStartCommand = (plan) => plan.meta.startCommand
     .map((token) => token
+    .replaceAll("<config-path>", plan.instancePaths.configPath)
+    .replaceAll("<home-path>", plan.instancePaths.homePath ?? "")
     .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 (plan.runtimeName !== "openclaw" || !plan.port) {
+    if (!["openclaw", "pi"].includes(plan.runtimeName) || !plan.port) {
         return [];
     }
     return [

package/dist/compiler/containerPackageRender.d.ts

@@ -0,0 +1,15 @@
+import type { RuntimeTargetPlan } from "./containerArtifactsTypes.js";
+import type { ResolvedPackage } from "./types.js";
+export interface PackagesByManager {
+    apt: ResolvedPackage[];
+    npm: ResolvedPackage[];
+    pipx: ResolvedPackage[];
+}
+export declare const createPackageInstallCommand: (packages: string[]) => string;
+export declare const createNpmPackageInstallCommand: (packages: string[]) => string;
+export declare const createPipxPackageInstallCommand: (packages: string[]) => string;
+export declare const createAptPackageInstallItem: (pkg: ResolvedPackage) => string;
+export declare const createNpmPackageInstallItem: (pkg: ResolvedPackage) => string;
+export declare const createPipxPackageInstallItem: (pkg: ResolvedPackage) => string;
+export declare const getNpmInstallItemName: (item: string) => string;
+export declare const collectPackagesByManager: (runtimePlans: RuntimeTargetPlan[]) => PackagesByManager;

package/dist/compiler/containerPackageRender.js

@@ -0,0 +1,63 @@
+import { SpawnfileError } from "../shared/index.js";
+export const createPackageInstallCommand = (packages) => `RUN apt-get update && apt-get install -y --no-install-recommends ${packages.join(" ")} && rm -rf /var/lib/apt/lists/*`;
+export const createNpmPackageInstallCommand = (packages) => `RUN npm install -g --omit=dev --no-fund --no-audit ${packages.join(" ")}`;
+export const createPipxPackageInstallCommand = (packages) => `RUN PIPX_HOME=/opt/pipx PIPX_BIN_DIR=/usr/local/bin pipx install ${packages.join(" ")}`;
+const packageIdentity = (pkg) => `${pkg.manager}\u0000${pkg.name}\u0000${pkg.version ?? ""}\u0000${pkg.scope ?? ""}`;
+const packageConflictIdentity = (pkg) => `${pkg.manager}\u0000${pkg.name}`;
+const dedupePackages = (packages) => {
+    const seen = new Map();
+    for (const currentPackage of packages) {
+        seen.set(packageIdentity(currentPackage), currentPackage);
+    }
+    return [...seen.values()].sort((left, right) => packageIdentity(left).localeCompare(packageIdentity(right)));
+};
+const assertImagePackageCompatibility = (packages) => {
+    const byName = new Map();
+    for (const currentPackage of packages) {
+        const conflictIdentity = packageConflictIdentity(currentPackage);
+        const existingPackage = byName.get(conflictIdentity);
+        if (!existingPackage) {
+            byName.set(conflictIdentity, currentPackage);
+            continue;
+        }
+        if (packageIdentity(existingPackage) !== packageIdentity(currentPackage)) {
+            throw new SpawnfileError("validation_error", `Generated container declares conflicting package definitions for ${currentPackage.manager} package ${currentPackage.name}`);
+        }
+    }
+};
+export const createAptPackageInstallItem = (pkg) => pkg.version ? `${pkg.name}=${pkg.version}` : pkg.name;
+export const createNpmPackageInstallItem = (pkg) => pkg.version ? `${pkg.name}@${pkg.version}` : pkg.name;
+export const createPipxPackageInstallItem = (pkg) => pkg.version ? `${pkg.name}==${pkg.version}` : pkg.name;
+export const getNpmInstallItemName = (item) => {
+    if (!item.startsWith("@")) {
+        const versionMarker = item.indexOf("@");
+        return versionMarker === -1 ? item : item.slice(0, versionMarker);
+    }
+    const slashIndex = item.indexOf("/");
+    if (slashIndex === -1) {
+        return item;
+    }
+    const versionMarker = item.indexOf("@", slashIndex);
+    return versionMarker === -1 ? item : item.slice(0, versionMarker);
+};
+export const collectPackagesByManager = (runtimePlans) => {
+    const packagesByManager = {
+        apt: [],
+        npm: [],
+        pipx: []
+    };
+    const imagePackages = runtimePlans.flatMap((plan) => plan.packages ?? []);
+    assertImagePackageCompatibility(imagePackages);
+    for (const packageConfig of dedupePackages(imagePackages)) {
+        if (packageConfig.manager === "apt") {
+            packagesByManager.apt.push(packageConfig);
+            continue;
+        }
+        if (packageConfig.manager === "npm") {
+            packagesByManager.npm.push(packageConfig);
+            continue;
+        }
+        packagesByManager.pipx.push(packageConfig);
+    }
+    return packagesByManager;
+};

package/dist/compiler/containerTargetResources.js

@@ -4,13 +4,15 @@ import { mergeWorkspaceResourcePlans } from "./workspaceResources.js";
 const CONFIG_FILE_PLACEHOLDER = "<config-file>";
 const INSTANCE_ROOT_PLACEHOLDER = "<instance-root>";
 const SOURCE_AGENT_PLACEHOLDER = "<agent-name>";
+const SOURCE_SLUG_PLACEHOLDER = "<source-slug>";
 const replaceSourceWorkspacePathTemplate = (template, input, instancePaths, meta) => {
     const agentName = input.value.kind === "agent" ? input.value.name : input.slug;
     const instanceRoot = instancePaths.instanceRoot ?? path.posix.dirname(instancePaths.workspacePath);
     return template
         .replaceAll(INSTANCE_ROOT_PLACEHOLDER, instanceRoot)
         .replaceAll(CONFIG_FILE_PLACEHOLDER, meta.configFileName)
-        .replaceAll(SOURCE_AGENT_PLACEHOLDER, agentName);
+        .replaceAll(SOURCE_AGENT_PLACEHOLDER, agentName)
+        .replaceAll(SOURCE_SLUG_PLACEHOLDER, input.slug);
 };
 const resolveSourceWorkspacePath = (input, instancePaths, meta) => meta.instancePaths.sourceWorkspacePathTemplate
     ? replaceSourceWorkspacePathTemplate(meta.instancePaths.sourceWorkspacePathTemplate, input, instancePaths, meta)

package/dist/compiler/moltnetArtifacts.js

@@ -1,5 +1,5 @@
 import { SpawnfileError } from "../shared/index.js";
-import { createMoltnetOpenTokenDirectory, createMoltnetNativeServerConfig, createMoltnetNodeConfigPath, createMoltnetServerConfigPath, resolveMoltnetBaseUrl, resolveMoltnetStorePersistenceMountPath } from "./moltnetConfigLowering.js";
+import { createMoltnetOpenTokenDirectory, createMoltnetNativeServerConfig, createMoltnetNodeConfigPath, createMoltnetServerConfigPath, resolveMoltnetClientAuth, resolveMoltnetBaseUrl, resolveMoltnetStorePersistenceMountPath } from "./moltnetConfigLowering.js";
 import { assertNetworkBindingEnvUniqueness } from "./networkBinding.js";
 import { listConcreteMoltnetRoomMemberIds } from "./moltnetRoomMemberships.js";
 import { assertCompatibleMoltnetNetworkName, assertCompatibleMoltnetRoomPolicy, assertCompatibleMoltnetServer } from "./moltnetRoomPolicyCompatibility.js";
@@ -178,6 +178,21 @@ export const generateMoltnetArtifacts = async (plan) => {
                 throw new SpawnfileError("validation_error", `Duplicate Moltnet node attachment for ${attachment.network}/${attachment.memberId}`);
             }
             nodePlanKeys.add(nodePlanKey);
+            if (agentNode.runtime.name === "pi") {
+                const clientAuth = resolveMoltnetClientAuth(serverPlan.server, attachment.network, attachment.memberId, node.slug);
+                const usesPerAttachmentOpenToken = clientAuth.mode === "open" &&
+                    clientAuth.staticToken !== true &&
+                    Boolean(clientAuth.tokenEnv || clientAuth.tokenPath);
+                if (usesPerAttachmentOpenToken && clientAuth.tokenPath) {
+                    const mountId = `agent-${node.slug}-moltnet-tokens`;
+                    addPersistentMount({
+                        id: mountId,
+                        mountPath: createMoltnetOpenTokenDirectory(node.slug),
+                        reason: `Moltnet open-mode generated agent tokens for ${agentNode.name}`,
+                        volumeName: createPersistentVolumeName(plan.root, mountId)
+                    });
+                }
+            }
             const nodeConfig = createMoltnetNodeConfigContent({
                 agentNode,
                 attachment: { ...attachment, memberId: attachment.memberId },

package/dist/compiler/moltnetBinaries.d.ts

@@ -1,4 +1,7 @@
 export declare const MOLTNET_BIN_DIRECTORY = "moltnet-bin";
 export declare const MOLTNET_BINARY_NAMES: readonly ["moltnet"];
+export type MoltnetTargetArchitecture = "amd64" | "arm64";
 export declare const resolveMoltnetCliCommand: () => Promise<string>;
-export declare const stageMoltnetBinaries: (outputDirectory: string) => Promise<boolean>;
+export declare const stageMoltnetBinaries: (outputDirectory: string, options?: {
+    architecture?: MoltnetTargetArchitecture;
+}) => Promise<boolean>;

package/dist/compiler/moltnetBinaries.js

@@ -7,11 +7,32 @@ import { SpawnfileError } from "../shared/index.js";
 const execFile = promisify(execFileCallback);
 const MOLTNET_CLI_ENV = "SPAWNFILE_MOLTNET_CLI";
 const MOLTNET_RELEASE_DIR_ENV = "SPAWNFILE_MOLTNET_RELEASE_DIR";
+const MOLTNET_TARGET_ARCH_ENV = "SPAWNFILE_MOLTNET_TARGET_ARCH";
 const LOCAL_MOLTNET_CLI_PATH = path.resolve(process.cwd(), "moltnet", "bin", "moltnet");
 const MOLTNET_TARGET_OS = "linux";
 export const MOLTNET_BIN_DIRECTORY = "moltnet-bin";
 export const MOLTNET_BINARY_NAMES = ["moltnet"];
-const resolveTargetArchitecture = () => {
+const normalizeTargetArchitecture = (architecture) => {
+    switch (architecture) {
+        case "amd64":
+        case "x86_64":
+        case "x64":
+            return "amd64";
+        case "aarch64":
+        case "arm64":
+            return "arm64";
+        default:
+            throw new SpawnfileError("compile_error", `Moltnet container installs do not support target architecture ${architecture}`);
+    }
+};
+const resolveTargetArchitecture = (architecture) => {
+    if (architecture) {
+        return architecture;
+    }
+    const configuredArchitecture = process.env[MOLTNET_TARGET_ARCH_ENV]?.trim();
+    if (configuredArchitecture) {
+        return normalizeTargetArchitecture(configuredArchitecture);
+    }
     switch (process.arch) {
         case "arm64":
             return "arm64";
@@ -73,12 +94,12 @@ export const resolveMoltnetCliCommand = async () => {
     }
     return validateMoltnetCli("moltnet", "PATH");
 };
-export const stageMoltnetBinaries = async (outputDirectory) => {
+export const stageMoltnetBinaries = async (outputDirectory, options = {}) => {
     const releaseDirectory = await resolveConfiguredReleaseDirectory();
     if (!releaseDirectory) {
         return false;
     }
-    const architecture = resolveTargetArchitecture();
+    const architecture = resolveTargetArchitecture(options.architecture);
     const releaseAssetPath = path.join(releaseDirectory, createReleaseAssetName(architecture));
     if (!(await fileExists(releaseAssetPath))) {
         throw new SpawnfileError("compile_error", `Moltnet release asset ${releaseAssetPath} does not exist. Build it with \`cd moltnet && make release-assets\` or set ${MOLTNET_RELEASE_DIR_ENV}.`);

package/dist/compiler/moltnetClientConfig.js

@@ -63,6 +63,17 @@ const createAttachmentConfig = (node, artifacts, attachment, agentSlug) => {
     };
 };
 export const resolveMoltnetWorkspaceLayout = (runtimeName, _agentName) => {
+    if (runtimeName === "daimon" || runtimeName === "pi") {
+        return {
+            clientConfigPath: `workspace/.moltnet/config.json`,
+            cliRuntime: "codex",
+            skillPaths: [
+                `workspace/.agents/skills/${GENERATED_SKILL_NAME}/SKILL.md`,
+                `workspace/.codex/skills/${GENERATED_SKILL_NAME}/SKILL.md`
+            ],
+            workspaceRootPath: "workspace"
+        };
+    }
     if (runtimeName === "openclaw" || runtimeName === "picoclaw") {
         return {
             clientConfigPath: `workspace/${GENERATED_CONFIG_PATH}`,

package/dist/compiler/moltnetRuntimeConfig.js

@@ -51,6 +51,17 @@ export const resolveRuntimeConfig = (plan, agentNode, nodeSlug, _networkId, _age
                 kind: "picoclaw"
             };
         }
+        case "daimon":
+        case "pi": {
+            const port = getRuntimeAdapter(agentNode.runtime.name).container.port;
+            if (!port) {
+                throw new SpawnfileError("compile_error", `Unable to resolve ${agentNode.runtime.name} control port for Moltnet agent ${agentNode.name}`);
+            }
+            return {
+                control_url: `http://127.0.0.1:${port}/agents/${nodeSlug}/wake`,
+                kind: "pi"
+            };
+        }
         default:
             throw new SpawnfileError("compile_error", `Moltnet does not know how to attach runtime ${agentNode.runtime.name} directly`);
     }

package/dist/compiler/runProject.js

@@ -6,7 +6,7 @@ import { ensureDirectory, fileExists, removeDirectory, writeUtf8File } from "../
 import { appendDockerLabelArgs, createDockerDeploymentLabels, createDockerDeploymentUnitId, createDockerProjectLabel, dockerContextNameForTarget, dockerHostValueForTarget, normalizeDeploymentName, readDeploymentRecordFromOutput, resolveDeploymentRecordPath, verifyDockerDeploymentTarget, writeDockerDeploymentRecordForRun } from "../deployment/index.js";
 import { DEFAULT_OUTPUT_DIRECTORY, SpawnfileError } from "../shared/index.js";
 import { compileProject } from "./compileProject.js";
-import { createDefaultImageTag } from "./buildProject.js";
+import { createDefaultImageTag, resolveDockerBuildArchitecture } from "./buildProject.js";
 import { slugify } from "./helpers.js";
 import { runDockerContainer } from "./runProjectDocker.js";
 import { assertDeclaredModelAuthSatisfied, assertRunEnvironmentSatisfied, prepareRuntimeAuthMounts, readRunEnvFile, renderDockerEnvFile, resolveAuthMountArgs, resolveRunEnvironment } from "./runProjectAuth.js";
@@ -142,8 +142,14 @@ export const runProject = async (inputPath, options = {}) => {
         imageTag: options.imageTag,
         targetExecFile: options.targetExecFile
     });
+    const targetArchitecture = options.containerArchitecture ??
+        await resolveDockerBuildArchitecture({
+            dockerCommand: options.dockerCommand,
+            dockerContext: resolvedOptions.dockerContext
+        });
     const compileResult = await compileProject(inputPath, {
         clean: options.clean,
+        containerArchitecture: targetArchitecture,
         outputDirectory: options.outputDirectory
     });
     const imageTag = resolvedOptions.imageTag ?? createDefaultImageTag(resolveImageTagRoot(inputPath));

package/dist/compiler/runProjectDocker.js

@@ -1,7 +1,137 @@
 import { execFile as execFileCallback, spawn } from "node:child_process";
+import path from "node:path";
 import { promisify } from "node:util";
 import { SpawnfileError } from "../shared/index.js";
 const execFile = promisify(execFileCallback);
+const parseDockerContextHost = (stdout) => {
+    const trimmed = stdout.trim();
+    if (!trimmed) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        return typeof parsed === "string" ? parsed : null;
+    }
+    catch {
+        return trimmed;
+    }
+};
+const resolveSshDockerContext = async (invocation) => {
+    if (!invocation.dockerContext) {
+        return null;
+    }
+    const { stdout } = await execFile(invocation.command, [
+        "context",
+        "inspect",
+        invocation.dockerContext,
+        "--format",
+        "{{json .Endpoints.docker.Host}}"
+    ], { cwd: invocation.cwd, timeout: 10_000 });
+    const host = parseDockerContextHost(stdout);
+    if (!host?.startsWith("ssh://")) {
+        return null;
+    }
+    const url = new URL(host);
+    const user = decodeURIComponent(url.username);
+    const targetHost = url.hostname;
+    return {
+        host,
+        ...(url.port ? { port: url.port } : {}),
+        target: user ? `${user}@${targetHost}` : targetHost
+    };
+};
+const sshArgs = (context, command) => [
+    ...(context.port ? ["-p", context.port] : []),
+    context.target,
+    command
+];
+const scpArgs = (context, source, target) => [
+    ...(context.port ? ["-P", context.port] : []),
+    "-r",
+    source,
+    `${context.target}:${target}`
+];
+const shellQuote = (value) => `'${value.replace(/'/g, `'\"'\"'`)}'`;
+const createRemoteDirectory = async (context) => {
+    const { stdout } = await execFile("ssh", sshArgs(context, "mktemp -d /tmp/spawnfile-run-XXXXXX"), {
+        timeout: 10_000
+    });
+    return stdout.trim();
+};
+const copyPathToRemote = async (context, sourcePath, remotePath) => {
+    await execFile("scp", scpArgs(context, sourcePath, remotePath), { timeout: 120_000 });
+};
+const removeRemoteDirectory = async (context, remoteDirectory) => {
+    await execFile("ssh", sshArgs(context, `rm -rf ${shellQuote(remoteDirectory)}`), {
+        timeout: 10_000
+    });
+};
+const splitVolumeSpec = (spec) => {
+    const delimiter = spec.indexOf(":");
+    if (delimiter <= 0) {
+        return null;
+    }
+    return {
+        rest: spec.slice(delimiter),
+        source: spec.slice(0, delimiter)
+    };
+};
+const collectBindMountSources = (args) => {
+    const sources = new Set();
+    for (let index = 0; index < args.length; index += 1) {
+        if (args[index] !== "-v" && args[index] !== "--volume") {
+            continue;
+        }
+        const volume = args[index + 1];
+        if (!volume) {
+            continue;
+        }
+        const parsed = splitVolumeSpec(volume);
+        if (parsed && path.isAbsolute(parsed.source)) {
+            sources.add(parsed.source);
+        }
+        index += 1;
+    }
+    return [...sources].sort();
+};
+const rewriteBindMountSources = (args, replacements) => args.map((arg, index) => {
+    const previous = args[index - 1];
+    if (previous !== "-v" && previous !== "--volume") {
+        return arg;
+    }
+    const parsed = splitVolumeSpec(arg);
+    if (!parsed) {
+        return arg;
+    }
+    const replacement = replacements.get(parsed.source);
+    return replacement ? `${replacement}${parsed.rest}` : arg;
+});
+const prepareRemoteBindMounts = async (invocation) => {
+    const context = await resolveSshDockerContext(invocation);
+    if (!context) {
+        return { cleanup: async () => undefined, invocation };
+    }
+    const sources = collectBindMountSources(invocation.args);
+    if (sources.length === 0) {
+        return { cleanup: async () => undefined, invocation };
+    }
+    const remoteDirectory = await createRemoteDirectory(context);
+    const replacements = new Map();
+    for (const [index, source] of sources.entries()) {
+        const remotePath = `${remoteDirectory}/${index}-${path.basename(source) || "mount"}`;
+        await copyPathToRemote(context, source, remotePath);
+        replacements.set(source, remotePath);
+    }
+    return {
+        cleanup: invocation.detach
+            ? async () => undefined
+            : async () => removeRemoteDirectory(context, remoteDirectory),
+        invocation: {
+            ...invocation,
+            args: rewriteBindMountSources(invocation.args, replacements)
+        }
+    };
+};
 const inspectImageArgs = (invocation, containerId) => {
     const base = invocation.dockerContext
         ? ["--context", invocation.dockerContext, "inspect"]
@@ -23,35 +153,50 @@ const inspectDetachedImageId = async (invocation, containerId) => {
         throw new SpawnfileError("runtime_error", `Unable to inspect detached container ${containerId} image id: ${message}`);
     }
 };
-export const runDockerContainer = async (invocation) => new Promise((resolve, reject) => {
+const runPreparedDockerContainer = (prepared) => new Promise((resolve, reject) => {
     let stdout = "";
-    const child = spawn(invocation.command, invocation.args, {
-        cwd: invocation.cwd,
-        stdio: invocation.detach ? ["ignore", "pipe", "inherit"] : "inherit"
+    const child = spawn(prepared.invocation.command, prepared.invocation.args, {
+        cwd: prepared.invocation.cwd,
+        stdio: prepared.invocation.detach ? ["ignore", "pipe", "inherit"] : "inherit"
     });
-    if (invocation.detach && child.stdout) {
+    const settle = (finish) => {
+        prepared.cleanup().then(finish, reject);
+    };
+    const rejectAfterCleanup = (error) => {
+        prepared.cleanup().then(() => reject(error), reject);
+    };
+    if (prepared.invocation.detach && child.stdout) {
         child.stdout.setEncoding("utf8");
         child.stdout.on("data", (chunk) => {
             stdout += chunk;
         });
     }
     child.once("error", (error) => {
-        reject(new SpawnfileError("runtime_error", `Unable to start docker run for ${invocation.imageTag}: ${error.message}`));
+        rejectAfterCleanup(new SpawnfileError("runtime_error", `Unable to start docker run for ${prepared.invocation.imageTag}: ${error.message}`));
     });
     child.once("exit", (code, signal) => {
         if (code === 0) {
             const containerId = stdout.trim().split(/\s+/)[0];
-            if (!invocation.detach || !containerId) {
-                resolve(undefined);
+            if (!prepared.invocation.detach || !containerId) {
+                settle(() => resolve(undefined));
                 return;
             }
-            inspectDetachedImageId(invocation, containerId)
+            inspectDetachedImageId(prepared.invocation, containerId)
                 .then((imageId) => resolve({ containerId, ...(imageId ? { imageId } : {}) }))
                 .catch(reject);
             return;
         }
-        reject(new SpawnfileError("runtime_error", signal
-            ? `Docker run for ${invocation.imageTag} exited from signal ${signal}`
-            : `Docker run for ${invocation.imageTag} failed with exit code ${code ?? "unknown"}`));
+        rejectAfterCleanup(new SpawnfileError("runtime_error", signal
+            ? `Docker run for ${prepared.invocation.imageTag} exited from signal ${signal}`
+            : `Docker run for ${prepared.invocation.imageTag} failed with exit code ${code ?? "unknown"}`));
     });
 });
+export const runDockerContainer = (invocation) => {
+    if (!invocation.dockerContext || collectBindMountSources(invocation.args).length === 0) {
+        return runPreparedDockerContainer({
+            cleanup: async () => undefined,
+            invocation
+        });
+    }
+    return prepareRemoteBindMounts(invocation).then(runPreparedDockerContainer);
+};

package/dist/compiler/upProject.js

@@ -21,6 +21,7 @@ export const upProject = async (inputPath, options = {}) => {
     const buildResult = await buildProject(inputPath, {
         buildRunner: options.buildRunner,
         clean: options.clean,
+        dockerContext: resolvedOptions.dockerContext,
         dockerCommand: options.dockerCommand,
         imageTag: resolvedOptions.imageTag,
         outputDirectory: options.outputDirectory

package/dist/deployment/dockerRecover.d.ts

@@ -0,0 +1,17 @@
+import type { DeploymentRecord } from "./record.js";
+import { type DockerTargetExecFile } from "./target.js";
+export interface RecoverDockerDeploymentRecordsOptions {
+    contains?: DeploymentRecord["units"][number]["contains"];
+    context: string;
+    dockerCommand?: string;
+    execFile?: DockerTargetExecFile;
+    outputDirectory: string;
+    projectLabel: string;
+    runtimeInstanceIds?: string[];
+    sourceRoot: string;
+    timeoutMs?: number;
+}
+export declare const recoverDockerDeploymentRecords: (options: RecoverDockerDeploymentRecordsOptions) => Promise<Array<{
+    path: string;
+    record: DeploymentRecord;
+}>>;