@genfeedai/workflow-engine 0.2.0

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

@@ -0,0 +1,110 @@
+import { createSoundOverlayExecutor } from '@workflow-engine/executors/saas/sound-overlay-executor';
+import { describe, expect, it, vi } from 'vitest';
+
+const ctx = {
+  organizationId: 'o',
+  runId: 'r',
+  userId: 'u',
+  workflowId: 'w',
+};
+describe('SoundOverlayExecutor', () => {
+  describe('validate', () => {
+    it('valid defaults', () => {
+      expect(
+        createSoundOverlayExecutor().validate({
+          config: {},
+          id: '1',
+          inputs: [],
+          label: 'SO',
+          type: 'soundOverlay',
+        }).valid,
+      ).toBe(true);
+    });
+    it('invalid mixMode', () => {
+      expect(
+        createSoundOverlayExecutor().validate({
+          config: { mixMode: 'surround' },
+          id: '1',
+          inputs: [],
+          label: 'SO',
+          type: 'soundOverlay',
+        }).valid,
+      ).toBe(false);
+    });
+    it('invalid audioVolume', () => {
+      expect(
+        createSoundOverlayExecutor().validate({
+          config: { audioVolume: 300 },
+          id: '1',
+          inputs: [],
+          label: 'SO',
+          type: 'soundOverlay',
+        }).valid,
+      ).toBe(false);
+    });
+    it('invalid videoVolume', () => {
+      expect(
+        createSoundOverlayExecutor().validate({
+          config: { videoVolume: -1 },
+          id: '1',
+          inputs: [],
+          label: 'SO',
+          type: 'soundOverlay',
+        }).valid,
+      ).toBe(false);
+    });
+  });
+  it('estimateCost returns 2', () => {
+    expect(
+      createSoundOverlayExecutor().estimateCost({
+        config: {},
+        id: '1',
+        inputs: [],
+        label: 'SO',
+        type: 'soundOverlay',
+      }),
+    ).toBe(2);
+  });
+  describe('execute', () => {
+    it('throws without processor', async () => {
+      await expect(
+        createSoundOverlayExecutor().execute({
+          context: ctx,
+          inputs: new Map([
+            ['videoUrl', 'v'],
+            ['soundUrl', 's'],
+          ]),
+          node: {
+            config: {},
+            id: '1',
+            inputs: [],
+            label: 'SO',
+            type: 'soundOverlay',
+          },
+        }),
+      ).rejects.toThrow('processor');
+    });
+    it('overlays sound', async () => {
+      const processor = vi
+        .fn()
+        .mockResolvedValue({ jobId: 'j', outputVideoUrl: 'http://out.mp4' });
+      const exec = createSoundOverlayExecutor(processor);
+      const result = await exec.execute({
+        context: ctx,
+        inputs: new Map([
+          ['videoUrl', 'v'],
+          ['soundUrl', 's'],
+        ]),
+        node: {
+          config: { mixMode: 'mix' },
+          id: '1',
+          inputs: [],
+          label: 'SO',
+          type: 'soundOverlay',
+        },
+      });
+      expect(result.data).toBe('http://out.mp4');
+      expect(result.metadata?.mixMode).toBe('mix');
+    });
+  });
+});

package/dist/workflow-engine/src/executors/saas/text-to-speech-executor.d.ts

@@ -0,0 +1,34 @@
+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 TtsResult {
+    audioUrl: string;
+    duration: number;
+}
+/**
+ * Resolver that generates speech audio from text using a TTS provider.
+ * The actual implementation is injected at runtime from the NestJS service layer.
+ */
+export type TtsResolver = (text: string, voiceId: string, context: ExecutionContext, node: ExecutableNode) => Promise<TtsResult>;
+/**
+ * Text to Speech Executor
+ *
+ * Converts text input into speech audio using ElevenLabs (or another provider).
+ * Text can come from an upstream input port or from node config.
+ *
+ * Node Type: textToSpeech
+ * Category: ai
+ */
+export declare class TextToSpeechExecutor extends BaseExecutor {
+    readonly nodeType = "textToSpeech";
+    private resolver;
+    setResolver(resolver: TtsResolver): void;
+    validate(node: ExecutableNode): {
+        valid: boolean;
+        errors: string[];
+    };
+    estimateCost(_node: ExecutableNode): number;
+    execute(input: ExecutorInput): Promise<ExecutorOutput>;
+}
+export declare function createTextToSpeechExecutor(): TextToSpeechExecutor;
+//# sourceMappingURL=text-to-speech-executor.d.ts.map

