spawnfile 0.1.1 → 0.1.2

package/dist/compiler/compileProject.js

@@ -1,23 +1,19 @@
 import path from "node:path";
 import { chmod } from "node:fs/promises";
-import { ensureDirectory, removeDirectory, writeUtf8File } from "../filesystem/index.js";
+import { ensureDirectory, removeDirectory } from "../filesystem/index.js";
 import { createCompileReport, createDiagnostic, writeCompileReport } from "../report/index.js";
 import { DEFAULT_OUTPUT_DIRECTORY } from "../shared/index.js";
 import { assertRuntimeCanCompile, createRuntimeLifecycleDiagnostics, getRuntimeAdapter } from "../runtime/index.js";
 import { buildCompilePlan } from "./buildCompilePlan.js";
 import { createContainerArtifacts } from "./containerArtifacts.js";
-const writeEmittedFiles = async (outputDirectory, files) => {
-    await Promise.all(files.map(async (file) => {
-        const targetPath = path.join(outputDirectory, file.path);
-        await ensureDirectory(path.dirname(targetPath));
-        await writeUtf8File(targetPath, file.content);
-    }));
-};
+import { injectMoltnetWorkspaceFiles, injectTeamCompileSupportFiles, prepareTeamCompileSupport, writeEmittedFiles } from "./compileProjectSupport.js";
+import { generateMoltnetArtifacts } from "./moltnetArtifacts.js";
+import { stageMoltnetBinaries } from "./moltnetBinaries.js";
 const createTeamCapabilities = (outcome, message) => [
     { key: "team.members", message, outcome },
-    { key: "team.structure.mode", message, outcome },
-    { key: "team.structure.leader", message, outcome },
-    { key: "team.structure.external", message, outcome },
+    { key: "team.mode", message, outcome },
+    { key: "team.lead", message, outcome },
+    { key: "team.external", message, outcome },
     { key: "team.shared", message, outcome },
     { key: "team.nested", message, outcome }
 ];
@@ -148,6 +144,46 @@ const enforcePolicy = (nodeReport, policyMode, onDegrade) => {
         }
     }
 };
