spawnfile 0.1.4 → 0.1.5

package/dist/compiler/containerEntrypointRender.d.ts

@@ -4,7 +4,7 @@ export interface EntrypointOptions {
     hasMoltnet?: boolean;
     hasStagedMoltnetBinaries?: boolean;
     moltnet?: {
-        bridgePlans: MoltnetArtifacts["bridgePlans"];
+        nodePlans: MoltnetArtifacts["nodePlans"];
         serverPlans: MoltnetArtifacts["serverPlans"];
     };
     moltnetPublishedPorts?: number[];

package/dist/compiler/containerEntrypointRender.js

@@ -1,8 +1,7 @@
 import path from "node:path";
+import { createWorkspaceResourceCommands, createWorkspaceResourceShellFunctions } from "./containerWorkspaceResourceRender.js";
 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) {
@@ -114,13 +113,19 @@ export const renderEntrypoint = (runtimePlans, requiredSecrets, options = {}) =>
         "",
         "cursor = data",
         "for part in json_path[:-1]:",
+        "    if isinstance(cursor, list):",
+        "        cursor = cursor[int(part)]",
+        "        continue",
         "    child = cursor.get(part)",
-        "    if not isinstance(child, dict):",
+        "    if not isinstance(child, (dict, list)):",
         "        child = {}",
         "        cursor[part] = child",
         "    cursor = child",
         "",
-        "cursor[json_path[-1]] = value",
+        "if isinstance(cursor, list):",
+        "    cursor[int(json_path[-1])] = value",
+        "else:",
+        "    cursor[json_path[-1]] = value",
         "",
         "with open(target_path, 'w', encoding='utf-8') as handle:",
         "    json.dump(data, handle, indent=2)",
@@ -136,7 +141,8 @@ export const renderEntrypoint = (runtimePlans, requiredSecrets, options = {}) =>
         '  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',
         "}",
-        ""
+        "",
+        ...createWorkspaceResourceShellFunctions()
     ];
     lines.push('if [ -n "${OPENCLAW_GATEWAY_TOKEN:-}" ] && [ -z "${OPENCLAW_HOOKS_TOKEN:-}" ]; then', '  export OPENCLAW_HOOKS_TOKEN="hooks-${OPENCLAW_GATEWAY_TOKEN}"', "fi", "");
     for (const secretName of requiredSecrets) {
@@ -146,40 +152,44 @@ export const renderEntrypoint = (runtimePlans, requiredSecrets, options = {}) =>
         lines.push("");
     }
     const moltnetServerPlans = options.moltnet?.serverPlans ?? [];
