@genfeedai/workflow-engine 0.2.0

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

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

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

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

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

@@ -0,0 +1,126 @@
+import { createPublishExecutor } from '@workflow-engine/executors/saas/publish-executor';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+function makeInput(config, inputMap) {
+  const node = {
+    config,
+    id: 'pub-1',
+    inputs: [],
+    label: 'Publish',
+    type: 'publish',
+  };
+  const inputs = new Map(Object.entries(inputMap ?? {}));
+  const context = {
+    organizationId: 'org-1',
+    runId: 'run-1',
+    userId: 'user-1',
+    workflowId: 'wf-1',
+  };
+  return { context, inputs, node };
+}
+describe('PublishExecutor', () => {
+  let executor;
+  let resolver;
+  beforeEach(() => {
+    resolver = vi.fn().mockResolvedValue({
+      platforms: ['twitter'],
+      postIds: ['post-1'],
+      scheduledFor: null,
+      status: 'published',
+    });
+    executor = createPublishExecutor(resolver);
+  });
+  describe('validate', () => {
+    it('returns valid for correct config', () => {
+      const node = {
+        config: {
+          platforms: { twitter: true },
+          schedule: { type: 'immediate' },
+        },
+        id: '1',
+        inputs: [],
+        label: 'Publish',
+        type: 'publish',
+      };
+      expect(executor.validate(node).valid).toBe(true);
+    });
+    it('requires platforms', () => {
+      const node = {
+        config: {},
+        id: '1',
+        inputs: [],
+        label: 'Publish',
+        type: 'publish',
+      };
+      expect(executor.validate(node).valid).toBe(false);
+      expect(executor.validate(node).errors).toContain(
+        'Platforms configuration is required',
+      );
+    });
+    it('requires at least one enabled platform', () => {
+      const node = {
+        config: { platforms: { twitter: false } },
+        id: '1',
+        inputs: [],
+        label: 'P',
+        type: 'publish',
+      };
+      expect(executor.validate(node).valid).toBe(false);
+    });
+    it('requires datetime for scheduled posts', () => {
+      const node = {
+        config: {
+          platforms: { twitter: true },
+          schedule: { type: 'scheduled' },
+        },
+        id: '1',
+        inputs: [],
+        label: 'P',
+        type: 'publish',
+      };
+      expect(executor.validate(node).valid).toBe(false);
+    });
+  });
+  describe('execute', () => {
+    it('throws without resolver', async () => {
+      const exec = createPublishExecutor();
+      const input = makeInput(
+        { platforms: { twitter: true } },
+        { brand: { brandId: 'b-1' }, media: 'img.png' },
+      );
+      await expect(exec.execute(input)).rejects.toThrow('resolver');
+    });
+    it('publishes immediately', async () => {
+      const input = makeInput(
+        { caption: 'Hello', platforms: { twitter: true } },
+        { brand: { brandId: 'b-1' }, media: 'img.png' },
+      );
+      const result = await executor.execute(input);
+      expect(result.metadata?.postCount).toBe(1);
+      expect(resolver).toHaveBeenCalledWith(
+        expect.objectContaining({ brandId: 'b-1', caption: 'Hello' }),
+      );
+    });
+    it('prefers caption from input over config', async () => {
+      const input = makeInput(
+        { caption: 'config', platforms: { twitter: true } },
+        { brand: { brandId: 'b-1' }, caption: 'input', media: 'img' },
+      );
+      await executor.execute(input);
+      expect(resolver).toHaveBeenCalledWith(
+        expect.objectContaining({ caption: 'input' }),
+      );
+    });
+    it('handles scheduled publish', async () => {
+      const input = makeInput(
+        {
+          platforms: { twitter: true },
+          schedule: { datetime: '2025-06-01T12:00:00Z', type: 'scheduled' },
+        },
+        { brand: { brandId: 'b-1' }, media: 'img' },
+      );
+      const result = await executor.execute(input);
+      expect(result.metadata?.scheduledFor).toBeTruthy();
+    });
+  });
+});

