spawnfile 0.1.12 → 0.1.14

package/dist/runtime/install.js

@@ -9,6 +9,27 @@ const convertRemoteToHttps = (remote) => {
     return remote.replace(/^git\+/, "");
 };
 const installHints = new Map([
+    [
+        "daimon",
+        {
+            container_image: {
+                ecosystem: "node",
+                installHint: "Copy a pinned Daimon runtime image."
+            },
+            github_release_archive: {
+                ecosystem: "node",
+                installHint: "Download a pinned Daimon runtime release archive."
+            },
+            npm: {
+                ecosystem: "node",
+                installHint: "Install the pinned Daimon package and Pi SDK dependencies inside the generated runtime app."
+            },
+            source_repo: {
+                ecosystem: "node",
+                installHint: "Checkout the pinned Daimon repo ref and install from the repository root."
+            }
+        }
+    ],
     [
         "openclaw",
         {
@@ -50,6 +71,27 @@ const installHints = new Map([
                 installHint: "Checkout the pinned repo ref and build/install from the repository root."
             }
         }
+    ],
+    [
+        "pi",
+        {
+            container_image: {
+                ecosystem: "node",
+                installHint: "Copy a pinned Pi harness runtime image."
+            },
+            github_release_archive: {
+                ecosystem: "node",
+                installHint: "Download a pinned Pi harness release archive."
+            },
+            npm: {
+                ecosystem: "node",
+                installHint: "Install pinned Pi SDK dependencies inside the generated runtime app."
+            },
+            source_repo: {
+                ecosystem: "node",
+                installHint: "Checkout the pinned Pi repo ref and install from the repository root."
+            }
+        }
     ]
 ]);
 export const resolveRuntimeInstallSelection = async (runtimeName) => {
@@ -61,7 +103,7 @@ export const resolveRuntimeInstallSelection = async (runtimeName) => {
     switch (runtime.install?.kind) {
         case "container_image":
             return {
-                ecosystem: "node",
+                ecosystem: installProfile.container_image.ecosystem,
                 image: runtime.install.image,
                 installHint: installProfile.container_image.installHint,
                 kind: "container_image",

package/dist/runtime/mnemeMcp.d.ts

@@ -0,0 +1,15 @@
+import type { ResolvedAgentNode } from "../compiler/types.js";
+export declare const MNEME_PACKAGE = "@noopolis/mneme@0.1.1";
+type MnemeMcpMode = "awake" | "dream";
+type MnemeMemoryAccess = NonNullable<ResolvedAgentNode["memoryAccess"]>[number];
+interface MnemeMcpServerOptions {
+    modes?: MnemeMcpMode[];
+}
+export declare const resolveMnemeMemoryRuntimeHomePath: (access: MnemeMemoryAccess) => string | null;
+export declare const isMnemeMemoryAccessSupported: (access: MnemeMemoryAccess) => boolean;
+export declare const mnemeMemoryServerBaseName: (node: ResolvedAgentNode, access: MnemeMemoryAccess) => string;
+export declare const mnemeMemoryServerName: (node: ResolvedAgentNode, access: MnemeMemoryAccess, mode: MnemeMcpMode) => string;
+export declare const buildMnemeMemoryMcpServers: (node: ResolvedAgentNode, options?: MnemeMcpServerOptions) => Record<string, Record<string, unknown>>;
+export declare const hasScheduledMemoryConsolidation: (node: ResolvedAgentNode) => boolean;
+export declare const hasUnsupportedMnemeMemoryAccess: (node: ResolvedAgentNode) => boolean;
+export {};

package/dist/runtime/mnemeMcp.js

@@ -0,0 +1,109 @@
+import { createHash } from "node:crypto";
+import path from "node:path/posix";
+import { slugify } from "../compiler/helpers.js";
+export const MNEME_PACKAGE = "@noopolis/mneme@0.1.1";
+export const resolveMnemeMemoryRuntimeHomePath = (access) => {
+    const store = access.bank.store;
+    if (store.kind !== "sqlite" && store.kind !== "json") {
+        return null;
+    }
+    if (store.persistence?.mount) {
+        return store.persistence.mount;
+    }
+    return store.path ? path.dirname(store.path) : null;
+};
+export const isMnemeMemoryAccessSupported = (access) => resolveMnemeMemoryRuntimeHomePath(access) !== null;
+const memoryAccessKey = (access) => `${access.source}:${access.bank.id}`;
+const sourceDiscriminatorFor = (access) => {
+    const nameSlug = slugify(`${access.declaringKind}-${access.bank.declaredName}`) || access.declaringKind;
+    const sourceHash = createHash("sha256").update(access.source).digest("hex").slice(0, 8);
+    return `${nameSlug}-${sourceHash}`;
+};
+const hasDuplicateBankId = (node, access) => {
+    const keys = new Set((node.memoryAccess ?? [])
+        .filter(isMnemeMemoryAccessSupported)
+        .filter((candidate) => candidate.bank.id === access.bank.id)
+        .map(memoryAccessKey));
+    return keys.size > 1;
+};
+export const mnemeMemoryServerBaseName = (node, access) => {
+    const bankSlug = slugify(access.bank.id) || "memory";
+    const sourceSuffix = hasDuplicateBankId(node, access) ? `-${sourceDiscriminatorFor(access)}` : "";
+    return `mneme-${bankSlug}${sourceSuffix}`;
+};
+export const mnemeMemoryServerName = (node, access, mode) => {
+    const baseName = mnemeMemoryServerBaseName(node, access);
+    return mode === "dream" ? `${baseName}-dream` : baseName;
+};
+const embeddingArgsFor = (access) => {
+    const vector = access.bank.index.vector;
+    if (!vector.enabled || !vector.model) {
+        return [];
+    }
+    const provider = vector.provider ?? "ollama";
+    if (provider !== "ollama") {
+        return [];
+    }
+    return [
+        "--embedding-provider",
+        provider,
+        "--embedding-model",
+        vector.model,
+        ...(vector.base_url ? ["--embedding-base-url", vector.base_url] : []),
+        ...(vector.dimensions ? ["--embedding-dimensions", String(vector.dimensions)] : []),
+        ...(vector.timeout_ms ? ["--embedding-timeout-ms", String(vector.timeout_ms)] : [])
+    ];
+};
+export const buildMnemeMemoryMcpServers = (node, options = {}) => {
+    const result = {};
+    const seen = new Set();
+    const modes = options.modes ?? ["awake"];
+    for (const access of node.memoryAccess ?? []) {
+        const runtimeHome = resolveMnemeMemoryRuntimeHomePath(access);
+        if (!runtimeHome) {
+            continue;
+        }
+        const key = `${access.source}:${access.bank.id}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        for (const mode of modes) {
+            const name = mnemeMemoryServerName(node, access, mode);
+            result[name] = {
+                enabled: true,
+                command: "mneme",
+                args: [
+                    "mcp",
+                    "--runtime-home",
+                    runtimeHome,
+                    "--agent-id",
+                    slugify(node.name) || "agent",
+                    "--mode",
+                    mode,
+                    "--source",
+                    `spawnfile:${access.declaringKind}:${access.bank.id}`,
+                    ...embeddingArgsFor(access)
+                ]
+            };
+        }
+    }
+    return result;
+};
+export const hasScheduledMemoryConsolidation = (node) => (node.memoryAccess ?? []).some((access) => isMnemeMemoryAccessSupported(access) &&
+    access.bank.consolidation.mode === "scheduled" &&
+    Boolean(access.bank.consolidation.schedule));
+export const hasUnsupportedMnemeMemoryAccess = (node) => {
+    const checked = new Set();
+    for (const access of node.memoryAccess ?? []) {
+        const key = `${access.source}:${access.bank.id}`;
+        if (checked.has(key)) {
+            continue;
+        }
+        checked.add(key);
+        if (!resolveMnemeMemoryRuntimeHomePath(access)) {
+            return true;
+        }
+    }
+    return false;
+};

package/dist/runtime/openclaw/adapter.js

@@ -6,6 +6,9 @@ import { prepareOpenClawRuntimeAuth } from "./runAuth.js";
 import { createOpenClawAgentScaffold } from "./scaffold.js";
 import { assertSupportedOpenClawSurfaces, buildOpenClawChannelConfig, buildOpenClawSurfaceEnvBindings } from "./surfaces.js";
 import { buildOpenClawMoltnetConfig, buildOpenClawMoltnetEnvBindings, validateOpenClawMoltnetRuntimeOptions } from "./moltnet.js";
+import { buildOpenClawMcpConfig, buildOpenClawMcpEnvBindings, openClawMemoryCapabilityFor } from "./mcp.js";
+import { MNEME_PACKAGE } from "../mnemeMcp.js";
+import { createOpenClawCronStoreFile } from "./schedules.js";
 import { openClawStatusProbes } from "./statusProbes.js";
 const buildEnvSecretRef = (envName) => ({
     id: envName,
@@ -88,6 +91,10 @@ const buildOpenClawConfig = (node) => {
     if (moltnet) {
         config.moltnet = moltnet;
     }
+    const mcp = buildOpenClawMcpConfig(node);
+    if (mcp) {
+        config.mcp = mcp;
+    }
     // Bake the import-auth (claude-code/codex) OAuth structure at compile time so
     // the image is self-sufficient; only the credential tokens are injected later.
     const authBaked = applyOpenClawImportAuthConfig(config, resolveOpenClawImportAuthModes(node));
@@ -118,6 +125,7 @@ const createContainerTargets = async (inputs) => inputs.map((input) => {
             ]
             : []),
         ...(buildOpenClawSurfaceEnvBindings(agent?.surfaces) ?? []),
+        ...(agent ? buildOpenClawMcpEnvBindings(agent.mcpServers) : []),
         ...(agent ? (buildOpenClawMoltnetEnvBindings(agent.runtime.options) ?? []) : [])
     ];
     return {
@@ -164,6 +172,7 @@ export const openClawAdapter = {
                 required: true
             }
         ],
+        globalNpmPackages: [MNEME_PACKAGE],
         homeEnv: "OPENCLAW_HOME",
         instancePaths: {
             configPathTemplate: "<instance-root>/home/.openclaw/<config-file>",
@@ -194,23 +203,25 @@ export const openClawAdapter = {
         }
     },
     async compileAgent(node) {
+        const memoryCapability = openClawMemoryCapabilityFor(node);
+        const cronStoreFile = createOpenClawCronStoreFile(node);
         return {
             capabilities: createAgentCapabilities(node, {
-                mcpOutcome: node.mcpServers.length > 0 ? "degraded" : "supported",
+                memoryMessage: memoryCapability.message,
+                memoryOutcome: memoryCapability.outcome,
+                mcpOutcome: "supported",
                 subagentOutcome: node.subagents.length > 0 ? "degraded" : "supported"
             }),
             diagnostics: [
                 ...(node.subagents.length > 0
                     ? [createDiagnostic("warn", "OpenClaw subagents lower to routed sessions in v0.1")]
-                    : []),
-                ...(node.mcpServers.length > 0
-                    ? [createDiagnostic("warn", "OpenClaw MCP goes through mcporter bridge; direct config may not apply")]
                     : [])
             ],
             files: [
                 ...createDocumentFiles("workspace", node.docs),
                 ...createSkillFiles("workspace/skills", node.skills),
                 ...createOpenClawStateFiles(),
+                ...(cronStoreFile ? [cronStoreFile] : []),
                 {
                     content: buildOpenClawConfig(node),
                     path: "openclaw.json"

package/dist/runtime/openclaw/mcp.d.ts

@@ -0,0 +1,10 @@
+import type { ResolvedAgentNode } from "../../compiler/types.js";
+import type { McpServer } from "../../manifest/index.js";
+import type { RuntimeContainerConfigEnvBinding } from "../types.js";
+export declare const buildOpenClawAuthoredMcpServers: (servers: McpServer[]) => Record<string, Record<string, unknown>>;
+export declare const buildOpenClawMcpConfig: (node: ResolvedAgentNode) => Record<string, unknown> | undefined;
+export declare const buildOpenClawMcpEnvBindings: (servers: McpServer[]) => RuntimeContainerConfigEnvBinding[];
+export declare const openClawMemoryCapabilityFor: (node: ResolvedAgentNode) => {
+    message: string;
+    outcome: "degraded" | "supported";
+};

package/dist/runtime/openclaw/mcp.js

@@ -0,0 +1,69 @@
+import { buildMnemeMemoryMcpServers, hasScheduledMemoryConsolidation, hasUnsupportedMnemeMemoryAccess } from "../mnemeMcp.js";
+const buildOpenClawAuthHeaders = (server) => server.auth
+    ? { [server.auth.mode === "bearer" ? "Authorization" : server.auth.secret]: "" }
+    : undefined;
+export const buildOpenClawAuthoredMcpServers = (servers) => {
+    const result = Object.create(null);
+    for (const server of servers) {
+        if (server.transport === "stdio" && server.auth?.mode === "bearer") {
+            throw new Error("OpenClaw stdio MCP servers do not support bearer auth");
+        }
+        const entry = { enabled: true };
+        if (server.transport === "stdio") {
+            entry.transport = "stdio";
+            entry.command = server.command;
+            if (server.args)
+                entry.args = server.args;
+            if (server.env)
+                entry.env = server.env;
+        }
+        else {
+            entry.transport = server.transport === "streamable_http" ? "streamable-http" : "sse";
+            entry.url = server.url;
+            const headers = buildOpenClawAuthHeaders(server);
+            if (headers)
+                entry.headers = headers;
+        }
+        result[server.name] = entry;
+    }
+    return result;
+};
+export const buildOpenClawMcpConfig = (node) => {
+    const servers = {
+        ...buildOpenClawAuthoredMcpServers(node.mcpServers),
+        ...buildMnemeMemoryMcpServers(node, {
+            modes: hasScheduledMemoryConsolidation(node) ? ["awake", "dream"] : ["awake"]
+        })
+    };
+    if (Object.keys(servers).length === 0) {
+        return undefined;
+    }
+    return { servers };
+};
+export const buildOpenClawMcpEnvBindings = (servers) => servers.flatMap((server) => server.auth
+    ? [
+        {
+            envName: server.auth.secret,
+            jsonPath: [
+                "mcp",
+                "servers",
+                server.name,
+                "headers",
+                server.auth.mode === "bearer" ? "Authorization" : server.auth.secret
+            ],
+            ...(server.auth.mode === "bearer" ? { transform: "bearer" } : {})
+        }
+    ]
+    : []);
+export const openClawMemoryCapabilityFor = (node) => {
+    if (hasUnsupportedMnemeMemoryAccess(node)) {
+        return {
+            message: "OpenClaw lowers file-backed Mneme memory through generated MCP servers; non-file stores are not lowered",
+            outcome: "degraded"
+        };
+    }
+    return {
+        message: "OpenClaw accesses Mneme memory through generated MCP servers",
+        outcome: "supported"
+    };
+};

package/dist/runtime/openclaw/runAuth.js

@@ -44,10 +44,10 @@ export const prepareOpenClawRuntimeAuth = async (input) => {
     if (!input.instance.home_path) {
         return { coveredModelSecrets: [], mountArgs: [] };
     }
-    const claudeCode = input.authProfile.imports["claude-code"]
+    const claudeCode = input.authProfile?.imports["claude-code"]
         ? await loadImportedClaudeCodeCredential(input.authProfile.imports["claude-code"].path)
         : null;
-    const codex = input.authProfile.imports.codex
+    const codex = input.authProfile?.imports.codex
         ? await loadImportedCodexCredential(input.authProfile.imports.codex.path)
         : null;
     const coveredModelSecrets = [];

package/dist/runtime/openclaw/scaffold.js

@@ -11,7 +11,7 @@ export const createOpenClawAgentScaffold = () => ({
             path: "SOUL.md"
         },
         {
-            content: loadRuntimeScaffoldAsset(import.meta.url, "AGENTS.md"),
+            content: loadRuntimeScaffoldAsset(import.meta.url, "WORKSPACE_AGENTS.md"),
             path: "AGENTS.md"
         }
     ],

package/dist/runtime/openclaw/schedules.d.ts

@@ -0,0 +1,38 @@
+import type { ResolvedAgentNode } from "../../compiler/types.js";
+import type { EmittedFile } from "../types.js";
+type OpenClawCronSchedule = {
+    anchorMs?: number;
+    everyMs: number;
+    kind: "every";
+} | {
+    expr: string;
+    kind: "cron";
+    staggerMs?: number;
+    tz?: string;
+};
+interface OpenClawCronJob {
+    agentId: string;
+    createdAtMs: number;
+    deleteAfterRun: boolean;
+    delivery: {
+        mode: "none";
+    };
+    enabled: boolean;
+    failureAlert: false;
+    id: string;
+    name: string;
+    payload: {
+        deliver: false;
+        kind: "agentTurn";
+        lightContext: true;
+        message: string;
+    };
+    schedule: OpenClawCronSchedule;
+    sessionTarget: "isolated";
+    state: Record<string, never>;
+    updatedAtMs: number;
+    wakeMode: "now";
+}
+export declare const createOpenClawMemoryDreamJobs: (node: ResolvedAgentNode) => OpenClawCronJob[];
+export declare const createOpenClawCronStoreFile: (node: ResolvedAgentNode) => EmittedFile | null;
+export {};

package/dist/runtime/openclaw/schedules.js

@@ -0,0 +1,74 @@
+import { slugify } from "../../compiler/helpers.js";
+import { isMnemeMemoryAccessSupported, mnemeMemoryServerName } from "../mnemeMcp.js";
+import { parseEveryScheduleMs } from "../scheduleUtils.js";
+const dreamPrompt = (bankId, serverName) => [
+    `Dream over Mneme memory bank ${bankId}.`,
+    "This is an isolated memory-maintenance session, not normal conversation.",
+    `Prefer the ${serverName} MCP tools when available.`,
+    "Search the active dream scope and read-only global scope for stale, duplicate, noisy, or important memories.",
+    "Use memory_summarize, memory_register, or memory_forget only when consolidation is evidence-backed."
+].join(" ");
+const scheduleFromMemoryConsolidation = (schedule) => {
+    const everyMs = parseEveryScheduleMs(schedule);
+    if (everyMs !== null) {
+        return { anchorMs: 0, everyMs, kind: "every" };
+    }
+    return { expr: schedule, kind: "cron", staggerMs: 0 };
+};
+export const createOpenClawMemoryDreamJobs = (node) => {
+    const jobs = [];
+    const seen = new Set();
+    for (const access of node.memoryAccess ?? []) {
+        const schedule = access.bank.consolidation.schedule;
+        if (!isMnemeMemoryAccessSupported(access) ||
+            access.bank.consolidation.mode !== "scheduled" ||
+            !schedule) {
+            continue;
+        }
+        const key = `${access.source}:${access.bank.id}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        const dreamServerName = mnemeMemoryServerName(node, access, "dream");
+        const bankSlug = dreamServerName.replace(/^mneme-/u, "").replace(/-dream$/u, "");
+        const agentSlug = slugify(node.name) || "agent";
+        const id = `spawnfile-dream-${agentSlug}-${bankSlug}`;
+        jobs.push({
+            agentId: "main",
+            createdAtMs: 0,
+            deleteAfterRun: false,
+            delivery: { mode: "none" },
+            enabled: true,
+            failureAlert: false,
+            id,
+            name: id,
+            payload: {
+                deliver: false,
+                kind: "agentTurn",
+                lightContext: true,
+                message: dreamPrompt(access.bank.id, dreamServerName)
+            },
+            schedule: scheduleFromMemoryConsolidation(schedule),
+            sessionTarget: "isolated",
+            state: {},
+            updatedAtMs: 0,
+            wakeMode: "now"
+        });
+    }
+    return jobs;
+};
+export const createOpenClawCronStoreFile = (node) => {
+    const jobs = createOpenClawMemoryDreamJobs(node);
+    if (jobs.length === 0) {
+        return null;
+    }
+    const store = {
+        jobs,
+        version: 1
+    };
+    return {
+        content: `${JSON.stringify(store, null, 2)}\n`,
+        path: "home/.openclaw/cron/jobs.json"
+    };
+};

package/dist/runtime/pi/adapter.d.ts

@@ -0,0 +1,4 @@
+import type { RuntimeAdapter } from "../types.js";
+export declare const piAdapter: RuntimeAdapter;
+export declare const daimonAdapter: RuntimeAdapter;
+export declare const PI_RUNTIME_PACKAGE = "@earendil-works/pi-coding-agent@0.79.10";