spawnfile 0.1.1 → 0.1.2

package/dist/compiler/containerEntrypointRender.js

@@ -0,0 +1,186 @@
+import path from "node:path";
+const MOLTNET_SERVER_DATA_DIRECTORY = "/var/lib/spawnfile/moltnet/servers";
+const shellQuote = (value) => `'${value.replace(/'/g, `'\"'\"'`)}'`;
+const pathSafeSegment = (value) => value.replace(/[^A-Za-z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "") || "server";
+const createMoltnetServerDataPath = (serverId) => `${MOLTNET_SERVER_DATA_DIRECTORY}/${pathSafeSegment(serverId)}.db`;
+const createEnvironmentAssignments = (plan) => {
+    const envAssignments = [];
+    if (plan.instancePaths.homePath) {
+        envAssignments.push(`HOME=${shellQuote(plan.instancePaths.homePath)}`);
+    }
+    if (plan.runtimeName === "tinyclaw" &&
+        plan.instancePaths.homePath &&
+        (plan.modelAuthMethods.openai === "api_key" || plan.modelAuthMethods.openai === "codex")) {
+        envAssignments.push(`CODEX_HOME=${shellQuote(path.posix.join(plan.instancePaths.homePath, ".codex"))}`);
+    }
+    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 createAuthSetupCommands = (plan) => {
+    if (plan.runtimeName !== "tinyclaw" ||
+        !plan.instancePaths.homePath ||
+        plan.modelAuthMethods.openai !== "api_key") {
+        return [];
+    }
+    return [`configure_codex_api_key_auth ${shellQuote(plan.instancePaths.homePath)}`];
+};
+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);
+const createRuntimeReadinessWait = (plan) => {
+    if (plan.runtimeName !== "openclaw" || !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 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",
+        "}",
+        "",
+        "configure_codex_api_key_auth() {",
+        '  local home_path="$1"',
+        '  if [ -z "${OPENAI_API_KEY:-}" ]; then',
+        "    return",
+        "  fi",
+        '  mkdir -p "$home_path/.codex"',
+        '  printf "%s\\n" "${OPENAI_API_KEY:-}" | HOME="$home_path" CODEX_HOME="$home_path/.codex" codex login --with-api-key >/dev/null',
+        "}",
+        ""
+    ];
+    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) {
+        lines.push(`require_env ${shellQuote(secretName)}`);
+    }
+    if (requiredSecrets.length > 0) {
+        lines.push("");
+    }
+    const moltnetServerPlans = options.moltnet?.serverPlans ?? [];
+    const moltnetBridgePlans = options.moltnet?.bridgePlans ?? [];
+    if (runtimePlans.length === 1 &&
+        moltnetServerPlans.length === 0 &&
+        moltnetBridgePlans.length === 0) {
+        const plan = runtimePlans[0];
+        const commandTokens = resolveStartCommand(plan);
+        const envAssignments = createEnvironmentAssignments(plan);
+        lines.push(`mkdir -p ${shellQuote(plan.instancePaths.workspacePath)}`, `require_file ${shellQuote(plan.instancePaths.configPath)}`, ...createEnvFileWrites(plan), ...createConfigEnvWrites(plan), ...createAuthSetupCommands(plan), `${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", "");
+    if (moltnetServerPlans.length > 0) {
+        lines.push(`mkdir -p ${shellQuote(MOLTNET_SERVER_DATA_DIRECTORY)}`, "");
+    }
+    for (const serverPlan of moltnetServerPlans) {
+        lines.push(`MOLTNET_DATA_PATH=${shellQuote(createMoltnetServerDataPath(serverPlan.id))} MOLTNET_LISTEN_ADDR=${shellQuote(`:${serverPlan.port}`)} MOLTNET_NETWORK_ID=${shellQuote(serverPlan.networkId)} MOLTNET_NETWORK_NAME=${shellQuote(serverPlan.name)} /usr/local/bin/moltnet &`, 'PIDS+=("$!")', "");
+    }
+    for (const plan of runtimePlans) {
+        const commandTokens = resolveStartCommand(plan);
+        const envAssignments = createEnvironmentAssignments(plan);
+        lines.push(`mkdir -p ${shellQuote(plan.instancePaths.workspacePath)}`, `require_file ${shellQuote(plan.instancePaths.configPath)}`, ...createEnvFileWrites(plan), ...createConfigEnvWrites(plan), ...createAuthSetupCommands(plan), `${envAssignments.join(" ")} ${commandTokens.map(shellQuote).join(" ")} &`, 'PIDS+=("$!")', "", ...createRuntimeReadinessWait(plan));
+    }
+    for (const serverPlan of moltnetServerPlans) {
+        lines.push(`until curl -sf ${shellQuote(`http://127.0.0.1:${serverPlan.port}/healthz`)} >/dev/null; do sleep 1; done`);
+        for (const room of serverPlan.rooms) {
+            lines.push(`curl -sf -X POST -H 'Content-Type: application/json' -d ${shellQuote(JSON.stringify({
+                id: room.id,
+                members: room.members
+            }))} ${shellQuote(`http://127.0.0.1:${serverPlan.port}/v1/rooms`)} >/dev/null || true`);
+        }
+        lines.push("");
+    }
+    for (const bridgePlan of moltnetBridgePlans) {
+        lines.push(`/usr/local/bin/moltnet bridge ${shellQuote(bridgePlan.configPath)} &`, 'PIDS+=("$!")', "");
+    }
+    lines.push('if [ "${#PIDS[@]}" -eq 0 ]; then', '  echo "No runtime targets were generated for this compile output" >&2', "  exit 1", "fi", "", "status=0", 'for pid in "${PIDS[@]}"; do', '  if ! wait "$pid"; then', "    status=1", "  fi", "done", "", 'exit "$status"');
+    return `${lines.join("\n").trimEnd()}\n`;
+};

package/dist/compiler/index.d.ts

@@ -7,3 +7,5 @@ export * from "./runProject.js";
 export * from "./syncProjectAuth.js";
 export * from "./types.js";
 export * from "./updateProjectModels.js";
+export * from "./updateProjectRuntime.js";
+export * from "./updateProjectSurfaces.js";

package/dist/compiler/index.js

@@ -7,3 +7,5 @@ export * from "./runProject.js";
 export * from "./syncProjectAuth.js";
 export * from "./types.js";
 export * from "./updateProjectModels.js";
+export * from "./updateProjectRuntime.js";
+export * from "./updateProjectSurfaces.js";

package/dist/compiler/interactiveSurfaceScopes.d.ts

@@ -0,0 +1,2 @@
+import type { ResolvedAgentSurfaces } from "./types.js";
+export declare const listInteractiveSurfaceScopes: (surfaces: ResolvedAgentSurfaces | undefined) => string[];

package/dist/compiler/interactiveSurfaceScopes.js

@@ -0,0 +1,21 @@
+const listMoltnetAttachmentScopes = (attachment) => {
+    const scopes = Object.keys(attachment.rooms ?? {})
+        .sort((left, right) => left.localeCompare(right))
+        .map((roomId) => `moltnet:${attachment.network}:room:${roomId}`);
+    if (attachment.dms?.enabled) {
+        scopes.push(`moltnet:${attachment.network}:dms`);
+    }
+    return scopes;
+};
+export const listInteractiveSurfaceScopes = (surfaces) => {
+    if (!surfaces) {
+        return [];
+    }
+    return [
+        ...(surfaces.discord ? ["discord"] : []),
+        ...(surfaces.moltnet?.flatMap(listMoltnetAttachmentScopes) ?? []),
+        ...(surfaces.slack ? ["slack"] : []),
+        ...(surfaces.telegram ? ["telegram"] : []),
+        ...(surfaces.whatsapp ? ["whatsapp"] : [])
+    ];
+};

package/dist/compiler/moltnetArtifacts.d.ts

@@ -0,0 +1,27 @@
+import type { EmittedFile } from "../runtime/index.js";
+import type { CompilePlan } from "./types.js";
+export interface MoltnetServerPlan {
+    id: string;
+    name: string;
+    networkId: string;
+    port: number;
+    rooms: Array<{
+        id: string;
+        members: string[];
+    }>;
+    teamSource: string;
+}
+export interface MoltnetBridgePlan {
+    agentId: string;
+    configPath: string;
+    networkId: string;
+    runtime: string;
+}
+export interface MoltnetArtifacts {
+    bridgePlans: MoltnetBridgePlan[];
+    files: EmittedFile[];
+    ports: number[];
+    publishedPorts: number[];
+    serverPlans: MoltnetServerPlan[];
+}
+export declare const generateMoltnetArtifacts: (plan: CompilePlan) => Promise<MoltnetArtifacts | null>;

package/dist/compiler/moltnetArtifacts.js

@@ -0,0 +1,204 @@
+import { getRuntimeAdapter } from "../runtime/index.js";
+import { SpawnfileError } from "../shared/index.js";
+const DEFAULT_MOLTNET_PORT = 8787;
+const DEFAULT_TINYCLAW_PORT = 3777;
+const ROOTFS_PREFIX = "container/rootfs";
+const INSTANCE_ROOT_PLACEHOLDER = "<instance-root>";
+const CONFIG_FILE_PLACEHOLDER = "<config-file>";
+const createServerKey = (networkId) => networkId;
+const createBridgeConfigPath = (teamSlug, networkId, agentId) => `${ROOTFS_PREFIX}/var/lib/spawnfile/moltnet/bridges/${teamSlug}-${networkId}-${agentId}.json`;
+const resolveSequentialRuntimePort = (plan, runtimeName, slug) => {
+    const adapter = getRuntimeAdapter(runtimeName);
+    const basePort = adapter.container.port;
+    if (basePort === undefined) {
+        return undefined;
+    }
+    const runtimeAgents = plan.nodes.filter((node) => node.kind === "agent" && node.runtimeName === runtimeName);
+    const index = runtimeAgents.findIndex((node) => node.slug === slug);
+    if (index < 0) {
+        return undefined;
+    }
+    return basePort + (index * (adapter.container.portStride ?? 1));
+};
+const createTinyClawChannel = (networkId, agentId) => `moltnet:${networkId}:${agentId}`;
+const replaceContainerPathTemplate = (template, instanceRoot, configFileName) => template
+    .replaceAll(INSTANCE_ROOT_PLACEHOLDER, instanceRoot)
+    .replaceAll(CONFIG_FILE_PLACEHOLDER, configFileName);
+const resolveRuntimeInstancePaths = (runtimeName, slug) => {
+    const adapter = getRuntimeAdapter(runtimeName);
+    const instanceRoot = `/var/lib/spawnfile/instances/${runtimeName}/agent-${slug}`;
+    return {
+        configPath: replaceContainerPathTemplate(adapter.container.instancePaths.configPathTemplate, instanceRoot, adapter.container.configFileName),
+        homePath: adapter.container.instancePaths.homePathTemplate
+            ? replaceContainerPathTemplate(adapter.container.instancePaths.homePathTemplate, instanceRoot, adapter.container.configFileName)
+            : undefined
+    };
+};
+const resolveRuntimeConfig = (plan, agentNode, nodeSlug, networkId, agentId) => {
+    switch (agentNode.runtime.name) {
+        case "openclaw": {
+            const port = resolveSequentialRuntimePort(plan, "openclaw", nodeSlug);
+            if (!port) {
+                throw new SpawnfileError("compile_error", `Unable to resolve OpenClaw gateway port for Moltnet agent ${agentNode.name}`);
+            }
+            const instancePaths = resolveRuntimeInstancePaths("openclaw", nodeSlug);
+            return {
+                gateway_url: `ws://127.0.0.1:${port}`,
+                ...(instancePaths.homePath ? { home_path: instancePaths.homePath } : {}),
+                kind: "openclaw",
+            };
+        }
+        case "picoclaw": {
+            const instancePaths = resolveRuntimeInstancePaths("picoclaw", nodeSlug);
+            return {
+                command: "/usr/local/bin/picoclaw",
+                config_path: instancePaths.configPath,
+                ...(instancePaths.homePath ? { home_path: instancePaths.homePath } : {}),
+                kind: "picoclaw",
+            };
+        }
+        case "tinyclaw": {
+            const channel = createTinyClawChannel(networkId, agentId);
+            return {
+                ack_url: `http://127.0.0.1:${DEFAULT_TINYCLAW_PORT}/api/responses`,
+                channel,
+                inbound_url: `http://127.0.0.1:${DEFAULT_TINYCLAW_PORT}/api/message`,
+                kind: "tinyclaw",
+                outbound_url: `http://127.0.0.1:${DEFAULT_TINYCLAW_PORT}/api/responses/pending?channel=${encodeURIComponent(channel)}`
+            };
+        }
+        default:
+            throw new SpawnfileError("compile_error", `Moltnet does not know how to attach runtime ${agentNode.runtime.name} directly`);
+    }
+};
+export const generateMoltnetArtifacts = async (plan) => {
+    const teamNodes = plan.nodes
+        .filter((node) => node.kind === "team")
+        .filter((node) => (node.value.networks?.length ?? 0) > 0);
+    if (teamNodes.length === 0) {
+        return null;
+    }
+    const serverPlans = new Map();
+    let nextPort = DEFAULT_MOLTNET_PORT;
+    for (const teamNode of teamNodes) {
+        for (const network of teamNode.value.networks ?? []) {
+            const serverKey = createServerKey(network.id);
+            const existingPlan = serverPlans.get(serverKey);
+            if (existingPlan) {
+                for (const room of network.rooms) {
+                    const existingRoom = existingPlan.rooms.find((entry) => entry.id === room.id);
+                    if (existingRoom) {
+                        existingRoom.members = [...new Set([...existingRoom.members, ...room.members])].sort();
+                    }
+                    else {
+                        existingPlan.rooms.push({
+                            id: room.id,
+                            members: [...new Set(room.members)].sort()
+                        });
+                    }
+                }
+                existingPlan.rooms.sort((left, right) => left.id.localeCompare(right.id));
+            }
+            else {
+                serverPlans.set(serverKey, {
+                    id: `${teamNode.slug}-${network.id}`,
+                    name: network.name,
+                    networkId: network.id,
+                    port: nextPort,
+                    rooms: network.rooms.map((room) => ({
+                        id: room.id,
+                        members: [...new Set(room.members)].sort()
+                    })),
+                    teamSource: teamNode.value.source
+                });
+                nextPort += 1;
+            }
+        }
+    }
+    const bridgePlans = [];
+    const bridgePlanKeys = new Set();
+    const configFiles = [];
+    for (const node of plan.nodes) {
+        if (node.kind !== "agent") {
+            continue;
+        }
+        const agentNode = node.value;
+        if (!agentNode.surfaces?.moltnet || agentNode.surfaces.moltnet.length === 0) {
+            continue;
+        }
+        for (const attachment of agentNode.surfaces.moltnet) {
+            if (!attachment.teamSource || !attachment.memberId) {
+                throw new SpawnfileError("validation_error", `Agent ${agentNode.name} Moltnet attachments require a team-bound network context`);
+            }
+            const teamNode = teamNodes.find((team) => team.value.source === attachment.teamSource);
+            if (!teamNode) {
+                throw new SpawnfileError("validation_error", `Unable to find team context for Moltnet attachment ${attachment.network} on ${agentNode.name}`);
+            }
+            const serverPlan = serverPlans.get(createServerKey(attachment.network));
+            if (!serverPlan) {
+                throw new SpawnfileError("validation_error", `Unable to find Moltnet network ${attachment.network} for ${agentNode.name}`);
+            }
+            const configPath = createBridgeConfigPath(teamNode.slug, attachment.network, attachment.memberId);
+            const bridgePlanKey = `${attachment.network}::${attachment.memberId}`;
+            if (bridgePlanKeys.has(bridgePlanKey)) {
+                throw new SpawnfileError("validation_error", `Duplicate Moltnet bridge attachment for ${attachment.network}/${attachment.memberId}`);
+            }
+            bridgePlanKeys.add(bridgePlanKey);
+            configFiles.push({
+                content: `${JSON.stringify({
+                    version: "moltnet.bridge.v1",
+                    agent: {
+                        id: attachment.memberId,
+                        name: agentNode.name
+                    },
+                    moltnet: {
+                        base_url: `http://127.0.0.1:${serverPlan.port}`,
+                        network_id: attachment.network
+                    },
+                    runtime: resolveRuntimeConfig(plan, agentNode, node.slug, attachment.network, attachment.memberId),
+                    ...(attachment.rooms
+                        ? {
+                            rooms: Object.entries(attachment.rooms)
+                                .sort(([left], [right]) => left.localeCompare(right))
+                                .map(([roomId, policy]) => ({
+                                id: roomId,
+                                ...(policy.read ? { read: policy.read } : {}),
+                                ...(policy.reply ? { reply: policy.reply } : {})
+                            }))
+                        }
+                        : {}),
+                    ...(attachment.dms
+                        ? {
+                            dms: {
+                                enabled: attachment.dms.enabled,
+                                ...(attachment.dms.read ? { read: attachment.dms.read } : {}),
+                                ...(attachment.dms.reply ? { reply: attachment.dms.reply } : {})
+                            }
+                        }
+                        : {})
+                }, null, 2)}\n`,
+                mode: 0o600,
+                path: configPath
+            });
+            bridgePlans.push({
+                agentId: attachment.memberId,
+                configPath: `/${configPath.replace(`${ROOTFS_PREFIX}/`, "")}`,
+                networkId: attachment.network,
+                runtime: agentNode.runtime.name
+            });
+        }
+    }
+    return {
+        bridgePlans: bridgePlans.sort((left, right) => left.configPath.localeCompare(right.configPath)),
+        files: configFiles,
+        ports: [...new Set([...serverPlans.values()].map((plan) => plan.port))].sort((left, right) => left - right),
+        publishedPorts: [
+            ...new Set(teamNodes
+                .flatMap((teamNode) => (teamNode.value.networks ?? []).map((network) => network.expose
+                ? serverPlans.get(createServerKey(network.id))?.port
+                : undefined))
+                .filter((port) => port !== undefined))
+        ].sort((left, right) => left - right),
+        serverPlans: [...serverPlans.values()].sort((left, right) => left.port - right.port)
+    };
+};

package/dist/compiler/moltnetBinaries.d.ts

@@ -0,0 +1,4 @@
+export declare const MOLTNET_BIN_DIRECTORY = "moltnet-bin";
+export declare const MOLTNET_BINARY_NAMES: readonly ["moltnet"];
+export declare const resolveMoltnetCliCommand: () => Promise<string>;
+export declare const stageMoltnetBinaries: (outputDirectory: string) => Promise<boolean>;

package/dist/compiler/moltnetBinaries.js

@@ -0,0 +1,103 @@
+import { execFile as execFileCallback } from "node:child_process";
+import path from "node:path";
+import { chmod } from "node:fs/promises";
+import { promisify } from "node:util";
+import { ensureDirectory, fileExists } from "../filesystem/index.js";
+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 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 = () => {
+    switch (process.arch) {
+        case "arm64":
+            return "arm64";
+        case "x64":
+            return "amd64";
+        default:
+            throw new SpawnfileError("compile_error", `Moltnet container installs do not support host architecture ${process.arch}`);
+    }
+};
+const createReleaseAssetName = (architecture) => `moltnet_${MOLTNET_TARGET_OS}_${architecture}.tar.gz`;
+const isCommandNotFoundError = (error) => typeof error === "object" &&
+    error !== null &&
+    "code" in error &&
+    error.code === "ENOENT";
+const validateMoltnetCli = async (command, sourceLabel) => {
+    try {
+        await execFile(command, ["version"]);
+        return command;
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new SpawnfileError("compile_error", `Unable to execute compiled Moltnet CLI from ${sourceLabel}: ${reason}. Install Moltnet with \`curl -fsSL https://moltnet.dev/install.sh | sh\` or set ${MOLTNET_CLI_ENV}.`);
+    }
+};
+const resolveConfiguredReleaseDirectory = async () => {
+    const configuredDirectory = process.env[MOLTNET_RELEASE_DIR_ENV]?.trim();
+    if (!configuredDirectory) {
+        return null;
+    }
+    if (!(await fileExists(configuredDirectory))) {
+        throw new SpawnfileError("compile_error", `Moltnet release directory ${configuredDirectory} does not exist`);
+    }
+    return configuredDirectory;
+};
+const findPathMoltnetCli = async () => {
+    try {
+        await execFile("moltnet", ["version"]);
+        return "moltnet";
+    }
+    catch (error) {
+        if (isCommandNotFoundError(error)) {
+            return null;
+        }
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new SpawnfileError("compile_error", `Unable to execute compiled Moltnet CLI from PATH: ${reason}. Install Moltnet with \`curl -fsSL https://moltnet.dev/install.sh | sh\` or set ${MOLTNET_CLI_ENV}.`);
+    }
+};
+export const resolveMoltnetCliCommand = async () => {
+    const configuredCli = process.env[MOLTNET_CLI_ENV]?.trim();
+    if (configuredCli) {
+        return validateMoltnetCli(configuredCli, configuredCli);
+    }
+    const pathCli = await findPathMoltnetCli();
+    if (pathCli) {
+        return pathCli;
+    }
+    if (await fileExists(LOCAL_MOLTNET_CLI_PATH)) {
+        return validateMoltnetCli(LOCAL_MOLTNET_CLI_PATH, LOCAL_MOLTNET_CLI_PATH);
+    }
+    return validateMoltnetCli("moltnet", "PATH");
+};
+export const stageMoltnetBinaries = async (outputDirectory) => {
+    const releaseDirectory = await resolveConfiguredReleaseDirectory();
+    if (!releaseDirectory) {
+        return false;
+    }
+    const architecture = resolveTargetArchitecture();
+    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}.`);
+    }
+    const installDirectory = path.join(outputDirectory, MOLTNET_BIN_DIRECTORY);
+    await ensureDirectory(installDirectory);
+    try {
+        await execFile("tar", ["-C", installDirectory, "-xzf", releaseAssetPath]);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new SpawnfileError("compile_error", `Unable to extract Moltnet release asset ${releaseAssetPath}: ${reason}`);
+    }
+    for (const binaryName of MOLTNET_BINARY_NAMES) {
+        const binaryPath = path.join(installDirectory, binaryName);
+        if (!(await fileExists(binaryPath))) {
+            throw new SpawnfileError("compile_error", `Moltnet release asset ${releaseAssetPath} did not contain ${binaryName}`);
+        }
+        await chmod(binaryPath, 0o755);
+    }
+    return true;
+};

package/dist/compiler/moltnetClientConfig.d.ts

@@ -0,0 +1,11 @@
+import type { EmittedFile } from "../runtime/index.js";
+import type { MoltnetArtifacts } from "./moltnetArtifacts.js";
+import type { ResolvedAgentNode } from "./types.js";
+export interface MoltnetWorkspaceLayout {
+    clientConfigPath: string;
+    cliRuntime: string;
+    skillPaths: string[];
+    workspaceRootPath: string;
+}
+export declare const resolveMoltnetWorkspaceLayout: (runtimeName: string, agentName: string) => MoltnetWorkspaceLayout;
+export declare const createMoltnetClientConfigFiles: (node: ResolvedAgentNode, artifacts: MoltnetArtifacts) => EmittedFile[];

package/dist/compiler/moltnetClientConfig.js

@@ -0,0 +1,89 @@
+import { SpawnfileError } from "../shared/index.js";
+const GENERATED_SKILL_NAME = "moltnet";
+const GENERATED_CONFIG_PATH = ".moltnet/config.json";
+const createConfigContent = (node, attachments) => `${JSON.stringify({
+    version: "moltnet.client.v1",
+    agent: {
+        name: node.name,
+        runtime: node.runtime.name
+    },
+    attachments
+}, null, 2)}\n`;
+const findServerPlan = (artifacts, attachment) => {
+    const exactPlan = artifacts.serverPlans.find((serverPlan) => serverPlan.networkId === attachment.network &&
+        serverPlan.teamSource === attachment.teamSource);
+    const plan = exactPlan ?? artifacts.serverPlans.find((serverPlan) => serverPlan.networkId === attachment.network);
+    if (!plan) {
+        throw new SpawnfileError("compile_error", `Unable to resolve Moltnet server plan for ${attachment.network} on ${attachment.memberId ?? "unknown-agent"}`);
+    }
+    return plan;
+};
+const createAttachmentConfig = (node, artifacts, attachment) => {
+    if (!attachment.memberId) {
+        throw new SpawnfileError("compile_error", `Moltnet client config requires a resolved member id for ${node.name}`);
+    }
+    const serverPlan = findServerPlan(artifacts, attachment);
+    return {
+        agent_name: node.name,
+        auth: { mode: "none" },
+        base_url: `http://127.0.0.1:${serverPlan.port}`,
+        ...(attachment.dms
+            ? {
+                dms: {
+                    enabled: attachment.dms.enabled,
+                    ...(attachment.dms.read ? { read: attachment.dms.read } : {}),
+                    ...(attachment.dms.reply ? { reply: attachment.dms.reply } : {})
+                }
+            }
+            : {}),
+        member_id: attachment.memberId,
+        network_id: attachment.network,
+        runtime: node.runtime.name,
+        ...(attachment.rooms
+            ? {
+                rooms: Object.entries(attachment.rooms)
+                    .sort(([left], [right]) => left.localeCompare(right))
+                    .map(([roomId, policy]) => ({
+                    id: roomId,
+                    ...(policy.read ? { read: policy.read } : {}),
+                    ...(policy.reply ? { reply: policy.reply } : {})
+                }))
+            }
+            : {})
+    };
+};
+export const resolveMoltnetWorkspaceLayout = (runtimeName, agentName) => {
+    if (runtimeName === "openclaw" || runtimeName === "picoclaw") {
+        return {
+            clientConfigPath: `workspace/${GENERATED_CONFIG_PATH}`,
+            cliRuntime: runtimeName,
+            skillPaths: [`workspace/skills/${GENERATED_SKILL_NAME}/SKILL.md`],
+            workspaceRootPath: "workspace"
+        };
+    }
+    if (runtimeName === "tinyclaw") {
+        return {
+            clientConfigPath: `workspace/${agentName}/${GENERATED_CONFIG_PATH}`,
+            cliRuntime: runtimeName,
+            skillPaths: [
+                `workspace/${agentName}/.agents/skills/${GENERATED_SKILL_NAME}/SKILL.md`,
+                `workspace/${agentName}/.claude/skills/${GENERATED_SKILL_NAME}/SKILL.md`
+            ],
+            workspaceRootPath: `workspace/${agentName}`
+        };
+    }
+    throw new SpawnfileError("compile_error", `Moltnet client config does not know how to emit files for runtime ${runtimeName}`);
+};
+export const createMoltnetClientConfigFiles = (node, artifacts) => {
+    const attachments = node.surfaces?.moltnet;
+    if (!attachments || attachments.length === 0) {
+        return [];
+    }
+    const layout = resolveMoltnetWorkspaceLayout(node.runtime.name, node.name);
+    return [
+        {
+            content: createConfigContent(node, attachments.map((attachment) => createAttachmentConfig(node, artifacts, attachment))),
+            path: layout.clientConfigPath
+        }
+    ];
+};