spawnfile 0.1.13 → 0.1.17

package/dist/compiler/compileProject.js

@@ -3,12 +3,19 @@ import { chmod } from "node:fs/promises";
 import { ensureDirectory, removeDirectory } from "../filesystem/index.js";
 import { createCompileReport, createDiagnostic, writeCompileReport } from "../report/index.js";
 import { DEFAULT_OUTPUT_DIRECTORY } from "../shared/index.js";
-import { assertRuntimeCanCompile, createRuntimeLifecycleDiagnostics, getRuntimeAdapter } from "../runtime/index.js";
+import { assertRuntimeCanCompile, createRuntimeLifecycleDiagnostics, getRuntimeAdapter, resolveNoopolisRunId } from "../runtime/index.js";
 import { buildCompilePlan } from "./buildCompilePlan.js";
 import { createContainerArtifacts } from "./containerArtifacts.js";
+import { stageRuntimePackageOverrides } from "./containerPackageOverrides.js";
+import { stageWorkspaceBundles } from "./workspaceBundleArtifacts.js";
+import { augmentNodeReports } from "./compileProjectReports.js";
+import { enforcePolicy } from "./compileProjectPolicy.js";
 import { injectMoltnetWorkspaceFiles, injectTeamCompileSupportFiles, prepareTeamCompileSupport, writeEmittedFiles } from "./compileProjectSupport.js";
 import { generateMoltnetArtifacts } from "./moltnetArtifacts.js";
 import { stageMoltnetBinaries } from "./moltnetBinaries.js";
+import { loadWorldBindingsForCompile } from "./worldBindingsFile.js";
+import { createOrganizationReadinessEvidence } from "./organizationReadyEvidence.js";
+export { createOrganizationReadinessEvidence, ORGANIZATION_READINESS_EVIDENCE_VERSION } from "./organizationReadyEvidence.js";
 const createTeamCapabilities = (outcome, message) => [
     { key: "team.members", message, outcome },
     { key: "team.mode", message, outcome },
@@ -132,76 +139,11 @@ const compileTeamNode = async (baseDirectory, node) => {
         value: node.value
     };
 };
