@genfeedai/workflow-engine 0.2.0

package/src/executors/saas/image-gen-executor.ts

@@ -0,0 +1,156 @@
+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 ImageGenOutput {
+  imageUrl: string;
+  imageBuffer?: Buffer;
+  filename?: string;
+  model: string;
+  provider: string;
+}
+
+/**
+ * Resolver that generates an image using the specified model/provider.
+ * The actual implementation is injected at runtime from the NestJS service layer.
+ */
+export type ImageGenResolver = (
+  model: string,
+  params: Record<string, unknown>,
+  context: ExecutionContext,
+  node: ExecutableNode,
+) => Promise<ImageGenOutput>;
+
+export class ImageGenExecutor extends BaseExecutor {
+  readonly nodeType = 'imageGen';
+  private resolver: ImageGenResolver | null = null;
+
+  setResolver(resolver: ImageGenResolver): void {
+    this.resolver = resolver;
+  }
+
+  validate(node: ExecutableNode): { valid: boolean; errors: string[] } {
+    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 image generation');
+    }
+
+    return {
+      errors,
+      valid: errors.length === 0,
+    };
+  }
+
+  estimateCost(_node: ExecutableNode): number {
+    return 5;
+  }
+
+  async execute(input: ExecutorInput): Promise<ExecutorOutput> {
+    const { node, inputs } = input;
+
+    if (!this.resolver) {
+      throw new Error('ImageGen resolver not configured');
+    }
+
+    const model = this.getRequiredConfig<string>(node.config, 'model');
+
+    // Collect params from node config and upstream inputs
+    const prompt =
+      (inputs.get('prompt') as string) ??
+      this.getOptionalConfig<string>(node.config, 'prompt', '');
+    const seed = this.getOptionalConfig<number | undefined>(
+      node.config,
+      'seed',
+      undefined,
+    );
+    const width = this.getOptionalConfig<number>(node.config, 'width', 1024);
+    const height = this.getOptionalConfig<number>(node.config, 'height', 1024);
+    const steps = this.getOptionalConfig<number | undefined>(
+      node.config,
+      'steps',
+      undefined,
+    );
+    const strength = this.getOptionalConfig<number | undefined>(
+      node.config,
+      'strength',
+      undefined,
+    );
+    const cfg = this.getOptionalConfig<number | undefined>(
+      node.config,
+      'cfg',
+      undefined,
+    );
+    const negativePrompt = this.getOptionalConfig<string | undefined>(
+      node.config,
+      'negativePrompt',
+      undefined,
+    );
+    const faceImage =
+      (inputs.get('faceImage') as string) ??
+      this.getOptionalConfig<string | undefined>(
+        node.config,
+        'faceImage',
+        undefined,
+      );
+    const image =
+      (inputs.get('image') as string) ??
+      this.getOptionalConfig<string | undefined>(
+        node.config,
+        'image',
+        undefined,
+      );
+    const style = this.getOptionalConfig<string | undefined>(
+      node.config,
+      'style',
+      undefined,
+    );
+
+    const params: Record<string, unknown> = {
+      brandId: this.getOptionalConfig<string | undefined>(
+        node.config,
+        'brandId',
+        undefined,
+      ),
+      cfg,
+      faceImage,
+      height,
+      negativePrompt,
+      prompt,
+      references: image ? [image] : undefined,
+      seed,
+      steps,
+      strength,
+      style,
+      width,
+    };
+
+    // Remove undefined params
+    for (const key of Object.keys(params)) {
+      if (params[key] === undefined) {
+        delete params[key];
+      }
+    }
+
+    const result = await this.resolver(model, params, input.context, node);
+
+    return {
+      data: result,
+      metadata: {
+        filename: result.filename,
+        model,
+        provider: result.provider,
+      },
+    };
+  }
+}
+
+export function createImageGenExecutor(): ImageGenExecutor {
+  return new ImageGenExecutor();
+}

package/src/executors/saas/index.ts

