spawnfile 0.1.4 → 0.1.6

package/dist/manifest/executionSchemas.js

@@ -0,0 +1,140 @@
+import { z } from "zod";
+const modelAuthMethodSchema = z.enum(["api_key", "claude-code", "codex", "none"]);
+const modelEndpointCompatibilitySchema = z.enum(["anthropic", "openai"]);
+const modelAuthSchema = z
+    .object({
+    method: modelAuthMethodSchema.optional(),
+    methods: z.record(z.string(), modelAuthMethodSchema).optional()
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (!value.method && !value.methods) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "model auth must declare method or methods"
+        });
+    }
+    if (value.method && value.methods) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "model auth must not declare both method and methods"
+        });
+    }
+    if (value.methods && Object.keys(value.methods).length === 0) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "model auth methods must not be empty"
+        });
+    }
+});
+export const modelEntryAuthSchema = z
+    .object({
+    key: z.string().optional(),
+    method: modelAuthMethodSchema.optional()
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (!value.method) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "model auth must declare method"
+        });
+    }
+    if (value.key && value.method !== "api_key") {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "model auth key is only valid for api_key auth"
+        });
+    }
+});
+export const modelEndpointSchema = z
+    .object({
+    base_url: z.string().min(1),
+    compatibility: modelEndpointCompatibilitySchema
+})
+    .strict();
+export const modelTargetSchema = z
+    .object({
+    auth: modelEntryAuthSchema.optional(),
+    endpoint: modelEndpointSchema.optional(),
+    name: z.string(),
+    provider: z.string()
+})
+    .strict()
+    .superRefine((value, context) => {
+    const usesCustomEndpoint = value.provider === "custom" || value.provider === "local";
+    if (usesCustomEndpoint && !value.endpoint) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `${value.provider} models must declare endpoint`
+        });
+    }
+    if (!usesCustomEndpoint && value.endpoint) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "endpoint is only valid for custom or local models"
+        });
+    }
+});
+export const executionSchema = z
+    .object({
+    model: z
+        .object({
+        auth: modelAuthSchema.optional(),
+        fallback: z.array(modelTargetSchema).optional(),
+        primary: modelTargetSchema
+    })
+        .superRefine((value, context) => {
+        const declaredProviders = new Set([
+            value.primary.provider,
+            ...(value.fallback ?? []).map((model) => model.provider)
+        ]);
+        if (value.auth?.methods) {
+            for (const provider of declaredProviders) {
+                if (!(provider in value.auth.methods)) {
+                    context.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        message: `model auth methods must declare provider ${provider}`
+                    });
+                }
+            }
+            for (const provider of Object.keys(value.auth.methods)) {
+                if (!declaredProviders.has(provider)) {
+                    context.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        message: `model auth methods declared unknown provider ${provider}`
+                    });
+                }
+            }
+        }
+        for (const target of [value.primary, ...(value.fallback ?? [])]) {
+            const method = target.auth?.method ??
+                value.auth?.methods?.[target.provider] ??
+                value.auth?.method ??
+                (target.provider === "local" ? "none" : undefined);
+            if (target.provider === "custom" && !method) {
+                context.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: "custom models must declare auth.method or inherit legacy model auth"
+                });
+            }
+            if ((target.provider === "custom" || target.provider === "local") &&
+                method === "api_key" &&
+                !target.auth?.key) {
+                context.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: `${target.provider} api_key auth must declare auth.key`
+                });
+            }
+        }
+    })
+        .strict()
+        .optional(),
+    sandbox: z
+        .object({
+        mode: z.enum(["sandboxed", "unrestricted", "workspace"])
+    })
+        .strict()
+        .optional()
+})
+    .strict();

package/dist/manifest/loadManifest.js

@@ -30,8 +30,7 @@ const assertMarkdownDocumentPath = (documentPath) => {
         throw new SpawnfileError("validation_error", `Document paths must point to Markdown files: ${documentPath}`);
     }
 };
