spawnfile 0.1.3 → 0.1.5

package/dist/manifest/schemas.js

@@ -1,93 +1,8 @@
 import { z } from "zod";
+import { agentScheduleSchema } from "./scheduleSchemas.js";
+import { executionSchema } from "./executionSchemas.js";
 import { surfacesSchema } from "./surfaceSchemas.js";
-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"
-        });
-    }
-});
-const modelEntryAuthMethodSchema = z.enum(["api_key", "claude-code", "codex", "none"]);
-const modelEntryAuthSchema = z
-    .object({
-    key: z.string().optional(),
-    method: modelEntryAuthMethodSchema.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"
-        });
-    }
-});
-const modelEndpointSchema = z
-    .object({
-    base_url: z.string().min(1),
-    compatibility: modelEndpointCompatibilitySchema
-})
-    .strict();
-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"
-        });
-    }
-});
-const docsSchema = z
-    .object({
-    extras: z.record(z.string(), z.string()).optional(),
-    heartbeat: z.string().optional(),
-    identity: z.string().optional(),
-    memory: z.string().optional(),
-    soul: z.string().optional(),
-    system: z.string().optional()
-})
-    .strict();
+import { teamNetworkSchema, teamWorkspaceSchema } from "./teamNetworkSchemas.js";
 const skillRequirementSchema = z
     .object({
     mcp: z.array(z.string()).optional()
@@ -129,74 +44,6 @@ const mcpServerSchema = z
         });
     }
 });
-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(),
-    workspace: z
-        .object({
-        isolation: z.enum(["isolated", "shared"])
-    })
-        .strict()
-        .optional()
-})
-    .strict();
 const runtimeBindingSchema = z.union([
     z.string().min(1),
     z
@@ -218,22 +65,57 @@ const policySchema = z
     on_degrade: z.enum(["allow", "error", "warn"])
 })
     .strict();
+const packageManagerSchema = z.enum(["apt", "npm", "pipx"]);
+const packageSchema = z
+    .object({
+    id: z.string().min(1),
+    manager: packageManagerSchema,
+    name: z.string().min(1),
+    scope: z.string().min(1).optional(),
+    version: z.string().min(1).optional()
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (value.manager !== "npm" && value.scope !== undefined) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "scope is only supported for npm-managed packages"
+        });
+    }
+    if (value.manager === "npm" && value.scope !== undefined && value.scope !== "global") {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "npm package scope must be global"
+        });
+    }
+});
+const environmentSchema = z
+    .object({
+    env: z.record(z.string(), z.string()).optional(),
+    mcp_servers: z.array(mcpServerSchema).optional(),
+    packages: z.array(packageSchema).optional(),
+    secrets: z.array(secretSchema).optional()
+})
+    .strict()
+    .superRefine((value, context) => {
+    const packageIds = value.packages?.map((pkg) => pkg.id) ?? [];
+    if (new Set(packageIds).size !== packageIds.length) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "environment package ids must be unique"
+        });
+    }
+});
 const commonManifestSchema = z
     .object({
     description: z.string().optional(),
-    docs: docsSchema.optional(),
-    env: z.record(z.string(), z.string()).optional(),
     execution: executionSchema.optional(),
     kind: z.enum(["agent", "team"]),
-    mcp_servers: z.array(mcpServerSchema).optional(),
     name: z
         .string()
         .min(1)
         .refine((value) => !/\s/.test(value), { message: "name must not contain whitespace" }),
     policy: policySchema.optional(),
-    runtime: runtimeBindingSchema.optional(),
-    secrets: z.array(secretSchema).optional(),
-    skills: z.array(skillReferenceSchema).optional(),
     surfaces: surfacesSchema.optional(),
     spawnfile_version: z.literal("0.1")
 })
@@ -246,10 +128,8 @@ const subagentSchema = z
     .strict();
 const sharedSurfaceSchema = z
     .object({
-    env: z.record(z.string(), z.string()).optional(),
-    mcp_servers: z.array(mcpServerSchema).optional(),
-    secrets: z.array(secretSchema).optional(),
-    skills: z.array(skillReferenceSchema).optional()
+    environment: environmentSchema.optional(),
+    workspace: teamWorkspaceSchema.optional()
 })
     .strict();
 const memberSchema = z
