@genfeedai/workflow-engine 0.2.0

package/dist/workflow-engine/src/executors/saas/tweet-input-executor.js

@@ -0,0 +1,75 @@
+import { BaseExecutor, } from '@workflow-engine/executors/base-executor';
+/**
+ * Tweet Input Executor
+ *
+ * Fetches tweets from Twitter/X via URL or uses manual text input.
+ * Requires Twitter API access for URL fetching mode.
+ *
+ * Node Type: tweetInput
+ * Definition: @genfeedai/workflow-saas/nodes/tweet-input.ts
+ */
+export class TweetInputExecutor extends BaseExecutor {
+    nodeType = 'tweetInput';
+    fetcher = null;
+    setFetcher(fetcher) {
+        this.fetcher = fetcher;
+    }
+    validate(node) {
+        const baseValidation = super.validate(node);
+        const errors = [...baseValidation.errors];
+        const inputMode = node.config.inputMode;
+        if (inputMode === 'url') {
+            const tweetUrl = node.config.tweetUrl;
+            if (!tweetUrl || typeof tweetUrl !== 'string') {
+                errors.push('Tweet URL is required when input mode is "url"');
+            }
+        }
+        else if (inputMode === 'text') {
+            const rawText = node.config.rawText;
+            if (!rawText || typeof rawText !== 'string') {
+                errors.push('Raw text is required when input mode is "text"');
+            }
+        }
+        else {
+            errors.push('Input mode must be "url" or "text"');
+        }
+        return {
+            errors,
+            valid: errors.length === 0,
+        };
+    }
+    async execute(input) {
+        const { node } = input;
+        const inputMode = this.getRequiredConfig(node.config, 'inputMode');
+        if (inputMode === 'text') {
+            const rawText = this.getRequiredConfig(node.config, 'rawText');
+            return {
+                data: rawText,
+                metadata: {
+                    authorHandle: null,
+                    inputMode: 'text',
+                },
+            };
+        }
+        if (!this.fetcher) {
+            throw new Error('Tweet fetcher not configured');
+        }
+        const tweetUrl = this.getRequiredConfig(node.config, 'tweetUrl');
+        const result = await this.fetcher(tweetUrl);
+        return {
+            data: result.text,
+            metadata: {
+                authorHandle: result.authorHandle,
+                inputMode: 'url',
+                tweetId: result.tweetId,
+            },
+        };
+    }
+}
+export function createTweetInputExecutor(fetcher) {
+    const executor = new TweetInputExecutor();
+    if (fetcher) {
+        executor.setFetcher(fetcher);
+    }
+    return executor;
+}

package/dist/workflow-engine/src/executors/saas/tweet-input-executor.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tweet-input-executor.spec.d.ts.map

package/dist/workflow-engine/src/executors/saas/tweet-input-executor.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tweet-input-executor.spec.d.ts","sourceRoot":"","sources":["../../../../../src/executors/saas/tweet-input-executor.spec.ts"],"names":[],"mappings":""}

package/dist/workflow-engine/src/executors/saas/tweet-input-executor.spec.js