@@ -0,0 +1,53 @@
+export * from '@workflow-engine/executors/saas/beat-analysis-executor';
+export * from '@workflow-engine/executors/saas/beat-sync-editor-executor';
+export * from '@workflow-engine/executors/saas/brand-asset-executor';
+export * from '@workflow-engine/executors/saas/brand-context-executor';
+export * from '@workflow-engine/executors/saas/brand-executor';
+// Cinematic post-production executors
+export * from '@workflow-engine/executors/saas/cinematic-camera-presets';
+export * from '@workflow-engine/executors/saas/cinematic-color-grade-executor';
+export * from '@workflow-engine/executors/saas/condition-executor';
+export * from '@workflow-engine/executors/saas/delay-executor';
+// Social trigger executors
+export * from '@workflow-engine/executors/saas/engagement-trigger-executor';
+export * from '@workflow-engine/executors/saas/film-grain-executor';
+// AI generation executors
+export * from '@workflow-engine/executors/saas/image-gen-executor';
+export * from '@workflow-engine/executors/saas/keyword-trigger-executor';
+export * from '@workflow-engine/executors/saas/lens-effects-executor';
+// Lip sync executor
+export * from '@workflow-engine/executors/saas/lip-sync-executor';
+export * from '@workflow-engine/executors/saas/mention-trigger-executor';
+export * from '@workflow-engine/executors/saas/music-source-executor';
+export * from '@workflow-engine/executors/saas/new-follower-trigger-executor';
+export * from '@workflow-engine/executors/saas/new-like-trigger-executor';
+export * from '@workflow-engine/executors/saas/new-repost-trigger-executor';
+// Social action executors
+export * from '@workflow-engine/executors/saas/post-reply-executor';
+// Prompt construction executor
+export * from '@workflow-engine/executors/saas/prompt-constructor-executor';
+export * from '@workflow-engine/executors/saas/publish-executor';
+// Reframe executor
+export * from '@workflow-engine/executors/saas/reframe-executor';
+export * from '@workflow-engine/executors/saas/rss-input-executor';
+export * from '@workflow-engine/executors/saas/send-dm-executor';
+export {
+  createSocialPublishExecutor,
+  SocialPublishExecutor,
+  type SocialPublisher,
+  type SocialPublishResult,
+  type SocialVisibility,
+  // Note: SocialPlatform is already exported from publish-executor
+} from '@workflow-engine/executors/saas/social-publish-executor';
+export * from '@workflow-engine/executors/saas/sound-overlay-executor';
+// Text to speech executor
+export * from '@workflow-engine/executors/saas/text-to-speech-executor';
+export * from '@workflow-engine/executors/saas/trend-trigger-executor';
+export * from '@workflow-engine/executors/saas/tweet-input-executor';
+export * from '@workflow-engine/executors/saas/tweet-remix-executor';
+// Upscale executor
+export * from '@workflow-engine/executors/saas/upscale-executor';
+// Beat-synced video editor executors
+export * from '@workflow-engine/executors/saas/video-input-executor';
+// Voice change executor
+export * from '@workflow-engine/executors/saas/voice-change-executor';

package/src/executors/saas/keyword-trigger-executor.spec.ts