@@ -258,35 +138,15 @@ const memberSchema = z
     ref: z.string()
 })
     .strict();
-const teamNetworkRoomSchema = z
-    .object({
-    id: z.string().min(1),
-    members: z.array(z.string().min(1)).min(1)
-})
-    .strict();
-const teamNetworkSchema = z
-    .object({
-    expose: z.boolean().optional(),
-    id: z.string().min(1),
-    name: z.string().min(1).optional(),
-    provider: z.literal("moltnet"),
-    rooms: z.array(teamNetworkRoomSchema).min(1)
-})
-    .strict()
-    .superRefine((value, context) => {
-    const roomIds = value.rooms.map((room) => room.id);
-    if (new Set(roomIds).size !== roomIds.length) {
-        context.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: `network ${value.id} declares duplicate room ids`
-        });
-    }
-});
 const agentManifestSchema = commonManifestSchema
     .extend({
     expose: z.boolean().optional(),
     kind: z.literal("agent"),
-    subagents: z.array(subagentSchema).optional()
+    environment: environmentSchema.optional(),
+    runtime: runtimeBindingSchema.optional(),
+    schedule: agentScheduleSchema.optional(),
+    subagents: z.array(subagentSchema).optional(),
+    workspace: teamWorkspaceSchema.optional()
 })
     .strict();
 const teamManifestSchema = commonManifestSchema

package/dist/manifest/teamNetworkSchemas.d.ts

