@viewportai/daemon 0.9.0 → 0.10.0

package/dist/workflows/workflow-schema.d.ts

@@ -1,5 +1,4 @@
 import { z } from 'zod';
-import type { WorkflowInputValue } from './run-types.js';
 export declare const WORKFLOW_SCHEMA_VERSION: "viewport.workflow/v1";
 export declare const WorkflowDefinitionSchema: z.ZodObject<{
     schema: z.ZodLiteral<"viewport.workflow/v1">;
@@ -14,9 +13,40 @@ export declare const WorkflowDefinitionSchema: z.ZodObject<{
             json: "json";
         }>;
         required: z.ZodOptional<z.ZodBoolean>;
-        default: z.ZodOptional<z.ZodType<WorkflowInputValue, unknown, z.core.$ZodTypeInternals<WorkflowInputValue, unknown>>>;
+        default: z.ZodOptional<z.ZodType<import("./run-types.js").WorkflowInputValue, unknown, z.core.$ZodTypeInternals<import("./run-types.js").WorkflowInputValue, unknown>>>;
         description: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>>;
+    triggers: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"manual">;
+        title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("./run-types.js").WorkflowInputValue, unknown, z.core.$ZodTypeInternals<import("./run-types.js").WorkflowInputValue, unknown>>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"webhook">;
+        title: z.ZodOptional<z.ZodString>;
+        provider: z.ZodOptional<z.ZodString>;
+        route: z.ZodOptional<z.ZodString>;
+        eventTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        signature: z.ZodOptional<z.ZodObject<{
+            algorithm: z.ZodEnum<{
+                "hmac-sha256": "hmac-sha256";
+            }>;
+            header: z.ZodString;
+            timestampHeader: z.ZodOptional<z.ZodString>;
+            toleranceSeconds: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        map: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"schedule">;
+        title: z.ZodOptional<z.ZodString>;
+        cron: z.ZodString;
+        timezone: z.ZodOptional<z.ZodString>;
+        missedRun: z.ZodOptional<z.ZodEnum<{
+            skip: "skip";
+            catch_up_once: "catch_up_once";
+            route_to_inbox: "route_to_inbox";
+        }>>;
+    }, z.core.$strict>], "type">>>;
     context: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
         ref: z.ZodString;
         as: z.ZodOptional<z.ZodString>;
@@ -62,6 +92,73 @@ export declare const WorkflowDefinitionSchema: z.ZodObject<{
             worktree: "worktree";
         }>>>;
     }, z.core.$strict>>;