@@ -0,0 +1,109 @@
+import { createTweetInputExecutor } from '@workflow-engine/executors/saas/tweet-input-executor';
+import { describe, expect, it, vi } from 'vitest';
+
+const ctx = {
+  organizationId: 'o',
+  runId: 'r',
+  userId: 'u',
+  workflowId: 'w',
+};
+describe('TweetInputExecutor', () => {
+  describe('validate', () => {
+    it('valid url mode', () => {
+      expect(
+        createTweetInputExecutor().validate({
+          config: { inputMode: 'url', tweetUrl: 'https://x.com/1' },
+          id: '1',
+          inputs: [],
+          label: 'T',
+          type: 'tweetInput',
+        }).valid,
+      ).toBe(true);
+    });
+    it('invalid url without tweetUrl', () => {
+      expect(
+        createTweetInputExecutor().validate({
+          config: { inputMode: 'url' },
+          id: '1',
+          inputs: [],
+          label: 'T',
+          type: 'tweetInput',
+        }).valid,
+      ).toBe(false);
+    });
+    it('valid text mode', () => {
+      expect(
+        createTweetInputExecutor().validate({
+          config: { inputMode: 'text', rawText: 'hi' },
+          id: '1',
+          inputs: [],
+          label: 'T',
+          type: 'tweetInput',
+        }).valid,
+      ).toBe(true);
+    });
+    it('invalid without mode', () => {
+      expect(
+        createTweetInputExecutor().validate({
+          config: {},
+          id: '1',
+          inputs: [],
+          label: 'T',
+          type: 'tweetInput',
+        }).valid,
+      ).toBe(false);
+    });
+  });
+  describe('execute', () => {
+    it('returns raw text', async () => {
+      const exec = createTweetInputExecutor();
+      const result = await exec.execute({
+        context: ctx,
+        inputs: new Map(),
+        node: {
+          config: { inputMode: 'text', rawText: 'Hello!' },
+          id: '1',
+          inputs: [],
+          label: 'T',
+          type: 'tweetInput',
+        },
+      });
+      expect(result.data).toBe('Hello!');
+      expect(result.metadata?.inputMode).toBe('text');
+    });
+    it('fetches tweet', async () => {
+      const fetcher = vi
+        .fn()
+        .mockResolvedValue({ authorHandle: '@u', text: 'Hi', tweetId: '1' });
+      const exec = createTweetInputExecutor(fetcher);
+      const result = await exec.execute({
+        context: ctx,
+        inputs: new Map(),
+        node: {
+          config: { inputMode: 'url', tweetUrl: 'https://x.com/1' },
+          id: '1',
+          inputs: [],
+          label: 'T',
+          type: 'tweetInput',
+        },
+      });
+      expect(result.data).toBe('Hi');
+      expect(result.metadata?.authorHandle).toBe('@u');
+    });
+    it('throws without fetcher', async () => {
+      await expect(
+        createTweetInputExecutor().execute({
+          context: ctx,
+          inputs: new Map(),
+          node: {
+            config: { inputMode: 'url', tweetUrl: 'https://x.com/1' },
+            id: '1',
+            inputs: [],
+            label: 'T',
+            type: 'tweetInput',
+          },
+        }),
+      ).rejects.toThrow('fetcher');
+    });
+  });
+});

package/dist/workflow-engine/src/executors/saas/tweet-remix-executor.d.ts

@@ -0,0 +1,39 @@
+import { BaseExecutor, type ExecutorInput, type ExecutorOutput } from '@workflow-engine/executors/base-executor';
+import type { ExecutableNode } from '@workflow-engine/types';
+export type TweetTone = 'professional' | 'casual' | 'witty' | 'viral';
+export interface TweetVariation {
+    id: string;
+    text: string;
+    charCount: number;
+}
+export interface TweetRemixResult {
+    variations: TweetVariation[];
+    selectedText: string;
+}
+export type TweetRemixer = (params: {
+    inputTweet: string;
+    tone: TweetTone;
+    maxLength: number;
+}) => Promise<TweetRemixResult>;
+/**
+ * Tweet Remix Executor
+ *
+ * Generates tweet variations using AI based on tone and length preferences.
+ * Used for social media content creation workflows.
+ *
+ * Node Type: tweetRemix
+ * Definition: @genfeedai/workflow-saas/nodes/tweet-remix.ts
+ */
+export declare class TweetRemixExecutor extends BaseExecutor {
+    readonly nodeType = "tweetRemix";
+    private remixer;
+    setRemixer(remixer: TweetRemixer): void;
+    validate(node: ExecutableNode): {
+        valid: boolean;
+        errors: string[];
+    };
+    estimateCost(_node: ExecutableNode): number;
+    execute(input: ExecutorInput): Promise<ExecutorOutput>;
+}
+export declare function createTweetRemixExecutor(remixer?: TweetRemixer): TweetRemixExecutor;
+//# sourceMappingURL=tweet-remix-executor.d.ts.map

package/dist/workflow-engine/src/executors/saas/tweet-remix-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tweet-remix-executor.d.ts","sourceRoot":"","sources":["../../../../../src/executors/saas/tweet-remix-executor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,KAAK,aAAa,EAClB,KAAK,cAAc,EACpB,MAAM,0CAA0C,CAAC;AAClD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE7D,MAAM,MAAM,SAAS,GAAG,cAAc,GAAG,QAAQ,GAAG,OAAO,GAAG,OAAO,CAAC;AAEtE,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,cAAc,EAAE,CAAC;IAC7B,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,MAAM,YAAY,GAAG,CAAC,MAAM,EAAE;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,SAAS,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;AAEhC;;;;;;;;GAQG;AACH,qBAAa,kBAAmB,SAAQ,YAAY;IAClD,QAAQ,CAAC,QAAQ,gBAAgB;IACjC,OAAO,CAAC,OAAO,CAA6B;IAE5C,UAAU,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;IAIvC,QAAQ,CAAC,IAAI,EAAE,cAAc,GAAG;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE;IA4BpE,YAAY,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM;IAIrC,OAAO,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;CAkC7D;AAED,wBAAgB,wBAAwB,CACtC,OAAO,CAAC,EAAE,YAAY,GACrB,kBAAkB,CAMpB"}