package/dist/workflow-engine/src/executors/saas/reframe-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 ReframeOutput {
+    mediaUrl: string;
+    format: string;
+    targetAspectRatio: string;
+}
+/**
+ * Resolver that reframes an image or video to a target aspect ratio.
+ * Injected at runtime from the NestJS service layer (Replicate/Luma).
+ */
+export type ReframeResolver = (mediaUrl: string, params: {
+    format: string;
+    targetAspectRatio: string;
+}, context: ExecutionContext, node: ExecutableNode) => Promise<ReframeOutput>;
+export declare class ReframeExecutor extends BaseExecutor {
+    readonly nodeType = "reframe";
+    private resolver;
+    setResolver(resolver: ReframeResolver): void;
+    validate(node: ExecutableNode): {
+        valid: boolean;
+        errors: string[];
+    };
+    estimateCost(_node: ExecutableNode): number;
+    execute(input: ExecutorInput): Promise<ExecutorOutput>;
+}
+export declare function createReframeExecutor(): ReframeExecutor;
+//# sourceMappingURL=reframe-executor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reframe-executor.d.ts","sourceRoot":"","sources":["../../../../../src/executors/saas/reframe-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,MAAM,EAAE,MAAM,CAAC;IACf,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,CAC5B,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,iBAAiB,EAAE,MAAM,CAAA;CAAE,EACrD,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;CAqC7D;AAED,wBAAgB,qBAAqB,IAAI,eAAe,CAEvD"}

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

@@ -0,0 +1,46 @@
+import { BaseExecutor, } from '@workflow-engine/executors/base-executor';
+export class ReframeExecutor extends BaseExecutor {
+    nodeType = 'reframe';
+    resolver = null;
+    setResolver(resolver) {
+        this.resolver = resolver;
+    }
+    validate(node) {
+        const baseValidation = super.validate(node);
+        const errors = [...baseValidation.errors];
+        const targetAspectRatio = node.config.targetAspectRatio;
+        if (!targetAspectRatio || typeof targetAspectRatio !== 'string') {
+            errors.push('Target aspect ratio is required for reframing');
+        }
+        return {
+            errors,
+            valid: errors.length === 0,
+        };
+    }
+    estimateCost(_node) {
+        return 3;
+    }
+    async execute(input) {
+        const { node, inputs } = input;
+        if (!this.resolver) {
+            throw new Error('Reframe resolver not configured');
+        }
+        const mediaUrl = inputs.get('media');
+        if (!mediaUrl) {
+            throw new Error('Media input is required for reframing');
+        }
+        const targetAspectRatio = this.getRequiredConfig(node.config, 'targetAspectRatio');
+        const format = this.getOptionalConfig(node.config, 'format', 'landscape');
+        const result = await this.resolver(mediaUrl, { format, targetAspectRatio }, input.context, node);
+        return {
+            data: result,
+            metadata: {
+                format: result.format,
+                targetAspectRatio: result.targetAspectRatio,
+            },
+        };
+    }
+}
+export function createReframeExecutor() {
+    return new ReframeExecutor();
+}

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

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

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

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

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