-    const moltnetBridgePlans = options.moltnet?.bridgePlans ?? [];
+    const moltnetNodePlans = options.moltnet?.nodePlans ?? [];
     if (runtimePlans.length === 1 &&
         moltnetServerPlans.length === 0 &&
-        moltnetBridgePlans.length === 0) {
+        moltnetNodePlans.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(" ")}`);
+        lines.push(`mkdir -p ${shellQuote(plan.instancePaths.workspacePath)}`, ...createWorkspaceResourceCommands(plan), `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) {
+    const managedMoltnetServerPlans = moltnetServerPlans.filter((serverPlan) => serverPlan.mode === "managed");
+    if (managedMoltnetServerPlans.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 serverPlan of managedMoltnetServerPlans) {
+        if (!serverPlan.configPath) {
+            continue;
+        }
+        for (const patch of serverPlan.secretPatches) {
+            lines.push(`apply_json_env_value ${shellQuote(serverPlan.configPath)} ${shellQuote(patch.envName)} ${shellQuote(patch.jsonPath)}`);
+        }
+        lines.push(`MOLTNET_CONFIG=${shellQuote(serverPlan.configPath)} /usr/local/bin/moltnet &`, 'PIDS+=("$!")', "");
+    }
+    for (const serverPlan of managedMoltnetServerPlans) {
+        if (!serverPlan.port) {
+            continue;
+        }
+        lines.push(`until curl -sf ${shellQuote(`http://127.0.0.1:${serverPlan.port}/healthz`)} >/dev/null; do sleep 1; done`);
+        lines.push("");
     }
     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("");
+        lines.push(`mkdir -p ${shellQuote(plan.instancePaths.workspacePath)}`, ...createWorkspaceResourceCommands(plan), `require_file ${shellQuote(plan.instancePaths.configPath)}`, ...createEnvFileWrites(plan), ...createConfigEnvWrites(plan), ...createAuthSetupCommands(plan), `${envAssignments.join(" ")} ${commandTokens.map(shellQuote).join(" ")} &`, 'PIDS+=("$!")', "", ...createRuntimeReadinessWait(plan));
     }
-    for (const bridgePlan of moltnetBridgePlans) {
-        lines.push(`/usr/local/bin/moltnet bridge ${shellQuote(bridgePlan.configPath)} &`, 'PIDS+=("$!")', "");
+    for (const nodePlan of moltnetNodePlans) {
+        lines.push(`/usr/local/bin/moltnet node ${shellQuote(nodePlan.configPath)} &`, 'PIDS+=("$!")', "");
     }
     lines.push('if [ "${#PIDS[@]}" -eq 0 ]; then', '  echo "No runtime targets were generated for this compile output" >&2', "  exit 1", "fi", "", "status=0", 'for pid in "${PIDS[@]}"; do', '  if ! wait "$pid"; then', "    status=1", "  fi", "done", "", 'exit "$status"');
     return `${lines.join("\n").trimEnd()}\n`;

package/dist/compiler/containerTargetResources.d.ts

@@ -0,0 +1,4 @@
+import type { ContainerTarget, ContainerTargetInput, RuntimeContainerMeta } from "../runtime/index.js";
+import type { RuntimeTargetPlan } from "./containerArtifactsTypes.js";
+import { type WorkspaceResourcePlan } from "./workspaceResources.js";
+export declare const resolveTargetResources: (target: ContainerTarget, inputs: ContainerTargetInput[], instancePaths: RuntimeTargetPlan["instancePaths"], meta: RuntimeContainerMeta) => WorkspaceResourcePlan[];

package/dist/compiler/containerTargetResources.js

@@ -0,0 +1,54 @@
+import path from "node:path";
+import { SpawnfileError } from "../shared/index.js";
+import { mergeWorkspaceResourcePlans } from "./workspaceResources.js";
+const CONFIG_FILE_PLACEHOLDER = "<config-file>";
+const INSTANCE_ROOT_PLACEHOLDER = "<instance-root>";
+const SOURCE_AGENT_PLACEHOLDER = "<agent-name>";
+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);
+};
+const resolveSourceWorkspacePath = (input, instancePaths, meta) => meta.instancePaths.sourceWorkspacePathTemplate
+    ? replaceSourceWorkspacePathTemplate(meta.instancePaths.sourceWorkspacePathTemplate, input, instancePaths, meta)
+    : instancePaths.workspacePath;
+const sourceTargetId = (target, input, isMergedTarget) => isMergedTarget ? `${target.id}:${input.id}` : target.id;
+const pathsOverlap = (left, right) => left === right || left.startsWith(`${right}/`) || right.startsWith(`${left}/`);
+const dedupeAndAssertResourcePlans = (target, resources) => {
+    const byLinkPath = new Map();
+    for (const resource of resources) {
+        const existing = byLinkPath.get(resource.linkPath);
+        if (existing) {
+            if (existing.backingPath !== resource.backingPath || existing.id !== resource.id) {
+                throw new SpawnfileError("validation_error", `Container target ${target.id} declares conflicting workspace resources at ${resource.linkPath}`);
+            }
+            continue;
+        }
+        const overlapping = [...byLinkPath.values()].find((candidate) => pathsOverlap(candidate.linkPath, resource.linkPath));
+        if (overlapping) {
+            throw new SpawnfileError("validation_error", `Container target ${target.id} declares overlapping workspace resource links ${overlapping.linkPath} and ${resource.linkPath}`);
+        }
+        byLinkPath.set(resource.linkPath, resource);
+    }
+    return [...byLinkPath.values()].sort((left, right) => left.linkPath.localeCompare(right.linkPath) || left.id.localeCompare(right.id));
+};
+export const resolveTargetResources = (target, inputs, instancePaths, meta) => {
+    const sourceIds = new Set(target.sourceIds ?? []);
+    if (sourceIds.size === 0) {
+        return [];
+    }
+    const isMergedTarget = sourceIds.size > 1;
+    const resources = inputs.flatMap((input) => {
+        if (!sourceIds.has(input.id) || input.value.kind !== "agent") {
+            return [];
+        }
+        return mergeWorkspaceResourcePlans(input.value.workspaceResources ?? [], `${target.id}/${input.id}`, {
+            targetId: sourceTargetId(target, input, isMergedTarget),
+            workspacePath: resolveSourceWorkspacePath(input, instancePaths, meta)
+        });
+    });
+    return dedupeAndAssertResourcePlans(target, resources);
+};

package/dist/compiler/containerWorkspaceResourceRender.d.ts