-const validateDocFiles = async (manifestPath, manifest) => {
-    const docs = manifest.docs;
+const validateDocFiles = async (manifestPath, docs) => {
     if (!docs) {
         return;
     }
@@ -86,21 +85,25 @@ const validateSkills = async (manifestPath, skills) => {
     }));
 };
 const validateLocalAgentManifest = async (manifestPath, manifest) => {
-    ensureUniqueNames((manifest.mcp_servers ?? []).map((server) => server.name), "MCP server");
+    const agentWorkspaceSkills = manifest.workspace?.skills;
+    const agentEnvironment = manifest.environment;
+    ensureUniqueNames((agentEnvironment?.mcp_servers ?? []).map((server) => server.name), "MCP server");
     ensureUniqueNames((manifest.subagents ?? []).map((subagent) => subagent.id), "subagent id");
-    await validateDocFiles(manifestPath, manifest);
-    await validateSkills(manifestPath, manifest.skills);
+    await validateDocFiles(manifestPath, manifest.workspace?.docs);
+    await validateSkills(manifestPath, agentWorkspaceSkills);
     await validateManifestRefs(manifestPath, manifest.subagents?.map((subagent) => subagent.ref), "Subagent");
-    validateSkillRequirements(manifest.skills, getMcpNames(manifest.mcp_servers));
+    validateSkillRequirements(agentWorkspaceSkills, getMcpNames(agentEnvironment?.mcp_servers));
 };
-const getSharedMcpNames = (shared) => getMcpNames(shared?.mcp_servers);
+const getSharedMcpNames = (shared) => getMcpNames(shared?.environment?.mcp_servers);
 const validateLocalTeamManifest = async (manifestPath, manifest) => {
-    ensureUniqueNames((manifest.shared?.mcp_servers ?? []).map((server) => server.name), "MCP server");
+    const sharedWorkspace = manifest.shared?.workspace;
+    const sharedEnvironment = manifest.shared?.environment;
+    ensureUniqueNames((sharedEnvironment?.mcp_servers ?? []).map((server) => server.name), "MCP server");
     ensureUniqueNames(manifest.members.map((member) => member.id), "member id");
-    await validateDocFiles(manifestPath, manifest);
-    await validateSkills(manifestPath, manifest.shared?.skills);
+    await validateDocFiles(manifestPath, sharedWorkspace?.docs);
+    await validateSkills(manifestPath, sharedWorkspace?.skills);
     await validateManifestRefs(manifestPath, manifest.members.map((member) => member.ref), "Member");
-    validateSkillRequirements(manifest.shared?.skills, getSharedMcpNames(manifest.shared));
+    validateSkillRequirements(sharedWorkspace?.skills, getSharedMcpNames(manifest.shared));
     const memberIds = new Set(manifest.members.map((member) => member.id));
     if (manifest.lead && !memberIds.has(manifest.lead)) {
         throw new SpawnfileError("validation_error", `Lead is not a declared team member: ${manifest.lead}`);
@@ -172,15 +175,6 @@ export const mergeExecution = (parentExecution, childExecution) => {
     if (sandbox && !sandbox.mode) {
         throw new SpawnfileError("validation_error", "Merged execution sandbox is missing mode");
     }
-    const workspace = parentExecution.workspace || childExecution.workspace
-        ? {
-            ...parentExecution.workspace,
-            ...childExecution.workspace
-        }
-        : undefined;
-    if (workspace && !workspace.isolation) {
-        throw new SpawnfileError("validation_error", "Merged execution workspace is missing isolation");
-    }
     const resolvedModel = model
         ? {
             auth: model.auth,
@@ -193,16 +187,10 @@ export const mergeExecution = (parentExecution, childExecution) => {
             mode: sandbox.mode
         }
         : undefined;
-    const resolvedWorkspace = workspace
-        ? {
-            isolation: workspace.isolation
-        }
-        : undefined;
     return {
         ...parentExecution,
         ...childExecution,
         model: resolvedModel,
-        sandbox: resolvedSandbox,
-        workspace: resolvedWorkspace
+        sandbox: resolvedSandbox
     };
 };

package/dist/manifest/renderSpawnfile.js

@@ -1,4 +1,6 @@
 import YAML from "yaml";
+import { orderTeamNetworks } from "./renderSpawnfileNetworks.js";
+import { orderWorkspace } from "./renderSpawnfileWorkspace.js";
 const withDefinedEntries = (entries) => Object.fromEntries(entries.filter((entry) => entry[1] !== undefined));
 const hasEntries = (value) => Object.keys(value).length > 0;
 const orderRuntimeBinding = (runtime) => {
@@ -10,19 +12,6 @@ const orderRuntimeBinding = (runtime) => {
         ["options", runtime.options]
     ]);
 };
-const orderDocs = (docs) => {
-    if (!docs) {
-        return undefined;
-    }
-    return withDefinedEntries([
-        ["identity", docs.identity],
-        ["soul", docs.soul],
-        ["system", docs.system],
-        ["memory", docs.memory],
-        ["heartbeat", docs.heartbeat],
-        ["extras", docs.extras]
-    ]);
-};
 const orderDiscordSurface = (surface) => {
     if (!surface) {
         return undefined;
@@ -180,19 +169,49 @@ const orderExecution = (execution) => {
                 ])
                 : undefined
         ],
-        ["workspace", execution.workspace],
         ["sandbox", execution.sandbox]
     ]);
 };