@@ -0,0 +1,132 @@
+import { createReframeExecutor } from '@workflow-engine/executors/saas/reframe-executor';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+function makeNode(configOverrides = {}) {
+  return {
+    config: { targetAspectRatio: '9:16', ...configOverrides },
+    id: 'reframe-1',
+    inputs: [],
+    label: 'Reframe',
+    type: 'reframe',
+  };
+}
+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('ReframeExecutor', () => {
+  let executor;
+  let mockResolver;
+  beforeEach(() => {
+    executor = createReframeExecutor();
+    mockResolver = vi.fn().mockResolvedValue({
+      format: 'portrait',
+      mediaUrl: 'https://cdn.example.com/reframed.mp4',
+      targetAspectRatio: '9:16',
+    });
+    executor.setResolver(mockResolver);
+  });
+  describe('validate', () => {
+    it('should pass with valid targetAspectRatio', () => {
+      const node = makeNode({ targetAspectRatio: '16:9' });
+      const result = executor.validate(node);
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+    it('should fail when targetAspectRatio is missing', () => {
+      const node = makeNode({});
+      delete node.config.targetAspectRatio;
+      const result = executor.validate(node);
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain(
+        'Target aspect ratio is required for reframing',
+      );
+    });
+    it('should fail when targetAspectRatio is not a string', () => {
+      const node = makeNode({ targetAspectRatio: 1.77 });
+      const result = executor.validate(node);
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain(
+        'Target aspect ratio is required for reframing',
+      );
+    });
+    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 = createReframeExecutor();
+      const input = makeInput({}, [
+        ['media', 'https://cdn.example.com/video.mp4'],
+      ]);
+      await expect(noResolverExecutor.execute(input)).rejects.toThrow(
+        'Reframe 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 reframing',
+      );
+    });
+    it('should call resolver with correct parameters', async () => {
+      const input = makeInput(
+        { format: 'portrait', targetAspectRatio: '9:16' },
+        [['media', 'https://cdn.example.com/video.mp4']],
+      );
+      await executor.execute(input);
+      expect(mockResolver).toHaveBeenCalledWith(
+        'https://cdn.example.com/video.mp4',
+        { format: 'portrait', targetAspectRatio: '9:16' },
+        input.context,
+        input.node,
+      );
+    });
+    it('should default format to landscape', async () => {
+      const input = makeInput({ targetAspectRatio: '16:9' }, [
+        ['media', 'https://cdn.example.com/video.mp4'],
+      ]);
+      delete input.node.config.format;
+      await executor.execute(input);
+      expect(mockResolver).toHaveBeenCalledWith(
+        expect.any(String),
+        { format: 'landscape', targetAspectRatio: '16:9' },
+        expect.anything(),
+        expect.anything(),
+      );
+    });
+    it('should return result data and metadata', async () => {
+      const input = makeInput({ targetAspectRatio: '9:16' }, [
+        ['media', 'https://cdn.example.com/video.mp4'],
+      ]);
+      const result = await executor.execute(input);
+      expect(result.data).toEqual({
+        format: 'portrait',
+        mediaUrl: 'https://cdn.example.com/reframed.mp4',
+        targetAspectRatio: '9:16',
+      });
+      expect(result.metadata?.format).toBe('portrait');
+      expect(result.metadata?.targetAspectRatio).toBe('9:16');
+    });
+  });
+});

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

@@ -0,0 +1,38 @@
+import { BaseExecutor, type ExecutorInput, type ExecutorOutput } from '@workflow-engine/executors/base-executor';
+import type { ExecutableNode } from '@workflow-engine/types';
+export type RssInputMode = 'url' | 'text';
+export interface RssFeedItem {
+    title: string;
+    description: string;
+    link: string;
+    pubDate: string | null;
+}
+export interface RssFeedResult {
+    title: string;
+    items: RssFeedItem[];
+}
+export type RssFeedFetcher = (feedUrl: string) => Promise<RssFeedResult>;
+export type RssFeedParser = (rawXml: string) => Promise<RssFeedResult>;
+/**
+ * RSS Input Executor
+ *
+ * Fetches and parses RSS feeds from URL or raw XML.
+ * Used for content aggregation workflows.
+ *
+ * Node Type: rssInput
+ * Definition: @genfeedai/workflow-saas/nodes/rss-input.ts
+ */
+export declare class RssInputExecutor extends BaseExecutor {
+    readonly nodeType = "rssInput";
+    private fetcher;
+    private parser;
+    setFetcher(fetcher: RssFeedFetcher): void;
+    setParser(parser: RssFeedParser): void;
+    validate(node: ExecutableNode): {
+        valid: boolean;
+        errors: string[];
+    };
+    execute(input: ExecutorInput): Promise<ExecutorOutput>;
+}
+export declare function createRssInputExecutor(fetcher?: RssFeedFetcher, parser?: RssFeedParser): RssInputExecutor;
+//# sourceMappingURL=rss-input-executor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rss-input-executor.d.ts","sourceRoot":"","sources":["../../../../../src/executors/saas/rss-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,YAAY,GAAG,KAAK,GAAG,MAAM,CAAC;AAE1C,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAED,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,WAAW,EAAE,CAAC;CACtB;AAED,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,aAAa,CAAC,CAAC;AACzE,MAAM,MAAM,aAAa,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,aAAa,CAAC,CAAC;AAEvE;;;;;;;;GAQG;AACH,qBAAa,gBAAiB,SAAQ,YAAY;IAChD,QAAQ,CAAC,QAAQ,cAAc;IAC/B,OAAO,CAAC,OAAO,CAA+B;IAC9C,OAAO,CAAC,MAAM,CAA8B;IAE5C,UAAU,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI;IAIzC,SAAS,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI;IAItC,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;CAmD7D;AAED,wBAAgB,sBAAsB,CACpC,OAAO,CAAC,EAAE,cAAc,EACxB,MAAM,CAAC,EAAE,aAAa,GACrB,gBAAgB,CASlB"}

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

