spawnfile 0.1.28 → 0.1.30

package/dist/distribution/consumeImageDaimonDocker.js

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { SpawnfileError } from "../shared/errors.js";
 import { DAIMON_DOCKER_RUNTIME_SECURITY_ARGS, daimonEngineDockerSecurityArgsForConfigs, materializeDaimonGrokSeccompProfile } from "../shared/daimonCodexDocker.js";
+import { readDaimonImageContract } from "./consumeImageDaimonContract.js";
 import { extractSingleFileFromTar } from "./tarReader.js";
 const DAIMON_CONFIG_SIZE_CAP_BYTES = 4 * 1024 * 1024;
 const daimonInstancesFrom = (report) => report.runtime_instances.filter((instance) => instance.runtime === "daimon");
@@ -10,7 +11,7 @@ const assertAbsoluteConfigPath = (instance) => {
     }
     return instance.config_path;
 };
-const readDaimonConfigSourcesFromImage = async (imageRef, instances, runDocker) => {
+const readDaimonConfigSourcesFromImage = async (imageRef, instances, runDocker, securityDirectory) => {
     const helperName = `spawnfile-daimon-config-${randomUUID()}`;
     await runDocker(["create", "--name", helperName, imageRef]);
     try {
@@ -27,19 +28,19 @@ const readDaimonConfigSourcesFromImage = async (imageRef, instances, runDocker)
             }
             sources.push(extractSingleFileFromTar(tar, { maxBytes: DAIMON_CONFIG_SIZE_CAP_BYTES }).toString("utf8"));
         }
-        return sources;
+        return { sources, engineDescriptors: await readDaimonImageContract(helperName, runDocker, securityDirectory) };
     }
     finally {
         await runDocker(["rm", "-f", helperName]).catch(() => undefined);
     }
 };