package/dist/workflow-engine/src/executors/saas/text-to-speech-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-to-speech-executor.d.ts","sourceRoot":"","sources":["../../../../../src/executors/saas/text-to-speech-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,SAAS;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,CACxB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,gBAAgB,EACzB,IAAI,EAAE,cAAc,KACjB,OAAO,CAAC,SAAS,CAAC,CAAC;AAExB;;;;;;;;GAQG;AACH,qBAAa,oBAAqB,SAAQ,YAAY;IACpD,QAAQ,CAAC,QAAQ,kBAAkB;IACnC,OAAO,CAAC,QAAQ,CAA4B;IAE5C,WAAW,CAAC,QAAQ,EAAE,WAAW,GAAG,IAAI;IAIxC,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,0BAA0B,IAAI,oBAAoB,CAEjE"}

package/dist/workflow-engine/src/executors/saas/text-to-speech-executor.js

@@ -0,0 +1,56 @@
+import { BaseExecutor, } from '@workflow-engine/executors/base-executor';
+/**
+ * Text to Speech Executor
+ *
+ * Converts text input into speech audio using ElevenLabs (or another provider).
+ * Text can come from an upstream input port or from node config.
+ *
+ * Node Type: textToSpeech
+ * Category: ai
+ */
+export class TextToSpeechExecutor extends BaseExecutor {
+    nodeType = 'textToSpeech';
+    resolver = null;
+    setResolver(resolver) {
+        this.resolver = resolver;
+    }
+    validate(node) {
+        const baseValidation = super.validate(node);
+        const errors = [...baseValidation.errors];
+        const voiceId = node.config.voiceId;
+        if (!voiceId || typeof voiceId !== 'string') {
+            errors.push('Voice ID is required for text to speech');
+        }
+        return {
+            errors,
+            valid: errors.length === 0,
+        };
+    }
+    estimateCost(_node) {
+        return 3;
+    }
+    async execute(input) {
+        const { node, inputs } = input;
+        if (!this.resolver) {
+            throw new Error('TextToSpeech resolver not configured');
+        }
+        // Text can come from input port or config
+        const text = inputs.get('text') ??
+            this.getOptionalConfig(node.config, 'text', '');
+        if (!text) {
+            throw new Error('Text is required: provide via input port or node config');
+        }
+        const voiceId = this.getRequiredConfig(node.config, 'voiceId');
+        const result = await this.resolver(text, voiceId, input.context, node);
+        return {
+            data: result,
+            metadata: {
+                duration: result.duration,
+                voiceId,
+            },
+        };
+    }
+}
+export function createTextToSpeechExecutor() {
+    return new TextToSpeechExecutor();
+}

package/dist/workflow-engine/src/executors/saas/text-to-speech-executor.spec.d.ts

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

package/dist/workflow-engine/src/executors/saas/text-to-speech-executor.spec.d.ts.map

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

package/dist/workflow-engine/src/executors/saas/text-to-speech-executor.spec.js

