@kazzle/app 0.1.945 → 0.1.947

package/README.md

@@ -15,7 +15,7 @@ App contracts used to be copied into every generated app repo as vendored files
 the AI stale types. This package replaces the copies with real imports:
 
 ```ts
-import { defineConfig } from '@kazzle/app';
+import { defineApp } from '@kazzle/app';
 import { defineTools } from '@kazzle/app/tools';
 import { kazzleAppVite, kazzleAppPwa } from '@kazzle/app/vite';
 import { registerAppSW } from '@kazzle/app/pwa';
@@ -29,7 +29,7 @@ and the root export must stay tiny and dependency-free.
 
 | Subpath | Owns | Runtime deps |
 |---|---|---|
-| `@kazzle/app` | `defineConfig`, `KazzleConfig` + component/trigger/env types | none |
+| `@kazzle/app` | `defineApp`, `AppDefinition` + component/trigger/env types | none |
 | `@kazzle/app/tools` | `defineTools`, `KazzleTool` types, Zod input helper types | `zod` (peer, type-only) |
 | `@kazzle/app/client` | install-scoped client: per-install secrets, sibling component URLs | none |
 | `@kazzle/app/vite` | `kazzleAppVite` + `kazzleAppPwa` (HOST/PORT + production SW plugins) | `vite` (peer), `vite-plugin-pwa` |

package/dist/definition.d.ts

@@ -0,0 +1,434 @@
+import { z } from 'zod';
+declare const ComponentEnvSchema: z.ZodObject<{
+    collection: z.ZodString;
+    environment: z.ZodString;
+    include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+declare const RuntimeModeSchema: z.ZodObject<{
+    command: z.ZodString;
+    build: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodObject<{
+        collection: z.ZodString;
+        environment: z.ZodString;
+        include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const TriggerSchema: z.ZodObject<{
+    name: z.ZodString;
+    kind: z.ZodEnum<{
+        schedule: "schedule";
+        webhook: "webhook";
+    }>;
+    schedule: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const AppDefinitionComponentSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        process: "process";
+        ui: "ui";
+    }>;
+    path: z.ZodString;
+    env: z.ZodOptional<z.ZodObject<{
+        collection: z.ZodString;
+        environment: z.ZodString;
+        include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    runtime: z.ZodOptional<z.ZodObject<{
+        dev: z.ZodOptional<z.ZodObject<{
+            command: z.ZodString;
+            build: z.ZodOptional<z.ZodString>;
+            env: z.ZodOptional<z.ZodObject<{
+                collection: z.ZodString;
+                environment: z.ZodString;
+                include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        prod: z.ZodOptional<z.ZodObject<{
+            command: z.ZodString;
+            build: z.ZodOptional<z.ZodString>;
+            env: z.ZodOptional<z.ZodObject<{
+                collection: z.ZodString;
+                environment: z.ZodString;
+                include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    processMode: z.ZodOptional<z.ZodEnum<{
+        persistent: "persistent";
+        triggered: "triggered";
+    }>>;
+    triggers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        kind: z.ZodEnum<{
+            schedule: "schedule";
+            webhook: "webhook";
+        }>;
+        schedule: z.ZodOptional<z.ZodString>;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export declare const AppDefinitionSetupFieldSchema: z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    kind: z.ZodEnum<{
+        email: "email";
+        hostname: "hostname";
+        password: "password";
+        select: "select";
+        text: "text";
+        url: "url";
+    }>;
+    required: z.ZodBoolean;
+    secret: z.ZodBoolean;
+    placeholder: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    prefix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    suffix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    pattern: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        value: z.ZodString;
+        label: z.ZodString;
+    }, z.core.$strict>>>;
+    documentationUrl: z.ZodOptional<z.ZodNullable<z.ZodURL>>;
+}, z.core.$strict>;
+export declare const AppDefinitionSetupSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<"none">;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"oauth">;
+    version: z.ZodLiteral<"2.0">;
+    metadata: z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"discovery">;
+        url: z.ZodURL;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"endpoints">;
+        authorizationUrl: z.ZodURL;
+        tokenUrl: z.ZodURL;
+    }, z.core.$strict>]>;
+    scopes: z.ZodArray<z.ZodString>;
+    pkce: z.ZodEnum<{
+        none: "none";
+        required: "required";
+        supported: "supported";
+    }>;
+    authorizationParams: z.ZodRecord<z.ZodString, z.ZodString>;
+    fields: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        kind: z.ZodEnum<{
+            email: "email";
+            hostname: "hostname";
+            password: "password";
+            select: "select";
+            text: "text";
+            url: "url";
+        }>;
+        required: z.ZodBoolean;
+        secret: z.ZodBoolean;
+        placeholder: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        prefix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        suffix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        pattern: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            value: z.ZodString;
+            label: z.ZodString;
+        }, z.core.$strict>>>;
+        documentationUrl: z.ZodOptional<z.ZodNullable<z.ZodURL>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"oauth">;
+    version: z.ZodLiteral<"1.0a">;
+    requestTokenUrl: z.ZodURL;
+    authorizationUrl: z.ZodURL;
+    accessTokenUrl: z.ZodURL;
+    authorizationParams: z.ZodRecord<z.ZodString, z.ZodString>;
+    fields: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        kind: z.ZodEnum<{
+            email: "email";
+            hostname: "hostname";
+            password: "password";
+            select: "select";
+            text: "text";
+            url: "url";
+        }>;
+        required: z.ZodBoolean;
+        secret: z.ZodBoolean;
+        placeholder: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        prefix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        suffix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        pattern: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            value: z.ZodString;
+            label: z.ZodString;
+        }, z.core.$strict>>>;
+        documentationUrl: z.ZodOptional<z.ZodNullable<z.ZodURL>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"form">;
+    fields: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        kind: z.ZodEnum<{
+            email: "email";
+            hostname: "hostname";
+            password: "password";
+            select: "select";
+            text: "text";
+            url: "url";
+        }>;
+        required: z.ZodBoolean;
+        secret: z.ZodBoolean;
+        placeholder: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        prefix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        suffix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        pattern: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            value: z.ZodString;
+            label: z.ZodString;
+        }, z.core.$strict>>>;
+        documentationUrl: z.ZodOptional<z.ZodNullable<z.ZodURL>>;
+    }, z.core.$strict>>;
+    labelField: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>]>;
+export declare const AppDefinitionLaunchSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<"none">;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"component">;
+    component: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"url">;
+    url: z.ZodURL;
+    target: z.ZodEnum<{
+        embedded: "embedded";
+        external: "external";
+    }>;
+}, z.core.$strict>]>;
+export declare const AppDefinitionToolSourceSchema: z.ZodUnion<readonly [z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodLiteral<"file">;
+    path: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodLiteral<"connection_actions">;
+    actions: z.ZodArray<z.ZodString>;
+}, z.core.$strict>]>;
+export declare const AppDefinitionSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    name: z.ZodString;
+    subtitle: z.ZodString;
+    categories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    description: z.ZodObject<{
+        type: z.ZodLiteral<"markdown">;
+        path: z.ZodString;
+    }, z.core.$strict>;
+    version: z.ZodOptional<z.ZodString>;
+    icon: z.ZodOptional<z.ZodString>;
+    accentColor: z.ZodOptional<z.ZodString>;
+    maxInstallations: z.ZodNullable<z.ZodNumber>;
+    setup: z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"none">;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"oauth">;
+        version: z.ZodLiteral<"2.0">;
+        metadata: z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodLiteral<"discovery">;
+            url: z.ZodURL;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"endpoints">;
+            authorizationUrl: z.ZodURL;
+            tokenUrl: z.ZodURL;
+        }, z.core.$strict>]>;
+        scopes: z.ZodArray<z.ZodString>;
+        pkce: z.ZodEnum<{
+            none: "none";
+            required: "required";
+            supported: "supported";
+        }>;
+        authorizationParams: z.ZodRecord<z.ZodString, z.ZodString>;
+        fields: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            kind: z.ZodEnum<{
+                email: "email";
+                hostname: "hostname";
+                password: "password";
+                select: "select";
+                text: "text";
+                url: "url";
+            }>;
+            required: z.ZodBoolean;
+            secret: z.ZodBoolean;
+            placeholder: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            prefix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            suffix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            pattern: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                value: z.ZodString;
+                label: z.ZodString;
+            }, z.core.$strict>>>;
+            documentationUrl: z.ZodOptional<z.ZodNullable<z.ZodURL>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"oauth">;
+        version: z.ZodLiteral<"1.0a">;
+        requestTokenUrl: z.ZodURL;
+        authorizationUrl: z.ZodURL;
+        accessTokenUrl: z.ZodURL;
+        authorizationParams: z.ZodRecord<z.ZodString, z.ZodString>;
+        fields: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            kind: z.ZodEnum<{
+                email: "email";
+                hostname: "hostname";
+                password: "password";
+                select: "select";
+                text: "text";
+                url: "url";
+            }>;
+            required: z.ZodBoolean;
+            secret: z.ZodBoolean;
+            placeholder: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            prefix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            suffix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            pattern: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                value: z.ZodString;
+                label: z.ZodString;
+            }, z.core.$strict>>>;
+            documentationUrl: z.ZodOptional<z.ZodNullable<z.ZodURL>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"form">;
+        fields: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            kind: z.ZodEnum<{
+                email: "email";
+                hostname: "hostname";
+                password: "password";
+                select: "select";
+                text: "text";
+                url: "url";
+            }>;
+            required: z.ZodBoolean;
+            secret: z.ZodBoolean;
+            placeholder: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            prefix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            suffix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            pattern: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                value: z.ZodString;
+                label: z.ZodString;
+            }, z.core.$strict>>>;
+            documentationUrl: z.ZodOptional<z.ZodNullable<z.ZodURL>>;
+        }, z.core.$strict>>;
+        labelField: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>]>;
+    launch: z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"none">;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"component">;
+        component: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"url">;
+        url: z.ZodURL;
+        target: z.ZodEnum<{
+            embedded: "embedded";
+            external: "external";
+        }>;
+    }, z.core.$strict>]>;
+    components: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            process: "process";
+            ui: "ui";
+        }>;
+        path: z.ZodString;
+        env: z.ZodOptional<z.ZodObject<{
+            collection: z.ZodString;
+            environment: z.ZodString;
+            include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        runtime: z.ZodOptional<z.ZodObject<{
+            dev: z.ZodOptional<z.ZodObject<{
+                command: z.ZodString;
+                build: z.ZodOptional<z.ZodString>;
+                env: z.ZodOptional<z.ZodObject<{
+                    collection: z.ZodString;
+                    environment: z.ZodString;
+                    include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            prod: z.ZodOptional<z.ZodObject<{
+                command: z.ZodString;
+                build: z.ZodOptional<z.ZodString>;
+                env: z.ZodOptional<z.ZodObject<{
+                    collection: z.ZodString;
+                    environment: z.ZodString;
+                    include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        processMode: z.ZodOptional<z.ZodEnum<{
+            persistent: "persistent";
+            triggered: "triggered";
+        }>>;
+        triggers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            kind: z.ZodEnum<{
+                schedule: "schedule";
+                webhook: "webhook";
+            }>;
+            schedule: z.ZodOptional<z.ZodString>;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    tools: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodLiteral<"file">;
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodLiteral<"connection_actions">;
+        actions: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>]>>;
+    skills: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        source: z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodLiteral<"file">;
+            path: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"inline">;
+            instructions: z.ZodString;
+        }, z.core.$strict>]>;
+    }, z.core.$strict>>;
+    kazzleAuth: z.ZodOptional<z.ZodEnum<{
+        optional: "optional";
+        required: "required";
+    }>>;
+    webhookUrl: z.ZodOptional<z.ZodURL>;
+    appLogin: z.ZodOptional<z.ZodBoolean>;
+    target: z.ZodOptional<z.ZodEnum<{
+        local: "local";
+        remote: "remote";
+    }>>;
+}, z.core.$strict>;
+export type AppDefinition = z.infer<typeof AppDefinitionSchema>;
+export type AppDefinitionComponent = z.infer<typeof AppDefinitionComponentSchema>;
+export type AppDefinitionComponentEnv = z.infer<typeof ComponentEnvSchema>;
+export type AppDefinitionRuntimeMode = z.infer<typeof RuntimeModeSchema>;
+export type AppDefinitionTrigger = z.infer<typeof TriggerSchema>;
+export type AppDefinitionToolSource = z.infer<typeof AppDefinitionToolSourceSchema>;
+export type AppDefinitionSetup = z.infer<typeof AppDefinitionSetupSchema>;
+export type AppDefinitionSetupField = z.infer<typeof AppDefinitionSetupFieldSchema>;
+export declare function defineApp(definition: AppDefinition): AppDefinition;
+export {};

package/dist/definition.js

@@ -0,0 +1,171 @@
+import { z } from 'zod';
+const ComponentEnvSchema = z.object({
+    collection: z.string().min(1),
+    environment: z.string().min(1),
+    include: z.array(z.string().min(1)).optional(),
+}).strict();
+const RuntimeModeSchema = z.object({
+    command: z.string().min(1),
+    build: z.string().min(1).optional(),
+    env: ComponentEnvSchema.optional(),
+}).strict();
+const TriggerSchema = z.object({
+    name: z.string().regex(/^[a-z][a-z0-9-]*$/),
+    kind: z.enum(['schedule', 'webhook']),
+    schedule: z.string().optional(),
+    path: z.string().startsWith('/').optional(),
+}).strict().superRefine((trigger, ctx) => {
+    if (trigger.kind === 'schedule' && !trigger.schedule) {
+        ctx.addIssue({ code: 'custom', path: ['schedule'], message: 'A schedule trigger requires a cron expression.' });
+    }
+});
+export const AppDefinitionComponentSchema = z.object({
+    name: z.string().min(1),
+    type: z.enum(['ui', 'process']),
+    path: z.string().min(1),
+    env: ComponentEnvSchema.optional(),
+    runtime: z.object({ dev: RuntimeModeSchema.optional(), prod: RuntimeModeSchema.optional() }).strict().optional(),
+    processMode: z.enum(['persistent', 'triggered']).optional(),
+    triggers: z.array(TriggerSchema).optional(),
+}).strict().superRefine((component, ctx) => {
+    const names = new Set();
+    for (const [index, trigger] of (component.triggers ?? []).entries()) {
+        if (component.type !== 'process') {
+            ctx.addIssue({ code: 'custom', path: ['triggers'], message: 'Only process components can declare triggers.' });
+            break;
+        }
+        if (names.has(trigger.name)) {
+            ctx.addIssue({ code: 'custom', path: ['triggers', index, 'name'], message: `Duplicate trigger name "${trigger.name}".` });
+        }
+        names.add(trigger.name);
+        if ((component.processMode ?? 'persistent') === 'persistent' && !trigger.path) {
+            ctx.addIssue({ code: 'custom', path: ['triggers', index, 'path'], message: `Persistent trigger "${trigger.name}" requires a path.` });
+        }
+    }
+});
+export const AppDefinitionSetupFieldSchema = z.object({
+    key: z.string().regex(/^[A-Za-z][A-Za-z0-9_]*$/),
+    label: z.string().min(1),
+    description: z.string().min(1).nullable().optional(),
+    kind: z.enum(['text', 'password', 'url', 'hostname', 'email', 'select']),
+    required: z.boolean(),
+    secret: z.boolean(),
+    placeholder: z.string().nullable().optional(),
+    prefix: z.string().nullable().optional(),
+    suffix: z.string().nullable().optional(),
+    pattern: z.string().nullable().optional(),
+    options: z.array(z.object({ value: z.string(), label: z.string().min(1) }).strict()).optional(),
+    documentationUrl: z.url().nullable().optional(),
+}).strict().superRefine((field, ctx) => {
+    if (field.kind === 'select' && !field.options?.length) {
+        ctx.addIssue({ code: 'custom', path: ['options'], message: `Select field "${field.key}" requires options.` });
+    }
+    if (field.pattern) {
+        try {
+            new RegExp(field.pattern);
+        }
+        catch {
+            ctx.addIssue({ code: 'custom', path: ['pattern'], message: `Field "${field.key}" has an invalid pattern.` });
+        }
+    }
+});
+const OAuthFieldsSchema = z.array(AppDefinitionSetupFieldSchema);
+const OAuth2MetadataSchema = z.union([
+    z.object({ type: z.literal('discovery'), url: z.url() }).strict(),
+    z.object({ type: z.literal('endpoints'), authorizationUrl: z.url(), tokenUrl: z.url() }).strict(),
+]);
+export const AppDefinitionSetupSchema = z.union([
+    z.object({ type: z.literal('none') }).strict(),
+    z.object({
+        type: z.literal('oauth'),
+        version: z.literal('2.0'),
+        metadata: OAuth2MetadataSchema,
+        scopes: z.array(z.string().min(1)),
+        pkce: z.enum(['required', 'supported', 'none']),
+        authorizationParams: z.record(z.string(), z.string()),
+        fields: OAuthFieldsSchema,
+    }).strict(),
+    z.object({
+        type: z.literal('oauth'),
+        version: z.literal('1.0a'),
+        requestTokenUrl: z.url(),
+        authorizationUrl: z.url(),
+        accessTokenUrl: z.url(),
+        authorizationParams: z.record(z.string(), z.string()),
+        fields: OAuthFieldsSchema,
+    }).strict(),
+    z.object({
+        type: z.literal('form'),
+        fields: z.array(AppDefinitionSetupFieldSchema).min(1),
+        labelField: z.string().min(1).nullable(),
+    }).strict().superRefine((setup, ctx) => {
+        const names = new Set();
+        for (const [index, field] of setup.fields.entries()) {
+            if (names.has(field.key))
+                ctx.addIssue({ code: 'custom', path: ['fields', index, 'key'], message: `Duplicate setup field "${field.key}".` });
+            names.add(field.key);
+        }
+        const label = setup.fields.find((field) => field.key === setup.labelField);
+        if (setup.labelField && !label) {
+            ctx.addIssue({ code: 'custom', path: ['labelField'], message: 'Credential label field does not exist.' });
+        }
+        else if (label?.secret) {
+            ctx.addIssue({ code: 'custom', path: ['labelField'], message: 'Credential label field cannot be secret.' });
+        }
+    }),
+]);
+export const AppDefinitionLaunchSchema = z.union([
+    z.object({ type: z.literal('none') }).strict(),
+    z.object({ type: z.literal('component'), component: z.string().min(1) }).strict(),
+    z.object({ type: z.literal('url'), url: z.url(), target: z.enum(['embedded', 'external']) }).strict(),
+]);
+export const AppDefinitionToolSourceSchema = z.union([
+    z.object({ name: z.string().min(1), type: z.literal('file'), path: z.string().min(1) }).strict(),
+    z.object({ name: z.string().min(1), type: z.literal('connection_actions'), actions: z.array(z.string().min(1)).min(1) }).strict(),
+]);
+const SkillSchema = z.object({
+    name: z.string().min(1),
+    source: z.union([
+        z.object({ type: z.literal('file'), path: z.string().min(1) }).strict(),
+        z.object({ type: z.literal('inline'), instructions: z.string().min(1) }).strict(),
+    ]),
+}).strict();
+export const AppDefinitionSchema = z.object({
+    schemaVersion: z.literal(1),
+    name: z.string().min(1),
+    subtitle: z.string().min(1),
+    categories: z.array(z.string().min(1)).optional(),
+    description: z.object({ type: z.literal('markdown'), path: z.string().min(1) }).strict(),
+    version: z.string().min(1).optional(),
+    icon: z.string().min(1).optional(),
+    accentColor: z.string().regex(/^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/).optional(),
+    maxInstallations: z.number().int().positive().nullable(),
+    setup: AppDefinitionSetupSchema,
+    launch: AppDefinitionLaunchSchema,
+    components: z.array(AppDefinitionComponentSchema),
+    tools: z.array(AppDefinitionToolSourceSchema),
+    skills: z.array(SkillSchema),
+    kazzleAuth: z.enum(['optional', 'required']).optional(),
+    webhookUrl: z.url().optional(),
+    appLogin: z.boolean().optional(),
+    target: z.enum(['local', 'remote']).optional(),
+}).strict().superRefine((definition, ctx) => {
+    const components = new Map(definition.components.map((component) => [component.name, component]));
+    if (definition.components.filter((component) => component.type === 'ui').length > 1) {
+        ctx.addIssue({ code: 'custom', path: ['components'], message: 'Only one UI component is allowed.' });
+    }
+    if (definition.launch.type === 'component' && !components.has(definition.launch.component)) {
+        ctx.addIssue({ code: 'custom', path: ['launch', 'component'], message: 'Launch component does not exist.' });
+    }
+    for (const field of ['components', 'tools', 'skills']) {
+        const names = new Set();
+        for (const [index, item] of definition[field].entries()) {
+            if (names.has(item.name))
+                ctx.addIssue({ code: 'custom', path: [field, index, 'name'], message: `Duplicate ${field} name "${item.name}".` });
+            names.add(item.name);
+        }
+    }
+});
+export function defineApp(definition) {
+    return AppDefinitionSchema.parse(definition);
+}