spawnfile 0.1.12 → 0.1.13

package/dist/deployment/dockerRecover.js

@@ -0,0 +1,129 @@
+import { execFile as execFileCallback } from "node:child_process";
+import { promisify } from "node:util";
+import { SpawnfileError } from "../shared/index.js";
+import { dockerDeploymentLabelKeys } from "./dockerLabels.js";
+import { resolveDockerDeploymentTarget } from "./target.js";
+const execFile = promisify(execFileCallback);
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const toStringOrNull = (value) => typeof value === "string" && value.length > 0 ? value : null;
+const labelsFrom = (inspection) => {
+    const labels = inspection.Config?.Labels;
+    if (!isRecord(labels)) {
+        return {};
+    }
+    return Object.fromEntries(Object.entries(labels).filter((entry) => typeof entry[1] === "string"));
+};
+const withContext = (context, args) => [
+    "--context",
+    context,
+    ...args
+];
+const containerNameFrom = (inspection) => {
+    const name = toStringOrNull(inspection.Name);
+    return name ? name.replace(/^\//u, "") : null;
+};
+const parseInspections = (stdout) => {
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch (error) {
+        throw new SpawnfileError("runtime_error", `Unable to parse recovered Docker container inspection: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return Array.isArray(parsed) ? parsed.filter(isRecord) : [];
+};
+const deploymentNameFor = (labels) => labels[dockerDeploymentLabelKeys.deployment] ?? null;
+const buildUnit = (inspection, labels, contains, runtimeInstanceIds) => {
+    const unitId = labels[dockerDeploymentLabelKeys.unit];
+    const imageTag = toStringOrNull(inspection.Config?.Image);
+    if (!unitId || !imageTag) {
+        return null;
+    }
+    return {
+        container_id: toStringOrNull(inspection.Id),
+        container_name: containerNameFrom(inspection),
+        contains,
+        id: unitId,
+        image_id: toStringOrNull(inspection.Image),
+        image_tag: imageTag,
+        kind: "container",
+        runtime_instances: runtimeInstanceIds
+    };
+};
+const groupByDeployment = (inspections, options, target) => {
+    const records = new Map();
+    const unitsByDeployment = new Map();
+    const contains = options.contains ?? [];
+    const runtimeInstanceIds = options.runtimeInstanceIds ?? [];
+    for (const inspection of inspections) {
+        const labels = labelsFrom(inspection);
+        if (labels[dockerDeploymentLabelKeys.project] !== options.projectLabel) {
+            continue;
+        }
+        const name = deploymentNameFor(labels);
+        const compileFingerprint = labels[dockerDeploymentLabelKeys.compileFingerprint];
+        if (!name || !compileFingerprint) {
+            continue;
+        }
+        const unit = buildUnit(inspection, labels, contains, runtimeInstanceIds);
+        if (!unit) {
+            continue;
+        }
+        const seenUnits = unitsByDeployment.get(name) ?? new Set();
+        if (seenUnits.has(unit.id)) {
+            throw new SpawnfileError("validation_error", `Recovered deployment "${name}" has multiple containers for unit "${unit.id}"`);
+        }
+        seenUnits.add(unit.id);
+        unitsByDeployment.set(name, seenUnits);
+        const record = records.get(name) ?? {
+            auth_profile: null,
+            compile_fingerprint: compileFingerprint,
+            created_at: toStringOrNull(inspection.Created) ?? new Date().toISOString(),
+            manager: "docker",
+            name,
+            output_directory: options.outputDirectory,
+            source: { kind: "project", root: options.sourceRoot },
+            target,
+            units: [],
+            version: "spawnfile.deployment.v2"
+        };
+        record.units.push(unit);
+        records.set(name, record);
+    }
+    return [...records.values()]
+        .sort((left, right) => left.name.localeCompare(right.name))
+        .map((record) => ({
+        path: `docker-context://${options.context}/${record.name}`,
+        record: {
+            ...record,
+            units: [...record.units].sort((left, right) => left.id.localeCompare(right.id))
+        }
+    }));
+};
+export const recoverDockerDeploymentRecords = async (options) => {
+    const resolved = {
+        dockerCommand: options.dockerCommand ?? "docker",
+        execFile: options.execFile ?? execFile,
+        timeoutMs: options.timeoutMs ?? 10_000
+    };
+    const target = await resolveDockerDeploymentTarget({
+        context: options.context,
+        dockerCommand: resolved.dockerCommand,
+        execFile: resolved.execFile,
+        timeoutMs: resolved.timeoutMs
+    });
+    const { stdout: listStdout } = await resolved.execFile(resolved.dockerCommand, withContext(options.context, [
+        "ps",
+        "-a",
+        "--filter",
+        `label=${dockerDeploymentLabelKeys.version}`,
+        "--format",
+        "{{.ID}}"
+    ]), { timeout: resolved.timeoutMs });
+    const ids = listStdout.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean);
+    if (ids.length === 0) {
+        return [];
+    }
+    const { stdout } = await resolved.execFile(resolved.dockerCommand, withContext(options.context, ["inspect", ...ids]), { timeout: resolved.timeoutMs });
+    return groupByDeployment(parseInspections(stdout), options, target);
+};