@@ -0,0 +1,92 @@
+import { BaseExecutor, } from '@workflow-engine/executors/base-executor';
+/**
+ * RSS Input Executor
+ *
+ * Fetches and parses RSS feeds from URL or raw XML.
+ * Used for content aggregation workflows.
+ *
+ * Node Type: rssInput
+ * Definition: @genfeedai/workflow-saas/nodes/rss-input.ts
+ */
+export class RssInputExecutor extends BaseExecutor {
+    nodeType = 'rssInput';
+    fetcher = null;
+    parser = null;
+    setFetcher(fetcher) {
+        this.fetcher = fetcher;
+    }
+    setParser(parser) {
+        this.parser = parser;
+    }
+    validate(node) {
+        const baseValidation = super.validate(node);
+        const errors = [...baseValidation.errors];
+        const inputMode = node.config.inputMode;
+        if (inputMode === 'url') {
+            const feedUrl = node.config.feedUrl;
+            if (!feedUrl || typeof feedUrl !== 'string') {
+                errors.push('Feed URL is required when input mode is "url"');
+            }
+        }
+        else if (inputMode === 'text') {
+            const rawXml = node.config.rawXml;
+            if (!rawXml || typeof rawXml !== 'string') {
+                errors.push('Raw XML 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');
+        const selectedItemIndex = this.getOptionalConfig(node.config, 'selectedItemIndex', 0);
+        let result;
+        if (inputMode === 'url') {
+            if (!this.fetcher) {
+                throw new Error('RSS feed fetcher not configured');
+            }
+            const feedUrl = this.getRequiredConfig(node.config, 'feedUrl');
+            result = await this.fetcher(feedUrl);
+        }
+        else {
+            if (!this.parser) {
+                throw new Error('RSS feed parser not configured');
+            }
+            const rawXml = this.getRequiredConfig(node.config, 'rawXml');
+            result = await this.parser(rawXml);
+        }
+        const selectedItem = result.items[selectedItemIndex];
+        if (!selectedItem) {
+            throw new Error(`No item at index ${selectedItemIndex}. Feed has ${result.items.length} items.`);
+        }
+        return {
+            data: {
+                description: selectedItem.description,
+                link: selectedItem.link,
+                title: selectedItem.title,
+            },
+            metadata: {
+                feedTitle: result.title,
+                inputMode,
+                itemCount: result.items.length,
+                selectedIndex: selectedItemIndex,
+            },
+        };
+    }
+}
+export function createRssInputExecutor(fetcher, parser) {
+    const executor = new RssInputExecutor();
+    if (fetcher) {
+        executor.setFetcher(fetcher);
+    }
+    if (parser) {
+        executor.setParser(parser);
+    }
+    return executor;
+}

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

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

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

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

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

@@ -0,0 +1,140 @@
+import { createRssInputExecutor } from '@workflow-engine/executors/saas/rss-input-executor';
+import { describe, expect, it, vi } from 'vitest';
+
+const ctx = {
+  organizationId: 'org-1',
+  runId: 'run-1',
+  userId: 'user-1',
+  workflowId: 'wf-1',
+};
+const feedResult = {
+  items: [
+    {
+      description: 'Desc 1',
+      link: 'http://1',
+      pubDate: '2025-01-01',
+      title: 'Item 1',
+    },
+    { description: 'Desc 2', link: 'http://2', pubDate: null, title: 'Item 2' },
+  ],
+  title: 'Test Feed',
+};
+function makeInput(config) {
+  return {
+    context: ctx,
+    inputs: new Map(),
+    node: {
+      config,
+      id: 'rss-1',
+      inputs: [],
+      label: 'RSS',
+      type: 'rssInput',
+    },
+  };
+}
+describe('RssInputExecutor', () => {
+  describe('validate', () => {
+    it('valid url mode', () => {
+      expect(
+        createRssInputExecutor().validate({
+          config: { feedUrl: 'http://f.xml', inputMode: 'url' },
+          id: '1',
+          inputs: [],
+          label: 'R',
+          type: 'rssInput',
+        }).valid,
+      ).toBe(true);
+    });
+    it('invalid url mode without url', () => {
+      expect(
+        createRssInputExecutor().validate({
+          config: { inputMode: 'url' },
+          id: '1',
+          inputs: [],
+          label: 'R',
+          type: 'rssInput',
+        }).valid,
+      ).toBe(false);
+    });
+    it('valid text mode', () => {
+      expect(
+        createRssInputExecutor().validate({
+          config: { inputMode: 'text', rawXml: '<rss/>' },
+          id: '1',
+          inputs: [],
+          label: 'R',
+          type: 'rssInput',
+        }).valid,
+      ).toBe(true);
+    });
+    it('invalid without mode', () => {
+      expect(
+        createRssInputExecutor().validate({
+          config: {},
+          id: '1',
+          inputs: [],
+          label: 'R',
+          type: 'rssInput',
+        }).valid,
+      ).toBe(false);
+    });
+  });
+  describe('execute', () => {
+    it('fetches from URL', async () => {
+      const fetcher = vi.fn().mockResolvedValue(feedResult);
+      const exec = createRssInputExecutor(fetcher);
+      const result = await exec.execute(
+        makeInput({ feedUrl: 'http://f.xml', inputMode: 'url' }),
+      );
+      expect(result.data.title).toBe('Item 1');
+      expect(result.metadata?.feedTitle).toBe('Test Feed');
+    });
+    it('parses raw XML', async () => {
+      const parser = vi.fn().mockResolvedValue(feedResult);
+      const exec = createRssInputExecutor(undefined, parser);
+      const result = await exec.execute(
+        makeInput({ inputMode: 'text', rawXml: '<rss/>' }),
+      );
+      expect(result.data.title).toBe('Item 1');
+    });
+    it('selects item by index', async () => {
+      const fetcher = vi.fn().mockResolvedValue(feedResult);
+      const exec = createRssInputExecutor(fetcher);
+      const result = await exec.execute(
+        makeInput({
+          feedUrl: 'http://f.xml',
+          inputMode: 'url',
+          selectedItemIndex: 1,
+        }),
+      );
+      expect(result.data.title).toBe('Item 2');
+    });
+    it('throws on out-of-range index', async () => {
+      const fetcher = vi.fn().mockResolvedValue(feedResult);
+      const exec = createRssInputExecutor(fetcher);
+      await expect(
+        exec.execute(
+          makeInput({
+            feedUrl: 'http://f.xml',
+            inputMode: 'url',
+            selectedItemIndex: 5,
+          }),
+        ),
+      ).rejects.toThrow('No item at index 5');
+    });
+    it('throws without fetcher', async () => {
+      await expect(
+        createRssInputExecutor().execute(
+          makeInput({ feedUrl: 'http://f', inputMode: 'url' }),
+        ),
+      ).rejects.toThrow('fetcher');
+    });
+    it('throws without parser', async () => {
+      await expect(
+        createRssInputExecutor().execute(
+          makeInput({ inputMode: 'text', rawXml: '<rss/>' }),
+        ),
+      ).rejects.toThrow('parser');
+    });
+  });
+});