-const enforcePolicy = (nodeReport, policyMode, onDegrade) => {
-    for (const capability of nodeReport.capabilities) {
-        if (capability.outcome === "unsupported") {
-            if (policyMode === "strict") {
-                throw new Error(`Policy violation: ${capability.key} is unsupported for ${nodeReport.id} (strict mode)${capability.message ? `: ${capability.message}` : ""}`);
-            }
-            if (policyMode === "warn") {
-                nodeReport.diagnostics.push(createDiagnostic("warn", `Policy warning: ${capability.key} is unsupported for ${nodeReport.id}${capability.message ? `: ${capability.message}` : ""}`));
-            }
-        }
-        if (capability.outcome === "degraded") {
-            if (onDegrade === "error") {
-                throw new Error(`Policy violation: ${capability.key} is degraded for ${nodeReport.id} (on_degrade: error)${capability.message ? `: ${capability.message}` : ""}`);
-            }
-            if (onDegrade === "warn") {
-                nodeReport.diagnostics.push(createDiagnostic("warn", `Policy warning: ${capability.key} is degraded for ${nodeReport.id}${capability.message ? `: ${capability.message}` : ""}`));
-            }
-        }
-    }
-};
-const createIdentityCapabilities = (node) => [
-    ...(node.surfaces?.slack?.identity
-        ? [{
-                key: "surfaces.slack.identity",
-                message: "Declared Slack identity was preserved for roster output",
-                outcome: "supported"
-            }]
-        : []),
-    ...(node.surfaces?.discord?.identity
-        ? [{
-                key: "surfaces.discord.identity",
-                message: "Declared Discord identity was preserved for roster output",
-                outcome: "supported"
-            }]
-        : []),
-    ...(node.surfaces?.telegram?.identity
-        ? [{
-                key: "surfaces.telegram.identity",
-                message: "Declared Telegram identity was preserved for roster output",
-                outcome: "supported"
-            }]
-        : []),
-    ...(node.surfaces?.whatsapp?.identity
-        ? [{
-                key: "surfaces.whatsapp.identity",
-                message: "Declared WhatsApp identity was preserved for roster output",
-                outcome: "supported"
-            }]
-        : [])
-];
-const createWorkspaceResourceCapabilities = (node) => (node.workspaceResources?.length ?? 0) > 0
-    ? [{
-            key: "workspace.resources",
-            message: `${node.workspaceResources?.length ?? 0} workspace resource(s) will be prepared at startup`,
-            outcome: "supported"
-        }]
-    : [];
-const augmentNodeReports = (compiledNodes, support) => {
-    for (const compiled of compiledNodes) {
-        compiled.report.capabilities.push(...createWorkspaceResourceCapabilities(compiled.value));
-        if (compiled.value.kind === "team") {
-            compiled.report.capabilities.push(...(support.capabilitiesByTeamSource.get(compiled.value.source) ?? []));
-            compiled.report.diagnostics.push(...(support.diagnosticsByTeamSource.get(compiled.value.source) ?? []));
-            continue;
-        }
-        compiled.report.capabilities.push(...createIdentityCapabilities(compiled.value));
-    }
-};
 export const compileProject = async (inputPath, options = {}) => {
     const plan = await buildCompilePlan(inputPath);
+    const worldBindings = options.worldBindingsPath === undefined
+        ? undefined
+        : await loadWorldBindingsForCompile(plan, options.worldBindingsPath, resolveNoopolisRunId(process.env));
     // The default output directory lives under the resolved project root, not the
     // process working directory, so `spawnfile compile ./org` writes ./org/.spawn.
     const outputDirectory = options.outputDirectory
@@ -230,18 +172,25 @@ export const compileProject = async (inputPath, options = {}) => {
     for (const compiled of compiledNodes) {
         enforcePolicy(compiled.report, compiled.value.policyMode, compiled.value.policyOnDegrade);
     }
-    const moltnetArtifacts = await generateMoltnetArtifacts(plan);
-    const hasStagedMoltnetBinaries = moltnetArtifacts
+    const moltnetArtifacts = await generateMoltnetArtifacts(plan, options.deploymentLineage);
+    const moltnetRelease = moltnetArtifacts
         ? await stageMoltnetBinaries(outputDirectory, {
             architecture: options.containerArchitecture
         })
-        : false;
+        : undefined;
     await injectMoltnetWorkspaceFiles(outputDirectory, compiledNodes, moltnetArtifacts);
+    const resolvedRuntimePackageOverrides = await stageRuntimePackageOverrides(outputDirectory, options.runtimePackageOverrides);
+    const hasWorkspaceBundles = await stageWorkspaceBundles(outputDirectory, plan);
     const generatedAt = new Date().toISOString();
     const containerArtifacts = await createContainerArtifacts(plan, compiledNodes, {
+        deploymentLineage: options.deploymentLineage,
         generatedAt,
-        hasStagedMoltnetBinaries,
-        moltnet: moltnetArtifacts
+        hasStagedMoltnetBinaries: Boolean(moltnetRelease),
+        hasWorkspaceBundles,
+        moltnet: moltnetArtifacts,
+        moltnetRelease,
+        runtimePackageOverrides: resolvedRuntimePackageOverrides,
+        ...(worldBindings ? { worldBindings } : {})
     });
     await writeEmittedFiles(outputDirectory, containerArtifacts.files);
     await Promise.all(containerArtifacts.executablePaths.map((filePath) => chmod(path.join(outputDirectory, filePath), 0o755)));
@@ -252,5 +201,12 @@ export const compileProject = async (inputPath, options = {}) => {
         projectName: containerArtifacts.distribution.report.organization.project
     });
     const reportPath = await writeCompileReport(outputDirectory, report);
-    return { outputDirectory, report, reportPath };
+    const organizationReadinessEvidence = createOrganizationReadinessEvidence({
+        compileVersion: report.spawnfile_version,
+        containerArtifacts,
+        moltnetArtifacts,
+        plan,
+        ...(worldBindings ? { worldBindings } : {})
+    });
+    return { organizationReadinessEvidence, outputDirectory, report, reportPath };
 };

package/dist/compiler/compileProjectPolicy.d.ts

@@ -0,0 +1,5 @@
+import type { Manifest } from "../manifest/index.js";
+import { type NodeReport } from "../report/index.js";
+export type PolicyMode = NonNullable<Manifest["policy"]>["mode"];
+export type OnDegrade = NonNullable<Manifest["policy"]>["on_degrade"];
+export declare const enforcePolicy: (nodeReport: NodeReport, policyMode: PolicyMode | null, onDegrade: OnDegrade | null) => void;

package/dist/compiler/compileProjectPolicy.js