package/dist/deployment/index.d.ts

@@ -3,6 +3,7 @@ export * from "./dockerInspect.js";
 export * from "./dockerLogs.js";
 export * from "./dockerManager.js";
 export * from "./dockerProbeGateway.js";
+export * from "./dockerRecover.js";
 export * from "./homeStore.js";
 export * from "./names.js";
 export * from "./record.js";

package/dist/deployment/index.js

@@ -3,6 +3,7 @@ export * from "./dockerInspect.js";
 export * from "./dockerLogs.js";
 export * from "./dockerManager.js";
 export * from "./dockerProbeGateway.js";
+export * from "./dockerRecover.js";
 export * from "./homeStore.js";
 export * from "./names.js";
 export * from "./record.js";

package/dist/dev/activity.d.ts

@@ -0,0 +1,14 @@
+import { type DevExecFile } from "./docker.js";
+import { type DevProjectOptions } from "./project.js";
+export interface DevActivityProjectOptions extends DevProjectOptions {
+    agent?: string;
+    execFile?: DevExecFile;
+    tail?: number;
+}
+export interface DevActivityProjectResult {
+    containerName: string;
+    deploymentName: string;
+    events: unknown[];
+    outputDirectory: string;
+}
+export declare const devActivityProject: (inputPath: string, options?: DevActivityProjectOptions) => Promise<DevActivityProjectResult>;

package/dist/dev/activity.js

@@ -0,0 +1,48 @@
+import { defaultExecFile, dockerArgsForRecord, firstContainerName, runDocker } from "./docker.js";
+import { PI_CONTROL_URL, resolveDevOutputDirectory, selectDeploymentRecord } from "./project.js";
+import { SpawnfileError } from "../shared/index.js";
+const activityPath = (options) => {
+    const params = new URLSearchParams();
+    if (options.agent) {
+        params.set("agent", options.agent);
+    }
+    if (typeof options.tail === "number" && Number.isInteger(options.tail) && options.tail > 0) {
+        params.set("tail", String(options.tail));
+    }
+    const query = params.toString();
+    return `${PI_CONTROL_URL}/spawnfile/activity${query ? `?${query}` : ""}`;
+};
+const parseActivityEvents = (stdout) => {
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch {
+        throw new SpawnfileError("runtime_error", "Pi activity endpoint returned invalid JSON");
+    }
+    if (typeof parsed !== "object" ||
+        parsed === null ||
+        !Array.isArray(parsed.events)) {
+        throw new SpawnfileError("runtime_error", "Pi activity endpoint response did not include an events array");
+    }
+    return parsed.events;
+};
+export const devActivityProject = async (inputPath, options = {}) => {
+    const outputDirectory = await resolveDevOutputDirectory(inputPath, options.outputDirectory);
+    const record = await selectDeploymentRecord(outputDirectory, options.deploymentName);
+    const containerName = firstContainerName(record);
+    const stdout = await runDocker(options.dockerCommand ?? "docker", [
+        ...dockerArgsForRecord(record),
+        "exec",
+        containerName,
+        "curl",
+        "-fsS",
+        activityPath(options)
+    ], options.execFile ?? defaultExecFile);
+    return {
+        containerName,
+        deploymentName: record.name,
+        events: parseActivityEvents(stdout),
+        outputDirectory
+    };
+};

package/dist/dev/docker.d.ts