+const orderAgentSchedule = (schedule) => {
+    if (!schedule) {
+        return undefined;
+    }
+    if (schedule.kind === "cron") {
+        return withDefinedEntries([
+            ["kind", schedule.kind],
+            ["cron", schedule.cron],
+            ["timezone", schedule.timezone],
+            ["prompt", schedule.prompt]
+        ]);
+    }
+    if (schedule.kind === "every") {
+        return withDefinedEntries([
+            ["kind", schedule.kind],
+            ["every", schedule.every],
+            ["timezone", schedule.timezone],
+            ["prompt", schedule.prompt]
+        ]);
+    }
+    return { kind: schedule.kind };
+};
+const orderEnvironment = (environment) => {
+    if (!environment) {
+        return undefined;
+    }
+    return withDefinedEntries([
+        ["env", environment.env],
+        ["secrets", environment.secrets],
+        ["packages", environment.packages],
+        ["mcp_servers", environment.mcp_servers]
+    ]);
+};
 const orderSharedSurface = (shared) => {
     if (!shared) {
         return undefined;
     }
     return withDefinedEntries([
-        ["env", shared.env],
-        ["mcp_servers", shared.mcp_servers],
-        ["secrets", shared.secrets],
-        ["skills", shared.skills]
+        ["workspace", orderWorkspace(shared.workspace)],
+        ["environment", orderEnvironment(shared.environment)]
     ]);
 };
 const orderSurfaces = (surfaces) => {
@@ -208,19 +227,6 @@ const orderSurfaces = (surfaces) => {
         ["moltnet", orderMoltnetSurface(surfaces.moltnet)]
     ]);
 };
-const orderTeamNetworks = (networks) => networks?.map((network) => withDefinedEntries([
-    ["id", network.id],
-    ["provider", network.provider],
-    ["name", network.name],
-    ["expose", network.expose],
-    [
-        "rooms",
-        network.rooms.map((room) => withDefinedEntries([
-            ["id", room.id],
-            ["members", room.members]
-        ]))
-    ]
-]));
 const renderSections = (sections) => sections
     .filter(hasEntries)
     .map((section) => YAML.stringify(section))
@@ -234,15 +240,11 @@ const orderAgentManifestSections = (manifest) => [
     ]),
     withDefinedEntries([["runtime", orderRuntimeBinding(manifest.runtime)]]),
     withDefinedEntries([["execution", orderExecution(manifest.execution)]]),
-    withDefinedEntries([["docs", orderDocs(manifest.docs)]]),
+    withDefinedEntries([["schedule", orderAgentSchedule(manifest.schedule)]]),
+    withDefinedEntries([["workspace", orderWorkspace(manifest.workspace)]]),
+    withDefinedEntries([["environment", orderEnvironment(manifest.environment)]]),
     withDefinedEntries([["surfaces", orderSurfaces(manifest.surfaces)]]),