@@ -0,0 +1,3 @@
+import type { RuntimeTargetPlan } from "./containerArtifactsTypes.js";
+export declare const createWorkspaceResourceCommands: (plan: RuntimeTargetPlan) => string[];
+export declare const createWorkspaceResourceShellFunctions: () => string[];

package/dist/compiler/containerWorkspaceResourceRender.js

@@ -0,0 +1,128 @@
+const shellQuote = (value) => `'${value.replace(/'/g, `'\"'\"'`)}'`;
+export const createWorkspaceResourceCommands = (plan) => (plan.resources ?? []).flatMap((resource) => {
+    const readonlyFlag = resource.mode === "readonly" ? "readonly" : "mutable";
+    if (resource.kind === "volume") {
+        return [
+            `prepare_volume_resource ${shellQuote(resource.id)} ${shellQuote(resource.linkPath)} ${shellQuote(resource.backingPath)} ${shellQuote(readonlyFlag)}`
+        ];
+    }
+    const selectorKind = resource.branch
+        ? "branch"
+        : resource.tag
+            ? "tag"
+            : resource.ref
+                ? "ref"
+                : "none";
+    const selectorValue = resource.branch ?? resource.tag ?? resource.ref ?? "";
+    return [
+        `prepare_git_resource ${shellQuote(resource.id)} ${shellQuote(resource.linkPath)} ${shellQuote(resource.backingPath)} ${shellQuote(resource.url ?? "")} ${shellQuote(selectorKind)} ${shellQuote(selectorValue)} ${shellQuote(readonlyFlag)}`
+    ];
+});
+export const createWorkspaceResourceShellFunctions = () => [
+    "directory_is_empty() {",
+    '  local target="$1"',
+    '  [ -d "$target" ] && [ -z "$(find "$target" -mindepth 1 -maxdepth 1 -print -quit)" ]',
+    "}",
+    "",
+    "prepare_resource_link() {",
+    '  local id="$1"',
+    '  local link_path="$2"',
+    '  local backing_path="$3"',
+    '  mkdir -p "$(dirname "$link_path")"',
+    '  if [ -L "$link_path" ]; then',
+    '    local existing_target',
+    '    existing_target="$(readlink "$link_path")"',
+    '    if [ "$existing_target" != "$backing_path" ]; then',
+    '      echo "Workspace resource $id link points to $existing_target, expected $backing_path" >&2',
+    "      exit 1",
+    "    fi",
+    "    return",
+    "  fi",
+    '  if [ -e "$link_path" ]; then',
+    '    echo "Workspace resource $id mount path already exists and is not a symlink: $link_path" >&2',
+    "    exit 1",
+    "  fi",
+    '  ln -s "$backing_path" "$link_path"',
+    "}",
+    "",
+    "mark_readonly_resource() {",
+    '  local target="$1"',
+    '  local mode="$2"',
+    '  if [ "$mode" = "readonly" ]; then',
+    '    chmod -R a-w "$target"',
+    "  fi",
+    "}",
+    "",
+    "prepare_volume_resource() {",
+    '  local id="$1"',
+    '  local link_path="$2"',
+    '  local backing_path="$3"',
+    '  local mode="$4"',
+    '  mkdir -p "$backing_path"',
+    '  if [ ! -d "$backing_path" ]; then',
+    '    echo "Workspace volume resource $id backing path is not a directory: $backing_path" >&2',
+    "    exit 1",
+    "  fi",
+    '  mark_readonly_resource "$backing_path" "$mode"',
+    '  prepare_resource_link "$id" "$link_path" "$backing_path"',
+    "}",
+    "",
+    "prepare_git_resource() {",
+    '  local id="$1"',
+    '  local link_path="$2"',
+    '  local backing_path="$3"',
+    '  local remote="$4"',
+    '  local selector_kind="$5"',
+    '  local selector_value="$6"',
+    '  local mode="$7"',
+    '  if [ -d "$backing_path/.git" ]; then',
+    '    local existing_remote',
+    '    existing_remote="$(git -C "$backing_path" config --get remote.origin.url || true)"',
+    '    if [ "$existing_remote" != "$remote" ]; then',
+    '      echo "Workspace git resource $id has remote $existing_remote, expected $remote" >&2',
+    "      exit 1",
+    "    fi",
+    '    if [ "$selector_kind" = "branch" ]; then',
+    '      local branch',
+    '      branch="$(git -C "$backing_path" rev-parse --abbrev-ref HEAD)"',
+    '      if [ "$branch" != "$selector_value" ]; then',
+    '        echo "Workspace git resource $id is on branch $branch, expected $selector_value" >&2',
+    "        exit 1",
+    "      fi",
+    '    elif [ "$selector_kind" = "tag" ]; then',
+    '      local tag',
+    '      tag="$(git -C "$backing_path" describe --tags --exact-match 2>/dev/null || true)"',
+    '      if [ "$tag" != "$selector_value" ]; then',
+    '        echo "Workspace git resource $id is on tag $tag, expected $selector_value" >&2',
+    "        exit 1",
+    "      fi",
+    '    elif [ "$selector_kind" = "ref" ]; then',
+    '      local current_ref',
+    '      current_ref="$(git -C "$backing_path" rev-parse HEAD)"',
+    '      if [ "$current_ref" != "$selector_value" ]; then',
+    '        echo "Workspace git resource $id is on ref $current_ref, expected $selector_value" >&2',
+    "        exit 1",
+    "      fi",
+    "    fi",
+    '    mark_readonly_resource "$backing_path" "$mode"',
+    '    prepare_resource_link "$id" "$link_path" "$backing_path"',
+    "    return",
+    "  fi",
+    '  if [ -e "$backing_path" ] && ! directory_is_empty "$backing_path"; then',
+    '    echo "Workspace git resource $id backing path is not empty: $backing_path" >&2',
+    "    exit 1",
+    "  fi",
+    '  mkdir -p "$(dirname "$backing_path")"',
+    '  if [ "$selector_kind" = "branch" ]; then',
+    '    git clone --branch "$selector_value" "$remote" "$backing_path"',
+    "  else",
+    '    git clone "$remote" "$backing_path"',
+    '    if [ "$selector_kind" = "tag" ] || [ "$selector_kind" = "ref" ]; then',
+    '      git -C "$backing_path" checkout "$selector_value"',
+    "    fi",
+    "  fi",
+    '  mark_readonly_resource "$backing_path" "$mode"',
+    '  prepare_resource_link "$id" "$link_path" "$backing_path"',
+    "}",
+    ""
+];