@@ -0,0 +1,16 @@
+import { type CompileProjectResult } from "../compiler/index.js";
+import { type DeploymentRecord } from "../deployment/index.js";
+export type DevExecFile = (file: string, args: string[], options: {
+    timeout: number;
+}) => Promise<{
+    stderr: string;
+    stdout: string;
+}>;
+export declare const defaultExecFile: DevExecFile;
+export declare const dockerArgsForRecord: (record: DeploymentRecord) => string[];
+export declare const firstContainerName: (record: DeploymentRecord) => string;
+export declare const compileForDevApply: (inputPath: string, outputDirectory: string, record: DeploymentRecord, dockerCommand: string, execFileImpl: DevExecFile) => Promise<CompileProjectResult>;
+export declare const runDocker: (command: string, args: string[], execFileImpl: DevExecFile, timeout?: number) => Promise<string>;
+export declare const copyIntoContainer: (dockerCommand: string, dockerPrefix: string[], source: string, destination: string, execFileImpl: DevExecFile) => Promise<void>;
+export declare const ensureContainerDirectories: (dockerCommand: string, dockerPrefix: string[], containerName: string, paths: string[], execFileImpl: DevExecFile) => Promise<void>;
+export declare const chownContainerPaths: (dockerCommand: string, dockerPrefix: string[], containerName: string, paths: string[], execFileImpl: DevExecFile) => Promise<void>;

package/dist/dev/docker.js

@@ -0,0 +1,71 @@
+import { execFile as execFileCallback } from "node:child_process";
+import { promisify } from "node:util";
+import { compileProject, normalizeDockerArchitecture } from "../compiler/index.js";
+import { dockerContextNameForTarget, dockerHostValueForTarget } from "../deployment/index.js";
+import { SpawnfileError } from "../shared/index.js";
+export const defaultExecFile = promisify(execFileCallback);
+export const dockerArgsForRecord = (record) => {
+    const context = dockerContextNameForTarget(record.target);
+    if (context) {
+        return ["--context", context];
+    }
+    const host = dockerHostValueForTarget(record.target);
+    return host ? ["--host", host] : [];
+};
+export const firstContainerName = (record) => {
+    const unit = record.units.find((candidate) => candidate.kind === "container") ?? record.units[0];
+    const name = unit?.container_name;
+    if (!name) {
+        throw new SpawnfileError("runtime_error", `Deployment "${record.name}" has no recorded container name`);
+    }
+    return name;
+};
+export const compileForDevApply = async (inputPath, outputDirectory, record, dockerCommand, execFileImpl) => {
+    const dockerContext = dockerContextNameForTarget(record.target) ?? undefined;
+    const architecture = dockerContext
+        ? normalizeDockerArchitecture((await execFileImpl(dockerCommand, ["--context", dockerContext, "info", "--format", "{{.Architecture}}"], { timeout: 10_000 })).stdout)
+        : undefined;
+    return compileProject(inputPath, {
+        clean: false,
+        containerArchitecture: architecture,
+        outputDirectory
+    });
+};
+export const runDocker = async (command, args, execFileImpl, timeout = 30_000) => {
+    const { stdout } = await execFileImpl(command, args, { timeout });
+    return stdout;
+};
+export const copyIntoContainer = async (dockerCommand, dockerPrefix, source, destination, execFileImpl) => {
+    await runDocker(dockerCommand, [...dockerPrefix, "cp", source, destination], execFileImpl, 60_000);
+};
+export const ensureContainerDirectories = async (dockerCommand, dockerPrefix, containerName, paths, execFileImpl) => {
+    if (paths.length === 0) {
+        return;
+    }
+    await runDocker(dockerCommand, [
+        ...dockerPrefix,
+        "exec",
+        "--user",
+        "root",
+        containerName,
+        "mkdir",
+        "-p",
+        ...paths
+    ], execFileImpl);
+};
+export const chownContainerPaths = async (dockerCommand, dockerPrefix, containerName, paths, execFileImpl) => {
+    if (paths.length === 0) {
+        return;
+    }
+    await runDocker(dockerCommand, [
+        ...dockerPrefix,
+        "exec",
+        "--user",
+        "root",
+        containerName,
+        "chown",
+        "-R",
+        "spawnfile:spawnfile",
+        ...paths
+    ], execFileImpl);
+};

package/dist/dev/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./activity.js";
+export * from "./project.js";

package/dist/dev/index.js

@@ -0,0 +1,2 @@
+export * from "./activity.js";
+export * from "./project.js";