-    withDefinedEntries([
-        ["skills", manifest.skills],
-        ["mcp_servers", manifest.mcp_servers],
-        ["secrets", manifest.secrets],
-        ["env", manifest.env],
-        ["policy", manifest.policy]
-    ]),
+    withDefinedEntries([["policy", manifest.policy]]),
     withDefinedEntries([["subagents", manifest.subagents]])
 ];
 const orderTeamManifestSections = (manifest) => [
@@ -251,20 +253,10 @@ const orderTeamManifestSections = (manifest) => [
         ["kind", manifest.kind],
         ["name", manifest.name]
     ]),
-    withDefinedEntries([["runtime", orderRuntimeBinding(manifest.runtime)]]),
     withDefinedEntries([["execution", orderExecution(manifest.execution)]]),
-    withDefinedEntries([
-        ["docs", orderDocs(manifest.docs)],
-        ["shared", orderSharedSurface(manifest.shared)],
-        ["networks", orderTeamNetworks(manifest.networks)]
-    ]),
-    withDefinedEntries([
-        ["skills", manifest.skills],
-        ["mcp_servers", manifest.mcp_servers],
-        ["secrets", manifest.secrets],
-        ["env", manifest.env],
-        ["policy", manifest.policy]
-    ]),
+    withDefinedEntries([["shared", orderSharedSurface(manifest.shared)]]),
+    withDefinedEntries([["networks", orderTeamNetworks(manifest.networks)]]),
+    withDefinedEntries([["policy", manifest.policy]]),
     withDefinedEntries([
         ["members", manifest.members],
         ["mode", manifest.mode],

package/dist/manifest/renderSpawnfileNetworks.d.ts

@@ -0,0 +1,2 @@
+import type { TeamManifest } from "./schemas.js";
+export declare const orderTeamNetworks: (networks: TeamManifest["networks"]) => TeamManifest["networks"] | undefined;

package/dist/manifest/renderSpawnfileNetworks.js

@@ -0,0 +1,63 @@
+const withDefinedEntries = (entries) => Object.fromEntries(entries.filter((entry) => entry[1] !== undefined));
+const orderTeamAuthToken = (token) => withDefinedEntries([
+    ["id", token.id],
+    ["agents", token.agents],
+    ["scopes", token.scopes]
+]);
+const orderTeamAuthPairing = (pairing) => withDefinedEntries([
+    ["id", pairing.id],
+    ["remote_base_url", pairing.remote_base_url],
+    ["remote_network_id", pairing.remote_network_id],
+    ["remote_network_name", pairing.remote_network_name]
+]);
+const orderTeamAuth = (server) => withDefinedEntries([
+    ["mode", server.mode],
+    ["url", server.url],
+    ["listen", server.mode === "managed" ? server.listen : undefined],
+    [
+        "auth",
+        withDefinedEntries([
+            ["mode", server.auth.mode],
+            ["tokens", server.auth.tokens?.map(orderTeamAuthToken)],
+            [
+                "client",
+                server.auth.client
+                    ? withDefinedEntries([
+                        ["static_token", server.auth.client.static_token],
+                        ["token_id", server.auth.client.token_id],
+                        ["token_env", server.auth.client.token_env],
+                        ["token_path", server.auth.client.token_path]
+                    ])
+                    : undefined
+            ]
+        ])
+    ],
+    ["store", server.mode === "managed" ? server.store : undefined],
+    [
+        "pairings",
+        server.mode === "managed" && server.pairings
+            ? server.pairings.map(orderTeamAuthPairing)
+            : undefined
+    ],
+    ["human_ingress", server.mode === "managed" ? server.human_ingress : undefined],
+    ["direct_messages", server.mode === "managed" ? server.direct_messages : undefined],
+    [
+        "trust_forwarded_proto",
+        server.mode === "managed" ? server.trust_forwarded_proto : undefined
+    ],
+    ["allowed_origins", server.mode === "managed" ? server.allowed_origins : undefined]
+]);
+export const orderTeamNetworks = (networks) => networks?.map((network) => withDefinedEntries([
+    ["id", network.id],
+    ["provider", network.provider],
+    ["name", network.name],
+    ["server", orderTeamAuth(network.server)],
+    [
+        "rooms",
+        network.rooms.map((room) => withDefinedEntries([
+            ["id", room.id],
+            ["name", room.name],
+            ["members", room.members]
+        ]))
+    ]
+]));

package/dist/manifest/renderSpawnfileWorkspace.d.ts

@@ -0,0 +1,2 @@
+import type { TeamWorkspace } from "./schemas.js";
+export declare const orderWorkspace: (workspace: TeamWorkspace | undefined) => TeamWorkspace | undefined;

package/dist/manifest/renderSpawnfileWorkspace.js

@@ -0,0 +1,47 @@
+const withDefinedEntries = (entries) => Object.fromEntries(entries.filter((entry) => entry[1] !== undefined));
+const orderDocs = (docs) => {
+    if (!docs) {
+        return undefined;
+    }
+    return withDefinedEntries([
+        ["identity", docs.identity],
+        ["soul", docs.soul],
+        ["system", docs.system],
+        ["memory", docs.memory],
+        ["heartbeat", docs.heartbeat],
+        ["extras", docs.extras]
+    ]);
+};
+const orderWorkspaceResource = (resource) => {
+    if (resource.kind === "git") {
+        return withDefinedEntries([
+            ["id", resource.id],
+            ["kind", resource.kind],
+            ["url", resource.url],
+            ["branch", resource.branch],
+            ["ref", resource.ref],
+            ["tag", resource.tag],
+            ["mount", resource.mount],
+            ["mode", resource.mode],
+            ["sharing", resource.sharing]
+        ]);
+    }
+    return withDefinedEntries([
+        ["id", resource.id],
+        ["kind", resource.kind],
+        ["mount", resource.mount],
+        ["mode", resource.mode],
+        ["name", resource.name],
+        ["sharing", resource.sharing]
+    ]);
+};
+export const orderWorkspace = (workspace) => {
+    if (!workspace) {
+        return undefined;
+    }
+    return withDefinedEntries([
+        ["docs", orderDocs(workspace.docs)],
+        ["resources", workspace.resources?.map(orderWorkspaceResource)],
+        ["skills", workspace.skills]
+    ]);
+};

package/dist/manifest/scaffold.js

@@ -20,10 +20,12 @@ export const createAgentScaffoldManifest = (options) => {
                 }
             }
         },