@@ -0,0 +1,21 @@
+import { createDiagnostic } from "../report/index.js";
+export const enforcePolicy = (nodeReport, policyMode, onDegrade) => {
+    for (const capability of nodeReport.capabilities) {
+        if (capability.outcome === "unsupported") {
+            if (policyMode === "strict") {
+                throw new Error(`Policy violation: ${capability.key} is unsupported for ${nodeReport.id} (strict mode)${capability.message ? `: ${capability.message}` : ""}`);
+            }
+            if (policyMode === "warn") {
+                nodeReport.diagnostics.push(createDiagnostic("warn", `Policy warning: ${capability.key} is unsupported for ${nodeReport.id}${capability.message ? `: ${capability.message}` : ""}`));
+            }
+        }
+        if (capability.outcome === "degraded") {
+            if (onDegrade === "error") {
+                throw new Error(`Policy violation: ${capability.key} is degraded for ${nodeReport.id} (on_degrade: error)${capability.message ? `: ${capability.message}` : ""}`);
+            }
+            if (onDegrade === "warn") {
+                nodeReport.diagnostics.push(createDiagnostic("warn", `Policy warning: ${capability.key} is degraded for ${nodeReport.id}${capability.message ? `: ${capability.message}` : ""}`));
+            }
+        }
+    }
+};

package/dist/compiler/compileProjectReports.d.ts

@@ -0,0 +1,9 @@
+import type { NodeReport } from "../report/index.js";
+import type { TeamCompileSupport } from "./compileProjectSupport.js";
+import type { ResolvedAgentNode, ResolvedTeamNode } from "./types.js";
+interface ReportTarget {
+    report: NodeReport;
+    value: ResolvedAgentNode | ResolvedTeamNode;
+}
+export declare const augmentNodeReports: (compiledNodes: ReportTarget[], support: TeamCompileSupport) => void;
+export {};

package/dist/compiler/compileProjectReports.js

@@ -0,0 +1,52 @@
+const createIdentityCapabilities = (node) => [
+    ...(node.surfaces?.slack?.identity
+        ? [{
+                key: "surfaces.slack.identity",
+                message: "Declared Slack identity was preserved for roster output",
+                outcome: "supported"
+            }]
+        : []),
+    ...(node.surfaces?.discord?.identity
+        ? [{
+                key: "surfaces.discord.identity",
+                message: "Declared Discord identity was preserved for roster output",
+                outcome: "supported"
+            }]
+        : []),
+    ...(node.surfaces?.telegram?.identity
+        ? [{
+                key: "surfaces.telegram.identity",
+                message: "Declared Telegram identity was preserved for roster output",
+                outcome: "supported"
+            }]
+        : []),
+    ...(node.surfaces?.whatsapp?.identity
+        ? [{
+                key: "surfaces.whatsapp.identity",
+                message: "Declared WhatsApp identity was preserved for roster output",
+                outcome: "supported"
+            }]
+        : [])
+];
+const createWorkspaceResourceCapabilities = (node) => (node.workspaceResources?.length ?? 0) > 0
+    ? [{
+            key: "workspace.resources",
+            message: `${node.workspaceResources?.length ?? 0} workspace resource(s) will be prepared at startup`,
+            outcome: "supported"
+        }]
+    : [];
+export const augmentNodeReports = (compiledNodes, support) => {
+    for (const compiled of compiledNodes) {
+        compiled.report.capabilities.push(...createWorkspaceResourceCapabilities(compiled.value));
+        if (compiled.value.kind === "team") {
+            compiled.report.capabilities.push(...(support.capabilitiesByTeamSource.get(compiled.value.source) ?? []));
+            compiled.report.diagnostics.push(...(support.diagnosticsByTeamSource.get(compiled.value.source) ?? []));
+            continue;
+        }
+        const activeEnvironments = support.activeEnvironmentsByAgentSource.get(compiled.value.source);
+        if (activeEnvironments) {
+            compiled.report.active_environments = activeEnvironments;
+        }
+        compiled.report.capabilities.push(...createIdentityCapabilities(compiled.value));
+    }
+};

package/dist/compiler/compileProjectSupport.js

@@ -100,6 +100,15 @@ export const injectMoltnetWorkspaceFiles = async (outputDirectory, compiledNodes
             upsertEmittedFile(compiled.emittedFiles, file);
         }
         await writeEmittedFiles(runtimeOutputDirectory, moltnetClientConfigFiles);