package/dist/dev/project.d.ts

@@ -0,0 +1,35 @@
+import { type UpProjectOptions, type UpProjectResult } from "../compiler/index.js";
+import { type DeploymentRecord } from "../deployment/index.js";
+import { type DevExecFile } from "./docker.js";
+export declare const PI_CONTROL_URL = "http://127.0.0.1:19690";
+export interface DevProjectOptions {
+    deploymentName?: string;
+    dockerCommand?: string;
+    outputDirectory?: string;
+}
+export interface DevApplyProjectOptions extends DevProjectOptions {
+    agent: string;
+    execFile?: DevExecFile;
+    restart?: boolean;
+}
+export interface DevApplyProjectResult {
+    agentId: string;
+    bridgeStarted: boolean;
+    containerName: string;
+    deploymentName: string;
+    existingAgent: boolean;
+    outputDirectory: string;
+}
+export interface DevStopProjectResult {
+    containerName: string;
+    deploymentName: string;
+    outputDirectory: string;
+}
+export declare const resolveDevOutputDirectory: (inputPath: string, outputDirectory?: string) => Promise<string>;
+export declare const devUpProject: (inputPath: string, options?: UpProjectOptions) => Promise<UpProjectResult>;
+export declare const selectDeploymentRecord: (outputDirectory: string, deploymentName?: string) => Promise<DeploymentRecord>;
+export declare const devApplyProject: (inputPath: string, options: DevApplyProjectOptions) => Promise<DevApplyProjectResult>;
+export declare const devRestartProject: (inputPath: string, options: DevApplyProjectOptions) => Promise<DevApplyProjectResult>;
+export declare const devStopProject: (inputPath: string, options?: DevProjectOptions & {
+    execFile?: DevExecFile;
+}) => Promise<DevStopProjectResult>;

package/dist/dev/project.js