+    runner: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodOptional<z.ZodEnum<{
+            paired_daemon: "paired_daemon";
+            self_hosted_runner: "self_hosted_runner";
+        }>>;
+        target: z.ZodOptional<z.ZodEnum<{
+            local_private: "local_private";
+            local_sandbox: "local_sandbox";
+            managed: "managed";
+            self_hosted: "self_hosted";
+            ci: "ci";
+        }>>;
+        capabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            shell: "shell";
+            resume: "resume";
+            "agent.prompt": "agent.prompt";
+            artifacts: "artifacts";
+            cancel: "cancel";
+            "files.read": "files.read";
+            "files.write": "files.write";
+            "network.egress": "network.egress";
+            secrets: "secrets";
+            worktree: "worktree";
+        }>>>;
+        labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        profile: z.ZodOptional<z.ZodString>;
+        leaseSeconds: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    policies: z.ZodOptional<z.ZodObject<{
+        run: z.ZodOptional<z.ZodObject<{
+            allowed: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            requireOnlineRunner: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        approve: z.ZodOptional<z.ZodObject<{
+            allowed: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            minApprovals: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        sideEffects: z.ZodOptional<z.ZodObject<{
+            requireApproval: z.ZodOptional<z.ZodBoolean>;
+            allowedAdapters: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        maxDurationSeconds: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    notifications: z.ZodOptional<z.ZodObject<{
+        inbox: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            approval_requested: "approval_requested";
+            run_failed: "run_failed";
+            runner_offline: "runner_offline";
+            action_failed: "action_failed";
+        }>>>;
+        email: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            approval_requested: "approval_requested";
+            run_failed: "run_failed";
+            run_completed: "run_completed";
+        }>>>;
+        webhook: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    dataCapture: z.ZodOptional<z.ZodObject<{
+        logs: z.ZodOptional<z.ZodEnum<{
+            compact: "compact";
+            full: "full";
+            off: "off";
+        }>>;
+        artifacts: z.ZodOptional<z.ZodBoolean>;
+        contextEvidence: z.ZodOptional<z.ZodBoolean>;
+        approvalPackets: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
     capabilityRequests: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"secret">;
         ref: z.ZodString;
@@ -84,6 +181,103 @@ export declare const WorkflowDefinitionSchema: z.ZodObject<{
         reason: z.ZodString;
     }, z.core.$strict>], "type">>>;
     nodes: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        needs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        when: z.ZodOptional<z.ZodString>;
+        triggerRule: z.ZodOptional<z.ZodEnum<{
+            all_success: "all_success";
+            all_done: "all_done";
+            one_success: "one_success";
+        }>>;
+        timeoutSeconds: z.ZodOptional<z.ZodNumber>;
+        retry: z.ZodOptional<z.ZodObject<{
+            maxAttempts: z.ZodNumber;
+            backoffSeconds: z.ZodOptional<z.ZodNumber>;
+            transient: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            fatal: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        policy: z.ZodOptional<z.ZodObject<{
+            onFailure: z.ZodOptional<z.ZodEnum<{
+                continue: "continue";
+                halt: "halt";
+                skip_dependents: "skip_dependents";
+            }>>;
+            approvalRequired: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                file: "file";
+                json: "json";
+                artifact: "artifact";
+            }>;
+            description: z.ZodOptional<z.ZodString>;
+            extract: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        artifacts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            path: z.ZodString;
+            type: z.ZodOptional<z.ZodEnum<{
+                file: "file";
+                directory: "directory";
+                patch: "patch";
+                report: "report";
+                log: "log";
+            }>>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            value: z.ZodOptional<z.ZodString>;
+            secret: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        type: z.ZodLiteral<"agent">;
+        prompt: z.ZodString;
+        agent: z.ZodString;
+        provider: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        session: z.ZodOptional<z.ZodObject<{
+            resume: z.ZodOptional<z.ZodBoolean>;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        handoff: z.ZodOptional<z.ZodObject<{
+            artifact: z.ZodOptional<z.ZodString>;
+            summary: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        hooks: z.ZodOptional<z.ZodObject<{
+            PreToolUse: z.ZodOptional<z.ZodObject<{
+                record: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>>;
+            PostToolUse: z.ZodOptional<z.ZodObject<{
+                record: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>>;
+            PostToolUseFailure: z.ZodOptional<z.ZodObject<{
+                record: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>>;
+            PermissionRequest: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                behavior: z.ZodEnum<{
+                    allow: "allow";
+                    deny: "deny";
+                }>;
+                message: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                default: z.ZodOptional<z.ZodObject<{
+                    behavior: z.ZodEnum<{
+                        allow: "allow";
+                        deny: "deny";
+                    }>;
+                    message: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+                tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                    behavior: z.ZodEnum<{
+                        allow: "allow";
+                        deny: "deny";
+                    }>;
+                    message: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>]>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
         title: z.ZodOptional<z.ZodString>;
         needs: z.ZodOptional<z.ZodArray<z.ZodString>>;
         when: z.ZodOptional<z.ZodString>;
@@ -350,7 +544,7 @@ export declare const WorkflowDefinitionSchema: z.ZodObject<{
             secret: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>>;
         type: z.ZodLiteral<"plan">;
-        title: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
         body: z.ZodString;
         summary: z.ZodOptional<z.ZodString>;
         source: z.ZodOptional<z.ZodString>;
@@ -425,6 +619,251 @@ export declare const WorkflowDefinitionSchema: z.ZodObject<{
             waitUntil: z.ZodString;
             description: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>], "type">;
+    }, z.core.$strict>, z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        needs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        when: z.ZodOptional<z.ZodString>;
+        triggerRule: z.ZodOptional<z.ZodEnum<{
+            all_success: "all_success";
+            all_done: "all_done";
+            one_success: "one_success";
+        }>>;
+        timeoutSeconds: z.ZodOptional<z.ZodNumber>;
+        retry: z.ZodOptional<z.ZodObject<{
+            maxAttempts: z.ZodNumber;
+            backoffSeconds: z.ZodOptional<z.ZodNumber>;
+            transient: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            fatal: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        policy: z.ZodOptional<z.ZodObject<{
+            onFailure: z.ZodOptional<z.ZodEnum<{
+                continue: "continue";
+                halt: "halt";
+                skip_dependents: "skip_dependents";
+            }>>;
+            approvalRequired: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                file: "file";
+                json: "json";
+                artifact: "artifact";
+            }>;
+            description: z.ZodOptional<z.ZodString>;
+            extract: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        artifacts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            path: z.ZodString;
+            type: z.ZodOptional<z.ZodEnum<{
+                file: "file";
+                directory: "directory";
+                patch: "patch";
+                report: "report";
+                log: "log";
+            }>>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            value: z.ZodOptional<z.ZodString>;
+            secret: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        type: z.ZodLiteral<"context">;
+        refs: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            ref: z.ZodString;
+            as: z.ZodOptional<z.ZodString>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            description: z.ZodOptional<z.ZodString>;
+            refresh: z.ZodOptional<z.ZodEnum<{
+                manual: "manual";
+                before_run: "before_run";
+                on_demand: "on_demand";
+            }>>;
+        }, z.core.$strict>]>>>;
+        query: z.ZodOptional<z.ZodString>;
+        refresh: z.ZodOptional<z.ZodEnum<{
+            manual: "manual";
+            before_run: "before_run";
+            on_demand: "on_demand";
+        }>>;
+    }, z.core.$strict>, z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        needs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        when: z.ZodOptional<z.ZodString>;
+        triggerRule: z.ZodOptional<z.ZodEnum<{
+            all_success: "all_success";
+            all_done: "all_done";
+            one_success: "one_success";
+        }>>;
+        timeoutSeconds: z.ZodOptional<z.ZodNumber>;
+        retry: z.ZodOptional<z.ZodObject<{
+            maxAttempts: z.ZodNumber;
+            backoffSeconds: z.ZodOptional<z.ZodNumber>;
+            transient: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            fatal: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        policy: z.ZodOptional<z.ZodObject<{
+            onFailure: z.ZodOptional<z.ZodEnum<{
+                continue: "continue";
+                halt: "halt";
+                skip_dependents: "skip_dependents";
+            }>>;
+            approvalRequired: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                file: "file";
+                json: "json";
+                artifact: "artifact";
+            }>;
+            description: z.ZodOptional<z.ZodString>;
+            extract: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        artifacts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            path: z.ZodString;
+            type: z.ZodOptional<z.ZodEnum<{
+                file: "file";
+                directory: "directory";
+                patch: "patch";
+                report: "report";
+                log: "log";
+            }>>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            value: z.ZodOptional<z.ZodString>;
+            secret: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        type: z.ZodLiteral<"condition">;
+        expression: z.ZodString;
+        then: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        else: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>, z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        needs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        when: z.ZodOptional<z.ZodString>;
+        triggerRule: z.ZodOptional<z.ZodEnum<{
+            all_success: "all_success";
+            all_done: "all_done";
+            one_success: "one_success";
+        }>>;
+        timeoutSeconds: z.ZodOptional<z.ZodNumber>;
+        retry: z.ZodOptional<z.ZodObject<{
+            maxAttempts: z.ZodNumber;
+            backoffSeconds: z.ZodOptional<z.ZodNumber>;
+            transient: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            fatal: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        policy: z.ZodOptional<z.ZodObject<{
+            onFailure: z.ZodOptional<z.ZodEnum<{
+                continue: "continue";
+                halt: "halt";
+                skip_dependents: "skip_dependents";
+            }>>;
+            approvalRequired: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                file: "file";
+                json: "json";
+                artifact: "artifact";
+            }>;
+            description: z.ZodOptional<z.ZodString>;
+            extract: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        artifacts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            path: z.ZodString;
+            type: z.ZodOptional<z.ZodEnum<{
+                file: "file";
+                directory: "directory";
+                patch: "patch";
+                report: "report";
+                log: "log";
+            }>>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            value: z.ZodOptional<z.ZodString>;
+            secret: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        type: z.ZodLiteral<"artifact">;
+        name: z.ZodString;
+        from: z.ZodOptional<z.ZodString>;
+        path: z.ZodOptional<z.ZodString>;
+        kind: z.ZodOptional<z.ZodEnum<{
+            url: "url";
+            file: "file";
+            directory: "directory";
+            patch: "patch";
+            report: "report";
+            log: "log";
+        }>>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        needs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        when: z.ZodOptional<z.ZodString>;
+        triggerRule: z.ZodOptional<z.ZodEnum<{
+            all_success: "all_success";
+            all_done: "all_done";
+            one_success: "one_success";
+        }>>;
+        timeoutSeconds: z.ZodOptional<z.ZodNumber>;
+        retry: z.ZodOptional<z.ZodObject<{
+            maxAttempts: z.ZodNumber;
+            backoffSeconds: z.ZodOptional<z.ZodNumber>;
+            transient: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            fatal: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        policy: z.ZodOptional<z.ZodObject<{
+            onFailure: z.ZodOptional<z.ZodEnum<{
+                continue: "continue";
+                halt: "halt";
+                skip_dependents: "skip_dependents";
+            }>>;
+            approvalRequired: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                file: "file";
+                json: "json";
+                artifact: "artifact";
+            }>;
+            description: z.ZodOptional<z.ZodString>;
+            extract: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        artifacts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            path: z.ZodString;
+            type: z.ZodOptional<z.ZodEnum<{
+                file: "file";
+                directory: "directory";
+                patch: "patch";
+                report: "report";
+                log: "log";
+            }>>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            value: z.ZodOptional<z.ZodString>;
+            secret: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        type: z.ZodLiteral<"action">;
+        adapter: z.ZodString;
+        action: z.ZodString;
+        with: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("./run-types.js").WorkflowInputValue, unknown, z.core.$ZodTypeInternals<import("./run-types.js").WorkflowInputValue, unknown>>>>;
+        idempotencyKey: z.ZodOptional<z.ZodString>;
+        requiresApproval: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strict>, z.ZodObject<{
         title: z.ZodOptional<z.ZodString>;
         needs: z.ZodOptional<z.ZodArray<z.ZodString>>;

package/dist/workflows/workflow-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"workflow-schema.d.ts","sourceRoot":"","sources":["../../src/workflows/workflow-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAGzD,eAAO,MAAM,uBAAuB,EAAG,sBAA+B,CAAC;AAuTvE,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAa1B,CAAC"}
+{"version":3,"file":"workflow-schema.d.ts","sourceRoot":"","sources":["../../src/workflows/workflow-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAsBxB,eAAO,MAAM,uBAAuB,EAAG,sBAA+B,CAAC;AA0RvE,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkB1B,CAAC"}

package/dist/workflows/workflow-schema.js

@@ -1,55 +1,8 @@
 import { z } from 'zod';
 import { CapabilityRequestSchema, ExecutorRequirementSchema } from './workflow-executor-schema.js';
+import { ArtifactDefinitionSchema, ContextSchema, EnvValueSchema, identifierSchema, InputDefinitionSchema, InputValueSchema, NodePolicySchema, OutputDefinitionSchema, RequiresSchema, RetryPolicySchema, } from './workflow-schema-common.js';
+import { WorkflowDataCaptureDefinitionSchema, WorkflowNotificationDefinitionSchema, WorkflowPolicyDefinitionSchema, WorkflowRunnerRequirementSchema, WorkflowTriggerDefinitionSchema, } from './workflow-production-schema.js';
 export const WORKFLOW_SCHEMA_VERSION = 'viewport.workflow/v1';
-const InputValueSchema = z.lazy(() => z.union([
-    z.string(),
-    z.number(),
-    z.boolean(),
-    z.null(),
-    z.array(InputValueSchema),
-    z.record(z.string(), InputValueSchema),
-]));
-const InputDefinitionSchema = z
-    .object({
-    type: z.enum(['string', 'number', 'boolean', 'json']),
-    required: z.boolean().optional(),
-    default: InputValueSchema.optional(),
-    description: z.string().optional(),
-})
-    .strict();
-const identifierSchema = z
-    .string()
-    .trim()
-    .min(1)
-    .regex(/^[a-zA-Z0-9._/-]+$/);
-const OutputDefinitionSchema = z
-    .object({
-    type: z.enum(['string', 'number', 'boolean', 'json', 'file', 'artifact']),
-    description: z.string().optional(),
-    extract: z.string().trim().min(1).optional(),
-})
-    .strict();
-const ArtifactDefinitionSchema = z
-    .object({
-    path: z.string().trim().min(1),
-    type: z.enum(['file', 'directory', 'patch', 'report', 'log']).optional(),
-    description: z.string().optional(),
-})
-    .strict();
-const RetryPolicySchema = z
-    .object({
-    maxAttempts: z.number().int().min(1).max(10),
-    backoffSeconds: z.number().int().min(0).max(86_400).optional(),
-    transient: z.array(z.string().min(1)).optional(),
-    fatal: z.array(z.string().min(1)).optional(),
-})
-    .strict();
-const NodePolicySchema = z
-    .object({
-    onFailure: z.enum(['halt', 'continue', 'skip_dependents']).optional(),
-    approvalRequired: z.boolean().optional(),
-})
-    .strict();
 const HookRecordSchema = z
     .object({
     record: z.boolean().optional(),
@@ -119,33 +72,6 @@ const GateDefinitionSchema = z.discriminatedUnion('type', [
     })
         .strict(),
 ]);
-const EnvValueSchema = z
-    .object({
-    value: z.string().optional(),
-    secret: identifierSchema.optional(),
-})
-    .strict()
-    .refine((entry) => Boolean(entry.value) !== Boolean(entry.secret), {
-    message: 'Set exactly one of value or secret.',
-});
-const RequiresSchema = z
-    .object({
-    agents: z.array(z.string().trim().min(1)).optional(),
-    tools: z.array(z.string().trim().min(1)).optional(),
-    integrations: z.array(z.string().trim().min(1)).optional(),
-    secrets: z.array(identifierSchema).optional(),
-})
-    .strict();
-const ContextReferenceSchema = z
-    .object({
-    ref: z.string().trim().min(1),
-    as: identifierSchema.optional(),
-    required: z.boolean().optional(),
-    description: z.string().optional(),
-    refresh: z.enum(['manual', 'before_run', 'on_demand']).optional(),
-})
-    .strict();
-const ContextSchema = z.array(z.union([z.string().trim().min(1), ContextReferenceSchema]));
 const TriggerRuleSchema = z.enum(['all_success', 'all_done', 'one_success']);
 const NodeBaseSchema = z.object({
     title: z.string().trim().min(1).optional(),
@@ -169,6 +95,28 @@ const PromptNodeSchema = NodeBaseSchema.extend({
     agents: z.record(identifierSchema, InlineAgentDefinitionSchema).optional(),
     inlineAgentFailurePolicy: z.enum(['fail', 'continue']).optional(),
 }).strict();
+const AgentNodeSchema = NodeBaseSchema.extend({
+    type: z.literal('agent'),
+    prompt: z.string().trim().min(1),
+    agent: z.string().trim().min(1),
+    provider: z.string().trim().min(1).optional(),
+    model: z.string().trim().min(1).optional(),
+    session: z
+        .object({
+        resume: z.boolean().optional(),
+        title: z.string().trim().min(1).optional(),
+    })
+        .strict()
+        .optional(),
+    handoff: z
+        .object({
+        artifact: identifierSchema.optional(),
+        summary: z.string().trim().min(1).optional(),
+    })
+        .strict()
+        .optional(),
+    hooks: HookRulesSchema.optional(),
+}).strict();
 const ShellNodeSchema = NodeBaseSchema.extend({
     type: z.literal('shell'),
     command: z.string().trim().min(1),
@@ -198,7 +146,7 @@ const ApprovalNodeSchema = NodeBaseSchema.extend({
 }).strict();
 const PlanNodeSchema = NodeBaseSchema.extend({
     type: z.literal('plan'),
-    title: z.string().trim().min(1),
+    title: z.string().trim().min(1).optional(),
     body: z.string().trim().min(1),
     summary: z.string().trim().min(1).optional(),
     source: z.string().trim().min(1).optional(),
@@ -209,6 +157,34 @@ const GateNodeSchema = NodeBaseSchema.extend({
     type: z.literal('gate'),
     gate: GateDefinitionSchema,
 }).strict();
+const ContextNodeSchema = NodeBaseSchema.extend({
+    type: z.literal('context'),
+    refs: ContextSchema.optional(),
+    query: z.string().trim().min(1).optional(),
+    refresh: z.enum(['manual', 'before_run', 'on_demand']).optional(),
+}).strict();
+const ConditionNodeSchema = NodeBaseSchema.extend({
+    type: z.literal('condition'),
+    expression: z.string().trim().min(1),
+    then: z.array(identifierSchema).optional(),
+    else: z.array(identifierSchema).optional(),
+}).strict();
+const ArtifactNodeSchema = NodeBaseSchema.extend({
+    type: z.literal('artifact'),
+    name: identifierSchema,
+    from: z.string().trim().min(1).optional(),
+    path: z.string().trim().min(1).optional(),
+    kind: z.enum(['file', 'directory', 'patch', 'report', 'log', 'url']).optional(),
+    description: z.string().optional(),
+}).strict();
+const ActionNodeSchema = NodeBaseSchema.extend({
+    type: z.literal('action'),
+    adapter: identifierSchema,
+    action: identifierSchema,
+    with: z.record(identifierSchema, InputValueSchema).optional(),
+    idempotencyKey: z.string().trim().min(1).optional(),
+    requiresApproval: z.boolean().optional(),
+}).strict();
 const LoopBodySchema = z.discriminatedUnion('type', [
     z
         .object({
@@ -269,11 +245,16 @@ const SubflowNodeSchema = NodeBaseSchema.extend({
     inputs: z.record(identifierSchema, z.string().trim().min(1)).optional(),
 }).strict();
 const WorkflowNodeSchema = z.discriminatedUnion('type', [
+    AgentNodeSchema,
     PromptNodeSchema,
     ShellNodeSchema,
     ApprovalNodeSchema,
     PlanNodeSchema,
     GateNodeSchema,
+    ContextNodeSchema,
+    ConditionNodeSchema,
+    ArtifactNodeSchema,
+    ActionNodeSchema,
     LoopNodeSchema,
     SubflowNodeSchema,
 ]);
@@ -284,9 +265,14 @@ export const WorkflowDefinitionSchema = z
     title: z.string().trim().min(1).optional(),
     description: z.string().optional(),
     inputs: z.record(z.string(), InputDefinitionSchema).optional(),
+    triggers: z.array(WorkflowTriggerDefinitionSchema).optional(),
     context: ContextSchema.optional(),
     requires: RequiresSchema.optional(),
     executor: ExecutorRequirementSchema.optional(),
+    runner: WorkflowRunnerRequirementSchema.optional(),
+    policies: WorkflowPolicyDefinitionSchema.optional(),
+    notifications: WorkflowNotificationDefinitionSchema.optional(),
+    dataCapture: WorkflowDataCaptureDefinitionSchema.optional(),
     capabilityRequests: z.array(CapabilityRequestSchema).optional(),
     nodes: z.record(z.string().trim().min(1), WorkflowNodeSchema),
 })