package/dist/workflow-engine/src/executors/saas/tweet-remix-executor.js

@@ -0,0 +1,67 @@
+import { BaseExecutor, } from '@workflow-engine/executors/base-executor';
+/**
+ * Tweet Remix Executor
+ *
+ * Generates tweet variations using AI based on tone and length preferences.
+ * Used for social media content creation workflows.
+ *
+ * Node Type: tweetRemix
+ * Definition: @genfeedai/workflow-saas/nodes/tweet-remix.ts
+ */
+export class TweetRemixExecutor extends BaseExecutor {
+    nodeType = 'tweetRemix';
+    remixer = null;
+    setRemixer(remixer) {
+        this.remixer = remixer;
+    }
+    validate(node) {
+        const baseValidation = super.validate(node);
+        const errors = [...baseValidation.errors];
+        const tone = node.config.tone;
+        if (tone &&
+            !['professional', 'casual', 'witty', 'viral'].includes(tone)) {
+            errors.push('Invalid tone. Must be: professional, casual, witty, or viral');
+        }
+        const maxLength = node.config.maxLength;
+        if (maxLength !== undefined &&
+            (typeof maxLength !== 'number' || maxLength < 1 || maxLength > 500)) {
+            errors.push('Max length must be between 1 and 500');
+        }
+        return {
+            errors,
+            valid: errors.length === 0,
+        };
+    }
+    estimateCost(_node) {
+        return 1; // AI generation costs 1 credit
+    }
+    async execute(input) {
+        const { node, inputs } = input;
+        if (!this.remixer) {
+            throw new Error('Tweet remixer not configured');
+        }
+        const inputTweet = this.getRequiredInput(inputs, 'text');
+        const tone = this.getOptionalConfig(node.config, 'tone', 'professional');
+        const maxLength = this.getOptionalConfig(node.config, 'maxLength', 280);
+        const result = await this.remixer({
+            inputTweet,
+            maxLength,
+            tone,
+        });
+        return {
+            data: result.selectedText,
+            metadata: {
+                tone,
+                variationCount: result.variations.length,
+                variations: result.variations,
+            },
+        };
+    }
+}
+export function createTweetRemixExecutor(remixer) {
+    const executor = new TweetRemixExecutor();
+    if (remixer) {
+        executor.setRemixer(remixer);
+    }
+    return executor;
+}

package/dist/workflow-engine/src/executors/saas/tweet-remix-executor.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tweet-remix-executor.spec.d.ts.map

package/dist/workflow-engine/src/executors/saas/tweet-remix-executor.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tweet-remix-executor.spec.d.ts","sourceRoot":"","sources":["../../../../../src/executors/saas/tweet-remix-executor.spec.ts"],"names":[],"mappings":""}

package/dist/workflow-engine/src/executors/saas/tweet-remix-executor.spec.js