@@ -0,0 +1,164 @@
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+import { buildCompilePlan, upProject } from "../compiler/index.js";
+import { listDeploymentRecords, normalizeDeploymentName } from "../deployment/index.js";
+import { SpawnfileError } from "../shared/index.js";
+import { chownContainerPaths, compileForDevApply, copyIntoContainer, defaultExecFile, dockerArgsForRecord, ensureContainerDirectories, firstContainerName, runDocker } from "./docker.js";
+const DEV_OUTPUT_DIRECTORY = ".spawn-dev";
+const PI_APP_CONFIG_PATH = "/var/lib/spawnfile/instances/pi/pi-app/pi/pi-app.json";
+export const PI_CONTROL_URL = "http://127.0.0.1:19690";
+export const resolveDevOutputDirectory = async (inputPath, outputDirectory) => {
+    if (outputDirectory) {
+        return path.resolve(outputDirectory);
+    }
+    const plan = await buildCompilePlan(inputPath);
+    return path.join(path.dirname(plan.root), DEV_OUTPUT_DIRECTORY);
+};
+export const devUpProject = async (inputPath, options = {}) => upProject(inputPath, {
+    ...options,
+    detach: true,
+    outputDirectory: await resolveDevOutputDirectory(inputPath, options.outputDirectory)
+});
+export const selectDeploymentRecord = async (outputDirectory, deploymentName) => {
+    const records = await listDeploymentRecords(outputDirectory);
+    if (records.length === 0) {
+        throw new SpawnfileError("validation_error", `No dev deployment records found in ${outputDirectory}; run spawnfile dev up first`);
+    }
+    if (deploymentName) {
+        const normalized = normalizeDeploymentName(deploymentName);
+        const selected = records.find((entry) => entry.record.name === normalized);
+        if (!selected) {
+            throw new SpawnfileError("validation_error", `Unknown dev deployment "${normalized}". Valid deployments: ${records.map((entry) => entry.record.name).join(", ")}`);
+        }
+        return selected.record;
+    }
+    if (records.length > 1) {
+        throw new SpawnfileError("validation_error", `--deployment is required: ${records.map((entry) => entry.record.name).join(", ")}`);
+    }
+    return records[0].record;
+};
+const readJson = async (filePath) => JSON.parse(await readFile(filePath, "utf8"));
+const rootfsPath = (outputDirectory, containerPath) => path.join(outputDirectory, "container", "rootfs", containerPath.replace(/^\/+/u, ""));
+const matchesAgent = (agent, input) => agent.slug === input || agent.id === input || agent.name === input || agent.id === `agent:${input}`;
+const selectPiAgent = async (outputDirectory, agentInput) => {
+    const configPath = rootfsPath(outputDirectory, PI_APP_CONFIG_PATH);
+    const config = await readJson(configPath);
+    const agent = (config.agents ?? []).find((candidate) => matchesAgent(candidate, agentInput));
+    if (!agent) {
+        throw new SpawnfileError("validation_error", `Pi agent "${agentInput}" was not found in compiled output`);
+    }
+    return {
+        agent,
+        configPath,
+        workspacePath: rootfsPath(outputDirectory, `/var/lib/spawnfile/instances/pi/pi-app/workspace/agents/${agent.slug}`)
+    };
+};
+const selectMoltnetNodes = async (result, agent) => {
+    const nodePlans = result.report.container?.moltnet?.node_plans ?? [];
+    const matches = [];
+    for (const plan of nodePlans) {
+        const configPath = rootfsPath(result.outputDirectory, plan.config_path);
+        const config = await readJson(configPath);
+        const attachment = (config.attachments ?? []).find((candidate) => {
+            const id = candidate.agent?.id ?? "";
+            const name = candidate.agent?.name ?? "";
+            return id === agent.slug || id === agent.id || name === agent.name;
+        });
+        if (attachment?.agent?.id) {
+            matches.push({
+                configPath,
+                remotePath: plan.config_path,
+                ...(attachment.moltnet?.token_path
+                    ? { tokenDirectory: path.posix.dirname(attachment.moltnet.token_path) }
+                    : {})
+            });
+        }
+    }
+    return matches;
+};
+const selectManagedMoltnetServers = (result) => (result.report.container?.moltnet?.server_plans ?? [])
+    .filter((plan) => plan.mode === "managed" && Boolean(plan.config_path))
+    .map((plan) => ({
+    configPath: rootfsPath(result.outputDirectory, plan.config_path),
+    remotePath: plan.config_path
+}));
+const shellQuote = (value) => `'${value.replaceAll("'", "'\"'\"'")}'`;
+const listRunningPiAgents = async (dockerCommand, dockerPrefix, containerName, execFileImpl) => {
+    const stdout = await runDocker(dockerCommand, [...dockerPrefix, "exec", containerName, "curl", "-fsS", `${PI_CONTROL_URL}/spawnfile/agents`], execFileImpl);
+    const parsed = JSON.parse(stdout);
+    return parsed.agents ?? [];
+};
+const loadPiAgent = async (dockerCommand, dockerPrefix, containerName, slug, action, execFileImpl) => {
+    await runDocker(dockerCommand, [
+        ...dockerPrefix,
+        "exec",
+        containerName,
+        "curl",
+        "-fsS",
+        "-X",
+        "POST",
+        "-H",
+        "content-type: application/json",
+        "--data",
+        JSON.stringify({ slug }),
+        `${PI_CONTROL_URL}/spawnfile/agents/${action}`
+    ], execFileImpl, 120_000);
+};
+export const devApplyProject = async (inputPath, options) => {
+    const outputDirectory = await resolveDevOutputDirectory(inputPath, options.outputDirectory);
+    const record = await selectDeploymentRecord(outputDirectory, options.deploymentName);
+    const dockerCommand = options.dockerCommand ?? "docker";
+    const dockerPrefix = dockerArgsForRecord(record);
+    const containerName = firstContainerName(record);
+    const execFileImpl = options.execFile ?? defaultExecFile;
+    const existingAgents = await listRunningPiAgents(dockerCommand, dockerPrefix, containerName, execFileImpl);
+    const compileResult = await compileForDevApply(inputPath, outputDirectory, record, dockerCommand, execFileImpl);
+    const { agent, configPath, workspacePath } = await selectPiAgent(outputDirectory, options.agent);
+    const nodes = await selectMoltnetNodes(compileResult, agent);
+    const serverConfigs = selectManagedMoltnetServers(compileResult);
+    const existingAgent = existingAgents.some((candidate) => matchesAgent(candidate, agent.slug));
+    await copyIntoContainer(dockerCommand, dockerPrefix, configPath, `${containerName}:${PI_APP_CONFIG_PATH}`, execFileImpl);
+    await copyIntoContainer(dockerCommand, dockerPrefix, workspacePath, `${containerName}:/var/lib/spawnfile/instances/pi/pi-app/workspace/agents`, execFileImpl);
+    for (const node of nodes) {
+        await copyIntoContainer(dockerCommand, dockerPrefix, node.configPath, `${containerName}:${node.remotePath}`, execFileImpl);
+    }
+    for (const serverConfig of serverConfigs) {
+        await copyIntoContainer(dockerCommand, dockerPrefix, serverConfig.configPath, `${containerName}:${serverConfig.remotePath}`, execFileImpl);
+    }
+    const tokenDirectories = nodes
+        .map((node) => node.tokenDirectory)
+        .filter((directory) => Boolean(directory));
+    await ensureContainerDirectories(dockerCommand, dockerPrefix, containerName, tokenDirectories, execFileImpl);
+    await chownContainerPaths(dockerCommand, dockerPrefix, containerName, [
+        "/var/lib/spawnfile/instances/pi/pi-app",
+        ...nodes.flatMap((node) => [
+            node.remotePath,
+            ...(node.tokenDirectory ? [node.tokenDirectory] : [])
+        ]),
+        ...serverConfigs.map((serverConfig) => serverConfig.remotePath)
+    ], execFileImpl);
+    await loadPiAgent(dockerCommand, dockerPrefix, containerName, agent.slug, options.restart === true ? "restart" : "load", execFileImpl);
+    if (!existingAgent) {
+        for (const node of nodes) {
+            const prepare = node.tokenDirectory ? `mkdir -p ${shellQuote(node.tokenDirectory)} && ` : "";
+            const command = `${prepare}/usr/local/bin/moltnet node ${shellQuote(node.remotePath)}`;
+            await runDocker(dockerCommand, [...dockerPrefix, "exec", "-d", "--user", "spawnfile", containerName, "sh", "-lc", command], execFileImpl);
+        }
+    }
+    return {
+        agentId: agent.id,
+        bridgeStarted: !existingAgent && nodes.length > 0,
+        containerName,
+        deploymentName: record.name,
+        existingAgent,
+        outputDirectory
+    };
+};
+export const devRestartProject = async (inputPath, options) => devApplyProject(inputPath, { ...options, restart: true });
+export const devStopProject = async (inputPath, options = {}) => {
+    const outputDirectory = await resolveDevOutputDirectory(inputPath, options.outputDirectory);
+    const record = await selectDeploymentRecord(outputDirectory, options.deploymentName);
+    const containerName = firstContainerName(record);
+    await runDocker(options.dockerCommand ?? "docker", [...dockerArgsForRecord(record), "rm", "-f", containerName], options.execFile ?? defaultExecFile);
+    return { containerName, deploymentName: record.name, outputDirectory };
+};