@@ -0,0 +1,228 @@
+import { z } from "zod";
+export { teamWorkspaceDocsSchema, teamWorkspaceSchema } from "./workspaceSchemas.js";
+export type { TeamWorkspace, TeamWorkspaceDocs, TeamWorkspaceResource, TeamWorkspaceResource as TeamNetworkResource } from "./workspaceSchemas.js";
+declare const teamNetworkAuthSchema: z.ZodObject<{
+    client: z.ZodOptional<z.ZodObject<{
+        static_token: z.ZodOptional<z.ZodBoolean>;
+        token_env: z.ZodOptional<z.ZodString>;
+        token_id: z.ZodOptional<z.ZodString>;
+        token_path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    mode: z.ZodEnum<{
+        none: "none";
+        open: "open";
+        bearer: "bearer";
+    }>;
+    tokens: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        agents: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        id: z.ZodString;
+        secret: z.ZodString;
+        scopes: z.ZodArray<z.ZodEnum<{
+            observe: "observe";
+            write: "write";
+            admin: "admin";
+            attach: "attach";
+            pair: "pair";
+        }>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+declare const teamNetworkStoreSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"sqlite">;
+    path: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"json">;
+    path: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"postgres">;
+    dsn_secret: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"memory">;
+}, z.core.$strict>], "kind">;
+declare const teamNetworkServerSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    allowed_origins: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    auth: z.ZodObject<{
+        client: z.ZodOptional<z.ZodObject<{
+            static_token: z.ZodOptional<z.ZodBoolean>;
+            token_env: z.ZodOptional<z.ZodString>;
+            token_id: z.ZodOptional<z.ZodString>;
+            token_path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        mode: z.ZodEnum<{
+            none: "none";
+            open: "open";
+            bearer: "bearer";
+        }>;
+        tokens: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            agents: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            id: z.ZodString;
+            secret: z.ZodString;
+            scopes: z.ZodArray<z.ZodEnum<{
+                observe: "observe";
+                write: "write";
+                admin: "admin";
+                attach: "attach";
+                pair: "pair";
+            }>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+    direct_messages: z.ZodOptional<z.ZodBoolean>;
+    human_ingress: z.ZodOptional<z.ZodBoolean>;
+    listen: z.ZodObject<{
+        bind: z.ZodString;
+        port: z.ZodNumber;
+    }, z.core.$strict>;
+    mode: z.ZodLiteral<"managed">;
+    pairings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        remote_base_url: z.ZodString;
+        remote_network_id: z.ZodString;
+        remote_network_name: z.ZodString;
+        token_secret: z.ZodString;
+    }, z.core.$strict>>>;
+    store: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"sqlite">;
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"json">;
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"postgres">;
+        dsn_secret: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"memory">;
+    }, z.core.$strict>], "kind">;
+    trust_forwarded_proto: z.ZodOptional<z.ZodBoolean>;
+    url: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    auth: z.ZodObject<{
+        client: z.ZodOptional<z.ZodObject<{
+            static_token: z.ZodOptional<z.ZodBoolean>;
+            token_env: z.ZodOptional<z.ZodString>;
+            token_id: z.ZodOptional<z.ZodString>;
+            token_path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        mode: z.ZodEnum<{
+            none: "none";
+            open: "open";
+            bearer: "bearer";
+        }>;
+        tokens: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            agents: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            id: z.ZodString;
+            secret: z.ZodString;
+            scopes: z.ZodArray<z.ZodEnum<{
+                observe: "observe";
+                write: "write";
+                admin: "admin";
+                attach: "attach";
+                pair: "pair";
+            }>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+    mode: z.ZodLiteral<"external">;
+    url: z.ZodString;
+}, z.core.$strict>], "mode">;
+declare const teamNetworkRoomSchema: z.ZodObject<{
+    id: z.ZodString;
+    members: z.ZodArray<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const teamNetworkSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    provider: z.ZodLiteral<"moltnet">;
+    rooms: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        members: z.ZodArray<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    server: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        allowed_origins: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        auth: z.ZodObject<{
+            client: z.ZodOptional<z.ZodObject<{
+                static_token: z.ZodOptional<z.ZodBoolean>;
+                token_env: z.ZodOptional<z.ZodString>;
+                token_id: z.ZodOptional<z.ZodString>;
+                token_path: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            mode: z.ZodEnum<{
+                none: "none";
+                open: "open";
+                bearer: "bearer";
+            }>;
+            tokens: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                agents: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                id: z.ZodString;
+                secret: z.ZodString;
+                scopes: z.ZodArray<z.ZodEnum<{
+                    observe: "observe";
+                    write: "write";
+                    admin: "admin";
+                    attach: "attach";
+                    pair: "pair";
+                }>>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>;
+        direct_messages: z.ZodOptional<z.ZodBoolean>;
+        human_ingress: z.ZodOptional<z.ZodBoolean>;
+        listen: z.ZodObject<{
+            bind: z.ZodString;
+            port: z.ZodNumber;
+        }, z.core.$strict>;
+        mode: z.ZodLiteral<"managed">;
+        pairings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            remote_base_url: z.ZodString;
+            remote_network_id: z.ZodString;
+            remote_network_name: z.ZodString;
+            token_secret: z.ZodString;
+        }, z.core.$strict>>>;
+        store: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"sqlite">;
+            path: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"json">;
+            path: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"postgres">;
+            dsn_secret: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"memory">;
+        }, z.core.$strict>], "kind">;
+        trust_forwarded_proto: z.ZodOptional<z.ZodBoolean>;
+        url: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        auth: z.ZodObject<{
+            client: z.ZodOptional<z.ZodObject<{
+                static_token: z.ZodOptional<z.ZodBoolean>;
+                token_env: z.ZodOptional<z.ZodString>;
+                token_id: z.ZodOptional<z.ZodString>;
+                token_path: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            mode: z.ZodEnum<{
+                none: "none";
+                open: "open";
+                bearer: "bearer";
+            }>;
+            tokens: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                agents: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                id: z.ZodString;
+                secret: z.ZodString;
+                scopes: z.ZodArray<z.ZodEnum<{
+                    observe: "observe";
+                    write: "write";
+                    admin: "admin";
+                    attach: "attach";
+                    pair: "pair";
+                }>>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>;
+        mode: z.ZodLiteral<"external">;
+        url: z.ZodString;
+    }, z.core.$strict>], "mode">;
+}, z.core.$strict>;
+export type TeamNetwork = z.infer<typeof teamNetworkSchema>;
+export type TeamNetworkRoom = z.infer<typeof teamNetworkRoomSchema>;
+export type TeamNetworkServer = z.infer<typeof teamNetworkServerSchema>;
+export type TeamNetworkAuth = z.infer<typeof teamNetworkAuthSchema>;
+export type TeamNetworkStore = z.infer<typeof teamNetworkStoreSchema>;