+const createIdentityCapabilities = (node) => [
+    ...(node.surfaces?.slack?.identity
+        ? [{
+                key: "surfaces.slack.identity",
+                message: "Declared Slack identity was preserved for roster output",
+                outcome: "supported"
+            }]
+        : []),
+    ...(node.surfaces?.discord?.identity
+        ? [{
+                key: "surfaces.discord.identity",
+                message: "Declared Discord identity was preserved for roster output",
+                outcome: "supported"
+            }]
+        : []),
+    ...(node.surfaces?.telegram?.identity
+        ? [{
+                key: "surfaces.telegram.identity",
+                message: "Declared Telegram identity was preserved for roster output",
+                outcome: "supported"
+            }]
+        : []),
+    ...(node.surfaces?.whatsapp?.identity
+        ? [{
+                key: "surfaces.whatsapp.identity",
+                message: "Declared WhatsApp identity was preserved for roster output",
+                outcome: "supported"
+            }]
+        : [])
+];
+const augmentNodeReports = (compiledNodes, support) => {
+    for (const compiled of compiledNodes) {
+        if (compiled.value.kind === "team") {
+            compiled.report.capabilities.push(...(support.capabilitiesByTeamSource.get(compiled.value.source) ?? []));
+            compiled.report.diagnostics.push(...(support.diagnosticsByTeamSource.get(compiled.value.source) ?? []));
+            continue;
+        }
+        compiled.report.capabilities.push(...createIdentityCapabilities(compiled.value));
+    }
+};
 export const compileProject = async (inputPath, options = {}) => {
     const plan = await buildCompilePlan(inputPath);
     const outputDirectory = path.resolve(options.outputDirectory ?? DEFAULT_OUTPUT_DIRECTORY);
@@ -155,21 +191,34 @@ export const compileProject = async (inputPath, options = {}) => {
         await removeDirectory(outputDirectory);
     }
     await ensureDirectory(outputDirectory);
+    const teamCompileSupport = await prepareTeamCompileSupport(plan);
     const nodeReports = [];
     const compiledNodes = [];
     for (const node of plan.nodes) {
         let compiled;
         if (node.kind === "agent") {
             compiled = await compileAgentNode(outputDirectory, node);
+            await injectTeamCompileSupportFiles(outputDirectory, compiled, teamCompileSupport);
         }
         else {
             compiled = await compileTeamNode(outputDirectory, node);
         }
-        enforcePolicy(compiled.report, node.value.policyMode, node.value.policyOnDegrade);
         nodeReports.push(compiled.report);
         compiledNodes.push(compiled);
     }
-    const containerArtifacts = await createContainerArtifacts(plan, compiledNodes);
+    augmentNodeReports(compiledNodes, teamCompileSupport);
+    for (const compiled of compiledNodes) {
+        enforcePolicy(compiled.report, compiled.value.policyMode, compiled.value.policyOnDegrade);
+    }
+    const moltnetArtifacts = await generateMoltnetArtifacts(plan);
+    const hasStagedMoltnetBinaries = moltnetArtifacts
+        ? await stageMoltnetBinaries(outputDirectory)
+        : false;
+    await injectMoltnetWorkspaceFiles(outputDirectory, compiledNodes, moltnetArtifacts);
+    const containerArtifacts = await createContainerArtifacts(plan, compiledNodes, {
+        hasStagedMoltnetBinaries,
+        moltnet: moltnetArtifacts
+    });
     await writeEmittedFiles(outputDirectory, containerArtifacts.files);
     await Promise.all(containerArtifacts.executablePaths.map((filePath) => chmod(path.join(outputDirectory, filePath), 0o755)));
     const report = createCompileReport(plan.root, nodeReports, [], containerArtifacts.report);

package/dist/compiler/compileProjectSupport.d.ts

@@ -0,0 +1,17 @@
+import { type EmittedFile } from "../runtime/index.js";
+import type { MoltnetArtifacts } from "./moltnetArtifacts.js";
+import type { TeamCompileSupport } from "./teamContextSupport.js";
+import type { ResolvedAgentNode, ResolvedTeamNode } from "./types.js";
+export { prepareTeamCompileSupport } from "./teamContextSupport.js";
+export type { TeamCompileSupport } from "./teamContextSupport.js";
+export interface CompiledNodeOutput {
+    emittedFiles: EmittedFile[];
+    kind: "agent" | "team";
+    report: {
+        output_dir: string | null;
+    };
+    value: ResolvedAgentNode | ResolvedTeamNode;
+}
+export declare const writeEmittedFiles: (outputDirectory: string, files: EmittedFile[]) => Promise<void>;
+export declare const injectTeamCompileSupportFiles: (outputDirectory: string, compiled: CompiledNodeOutput, support: TeamCompileSupport) => Promise<void>;
+export declare const injectMoltnetWorkspaceFiles: (outputDirectory: string, compiledNodes: CompiledNodeOutput[], artifacts: MoltnetArtifacts | null) => Promise<void>;

package/dist/compiler/compileProjectSupport.js

@@ -0,0 +1,136 @@
+import { execFile as execFileCallback } from "node:child_process";
+import { chmod, readFile } from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+import { ensureDirectory, writeUtf8File } from "../filesystem/index.js";
+import { getRuntimeAdapter } from "../runtime/index.js";
+import { SpawnfileError } from "../shared/index.js";
+import { resolveMoltnetCliCommand } from "./moltnetBinaries.js";
+import { createMoltnetClientConfigFiles, resolveMoltnetWorkspaceLayout } from "./moltnetClientConfig.js";
+export { prepareTeamCompileSupport } from "./teamContextSupport.js";
+const execFile = promisify(execFileCallback);
+const resolveAgentWorkspacePaths = (node) => {
+    const systemInstructionSurface = getRuntimeAdapter(node.runtime.name).systemInstructionSurface;
+    if (!systemInstructionSurface) {
+        return null;
+    }
+    const systemInstructionPath = systemInstructionSurface.resolvePath({ node });
+    const systemInstructionDirectory = path.posix.dirname(systemInstructionPath);
+    return {
+        systemInstructionPath,
+        spawnfileDirectory: systemInstructionDirectory === "."
+            ? ".spawnfile"
+            : `${systemInstructionDirectory}/.spawnfile`
+    };
+};
+const upsertEmittedFile = (emittedFiles, nextFile) => {
+    const existing = emittedFiles.find((file) => file.path === nextFile.path);
+    if (existing) {
+        existing.content = nextFile.content;
+        return existing;
+    }
+    emittedFiles.push(nextFile);
+    return nextFile;
+};
+export const writeEmittedFiles = async (outputDirectory, files) => {
+    await Promise.all(files.map(async (file) => {
+        const targetPath = path.join(outputDirectory, file.path);
+        await ensureDirectory(path.dirname(targetPath));
+        await writeUtf8File(targetPath, file.content);
+        if (file.mode !== undefined) {
+            await chmod(targetPath, file.mode);
+        }
+    }));
+};
+export const injectTeamCompileSupportFiles = async (outputDirectory, compiled, support) => {
+    if (compiled.kind !== "agent" ||
+        compiled.value.kind !== "agent" ||
+        !compiled.report.output_dir) {
+        return;
+    }
+    const supportFiles = support.filesByAgentSource.get(compiled.value.source);
+    if (!supportFiles || supportFiles.length === 0) {
+        return;
+    }
+    const workspacePaths = resolveAgentWorkspacePaths(compiled.value);
+    if (!workspacePaths) {
+        return;
+    }
+    const filesToWrite = supportFiles.map((file) => upsertEmittedFile(compiled.emittedFiles, {
+        ...file,
+        path: file.path.startsWith(".spawnfile/") || file.path === "TEAM.md"
+            ? path.posix.join(path.posix.dirname(workspacePaths.spawnfileDirectory), file.path)
+            : file.path
+    }));
+    const rosterBlock = "\n\n<!-- spawnfile-team-context:start -->\n" +
+        "## Spawnfile Team Context\n\n" +
+        "Read `.spawnfile/team-contexts.md` and `.spawnfile/team-contexts.yaml` for generated team membership, representative context, and surface bindings.\n" +
+        "<!-- spawnfile-team-context:end -->\n";
+    const existingAgentsMd = compiled.emittedFiles.find((file) => file.path === workspacePaths.systemInstructionPath);
+    filesToWrite.push(existingAgentsMd
+        ? (() => {
+            existingAgentsMd.content += rosterBlock;
+            return existingAgentsMd;
+        })()
+        : upsertEmittedFile(compiled.emittedFiles, {
+            content: rosterBlock.trimStart(),
+            path: workspacePaths.systemInstructionPath
+        }));
+    await writeEmittedFiles(path.join(outputDirectory, compiled.report.output_dir), filesToWrite);
+};
+export const injectMoltnetWorkspaceFiles = async (outputDirectory, compiledNodes, artifacts) => {
+    if (!artifacts) {
+        return;
+    }
+    let moltnetCliCommand = null;
+    for (const compiled of compiledNodes) {
+        if (compiled.kind !== "agent" ||
+            compiled.value.kind !== "agent" ||
+            !compiled.report.output_dir) {
+            continue;
+        }
+        const runtimeOutputDirectory = path.join(outputDirectory, compiled.report.output_dir);
+        const moltnetClientConfigFiles = createMoltnetClientConfigFiles(compiled.value, artifacts);
+        if (moltnetClientConfigFiles.length === 0) {
+            continue;
+        }
+        const layout = resolveMoltnetWorkspaceLayout(compiled.value.runtime.name, compiled.value.name);
+        const workspacePath = path.join(runtimeOutputDirectory, layout.workspaceRootPath);
+        for (const file of moltnetClientConfigFiles) {
+            upsertEmittedFile(compiled.emittedFiles, file);
+        }
+        await writeEmittedFiles(runtimeOutputDirectory, moltnetClientConfigFiles);
+        if (!moltnetCliCommand) {
+            moltnetCliCommand = await resolveMoltnetCliCommand();
+        }
+        try {
+            await execFile(moltnetCliCommand, [
+                "skill",
+                "install",
+                "--runtime",
+                layout.cliRuntime,
+                "--workspace",
+                workspacePath
+            ]);
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            throw new SpawnfileError("compile_error", `Unable to install the Moltnet skill into ${compiled.value.name}: ${reason}`);
+        }
+        const moltnetSkillFiles = await Promise.all(layout.skillPaths.map(async (filePath) => {
+            try {
+                return {
+                    content: await readFile(path.join(runtimeOutputDirectory, filePath), "utf8"),
+                    path: filePath
+                };
+            }
+            catch (error) {
+                const reason = error instanceof Error ? error.message : String(error);
+                throw new SpawnfileError("compile_error", `Moltnet skill install for ${compiled.value.name} did not produce ${filePath}: ${reason}`);
+            }
+        }));
+        for (const file of moltnetSkillFiles) {
+            upsertEmittedFile(compiled.emittedFiles, file);
+        }
+    }
+};

package/dist/compiler/containerArtifacts.d.ts

@@ -1,4 +1,9 @@
+import type { MoltnetArtifacts } from "./moltnetArtifacts.js";
 import type { CompiledNodeArtifact, GeneratedContainerArtifacts } from "./containerArtifactsTypes.js";
 import type { CompilePlan } from "./types.js";
 export type { CompiledNodeArtifact, GeneratedContainerArtifacts } from "./containerArtifactsTypes.js";
-export declare const createContainerArtifacts: (plan: CompilePlan, compiledNodes: CompiledNodeArtifact[]) => Promise<GeneratedContainerArtifacts>;
+export interface ContainerArtifactOptions {
+    hasStagedMoltnetBinaries?: boolean;
+    moltnet?: MoltnetArtifacts | null;
+}
+export declare const createContainerArtifacts: (plan: CompilePlan, compiledNodes: CompiledNodeArtifact[], options?: ContainerArtifactOptions) => Promise<GeneratedContainerArtifacts>;

package/dist/compiler/containerArtifacts.js

@@ -1,6 +1,6 @@
 import { createEnvVariableMap, createRuntimeTargetPlans } from "./containerArtifactsPlans.js";
 import { createRootfsFiles, renderDockerfile, renderEntrypoint, renderEnvExample } from "./containerArtifactsRender.js";
-export const createContainerArtifacts = async (plan, compiledNodes) => {
+export const createContainerArtifacts = async (plan, compiledNodes, options = {}) => {
     const runtimePlans = await createRuntimeTargetPlans(plan, compiledNodes);
     const envVariables = [...createEnvVariableMap(compiledNodes, runtimePlans).values()].sort((left, right) => left.name.localeCompare(right.name));
     const requiredSecrets = envVariables
@@ -17,12 +17,24 @@ export const createContainerArtifacts = async (plan, compiledNodes) => {
         .sort();
     const files = [
         ...createRootfsFiles(runtimePlans),
+        ...(options.moltnet?.files ?? []),
         {
-            content: await renderDockerfile(runtimePlans),
+            content: await renderDockerfile(runtimePlans, {
+                hasMoltnet: Boolean(options.moltnet),
+                hasStagedMoltnetBinaries: options.hasStagedMoltnetBinaries,
+                moltnetPublishedPorts: options.moltnet?.publishedPorts ?? []
+            }),
             path: "Dockerfile"
         },
         {
-            content: renderEntrypoint(runtimePlans, requiredSecrets.filter((secretName) => !modelSecretsRequired.includes(secretName))),
+            content: renderEntrypoint(runtimePlans, requiredSecrets.filter((secretName) => !modelSecretsRequired.includes(secretName)), {
+                moltnet: options.moltnet
+                    ? {
+                        bridgePlans: options.moltnet.bridgePlans,
+                        serverPlans: options.moltnet.serverPlans
+                    }
+                    : undefined
+            }),
             path: "entrypoint.sh"
         },
         {
@@ -30,7 +42,9 @@ export const createContainerArtifacts = async (plan, compiledNodes) => {
             path: ".env.example"
         }
     ];
-    const ports = [...new Set(runtimePlans.flatMap((plan) => (plan.port ? [plan.port] : [])))].sort((left, right) => left - right);
+    const runtimePorts = runtimePlans.flatMap((plan) => plan.publishedPort ? [plan.publishedPort] : []);
+    const moltnetPorts = options.moltnet?.publishedPorts ?? [];
+    const ports = [...new Set([...runtimePorts, ...moltnetPorts])].sort((left, right) => left - right);
     const runtimeHomes = [
         ...new Set(runtimePlans.flatMap((plan) => (plan.instancePaths.homePath ? [plan.instancePaths.homePath] : [])))
     ].sort();
@@ -48,6 +62,14 @@ export const createContainerArtifacts = async (plan, compiledNodes) => {
     return {
         executablePaths: ["entrypoint.sh"],
         files,
+        ...(options.moltnet
+            ? {
+                moltnet: {
+                    bridgePlans: options.moltnet.bridgePlans,
+                    serverPlans: options.moltnet.serverPlans
+                }
+            }
+            : {}),
         report: {
             dockerfile: "Dockerfile",
             entrypoint: "entrypoint.sh",

package/dist/compiler/containerArtifactsPlans.js

@@ -76,6 +76,9 @@ export const createEnvVariableMap = (compiledNodes, runtimePlans) => {
         for (const variable of runtimePlan.meta.env ?? []) {
             register(variable.name, variable.required, variable.description, "runtime");
         }
+        for (const binding of runtimePlan.targetConfigEnvBindings ?? []) {
+            register(binding.envName, true, `Injected into ${runtimePlan.runtimeName} runtime config`, "runtime");
+        }
     }
     return variables;
 };
@@ -115,6 +118,13 @@ const resolveTargetModelAuthMethods = (target, inputs) => {
     }
     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);
+};
 export const createRuntimeTargetPlans = async (plan, compiledNodes) => {
     const runtimeNames = Object.keys(plan.runtimes).sort();
     const runtimePlans = [];
@@ -135,6 +145,7 @@ export const createRuntimeTargetPlans = async (plan, compiledNodes) => {
         targets.forEach((target, index) => {
             assertTargetHasConfig(runtimeName, target.id, adapter.container, target.files);
             const instancePaths = resolveInstancePaths(runtimeName, target.id, adapter.container);
+            const portStride = adapter.container.portStride ?? 1;
             runtimePlans.push({
                 configEnvBindings: resolveTargetConfigEnvBindings(adapter.container, target) ?? [],
                 envFiles: resolveTargetEnvFiles(instancePaths.configPath, target),
@@ -143,9 +154,13 @@ export const createRuntimeTargetPlans = async (plan, compiledNodes) => {
                 meta: adapter.container,
                 modelAuthMethods: resolveTargetModelAuthMethods(target, targetInputs),
                 modelSecretsRequired: resolveTargetModelSecrets(target, targetInputs),
-                port: adapter.container.port ? adapter.container.port + index : undefined,
+                port: adapter.container.port ? adapter.container.port + (index * portStride) : undefined,
+                publishedPort: resolveTargetExposure(target, targetInputs) && adapter.container.port
+                    ? adapter.container.port + (index * portStride)
+                    : undefined,
                 runtimeName,
                 runtimeRoot: recipe.runtimeRoot,
+                targetConfigEnvBindings: target.configEnvBindings,
                 targetFiles: target.files
             });
         });

package/dist/compiler/containerArtifactsRender.d.ts

@@ -1,6 +1,8 @@
 import type { EmittedFile } from "../runtime/index.js";
 import type { ContainerEnvVariable, RuntimeTargetPlan } from "./containerArtifactsTypes.js";
+import type { EntrypointOptions } from "./containerEntrypointRender.js";
+export { renderEntrypoint } from "./containerEntrypointRender.js";
+export type { EntrypointOptions } from "./containerEntrypointRender.js";
 export declare const renderEnvExample: (variables: ContainerEnvVariable[]) => string;
-export declare const renderDockerfile: (runtimePlans: RuntimeTargetPlan[]) => Promise<string>;
+export declare const renderDockerfile: (runtimePlans: RuntimeTargetPlan[], options?: EntrypointOptions) => Promise<string>;
 export declare const createRootfsFiles: (runtimePlans: RuntimeTargetPlan[]) => EmittedFile[];
-export declare const renderEntrypoint: (runtimePlans: RuntimeTargetPlan[], requiredSecrets: string[]) => string;

package/dist/compiler/containerArtifactsRender.js

@@ -1,8 +1,11 @@
 import path from "node:path";
 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";
 const CONTAINER_ROOTFS_ROOT = "container/rootfs";
 const GATEWAY_PORT_PLACEHOLDER = "<gateway-port>";
+const MOLTNET_INSTALL_SCRIPT_URL = "https://moltnet.dev/install.sh";
 const WORKSPACE_PLACEHOLDER = "<workspace-path>";
 const shellQuote = (value) => `'${value.replace(/'/g, `'\"'\"'`)}'`;
 const extractNodeMajorVersion = (image) => Number(image.match(/^node:(\d+)/)?.[1] ?? "0");
@@ -44,7 +47,7 @@ export const renderEnvExample = (variables) => {
     }
     return `${lines.join("\n").trimEnd()}\n`;
 };
-export const renderDockerfile = async (runtimePlans) => {
+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);
@@ -52,20 +55,33 @@ export const renderDockerfile = async (runtimePlans) => {
     const systemDeps = [
         ...new Set([
             ...runtimePlans.flatMap((plan) => plan.meta.systemDeps),
+            ...(options.hasMoltnet && !options.hasStagedMoltnetBinaries
+                ? ["ca-certificates", "curl", "tar"]
+                : []),
             ...(needsJsonEnvWriter ? ["python3"] : [])
         ])
     ].sort();
     const globalNpmPackages = [
         ...new Set(runtimePlans.flatMap((plan) => plan.meta.globalNpmPackages ?? []))
     ].sort();
-    const exposedPorts = [...new Set(runtimePlans.flatMap((plan) => (plan.port ? [plan.port] : [])))].sort((left, right) => left - right);
-    const lines = [`FROM ${baseImage}`, "USER root", "", "WORKDIR /opt/spawnfile"];
+    const runtimePorts = runtimePlans.flatMap((plan) => plan.publishedPort ? [plan.publishedPort] : []);
+    const moltnetPorts = options.moltnetPublishedPorts ?? [];
+    const exposedPorts = [...new Set([...runtimePorts, ...moltnetPorts])].sort((left, right) => left - right);
+    const lines = [];
+    lines.push(`FROM ${baseImage}`);
+    lines.push("USER root", "", "WORKDIR /opt/spawnfile");
     if (systemDeps.length > 0) {
         lines.push(createPackageInstallCommand(systemDeps), "");
     }
     if (globalNpmPackages.length > 0) {
         lines.push(createNpmPackageInstallCommand(globalNpmPackages), "");
     }
+    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(`RUN 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);
@@ -76,7 +92,8 @@ export const renderDockerfile = async (runtimePlans) => {
         lines.push("");
     }
     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", "RUN mkdir -p /var/lib/spawnfile && chown -R spawnfile:spawnfile /var/lib/spawnfile /opt/spawnfile");
+    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");
+    lines.push("RUN mkdir -p /var/lib/spawnfile && chown -R spawnfile:spawnfile /var/lib/spawnfile /opt/spawnfile");
     if (exposedPorts.length > 0) {
         lines.push(`EXPOSE ${exposedPorts.join(" ")}`);
     }
@@ -84,32 +101,6 @@ export const renderDockerfile = async (runtimePlans) => {
     lines.push('ENTRYPOINT ["/opt/spawnfile/entrypoint.sh"]');
     return `${lines.join("\n").trimEnd()}\n`;
 };
-const createEnvironmentAssignments = (plan) => {
-    const envAssignments = [];
-    if (plan.instancePaths.homePath) {
-        envAssignments.push(`HOME=${shellQuote(plan.instancePaths.homePath)}`);
-    }
-    if (plan.meta.homeEnv && plan.instancePaths.homePath) {
-        envAssignments.push(`${plan.meta.homeEnv}=${shellQuote(plan.instancePaths.homePath)}`);
-    }
-    if (plan.meta.configPathEnv) {
-        envAssignments.push(`${plan.meta.configPathEnv}=${shellQuote(plan.instancePaths.configPath)}`);
-    }
-    if (plan.meta.portEnv && plan.port) {
-        envAssignments.push(`${plan.meta.portEnv}=${shellQuote(String(plan.port))}`);
-    }
-    for (const [name, value] of Object.entries(plan.meta.staticEnv ?? {}).sort(([left], [right]) => left.localeCompare(right))) {
-        envAssignments.push(`${name}=${shellQuote(value)}`);
-    }
-    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 resolveStartCommand = (plan) => plan.meta.startCommand
-    .map((token) => token
-    .replaceAll("<runtime-root>", plan.runtimeRoot)
-    .replaceAll("<port>", plan.port ? String(plan.port) : ""))
-    .filter((token) => token.length > 0);
 export const createRootfsFiles = (runtimePlans) => runtimePlans.flatMap((plan) => plan.targetFiles.map((file) => {
     if (file.path === plan.meta.configFileName) {
         return {
@@ -139,99 +130,3 @@ export const createRootfsFiles = (runtimePlans) => runtimePlans.flatMap((plan) =
     }
     throw new SpawnfileError("runtime_error", `Container target ${plan.id} for ${plan.runtimeName} emitted unsupported path ${file.path}`);
 }));
-export const renderEntrypoint = (runtimePlans, requiredSecrets) => {
-    const lines = [
-        "#!/usr/bin/env bash",
-        "set -euo pipefail",
-        "",
-        "require_env() {",
-        '  local name=\"$1\"',
-        '  if [ -z \"${!name:-}\" ]; then',
-        '    echo \"Missing required env: $name\" >&2',
-        "    exit 1",
-        "  fi",
-        "}",
-        "",
-        "require_file() {",
-        '  local target=\"$1\"',
-        '  if [ ! -f \"$target\" ]; then',
-        '    echo \"Missing required file: $target\" >&2',
-        "    exit 1",
-        "  fi",
-        "}",
-        "",
-        "write_env_file() {",
-        '  local name=\"$1\"',
-        '  local target=\"$2\"',
-        '  if [ -z \"${!name:-}\" ]; then',
-        "    return",
-        "  fi",
-        '  mkdir -p \"$(dirname \"$target\")\"',
-        '  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]:",
-        "    child = cursor.get(part)",
-        "    if not isinstance(child, dict):",
-        "        child = {}",
-        "        cursor[part] = child",
-        "    cursor = child",
-        "",
-        "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",
-        "}",
-        ""
-    ];
-    for (const secretName of requiredSecrets) {
-        lines.push(`require_env ${shellQuote(secretName)}`);
-    }
-    if (requiredSecrets.length > 0) {
-        lines.push("");
-    }
-    if (runtimePlans.length === 1) {
-        const plan = runtimePlans[0];
-        const commandTokens = resolveStartCommand(plan);
-        const envAssignments = createEnvironmentAssignments(plan);
-        const envFileWrites = createEnvFileWrites(plan);
-        const configEnvWrites = createConfigEnvWrites(plan);
-        lines.push(`mkdir -p ${shellQuote(plan.instancePaths.workspacePath)}`, `require_file ${shellQuote(plan.instancePaths.configPath)}`, ...envFileWrites, ...configEnvWrites, `${envAssignments.join(" ")} exec ${commandTokens.map(shellQuote).join(" ")}`);
-        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 plan of runtimePlans) {
-        const commandTokens = resolveStartCommand(plan);
-        const envAssignments = createEnvironmentAssignments(plan);
-        const envFileWrites = createEnvFileWrites(plan);
-        const configEnvWrites = createConfigEnvWrites(plan);
-        lines.push(`mkdir -p ${shellQuote(plan.instancePaths.workspacePath)}`, `require_file ${shellQuote(plan.instancePaths.configPath)}`, ...envFileWrites, ...configEnvWrites, `${envAssignments.join(" ")} ${commandTokens.map(shellQuote).join(" ")} &`, '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/containerArtifactsTypes.d.ts

@@ -2,6 +2,7 @@ import type { ContainerReport } from "../report/index.js";
 import type { EmittedFile, RuntimeContainerConfigEnvBinding, RuntimeContainerMeta } from "../runtime/index.js";
 import type { ModelAuthMethod } from "../shared/index.js";
 import type { ResolvedAgentNode, ResolvedTeamNode } from "./types.js";
+import type { MoltnetBridgePlan, MoltnetServerPlan } from "./moltnetArtifacts.js";
 export interface ContainerEnvVariable {
     categories: Array<"model" | "project" | "runtime" | "surface">;
     description: string;
@@ -24,8 +25,10 @@ export interface RuntimeTargetPlan {
     modelAuthMethods: Record<string, ModelAuthMethod>;
     modelSecretsRequired: string[];
     port?: number;
+    publishedPort?: number;
     runtimeName: string;
     runtimeRoot: string;
+    targetConfigEnvBindings?: RuntimeContainerConfigEnvBinding[];
     targetFiles: EmittedFile[];
 }
 export interface CompiledNodeArtifact {
@@ -38,5 +41,9 @@ export interface CompiledNodeArtifact {
 export interface GeneratedContainerArtifacts {
     executablePaths: string[];
     files: EmittedFile[];
+    moltnet?: {
+        bridgePlans: MoltnetBridgePlan[];
+        serverPlans: MoltnetServerPlan[];
+    };
     report: ContainerReport;
 }

package/dist/compiler/containerEntrypointRender.d.ts

@@ -0,0 +1,12 @@
+import type { RuntimeTargetPlan } from "./containerArtifactsTypes.js";
+import type { MoltnetArtifacts } from "./moltnetArtifacts.js";
+export interface EntrypointOptions {
+    hasMoltnet?: boolean;
+    hasStagedMoltnetBinaries?: boolean;
+    moltnet?: {
+        bridgePlans: MoltnetArtifacts["bridgePlans"];
+        serverPlans: MoltnetArtifacts["serverPlans"];
+    };
+    moltnetPublishedPorts?: number[];
+}
+export declare const renderEntrypoint: (runtimePlans: RuntimeTargetPlan[], requiredSecrets: string[], options?: EntrypointOptions) => string;