package/dist/runtime/common.d.ts

@@ -7,6 +7,8 @@ export declare const createDocumentFiles: (baseDirectory: string, documents: Res
 export declare const createSkillFiles: (baseDirectory: string, skills: ResolvedSkill[]) => EmittedFile[];
 export declare const createAgentCapabilities: (node: ResolvedAgentNode, options?: {
     mcpOutcome?: CapabilityReport["outcome"];
+    moltnetMessage?: string;
+    moltnetOutcome?: CapabilityReport["outcome"];
     sandboxOutcome?: CapabilityReport["outcome"];
     scheduleMessage?: string;
     scheduleOutcome?: CapabilityReport["outcome"];

package/dist/runtime/common.js

@@ -48,7 +48,7 @@ export const createAgentCapabilities = (node, options = {}) => {
         capabilities.push(createCapability("surfaces.discord", "supported"));
     }
     if (node.surfaces?.moltnet) {
-        capabilities.push(createCapability("surfaces.moltnet", "supported"));
+        capabilities.push(createCapability("surfaces.moltnet", options.moltnetOutcome ?? "supported", options.moltnetMessage));
     }
     if (node.surfaces?.telegram) {
         capabilities.push(createCapability("surfaces.telegram", "supported"));

package/dist/runtime/container.d.ts

@@ -1,5 +1,6 @@
 export declare const RUNTIME_INSTALL_ROOT = "/opt/spawnfile/runtime-installs";
 export interface RuntimeInstallRecipe {
+    baseImage?: string;
     commands: string[];
     copyCommands: string[];
     runtimeName: string;