@@ -0,0 +1,94 @@
+import { createTweetRemixExecutor } from '@workflow-engine/executors/saas/tweet-remix-executor';
+import { describe, expect, it, vi } from 'vitest';
+
+const ctx = {
+  organizationId: 'o',
+  runId: 'r',
+  userId: 'u',
+  workflowId: 'w',
+};
+describe('TweetRemixExecutor', () => {
+  describe('validate', () => {
+    it('valid with no config', () => {
+      expect(
+        createTweetRemixExecutor().validate({
+          config: {},
+          id: '1',
+          inputs: [],
+          label: 'TR',
+          type: 'tweetRemix',
+        }).valid,
+      ).toBe(true);
+    });
+    it('invalid tone', () => {
+      expect(
+        createTweetRemixExecutor().validate({
+          config: { tone: 'angry' },
+          id: '1',
+          inputs: [],
+          label: 'TR',
+          type: 'tweetRemix',
+        }).valid,
+      ).toBe(false);
+    });
+    it('invalid maxLength', () => {
+      expect(
+        createTweetRemixExecutor().validate({
+          config: { maxLength: 600 },
+          id: '1',
+          inputs: [],
+          label: 'TR',
+          type: 'tweetRemix',
+        }).valid,
+      ).toBe(false);
+    });
+  });
+  it('estimateCost returns 1', () => {
+    expect(
+      createTweetRemixExecutor().estimateCost({
+        config: {},
+        id: '1',
+        inputs: [],
+        label: 'TR',
+        type: 'tweetRemix',
+      }),
+    ).toBe(1);
+  });
+  describe('execute', () => {
+    it('throws without remixer', async () => {
+      await expect(
+        createTweetRemixExecutor().execute({
+          context: ctx,
+          inputs: new Map([['text', 'hi']]),
+          node: {
+            config: {},
+            id: '1',
+            inputs: [],
+            label: 'TR',
+            type: 'tweetRemix',
+          },
+        }),
+      ).rejects.toThrow('remixer');
+    });
+    it('remixes tweet', async () => {
+      const remixer = vi.fn().mockResolvedValue({
+        selectedText: 'Remix',
+        variations: [{ charCount: 5, id: 'v1', text: 'Remix' }],
+      });
+      const exec = createTweetRemixExecutor(remixer);
+      const result = await exec.execute({
+        context: ctx,
+        inputs: new Map([['text', 'hi']]),
+        node: {
+          config: { tone: 'witty' },
+          id: '1',
+          inputs: [],
+          label: 'TR',
+          type: 'tweetRemix',
+        },
+      });
+      expect(result.data).toBe('Remix');
+      expect(result.metadata?.tone).toBe('witty');
+    });
+  });
+});

package/dist/workflow-engine/src/executors/saas/upscale-executor.d.ts

@@ -0,0 +1,29 @@
+import type { ExecutionContext } from '@workflow-engine/execution/engine';
+import { BaseExecutor, type ExecutorInput, type ExecutorOutput } from '@workflow-engine/executors/base-executor';
+import type { ExecutableNode } from '@workflow-engine/types';
+export interface UpscaleOutput {
+    mediaUrl: string;
+    model: string;
+    scale: string;
+}
+/**
+ * Resolver that upscales media (image or video) using AI.
+ * Injected at runtime from the NestJS service layer (Replicate/Topaz).
+ */
+export type UpscaleResolver = (mediaUrl: string, params: {
+    model: string;
+    scale: string;
+}, context: ExecutionContext, node: ExecutableNode) => Promise<UpscaleOutput>;
+export declare class UpscaleExecutor extends BaseExecutor {
+    readonly nodeType = "upscale";
+    private resolver;
+    setResolver(resolver: UpscaleResolver): void;
+    validate(node: ExecutableNode): {
+        valid: boolean;
+        errors: string[];
+    };
+    estimateCost(_node: ExecutableNode): number;
+    execute(input: ExecutorInput): Promise<ExecutorOutput>;
+}
+export declare function createUpscaleExecutor(): UpscaleExecutor;
+//# sourceMappingURL=upscale-executor.d.ts.map

package/dist/workflow-engine/src/executors/saas/upscale-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upscale-executor.d.ts","sourceRoot":"","sources":["../../../../../src/executors/saas/upscale-executor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAC1E,OAAO,EACL,YAAY,EACZ,KAAK,aAAa,EAClB,KAAK,cAAc,EACpB,MAAM,0CAA0C,CAAC;AAClD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE7D,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,CAC5B,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EACxC,OAAO,EAAE,gBAAgB,EACzB,IAAI,EAAE,cAAc,KACjB,OAAO,CAAC,aAAa,CAAC,CAAC;AAE5B,qBAAa,eAAgB,SAAQ,YAAY;IAC/C,QAAQ,CAAC,QAAQ,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAgC;IAEhD,WAAW,CAAC,QAAQ,EAAE,eAAe,GAAG,IAAI;IAI5C,QAAQ,CAAC,IAAI,EAAE,cAAc,GAAG;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE;IAepE,YAAY,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM;IAIrC,OAAO,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;CA8B7D;AAED,wBAAgB,qBAAqB,IAAI,eAAe,CAEvD"}

package/dist/workflow-engine/src/executors/saas/upscale-executor.js