package/dist/compiler/executionDefaults.js

@@ -2,8 +2,5 @@ export const applyExecutionDefaults = (execution) => ({
     model: execution?.model,
     sandbox: execution?.sandbox ?? {
         mode: "workspace"
-    },
-    workspace: execution?.workspace ?? {
-        isolation: "isolated"
     }
 });

package/dist/compiler/helpers.d.ts

@@ -1,4 +1,4 @@
-import { CompilePlanNode } from "./types.js";
+import type { CompilePlanNode } from "./types.js";
 export declare const createShortHash: (value: string) => string;
 export declare const slugify: (value: string) => string;
 export declare const stableStringify: (value: unknown) => string;

package/dist/compiler/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./addProjectNode.js";
 export * from "./buildCompilePlan.js";
 export * from "./buildProject.js";
+export * from "./upProject.js";
 export * from "./compileProject.js";
 export * from "./initProject.js";
 export * from "./moltnetRoomMemberships.js";

package/dist/compiler/index.js

@@ -1,6 +1,7 @@
 export * from "./addProjectNode.js";
 export * from "./buildCompilePlan.js";
 export * from "./buildProject.js";
+export * from "./upProject.js";
 export * from "./compileProject.js";
 export * from "./initProject.js";
 export * from "./moltnetRoomMemberships.js";

package/dist/compiler/moltnetArtifacts.d.ts

@@ -1,25 +1,31 @@
 import type { EmittedFile } from "../runtime/index.js";
+import type { TeamNetworkServer } from "../manifest/index.js";
+import { type MoltnetSecretPatch } from "./moltnetConfigLowering.js";
 import type { CompilePlan } from "./types.js";
 export interface MoltnetServerPlan {
+    baseUrl: string;
+    configPath?: string;
     id: string;
+    mode: "external" | "managed";
     name: string;
     networkId: string;
-    port: number;
+    port?: number;
     rooms: Array<{
         id: string;
         members: string[];
+        name?: string;
     }>;
+    server: TeamNetworkServer;
+    secretPatches: MoltnetSecretPatch[];
     teamSource: string;
 }
-export interface MoltnetBridgePlan {
-    agentId: string;
+export interface MoltnetNodePlan {
     configPath: string;
     networkId: string;
-    runtime: string;
 }
 export interface MoltnetArtifacts {
-    bridgePlans: MoltnetBridgePlan[];
     files: EmittedFile[];
+    nodePlans: MoltnetNodePlan[];
     ports: number[];
     publishedPorts: number[];
     serverPlans: MoltnetServerPlan[];