@@ -0,0 +1,133 @@
+import { createTextToSpeechExecutor } from '@workflow-engine/executors/saas/text-to-speech-executor';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+function makeNode(configOverrides = {}) {
+  return {
+    config: { voiceId: 'voice-abc', ...configOverrides },
+    id: 'tts-1',
+    inputs: [],
+    label: 'Text to Speech',
+    type: 'textToSpeech',
+  };
+}
+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('TextToSpeechExecutor', () => {
+  let executor;
+  let mockResolver;
+  beforeEach(() => {
+    executor = createTextToSpeechExecutor();
+    mockResolver = vi.fn().mockResolvedValue({
+      audioUrl: 'https://cdn.example.com/speech.mp3',
+      duration: 5.2,
+    });
+    executor.setResolver(mockResolver);
+  });
+  describe('validate', () => {
+    it('should pass with valid voiceId', () => {
+      const node = makeNode({ voiceId: 'voice-abc' });
+      const result = executor.validate(node);
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+    it('should fail when voiceId is missing', () => {
+      const node = makeNode({});
+      delete node.config.voiceId;
+      const result = executor.validate(node);
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain(
+        'Voice ID is required for text to speech',
+      );
+    });
+    it('should fail when voiceId is not a string', () => {
+      const node = makeNode({ voiceId: 42 });
+      const result = executor.validate(node);
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain(
+        'Voice ID is required for text to speech',
+      );
+    });
+    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 3 credits', () => {
+      expect(executor.estimateCost(makeNode())).toBe(3);
+    });
+  });
+  describe('execute', () => {
+    it('should throw when resolver is not configured', async () => {
+      const noResolverExecutor = createTextToSpeechExecutor();
+      const input = makeInput({}, [['text', 'Hello world']]);
+      await expect(noResolverExecutor.execute(input)).rejects.toThrow(
+        'TextToSpeech resolver not configured',
+      );
+    });
+    it('should throw when no text is provided from input or config', async () => {
+      const input = makeInput({}, []);
+      delete input.node.config.text;
+      await expect(executor.execute(input)).rejects.toThrow(
+        'Text is required: provide via input port or node config',
+      );
+    });
+    it('should use text from input port', async () => {
+      const input = makeInput({}, [['text', 'Hello from input']]);
+      const result = await executor.execute(input);
+      expect(mockResolver).toHaveBeenCalledWith(
+        'Hello from input',
+        'voice-abc',
+        input.context,
+        input.node,
+      );
+      expect(result.data).toEqual({
+        audioUrl: 'https://cdn.example.com/speech.mp3',
+        duration: 5.2,
+      });
+    });
+    it('should fall back to text from config when input port is absent', async () => {
+      const input = makeInput({ text: 'Hello from config' }, []);
+      await executor.execute(input);
+      expect(mockResolver).toHaveBeenCalledWith(
+        'Hello from config',
+        'voice-abc',
+        input.context,
+        input.node,
+      );
+    });
+    it('should prefer text from input port over config', async () => {
+      const input = makeInput({ text: 'config text' }, [
+        ['text', 'input text'],
+      ]);
+      await executor.execute(input);
+      expect(mockResolver).toHaveBeenCalledWith(
+        'input text',
+        'voice-abc',
+        expect.anything(),
+        expect.anything(),
+      );
+    });
+    it('should return metadata with duration and voiceId', async () => {
+      const input = makeInput({}, [['text', 'Test speech']]);
+      const result = await executor.execute(input);
+      expect(result.metadata?.duration).toBe(5.2);
+      expect(result.metadata?.voiceId).toBe('voice-abc');
+    });
+  });
+});

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

@@ -0,0 +1,44 @@
+import { BaseExecutor, type ExecutorInput, type ExecutorOutput } from '@workflow-engine/executors/base-executor';
+import type { ExecutableNode } from '@workflow-engine/types';
+export type TrendPlatform = 'tiktok' | 'instagram' | 'youtube' | 'twitter';
+export type TrendType = 'video' | 'sound' | 'hashtag';
+export type CheckFrequency = '15min' | '30min' | '1hr' | '6hr' | '24hr';
+export interface TrendTriggerOutput {
+    trendId: string;
+    topic: string;
+    platform: TrendPlatform;
+    viralScore: number;
+    hashtags: string[];
+    videoUrl: string | null;
+    soundId: string | null;
+}
+export type TrendChecker = (params: {
+    organizationId: string;
+    platform: TrendPlatform;
+    trendType: TrendType;
+    minViralScore: number;
+    keywords: string[];
+    excludeKeywords: string[];
+    lastTrendId: string | null;
+}) => Promise<TrendTriggerOutput | null>;
+/**
+ * Trend Trigger Executor
+ *
+ * Starts a workflow when a new trend matches the configured criteria.
+ * Polls trends at configurable intervals and deduplicates to avoid re-triggering.
+ *
+ * Node Type: trendTrigger
+ * Definition: @genfeedai/workflow-saas/nodes/trend-trigger.ts
+ */
+export declare class TrendTriggerExecutor extends BaseExecutor {
+    readonly nodeType = "trendTrigger";
+    private checker;
+    setChecker(checker: TrendChecker): void;
+    validate(node: ExecutableNode): {
+        valid: boolean;
+        errors: string[];
+    };
+    execute(input: ExecutorInput): Promise<ExecutorOutput>;
+}
+export declare function createTrendTriggerExecutor(checker?: TrendChecker): TrendTriggerExecutor;
+//# sourceMappingURL=trend-trigger-executor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"trend-trigger-executor.d.ts","sourceRoot":"","sources":["../../../../../src/executors/saas/trend-trigger-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,aAAa,GAAG,QAAQ,GAAG,WAAW,GAAG,SAAS,GAAG,SAAS,CAAC;AAC3E,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,OAAO,GAAG,SAAS,CAAC;AACtD,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,OAAO,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC;AAExE,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,aAAa,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAED,MAAM,MAAM,YAAY,GAAG,CAAC,MAAM,EAAE;IAClC,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,aAAa,CAAC;IACxB,SAAS,EAAE,SAAS,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B,KAAK,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAAC;AAEzC;;;;;;;;GAQG;AACH,qBAAa,oBAAqB,SAAQ,YAAY;IACpD,QAAQ,CAAC,QAAQ,kBAAkB;IACnC,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;IAyC9D,OAAO,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;CAuE7D;AAED,wBAAgB,0BAA0B,CACxC,OAAO,CAAC,EAAE,YAAY,GACrB,oBAAoB,CAMtB"}

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