-        docs: {
-            ...(options.docs.identity ? { identity: options.docs.identity } : {}),
-            ...(options.docs.soul ? { soul: options.docs.soul } : {}),
-            system: options.docs.system
+        workspace: {
+            docs: {
+                ...(options.docs.identity ? { identity: options.docs.identity } : {}),
+                ...(options.docs.soul ? { soul: options.docs.soul } : {}),
+                system: options.docs.system
+            }
         }
     };
 };
@@ -31,8 +33,12 @@ export const createTeamScaffoldManifest = () => ({
     spawnfile_version: "0.1",
     kind: "team",
     name: "my-team",
-    docs: {
-        system: "TEAM.md"
+    shared: {
+        workspace: {
+            docs: {
+                system: "TEAM.md"
+            }
+        }
     },
     members: [],
     mode: "swarm"

package/dist/manifest/scheduleSchemas.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export declare const agentScheduleSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    cron: z.ZodString;
+    kind: z.ZodLiteral<"cron">;
+    prompt: z.ZodOptional<z.ZodString>;
+    timezone: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    every: z.ZodString;
+    kind: z.ZodLiteral<"every">;
+    prompt: z.ZodOptional<z.ZodString>;
+    timezone: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"disabled">;
+}, z.core.$strict>], "kind">;
+export type AgentSchedule = z.infer<typeof agentScheduleSchema>;

package/dist/manifest/scheduleSchemas.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+const schedulePromptSchema = z.string().min(1);
+const scheduleTimezoneSchema = z.string().min(1);
+export const agentScheduleSchema = z.discriminatedUnion("kind", [
+    z
+        .object({
+        cron: z.string().min(1),
+        kind: z.literal("cron"),
+        prompt: schedulePromptSchema.optional(),
+        timezone: scheduleTimezoneSchema.optional()
+    })
+        .strict(),
+    z
+        .object({
+        every: z.string().min(1),
+        kind: z.literal("every"),
+        prompt: schedulePromptSchema.optional(),
+        timezone: scheduleTimezoneSchema.optional()
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("disabled")
+    })
+        .strict()
+]);