@@ -0,0 +1,46 @@
+import { BaseExecutor, } from '@workflow-engine/executors/base-executor';
+export class UpscaleExecutor extends BaseExecutor {
+    nodeType = 'upscale';
+    resolver = null;
+    setResolver(resolver) {
+        this.resolver = resolver;
+    }
+    validate(node) {
+        const baseValidation = super.validate(node);
+        const errors = [...baseValidation.errors];
+        const model = node.config.model;
+        if (!model || typeof model !== 'string') {
+            errors.push('Model is required for upscaling');
+        }
+        return {
+            errors,
+            valid: errors.length === 0,
+        };
+    }
+    estimateCost(_node) {
+        return 5;
+    }
+    async execute(input) {
+        const { node, inputs } = input;
+        if (!this.resolver) {
+            throw new Error('Upscale resolver not configured');
+        }
+        const mediaUrl = inputs.get('media');
+        if (!mediaUrl) {
+            throw new Error('Media input is required for upscaling');
+        }
+        const model = this.getRequiredConfig(node.config, 'model');
+        const scale = this.getOptionalConfig(node.config, 'scale', '2x');
+        const result = await this.resolver(mediaUrl, { model, scale }, input.context, node);
+        return {
+            data: result,
+            metadata: {
+                model: result.model,
+                scale: result.scale,
+            },
+        };
+    }
+}
+export function createUpscaleExecutor() {
+    return new UpscaleExecutor();
+}

package/dist/workflow-engine/src/executors/saas/upscale-executor.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=upscale-executor.spec.d.ts.map

package/dist/workflow-engine/src/executors/saas/upscale-executor.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upscale-executor.spec.d.ts","sourceRoot":"","sources":["../../../../../src/executors/saas/upscale-executor.spec.ts"],"names":[],"mappings":""}

package/dist/workflow-engine/src/executors/saas/upscale-executor.spec.js