@@ -0,0 +1,98 @@
+import { BaseExecutor, } from '@workflow-engine/executors/base-executor';
+/**
+ * Trend Trigger Executor
+ *
+ * Starts a workflow when a new trend matches the configured criteria.
+ * Polls trends at configurable intervals and deduplicates to avoid re-triggering.
+ *
+ * Node Type: trendTrigger
+ * Definition: @genfeedai/workflow-saas/nodes/trend-trigger.ts
+ */
+export class TrendTriggerExecutor extends BaseExecutor {
+    nodeType = 'trendTrigger';
+    checker = null;
+    setChecker(checker) {
+        this.checker = checker;
+    }
+    validate(node) {
+        const baseValidation = super.validate(node);
+        const errors = [...baseValidation.errors];
+        const platform = node.config.platform;
+        const validPlatforms = [
+            'tiktok',
+            'instagram',
+            'youtube',
+            'twitter',
+        ];
+        if (!platform || !validPlatforms.includes(platform)) {
+            errors.push(`Invalid platform. Must be one of: ${validPlatforms.join(', ')}`);
+        }
+        const trendType = node.config.trendType;
+        const validTypes = ['video', 'sound', 'hashtag'];
+        if (!trendType || !validTypes.includes(trendType)) {
+            errors.push(`Invalid trend type. Must be one of: ${validTypes.join(', ')}`);
+        }
+        const minViralScore = node.config.minViralScore;
+        if (minViralScore !== undefined &&
+            (typeof minViralScore !== 'number' ||
+                minViralScore < 0 ||
+                minViralScore > 100)) {
+            errors.push('Min viral score must be between 0 and 100');
+        }
+        return {
+            errors,
+            valid: errors.length === 0,
+        };
+    }
+    async execute(input) {
+        const { node, context } = input;
+        if (!this.checker) {
+            throw new Error('Trend checker not configured');
+        }
+        const platform = this.getRequiredConfig(node.config, 'platform');
+        const trendType = this.getRequiredConfig(node.config, 'trendType');
+        const minViralScore = this.getOptionalConfig(node.config, 'minViralScore', 70);
+        const keywords = this.getOptionalConfig(node.config, 'keywords', []);
+        const excludeKeywords = this.getOptionalConfig(node.config, 'excludeKeywords', []);
+        const lastTrendId = this.getOptionalConfig(node.config, 'lastTrendId', null);
+        const trend = await this.checker({
+            excludeKeywords,
+            keywords,
+            lastTrendId,
+            minViralScore,
+            organizationId: context.organizationId,
+            platform,
+            trendType,
+        });
+        if (!trend) {
+            return {
+                data: null,
+                metadata: {
+                    noNewTrend: true,
+                },
+            };
+        }
+        return {
+            data: {
+                hashtags: trend.hashtags,
+                platform: trend.platform,
+                soundId: trend.soundId,
+                topic: trend.topic,
+                trendId: trend.trendId,
+                videoUrl: trend.videoUrl,
+                viralScore: trend.viralScore,
+            },
+            metadata: {
+                checkedAt: new Date().toISOString(),
+                trendId: trend.trendId,
+            },
+        };
+    }
+}
+export function createTrendTriggerExecutor(checker) {
+    const executor = new TrendTriggerExecutor();
+    if (checker) {
+        executor.setChecker(checker);
+    }
+    return executor;
+}

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

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

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

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

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