+        // Daimon agents talk Moltnet through the native moltnet_send/moltnet_read
+        // tools, and the moltnet CLI is not authenticated inside a Daimon
+        // workspace. Installing its skill there only teaches the agent a shell
+        // path that fails before it falls back to the tools it already has, so
+        // Daimon skips the skill install entirely; .moltnet/config.json above is
+        // still emitted since the native tools read it.
+        if (compiled.value.runtime.name === "daimon") {
+            continue;
+        }
         if (!moltnetCliCommand) {
             moltnetCliCommand = await resolveMoltnetCliCommand();
         }

package/dist/compiler/containerArtifactSummaries.d.ts

@@ -0,0 +1,7 @@
+import type { DistributionOrganizationSummary } from "../distribution/index.js";
+import type { MoltnetArtifacts } from "./moltnetArtifacts.js";
+import type { MoltnetReleaseIdentity } from "./moltnetBinaries.js";
+import type { CompiledNodeArtifact, GeneratedContainerArtifacts } from "./containerArtifactsTypes.js";
+import type { CompilePlan } from "./types.js";
+export declare const createOrganizationSummary: (plan: CompilePlan, compiledNodes: CompiledNodeArtifact[]) => DistributionOrganizationSummary;
+export declare const createMoltnetSummary: (moltnet: MoltnetArtifacts | undefined | null, release: MoltnetReleaseIdentity | undefined) => GeneratedContainerArtifacts["report"]["moltnet"] | undefined;

package/dist/compiler/containerArtifactSummaries.js

@@ -0,0 +1,138 @@
+import { SpawnfileError } from "../shared/index.js";
+export const createOrganizationSummary = (plan, compiledNodes) => {
+    const nodes = compiledNodes.map((node) => ({
+        id: node.id ?? `${node.kind}:${node.slug}`,
+        kind: node.kind,
+        name: node.value.name,
+        runtimeName: node.runtimeName,
+        source: node.value.source
+    }));
+    const rootNode = nodes.find((node) => node.source === plan.root)
+        ?? nodes.find((node) => !plan.edges.some((edge) => edge.to === node.id))
+        ?? nodes[0];
+    if (!rootNode) {
+        throw new SpawnfileError("compile_error", `Unable to resolve the root node for ${plan.root}`);
+    }
+    const memberEdges = plan.edges.filter((edge) => edge.kind === "team_member");
+    const teamsByAgent = new Map();
+    for (const edge of memberEdges) {
+        teamsByAgent.set(edge.to, [...(teamsByAgent.get(edge.to) ?? []), edge.from]);
+    }
+    const agentNodes = nodes.filter((node) => node.kind === "agent");
+    const teamNodes = nodes.filter((node) => node.kind === "team");
+    const agentIds = new Set(agentNodes.map((node) => node.id));
+    return {
+        agents: agentNodes
+            .map((node) => ({
+            id: node.id,
+            name: node.name,
+            runtime: node.runtimeName,
+            teams: [...(teamsByAgent.get(node.id) ?? [])].sort()
+        }))
+            .sort((left, right) => left.id.localeCompare(right.id)),
+        project: rootNode.name,
+        teams: teamNodes
+            .map((node) => ({
+            agents: memberEdges
+                .filter((edge) => edge.from === node.id && agentIds.has(edge.to))
+                .map((edge) => edge.to)
+                .sort(),
+            id: node.id,
+            name: node.name
+        }))
+            .sort((left, right) => left.id.localeCompare(right.id))
+    };
+};
+const resolveMoltnetOperatorCredential = (plan) => {
+    const client = plan.server.auth.client;
+    if (!client) {
+        return {};
+    }
+    if (client.token_env) {
+        return { secret: client.token_env };
+    }
+    if (client.token_path) {
+        return { secret: client.token_path };
+    }
+    if (!client.token_id) {
+        return {};
+    }
+    const token = plan.server.auth.tokens?.find((candidate) => candidate.id === client.token_id);
+    const agents = [...new Set((token?.agents ?? []).map((agent) => agent.trim()))].filter(Boolean);
+    return {
+        ...(agents.length === 1 ? { agentId: agents[0] } : {}),
+        id: client.token_id,
+        ...(token?.secret ? { secret: token.secret } : {})
+    };
+};
+export const createMoltnetSummary = (moltnet, release) => {
+    if (!moltnet) {
+        return undefined;
+    }
+    return {
+        node_plans: moltnet.nodePlans.map((plan) => ({
+            config_path: plan.configPath,
+            ...(plan.credentialAgentId ? { credential_agent_id: plan.credentialAgentId } : {}),
+            ...(plan.credentialId ? { credential_id: plan.credentialId } : {}),
+            ...(plan.credentialSecret ? { credential_secret: plan.credentialSecret } : {}),
+            ...(plan.memberId ? { member_id: plan.memberId } : {}),
+            network_id: plan.networkId
+        })),
+        release,
+        server_plans: moltnet.serverPlans.map((plan) => {
+            const operatorCredential = resolveMoltnetOperatorCredential(plan);
+            return {
+                ...(plan.server.auth.agent_registration
+                    ? { agent_registration: plan.server.auth.agent_registration }
+                    : {}),
+                auth_mode: plan.server.auth.mode,
+                ...(plan.server.mode === "managed" && plan.server.auth.tokens
+                    ? {
+                        auth_tokens: plan.server.auth.tokens.map((token) => ({
+                            agents: [...new Set((token.agents ?? []).map((agent) => agent.trim()))]
+                                .filter(Boolean)
+                                .sort(),
+                            id: token.id,
+                            scopes: [...token.scopes].sort(),
+                            secret: token.secret
+                        }))
+                    }
+                    : {}),
+                base_url: plan.baseUrl,
+                ...(plan.configPath ? { config_path: plan.configPath } : {}),
+                ...(plan.server.mode === "managed"
+                    ? {
+                        debug_events: plan.server.debug_events,
+                        direct_messages: plan.server.direct_messages,
+                        human_ingress: plan.server.human_ingress,
+                        trust_forwarded_proto: plan.server.trust_forwarded_proto
+                    }
+                    : {}),
+                id: plan.id,
+                mode: plan.mode,
+                network_id: plan.networkId,
+                network_name: plan.name,
+                ...(operatorCredential.agentId
+                    ? { operator_agent_id: operatorCredential.agentId }
+                    : {}),
+                ...(operatorCredential.id ? { operator_token_id: operatorCredential.id } : {}),
+                ...(operatorCredential.secret
+                    ? { operator_token_secret: operatorCredential.secret }
+                    : {}),
+                ...(plan.port ? { port: plan.port } : {}),
+                ...(plan.server.auth.public_read !== undefined
+                    ? { public_read: plan.server.auth.public_read }
+                    : {}),
+                rooms: plan.rooms.map((room) => ({
+                    id: room.id,
+                    members: [...room.members],
+                    ...(room.visibility ? { visibility: room.visibility } : {}),
+                    ...(room.write_policy ? { write_policy: room.write_policy } : {})
+                })),
+                ...(plan.server.mode === "managed"
+                    ? { store_kind: plan.server.store.kind }
+                    : {})
+            };
+        })
+    };
+};