@@ -0,0 +1,127 @@
+import { createUpscaleExecutor } from '@workflow-engine/executors/saas/upscale-executor';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+function makeNode(configOverrides = {}) {
+  return {
+    config: { model: 'topaz-standard', ...configOverrides },
+    id: 'upscale-1',
+    inputs: [],
+    label: 'Upscale',
+    type: 'upscale',
+  };
+}
+function makeContext() {
+  return {
+    organizationId: 'org-1',
+    runId: 'run-1',
+    userId: 'user-1',
+    workflowId: 'wf-1',
+  };
+}
+function makeInput(configOverrides = {}, inputEntries = []) {
+  return {
+    context: makeContext(),
+    inputs: new Map(inputEntries),
+    node: makeNode(configOverrides),
+  };
+}
+describe('UpscaleExecutor', () => {
+  let executor;
+  let mockResolver;
+  beforeEach(() => {
+    executor = createUpscaleExecutor();
+    mockResolver = vi.fn().mockResolvedValue({
+      mediaUrl: 'https://cdn.example.com/upscaled.png',
+      model: 'topaz-standard',
+      scale: '4x',
+    });
+    executor.setResolver(mockResolver);
+  });
+  describe('validate', () => {
+    it('should pass with valid model', () => {
+      const node = makeNode({ model: 'topaz-standard' });
+      const result = executor.validate(node);
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+    it('should fail when model is missing', () => {
+      const node = makeNode({});
+      delete node.config.model;
+      const result = executor.validate(node);
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain('Model is required for upscaling');
+    });
+    it('should fail when model is not a string', () => {
+      const node = makeNode({ model: 42 });
+      const result = executor.validate(node);
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain('Model is required for upscaling');
+    });
+    it('should fail when node type does not match', () => {
+      const node = makeNode();
+      node.type = 'wrongType';
+      const result = executor.validate(node);
+      expect(result.valid).toBe(false);
+    });
+  });
+  describe('estimateCost', () => {
+    it('should return 5 credits', () => {
+      expect(executor.estimateCost(makeNode())).toBe(5);
+    });
+  });
+  describe('execute', () => {
+    it('should throw when resolver is not configured', async () => {
+      const noResolverExecutor = createUpscaleExecutor();
+      const input = makeInput({}, [
+        ['media', 'https://cdn.example.com/image.png'],
+      ]);
+      await expect(noResolverExecutor.execute(input)).rejects.toThrow(
+        'Upscale resolver not configured',
+      );
+    });
+    it('should throw when media input is missing', async () => {
+      const input = makeInput({}, []);
+      await expect(executor.execute(input)).rejects.toThrow(
+        'Media input is required for upscaling',
+      );
+    });
+    it('should call resolver with correct parameters', async () => {
+      const input = makeInput({ model: 'topaz-standard', scale: '4x' }, [
+        ['media', 'https://cdn.example.com/image.png'],
+      ]);
+      await executor.execute(input);
+      expect(mockResolver).toHaveBeenCalledWith(
+        'https://cdn.example.com/image.png',
+        { model: 'topaz-standard', scale: '4x' },
+        input.context,
+        input.node,
+      );
+    });
+    it('should default scale to 2x when not specified', async () => {
+      const input = makeInput({ model: 'topaz-standard' }, [
+        ['media', 'https://cdn.example.com/image.png'],
+      ]);
+      delete input.node.config.scale;
+      await executor.execute(input);
+      expect(mockResolver).toHaveBeenCalledWith(
+        expect.any(String),
+        { model: 'topaz-standard', scale: '2x' },
+        expect.anything(),
+        expect.anything(),
+      );
+    });
+    it('should return result data and metadata', async () => {
+      const input = makeInput({ model: 'topaz-standard', scale: '4x' }, [
+        ['media', 'https://cdn.example.com/image.png'],
+      ]);
+      const result = await executor.execute(input);
+      expect(result.data).toEqual({
+        mediaUrl: 'https://cdn.example.com/upscaled.png',
+        model: 'topaz-standard',
+        scale: '4x',
+      });
+      expect(result.metadata?.model).toBe('topaz-standard');
+      expect(result.metadata?.scale).toBe('4x');
+    });
+  });
+});

package/dist/workflow-engine/src/executors/saas/video-input-executor.d.ts

@@ -0,0 +1,35 @@
+import { BaseExecutor, type ExecutorInput, type ExecutorOutput } from '@workflow-engine/executors/base-executor';
+import type { ExecutableNode } from '@workflow-engine/types';
+export interface VideoInputResult {
+    videoFiles: string[];
+    totalDuration: number;
+    videoCount: number;
+}
+export type VideoInputValidator = (params: {
+    organizationId: string;
+    videoUrls: string[];
+    maxVideos: number;
+    minClipDuration: number;
+}) => Promise<VideoInputResult>;
+/**
+ * Video Input Executor
+ *
+ * Accepts multiple video URLs as input for beat-synced editing.
+ * Validates and resolves video files, calculates total duration.
+ *
+ * Node Type: videoInput
+ * Definition: @genfeedai/workflow-saas/nodes/video-input.ts
+ */
+export declare class VideoInputExecutor extends BaseExecutor {
+    readonly nodeType = "videoInput";
+    private validator;
+    setValidator(validator: VideoInputValidator): void;
+    validate(node: ExecutableNode): {
+        valid: boolean;
+        errors: string[];
+    };
+    estimateCost(_node: ExecutableNode): number;
+    execute(input: ExecutorInput): Promise<ExecutorOutput>;
+}
+export declare function createVideoInputExecutor(validator?: VideoInputValidator): VideoInputExecutor;
+//# sourceMappingURL=video-input-executor.d.ts.map

package/dist/workflow-engine/src/executors/saas/video-input-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"video-input-executor.d.ts","sourceRoot":"","sources":["../../../../../src/executors/saas/video-input-executor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,KAAK,aAAa,EAClB,KAAK,cAAc,EACpB,MAAM,0CAA0C,CAAC;AAClD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE7D,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,MAAM,mBAAmB,GAAG,CAAC,MAAM,EAAE;IACzC,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;CACzB,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;AAEhC;;;;;;;;GAQG;AACH,qBAAa,kBAAmB,SAAQ,YAAY;IAClD,QAAQ,CAAC,QAAQ,gBAAgB;IACjC,OAAO,CAAC,SAAS,CAAoC;IAErD,YAAY,CAAC,SAAS,EAAE,mBAAmB,GAAG,IAAI;IAIlD,QAAQ,CAAC,IAAI,EAAE,cAAc,GAAG;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE;IA4BpE,YAAY,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM;IAIrC,OAAO,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;CAmD7D;AAED,wBAAgB,wBAAwB,CACtC,SAAS,CAAC,EAAE,mBAAmB,GAC9B,kBAAkB,CAMpB"}