@@ -0,0 +1,186 @@
+import type { ExecutionContext } from '@workflow-engine/execution/engine';
+import type { ExecutorInput } from '@workflow-engine/executors/base-executor';
+import {
+  createKeywordTriggerExecutor,
+  type KeywordChecker,
+  type KeywordTriggerExecutor,
+} from '@workflow-engine/executors/saas/keyword-trigger-executor';
+import type { ExecutableNode } from '@workflow-engine/types';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+function makeInput(config: Record<string, unknown>): ExecutorInput {
+  const node: ExecutableNode = {
+    config,
+    id: 'trigger-1',
+    inputs: [],
+    label: 'Keyword Trigger',
+    type: 'keywordTrigger',
+  };
+  const context: ExecutionContext = {
+    organizationId: 'org-1',
+    runId: 'run-1',
+    userId: 'user-1',
+    workflowId: 'wf-1',
+  };
+  return { context, inputs: new Map(), node };
+}
+
+describe('KeywordTriggerExecutor', () => {
+  let executor: KeywordTriggerExecutor;
+  let mockChecker: KeywordChecker;
+
+  beforeEach(() => {
+    executor = createKeywordTriggerExecutor();
+    mockChecker = vi.fn().mockResolvedValue({
+      authorId: 'a-1',
+      authorUsername: 'poster',
+      detectedAt: '2026-02-22T20:00:00Z',
+      matchedKeyword: 'genfeed',
+      platform: 'twitter',
+      postId: 'post-1',
+      postUrl: 'https://x.com/poster/status/post-1',
+      text: 'Check out genfeed for social automation!',
+    });
+    executor.setChecker(mockChecker);
+  });
+
+  it('creates via factory', () => {
+    expect(executor.nodeType).toBe('keywordTrigger');
+  });
+
+  it('throws if checker not configured', async () => {
+    const fresh = createKeywordTriggerExecutor();
+    const input = makeInput({ keywords: ['genfeed'], platform: 'twitter' });
+    await expect(fresh.execute(input)).rejects.toThrow(
+      'checker not configured',
+    );
+  });
+
+  it('returns keyword match data when matched', async () => {
+    const input = makeInput({ keywords: ['genfeed'], platform: 'twitter' });
+    const result = await executor.execute(input);
+    expect(result.metadata).toMatchObject({
+      matched: true,
+      matchedKeyword: 'genfeed',
+      postId: 'post-1',
+    });
+    expect(result.data).toMatchObject({
+      matchedKeyword: 'genfeed',
+      postId: 'post-1',
+    });
+  });
+
+  it('returns null when no match', async () => {
+    (mockChecker as ReturnType<typeof vi.fn>).mockResolvedValue(null);
+    const input = makeInput({ keywords: ['genfeed'], platform: 'twitter' });
+    const result = await executor.execute(input);
+    expect(result.metadata).toMatchObject({ matched: false });
+    expect(result.data).toBeNull();
+  });
+
+  it('passes keywords and match mode to checker', async () => {
+    const input = makeInput({
+      caseSensitive: true,
+      excludeKeywords: ['spam'],
+      keywords: ['genfeed', 'AI'],
+      matchMode: 'exact',
+      platform: 'twitter',
+    });
+    await executor.execute(input);
+    expect(mockChecker).toHaveBeenCalledWith(
+      expect.objectContaining({
+        caseSensitive: true,
+        excludeKeywords: ['spam'],
+        keywords: ['genfeed', 'AI'],
+        matchMode: 'exact',
+      }),
+    );
+  });
+
+  it('uses default match mode and caseSensitive', async () => {
+    const input = makeInput({ keywords: ['genfeed'], platform: 'twitter' });
+    await executor.execute(input);
+    expect(mockChecker).toHaveBeenCalledWith(
+      expect.objectContaining({
+        caseSensitive: false,
+        matchMode: 'contains',
+      }),
+    );
+  });
+
+  it('validates platform', () => {
+    const node: ExecutableNode = {
+      config: { keywords: ['test'], platform: 'tiktok' },
+      id: 't1',
+      inputs: [],
+      label: 'T',
+      type: 'keywordTrigger',
+    };
+    expect(executor.validate(node).valid).toBe(false);
+  });
+
+  it('validates keywords are required', () => {
+    const node: ExecutableNode = {
+      config: { keywords: [], platform: 'twitter' },
+      id: 't1',
+      inputs: [],
+      label: 'T',
+      type: 'keywordTrigger',
+    };
+    const result = executor.validate(node);
+    expect(result.valid).toBe(false);
+    expect(result.errors).toContain('At least one keyword is required');
+  });
+
+  it('validates missing keywords', () => {
+    const node: ExecutableNode = {
+      config: { platform: 'twitter' },
+      id: 't1',
+      inputs: [],
+      label: 'T',
+      type: 'keywordTrigger',
+    };
+    const result = executor.validate(node);
+    expect(result.valid).toBe(false);
+    expect(result.errors).toContain('At least one keyword is required');
+  });
+
+  it('validates match mode', () => {
+    const node: ExecutableNode = {
+      config: { keywords: ['test'], matchMode: 'fuzzy', platform: 'twitter' },
+      id: 't1',
+      inputs: [],
+      label: 'T',
+      type: 'keywordTrigger',
+    };
+    const result = executor.validate(node);
+    expect(result.valid).toBe(false);
+    expect(result.errors[0]).toContain('Invalid match mode');
+  });
+
+  it('accepts valid config', () => {
+    const node: ExecutableNode = {
+      config: {
+        keywords: ['genfeed'],
+        matchMode: 'regex',
+        platform: 'instagram',
+      },
+      id: 't1',
+      inputs: [],
+      label: 'T',
+      type: 'keywordTrigger',
+    };
+    expect(executor.validate(node).valid).toBe(true);
+  });
+
+  it('estimates cost as zero', () => {
+    const node: ExecutableNode = {
+      config: { keywords: ['test'], platform: 'twitter' },
+      id: 't1',
+      inputs: [],
+      label: 'T',
+      type: 'keywordTrigger',
+    };
+    expect(executor.estimateCost(node)).toBe(0);
+  });
+});

package/src/executors/saas/keyword-trigger-executor.ts