-export const resolveDaimonDockerSecurityArgsForImage = async (imageRef, report, runDocker, securityDirectory) => {
+export const resolveDaimonRuntimeForImage = async (imageRef, report, runDocker, securityDirectory) => {
     const daimonInstances = daimonInstancesFrom(report);
     if (daimonInstances.length === 0)
-        return [];
-    const sources = await readDaimonConfigSourcesFromImage(imageRef, daimonInstances, runDocker);
-    return [
-        ...DAIMON_DOCKER_RUNTIME_SECURITY_ARGS,
-        ...(await daimonEngineDockerSecurityArgsForConfigs(sources, () => materializeDaimonGrokSeccompProfile(securityDirectory)))
-    ];
+        return { securityArgs: [] };
+    const { sources, engineDescriptors } = await readDaimonConfigSourcesFromImage(imageRef, daimonInstances, runDocker, securityDirectory);
+    return { engineDescriptors, securityArgs: [
+            ...DAIMON_DOCKER_RUNTIME_SECURITY_ARGS,
+            ...(await daimonEngineDockerSecurityArgsForConfigs(sources, () => materializeDaimonGrokSeccompProfile(securityDirectory)))
+        ] };
 };

package/dist/distribution/daimonImageContract.test-fixtures.d.ts

@@ -0,0 +1,2 @@
+export declare const daimonImageManifestBytes: (version?: 5 | 6 | 7) => Buffer;
+export declare const daimonImageContractFiles: (bytes?: Buffer<ArrayBufferLike>) => Record<string, Buffer>;

package/dist/distribution/daimonImageContract.test-fixtures.js

@@ -0,0 +1,16 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+// Historical bytes, unchanged: v5 a483f6e4, v6 bf61e6bb.
+export const daimonImageManifestBytes = (version = 7) => readFileSync(new URL(version === 7 ? "../runtime/daimon/contract-manifest.json"
+    : `./daimon-contract-v${version}.fixture.json`, import.meta.url));
+export const daimonImageContractFiles = (bytes = daimonImageManifestBytes()) => {
+    const digest = `sha256:${createHash("sha256").update(bytes).digest("hex")}`;
+    const root = "/opt/spawnfile/runtime-installs/daimon";
+    return {
+        [`${root}/contract-manifest.json`]: bytes,
+        [`${root}/contract-manifest.sha256`]: Buffer.from(`${digest}\n`),
+        [`${root}/capability-receipt.json`]: Buffer.from(JSON.stringify({
+            version: "spawnfile.daimon-runtime-capability-receipt.v1", manifest_sha256: digest
+        }))
+    };
+};

package/dist/distribution/imageRuntimeAuth.d.ts

@@ -1,3 +1,4 @@
+import type { DaimonEngineDescriptors } from "../runtime/daimon/engineDescriptorSchema.js";
 import type { ResolvedAuthProfile } from "../auth/index.js";
 import type { DistributionReport } from "./types.js";
 export interface ImageRuntimeAuthInput {
@@ -8,6 +9,7 @@ export interface ImageRuntimeAuthInput {
      * known to run under a different identity.
      */
     daimonContainerCredentialUid?: number;
+    daimonEngineDescriptors?: DaimonEngineDescriptors;
     report: DistributionReport;
     sourceEnvironment?: Record<string, string | undefined>;
     tempRoot: string;
@@ -16,7 +18,7 @@ export interface ImageRuntimeAuthResult {
     coveredModelSecrets: Set<string>;
     mountArgs: string[];
 }
-export declare const prepareDaimonImageAuthMounts: (instance: DistributionReport["runtime_instances"][number], environment: Record<string, string | undefined>, authProfile: ResolvedAuthProfile | null, containerCredentialUid?: number) => Promise<string[]>;
+export declare const prepareDaimonImageAuthMounts: (instance: DistributionReport["runtime_instances"][number], environment: Record<string, string | undefined>, authProfile: ResolvedAuthProfile | null, containerCredentialUid?: number, inventory?: DaimonEngineDescriptors) => Promise<string[]>;
 /**
  * Builds the credential mounts for a sourceless image deployment that uses
  * import-based model auth. The OAuth-mode config is already baked into the

package/dist/distribution/imageRuntimeAuth.js

@@ -1,4 +1,4 @@
-import { getDaimonEngineDescriptor } from "../runtime/daimon/index.js";
+import { DAIMON_ENGINE_DESCRIPTORS } from "../runtime/daimon/engines.js";
 import path from "node:path";
 import { loadImportedClaudeCodeCredential, loadImportedCodexCredential } from "../auth/index.js";
 import { fileExists } from "../filesystem/index.js";
@@ -10,13 +10,13 @@ const daimonNodeSlug = (nodeId) => nodeId.replace(/^agent:/u, "").toLowerCase()
     .replace(/[^a-z0-9]+/gu, "-").replace(/^-+|-+$/gu, "");
 const daimonInstanceRoot = (instance) => {
     const root = path.posix.join("/var/lib/spawnfile/instances/daimon", instance.id);
-    if (instance.config_path !== path.posix.join(root, "daimon/daimon-organization-runtime.json")
+    if (instance.home_path !== null || instance.config_path !== path.posix.join(root, "daimon/daimon-organization-runtime.json")
         || instance.workspace_path !== path.posix.join(root, "workspace")) {
         throw new SpawnfileError("validation_error", "Daimon image runtime paths are not canonical");
     }
     return root;
 };
-export const prepareDaimonImageAuthMounts = async (instance, environment, authProfile, containerCredentialUid = DAIMON_CREDENTIAL_CONTAINER_UID) => {
+export const prepareDaimonImageAuthMounts = async (instance, environment, authProfile, containerCredentialUid = DAIMON_CREDENTIAL_CONTAINER_UID, inventory = DAIMON_ENGINE_DESCRIPTORS) => {
     const engines = Object.entries(instance.engine_by_node_id ?? {}).sort(([left], [right]) => left.localeCompare(right));
     if (engines.length === 0) {
         throw new SpawnfileError("validation_error", "Daimon image report is missing its engine map");
@@ -25,7 +25,7 @@ export const prepareDaimonImageAuthMounts = async (instance, environment, authPr
     if (JSON.stringify(engineNodeIds) !== JSON.stringify([...instance.node_ids].sort())) {
         throw new SpawnfileError("validation_error", "Daimon image engine map does not match its declared agents");
     }
-    if (engines.some(([, engine]) => !getDaimonEngineDescriptor(engine))) {
+    if (engines.some(([, engine]) => !Object.hasOwn(inventory, engine))) {
         throw new SpawnfileError("validation_error", "Daimon image report declares an unsupported engine");
     }
     const root = daimonInstanceRoot(instance);
@@ -38,14 +38,14 @@ export const prepareDaimonImageAuthMounts = async (instance, environment, authPr
         slugs.set(slug, nodeId);
     }
     const descriptors = [...new Set(engines.map(([, engine]) => engine))]
-        .map((engine) => getDaimonEngineDescriptor(engine));
+        .map((engine) => inventory[engine]);
     // Keep portable leaves, broker bootstrap, then realm unlock mounts in the
     // existing order while resolving every engine's staging contract from data.
     for (const descriptor of descriptors) {
         if (descriptor.auth.staging !== "portable-file")
             continue;
-        const source = daimonSourcePathForEngine(descriptor.id, environment, authProfile);
-        const ownerUid = await assertSafeDaimonSourceFile(source, descriptor.id, descriptor.auth.maxCredentialBytes, descriptor.id);
+        const source = daimonSourcePathForEngine(descriptor.id, environment, authProfile, descriptor);
+        const ownerUid = await assertSafeDaimonSourceFile(source, descriptor.id, descriptor.auth.maxCredentialBytes, descriptor);
         assertDaimonCredentialContainerOwner(ownerUid, descriptor.id, containerCredentialUid);
         for (const [nodeId, engine] of engines) {
             if (engine !== descriptor.id)
@@ -54,13 +54,21 @@ export const prepareDaimonImageAuthMounts = async (instance, environment, authPr
             mounts.push("-v", `${source}:${target}:ro`);
         }
     }
+    for (const descriptor of descriptors) {
+        if (descriptor.auth.staging !== "portable-realm")
+            continue;
+        const source = daimonSourcePathForEngine(descriptor.id, environment, authProfile, descriptor);
+        const ownerUid = await assertSafeDaimonSourceFile(source, descriptor.id, descriptor.auth.maxCredentialBytes, descriptor);
+        assertDaimonCredentialContainerOwner(ownerUid, descriptor.id, containerCredentialUid);
+        mounts.push("-v", `${source}:${descriptor.auth.realm.bootstrapMountPath}:ro`);
+    }
     for (const descriptor of descriptors) {
         if (descriptor.auth.staging !== "broker-realm")
             continue;
         // Broker bootstrap leaves are read and staged by root, so they deliberately
         // do not require ownership by the eventual organization uid.
-        const source = daimonSourcePathForEngine(descriptor.id, environment);
-        await assertSafeDaimonSourceFile(source, descriptor.id, descriptor.auth.maxCredentialBytes, descriptor.id);
+        const source = daimonSourcePathForEngine(descriptor.id, environment, null, descriptor);
+        await assertSafeDaimonSourceFile(source, descriptor.id, descriptor.auth.maxCredentialBytes, descriptor);
         mounts.push("-v", `${source}:${descriptor.auth.realm.bootstrapMountPath}:ro`);
     }
     for (const descriptor of descriptors) {
@@ -88,13 +96,12 @@ export const prepareImageRuntimeAuthMounts = async (input) => {
     const mountArgs = [];
     const runtimeHomes = new Set();
     for (const instance of input.report.runtime_instances) {
-        if (instance.home_path) {
-            runtimeHomes.add(instance.home_path);
-        }
         if (instance.runtime === "daimon") {
-            mountArgs.push(...await prepareDaimonImageAuthMounts(instance, input.sourceEnvironment ?? process.env, input.authProfile, input.daimonContainerCredentialUid ?? DAIMON_CREDENTIAL_CONTAINER_UID));
+            mountArgs.push(...await prepareDaimonImageAuthMounts(instance, input.sourceEnvironment ?? process.env, input.authProfile, input.daimonContainerCredentialUid ?? DAIMON_CREDENTIAL_CONTAINER_UID, input.daimonEngineDescriptors));
             continue;
         }
+        if (instance.home_path)
+            runtimeHomes.add(instance.home_path);
         if (!input.authProfile)
             continue;
         const adapter = getRuntimeAdapter(instance.runtime);

package/dist/manifest/trainingDataSchemas.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-export declare const trainingInstantSchema: z.ZodISODateTime;
+export declare const trainingInstantSchema: z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODateTime]>;
 export declare const trainingWakeSchema: z.ZodObject<{
     surface: z.ZodLiteral<"moltnet">;
     room: z.ZodString;
@@ -9,7 +9,7 @@ export declare const trainingWakeSchema: z.ZodObject<{
 export declare const trainingDatasetSchema: z.ZodObject<{
     examples: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
-        at: z.ZodISODateTime;
+        at: z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODateTime]>;
         wake: z.ZodObject<{
             surface: z.ZodLiteral<"moltnet">;
             room: z.ZodString;

package/dist/manifest/trainingDataSchemas.js

@@ -1,3 +1,4 @@
+import { compatibleIsoDateTimeSchema } from '../shared/index.js';
 import { z } from "zod";
 import { memoryBankSchema } from "./memorySchemas.js";
 import { teamNetworkSchema } from "./teamNetworkSchemas.js";
@@ -11,7 +12,7 @@ const uniqueIds = (entries, context) => {
         ids.add(entry.id);
     });
 };
-export const trainingInstantSchema = z.iso.datetime({ offset: true });
+export const trainingInstantSchema = compatibleIsoDateTimeSchema({ offset: true });
 export const trainingWakeSchema = z.object({
     surface: z.literal("moltnet"),
     room: z.string(),

package/dist/recording/moment.d.ts

@@ -5,20 +5,20 @@ export declare const momentRecordSchema: z.ZodObject<{
     version: z.ZodLiteral<"spawnfile.moment-record.v1">;
     agent: z.ZodString;
     wake: z.ZodObject<{
-        at: z.ZodISODateTime;
-        startedAt: z.ZodISODateTime;
+        at: z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODateTime]>;
+        startedAt: z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODateTime]>;
         executionId: z.ZodString;
         deliveries: z.ZodArray<z.ZodObject<{
             deliveryId: z.ZodString;
             kind: z.ZodString;
-            occurredAt: z.ZodISODateTime;
+            occurredAt: z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODateTime]>;
         }, z.core.$strict>>;
         surface: z.ZodOptional<z.ZodLiteral<"moltnet">>;
         room: z.ZodOptional<z.ZodString>;
         from: z.ZodOptional<z.ZodString>;
         messageId: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>;
-    recordedAt: z.ZodISODateTime;
+    recordedAt: z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODateTime]>;
     exact: z.ZodBoolean;
     errors: z.ZodOptional<z.ZodArray<z.ZodString>>;
     resources: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -38,7 +38,7 @@ export declare const momentRecordSchema: z.ZodObject<{
         commit: z.ZodOptional<z.ZodString>;
         ref: z.ZodOptional<z.ZodString>;
         paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        landedAt: z.ZodISODateTime;
+        landedAt: z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODateTime]>;
         period: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
     memory: z.ZodArray<z.ZodObject<{
@@ -49,7 +49,7 @@ export declare const momentRecordSchema: z.ZodObject<{
     }, z.core.$strict>>;
     moltnet: z.ZodArray<z.ZodObject<{
         network: z.ZodString;
-        cursor: z.ZodISODateTime;
+        cursor: z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODateTime]>;
         messageIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
     volumes: z.ZodArray<z.ZodObject<{

package/dist/recording/parse.js

@@ -1,7 +1,8 @@
+import { compatibleIsoDateTimeSchema } from '../shared/index.js';
 import { z } from "zod";
 import { WAKE_MOMENT_VERSION } from "./types.js";
 const text = z.string().min(1);
-const instant = z.iso.datetime({ offset: true }).refine((value) => Number.isFinite(Date.parse(value)));
+const instant = compatibleIsoDateTimeSchema({ offset: true }).refine((value) => Number.isFinite(Date.parse(value)));
 const count = z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
 const snapshot = z.object({
     id: text.regex(/^[A-Za-z0-9._-]{1,128}$/u),

package/dist/runtime/daimon/adapter.js

@@ -105,7 +105,7 @@ const unsupportedAgentFeatures = (node) => {
     if (!descriptor.modelSelection.configurable && node.execution?.model) {
         throw new SpawnfileError("validation_error", "Daimon AGY agents must omit Spawnfile execution.model; their subscription auth and model selection are Daimon-owned");
     }
-    if (descriptor.auth.staging === "portable-file" && node.execution?.model?.primary.auth?.method === getDaimonEngineDescriptor(DAIMON_BROKER_ENGINE_ID)?.auth.method) {
+    if ((descriptor.auth.staging === "portable-file" || descriptor.auth.staging === "portable-realm") && node.execution?.model?.primary.auth?.method === getDaimonEngineDescriptor(DAIMON_BROKER_ENGINE_ID)?.auth.method) {
         throw new SpawnfileError("validation_error", `Daimon Codex agent ${node.name} cannot declare Grok model auth`);
     }
     if (descriptor.broker)

package/dist/runtime/daimon/config.js

@@ -2,6 +2,7 @@ import path from "node:path";
 import { CLI_ENGINE_SKILL_BASE_DIRECTORIES } from "../common.js";
 import { daimonGrokSkillsError } from "./grokSkillsSupport.js";
 import { daimonAgentSkillsFromResolved } from "./grokWorkerSkills.js";
+import { daimonPortableSubscriptionRealms } from "./subscriptionRealms.js";
 import { parseEveryScheduleMs } from "../scheduleUtils.js";
 import { SpawnfileError } from "../../shared/index.js";
 import { DAIMON_AGY_SUBSCRIPTION_REALM, DAIMON_GROK_SUBSCRIPTION_REALM, DAIMON_GROK_TURN_USAGE_LEDGER } from "./contractManifest.js";
@@ -223,6 +224,7 @@ export const createDaimonContainerTargets = async (inputs) => {
         .map((input) => [input.id, daimonAgentSkillsFromResolved(input.value.skills)]));
     const hasAgy = configAgents.some((agent) => getDaimonEngineDescriptor(agent.engine.kind)?.auth.staging === "secret-service");
     const hasGrok = configAgents.some((agent) => daimonEngineHasBroker(agent.engine.kind));
+    const portableRealms = daimonPortableSubscriptionRealms(configAgents.map((agent) => agent.engine.kind));
     const agyRuntimeHomeMounts = configAgents
         .filter((agent) => getDaimonEngineDescriptor(agent.engine.kind)?.auth.staging === "secret-service")
         .map((agent) => ({
@@ -277,13 +279,14 @@ export const createDaimonContainerTargets = async (inputs) => {
                 }
             ],
             id: DAIMON_ORGANIZATION_TARGET_ID,
-            ...(hasAgy || hasGrok ? {
+            ...(hasAgy || hasGrok || portableRealms.opaqueMountTargets.length > 0 ? {
                 opaqueMountTargets: [
+                    ...portableRealms.opaqueMountTargets,
                     ...(hasAgy ? [DAIMON_AGY_SUBSCRIPTION_REALM.unlockMountPath] : []),
                     ...(hasGrok ? [DAIMON_GROK_SUBSCRIPTION_REALM.bootstrapMountPath] : [])
                 ],
             } : {}),
-            persistentMounts: [...portableEngineHomeMounts, ...toolStateMounts, ...recordingMounts, {
+            persistentMounts: [...portableRealms.persistentMounts, ...portableEngineHomeMounts, ...toolStateMounts, ...recordingMounts, {
                     id: DAIMON_RUNTIME_ACCEPTANCE_STORE_MOUNT_ID,
                     mountPath: `<instance-root>/${DAIMON_RUNTIME_ACCEPTANCE_STORE_DIRECTORY}`,
                     reason: "Daimon organization durable wake acceptance store"