package/dist/compiler/containerArtifacts.d.ts

@@ -1,10 +1,22 @@
+import { type RuntimeContainerPackageOverrides } from "../runtime/index.js";
 import type { MoltnetArtifacts } from "./moltnetArtifacts.js";
+import type { MoltnetReleaseIdentity } from "./moltnetBinaries.js";
 import type { CompiledNodeArtifact, GeneratedContainerArtifacts } from "./containerArtifactsTypes.js";
 import type { CompilePlan } from "./types.js";
+import { type ResolvedWorldBindings } from "./worldBindings.js";
 export type { CompiledNodeArtifact, GeneratedContainerArtifacts } from "./containerArtifactsTypes.js";
 export interface ContainerArtifactOptions {
+    deploymentLineage?: string;
     generatedAt?: string;
     hasStagedMoltnetBinaries?: boolean;
+    hasWorkspaceBundles?: boolean;
     moltnet?: MoltnetArtifacts | null;
+    moltnetRelease?: MoltnetReleaseIdentity;
+    worldBindings?: ResolvedWorldBindings;
+    /** Resolved local overrides for runtime install npm packages, produced by
+     * stageRuntimePackageOverrides.ts from a compile-time-only
+     * RuntimePackageOverrideRequest (see compileProject.ts). Undefined for a
+     * standard compile. */
+    runtimePackageOverrides?: RuntimeContainerPackageOverrides;
 }
 export declare const createContainerArtifacts: (plan: CompilePlan, compiledNodes: CompiledNodeArtifact[], options?: ContainerArtifactOptions) => Promise<GeneratedContainerArtifacts>;