@@ -0,0 +1,171 @@
+import {
+  BaseExecutor,
+  type ExecutorInput,
+  type ExecutorOutput,
+} from '@workflow-engine/executors/base-executor';
+import type { ExecutableNode } from '@workflow-engine/types';
+
+// =============================================================================
+// TYPES
+// =============================================================================
+
+export type KeywordTriggerPlatform = 'twitter' | 'instagram' | 'threads';
+
+export type KeywordMatchMode = 'exact' | 'contains' | 'regex';
+
+export interface KeywordTriggerOutput {
+  /** The post/tweet ID containing the keyword match */
+  postId: string;
+  /** URL of the post */
+  postUrl: string;
+  /** Full text of the post */
+  text: string;
+  /** The keyword or phrase that matched */
+  matchedKeyword: string;
+  /** Author user ID */
+  authorId: string;
+  /** Author username */
+  authorUsername: string;
+  /** Platform */
+  platform: KeywordTriggerPlatform;
+  /** Timestamp of the post */
+  detectedAt: string;
+}
+
+export type KeywordChecker = (params: {
+  organizationId: string;
+  platform: KeywordTriggerPlatform;
+  keywords: string[];
+  excludeKeywords: string[];
+  matchMode: KeywordMatchMode;
+  caseSensitive: boolean;
+  lastPostId: string | null;
+}) => Promise<KeywordTriggerOutput | null>;
+
+// =============================================================================
+// EXECUTOR
+// =============================================================================
+
+/**
+ * Keyword Trigger Executor
+ *
+ * Starts a workflow when a keyword or phrase is detected in incoming social posts.
+ * Polls posts at configurable intervals and deduplicates.
+ *
+ * Node Type: keywordTrigger
+ */
+export class KeywordTriggerExecutor extends BaseExecutor {
+  readonly nodeType = 'keywordTrigger';
+  private checker: KeywordChecker | null = null;
+
+  setChecker(checker: KeywordChecker): void {
+    this.checker = checker;
+  }
+
+  validate(node: ExecutableNode): { valid: boolean; errors: string[] } {
+    const baseValidation = super.validate(node);
+    const errors = [...baseValidation.errors];
+
+    const platform = node.config.platform;
+    const validPlatforms: KeywordTriggerPlatform[] = [
+      'twitter',
+      'instagram',
+      'threads',
+    ];
+    if (
+      !platform ||
+      !validPlatforms.includes(platform as KeywordTriggerPlatform)
+    ) {
+      errors.push(
+        `Invalid platform. Must be one of: ${validPlatforms.join(', ')}`,
+      );
+    }
+
+    const keywords = node.config.keywords;
+    if (!Array.isArray(keywords) || keywords.length === 0) {
+      errors.push('At least one keyword is required');
+    }
+
+    const matchMode = node.config.matchMode;
+    const validMatchModes: KeywordMatchMode[] = ['exact', 'contains', 'regex'];
+    if (
+      matchMode !== undefined &&
+      !validMatchModes.includes(matchMode as KeywordMatchMode)
+    ) {
+      errors.push(
+        `Invalid match mode. Must be one of: ${validMatchModes.join(', ')}`,
+      );
+    }
+
+    return { errors, valid: errors.length === 0 };
+  }
+
+  async execute(input: ExecutorInput): Promise<ExecutorOutput> {
+    const { node, context } = input;
+
+    if (!this.checker) {
+      throw new Error('Keyword checker not configured');
+    }
+
+    const platform = this.getRequiredConfig<KeywordTriggerPlatform>(
+      node.config,
+      'platform',
+    );
+    const keywords = this.getRequiredConfig<string[]>(node.config, 'keywords');
+    const excludeKeywords = this.getOptionalConfig<string[]>(
+      node.config,
+      'excludeKeywords',
+      [],
+    );
+    const matchMode = this.getOptionalConfig<KeywordMatchMode>(
+      node.config,
+      'matchMode',
+      'contains',
+    );
+    const caseSensitive = this.getOptionalConfig<boolean>(
+      node.config,
+      'caseSensitive',
+      false,
+    );
+    const lastPostId = this.getOptionalConfig<string | null>(
+      node.config,
+      'lastPostId',
+      null,
+    );
+
+    const result = await this.checker({
+      caseSensitive,
+      excludeKeywords,
+      keywords,
+      lastPostId,
+      matchMode,
+      organizationId: context.organizationId,
+      platform,
+    });
+
+    if (!result) {
+      return {
+        data: null,
+        metadata: { matched: false, platform },
+      };
+    }
+
+    return {
+      data: result,
+      metadata: {
+        matched: true,
+        matchedKeyword: result.matchedKeyword,
+        platform,
+        postId: result.postId,
+      },
+    };
+  }
+
+  estimateCost(_node: ExecutableNode): number {
+    return 0;
+  }
+}
+
+export function createKeywordTriggerExecutor(): KeywordTriggerExecutor {
+  return new KeywordTriggerExecutor();
+}