@@ -0,0 +1,119 @@
+import { createTrendTriggerExecutor } from '@workflow-engine/executors/saas/trend-trigger-executor';
+import { describe, expect, it, vi } from 'vitest';
+
+const ctx = {
+  organizationId: 'o',
+  runId: 'r',
+  userId: 'u',
+  workflowId: 'w',
+};
+describe('TrendTriggerExecutor', () => {
+  describe('validate', () => {
+    it('valid config', () => {
+      expect(
+        createTrendTriggerExecutor().validate({
+          config: { platform: 'tiktok', trendType: 'video' },
+          id: '1',
+          inputs: [],
+          label: 'T',
+          type: 'trendTrigger',
+        }).valid,
+      ).toBe(true);
+    });
+    it('invalid platform', () => {
+      expect(
+        createTrendTriggerExecutor().validate({
+          config: { platform: 'snap', trendType: 'video' },
+          id: '1',
+          inputs: [],
+          label: 'T',
+          type: 'trendTrigger',
+        }).valid,
+      ).toBe(false);
+    });
+    it('invalid trendType', () => {
+      expect(
+        createTrendTriggerExecutor().validate({
+          config: { platform: 'tiktok', trendType: 'meme' },
+          id: '1',
+          inputs: [],
+          label: 'T',
+          type: 'trendTrigger',
+        }).valid,
+      ).toBe(false);
+    });
+    it('invalid minViralScore', () => {
+      expect(
+        createTrendTriggerExecutor().validate({
+          config: {
+            minViralScore: 150,
+            platform: 'tiktok',
+            trendType: 'video',
+          },
+          id: '1',
+          inputs: [],
+          label: 'T',
+          type: 'trendTrigger',
+        }).valid,
+      ).toBe(false);
+    });
+  });
+  describe('execute', () => {
+    it('throws without checker', async () => {
+      await expect(
+        createTrendTriggerExecutor().execute({
+          context: ctx,
+          inputs: new Map(),
+          node: {
+            config: { platform: 'tiktok', trendType: 'video' },
+            id: '1',
+            inputs: [],
+            label: 'T',
+            type: 'trendTrigger',
+          },
+        }),
+      ).rejects.toThrow('checker');
+    });
+    it('returns trend data', async () => {
+      const checker = vi.fn().mockResolvedValue({
+        hashtags: ['#ai'],
+        platform: 'tiktok',
+        soundId: null,
+        topic: 'AI',
+        trendId: 't-1',
+        videoUrl: null,
+        viralScore: 90,
+      });
+      const exec = createTrendTriggerExecutor(checker);
+      const result = await exec.execute({
+        context: ctx,
+        inputs: new Map(),
+        node: {
+          config: { platform: 'tiktok', trendType: 'video' },
+          id: '1',
+          inputs: [],
+          label: 'T',
+          type: 'trendTrigger',
+        },
+      });
+      expect(result.data.trendId).toBe('t-1');
+    });
+    it('returns null when no trend', async () => {
+      const checker = vi.fn().mockResolvedValue(null);
+      const exec = createTrendTriggerExecutor(checker);
+      const result = await exec.execute({
+        context: ctx,
+        inputs: new Map(),
+        node: {
+          config: { platform: 'tiktok', trendType: 'video' },
+          id: '1',
+          inputs: [],
+          label: 'T',
+          type: 'trendTrigger',
+        },
+      });
+      expect(result.data).toBeNull();
+      expect(result.metadata?.noNewTrend).toBe(true);
+    });
+  });
+});

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

@@ -0,0 +1,30 @@
+import { BaseExecutor, type ExecutorInput, type ExecutorOutput } from '@workflow-engine/executors/base-executor';
+import type { ExecutableNode } from '@workflow-engine/types';
+export type TweetInputMode = 'url' | 'text';
+export interface TweetFetchResult {
+    text: string;
+    authorHandle: string | null;
+    tweetId: string | null;
+}
+export type TweetFetcher = (tweetUrl: string) => Promise<TweetFetchResult>;
+/**
+ * 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 declare class TweetInputExecutor extends BaseExecutor {
+    readonly nodeType = "tweetInput";
+    private fetcher;
+    setFetcher(fetcher: TweetFetcher): void;
+    validate(node: ExecutableNode): {
+        valid: boolean;
+        errors: string[];
+    };
+    execute(input: ExecutorInput): Promise<ExecutorOutput>;
+}
+export declare function createTweetInputExecutor(fetcher?: TweetFetcher): TweetInputExecutor;
+//# sourceMappingURL=tweet-input-executor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tweet-input-executor.d.ts","sourceRoot":"","sources":["../../../../../src/executors/saas/tweet-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,MAAM,cAAc,GAAG,KAAK,GAAG,MAAM,CAAC;AAE5C,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAED,MAAM,MAAM,YAAY,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;AAE3E;;;;;;;;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;IA0B9D,OAAO,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;CAmC7D;AAED,wBAAgB,wBAAwB,CACtC,OAAO,CAAC,EAAE,YAAY,GACrB,kBAAkB,CAMpB"}