@framers/agentos-ext-tool-multi-channel-post 0.1.0 → 0.1.1

package/manifest.json

@@ -2,12 +2,12 @@
   "$schema": "https://agentos.sh/schemas/extension-manifest-v1.json",
   "id": "com.framers.tools.multi-channel-post",
   "name": "Multi-Channel Post Tool",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Publish adapted content to multiple social platforms simultaneously. Handles platform-specific content adaptation, media format validation, and per-platform result tracking.",
   "author": {
     "name": "Frame.dev",
     "email": "support@frame.dev",
-    "url": "https://github.com/framersai"
+    "url": "https://github.com/framerslab"
   },
   "license": "MIT",
   "keywords": ["social", "multi-channel", "cross-platform", "posting", "content-adaptation"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@framers/agentos-ext-tool-multi-channel-post",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Cross-platform social media posting tool — publish adapted content to multiple platforms in a single operation.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -37,30 +37,37 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/framersai/agentos-extensions.git",
+    "url": "git+https://github.com/framerslab/agentos-extensions.git",
     "directory": "registry/curated/tools/multi-channel-post"
   },
   "publishConfig": {
     "access": "public"
   },
   "peerDependencies": {
-    "@framers/agentos": "^0.5.2"
+    "@framers/agentos": ">=0.10.40"
   },
   "devDependencies": {
-    "@framers/agentos": "^0.6.6",
     "@types/node": "^20.12.12",
-    "@vitest/coverage-v8": "^1.6.0",
+    "@vitest/coverage-v8": "^3.2.7",
     "rimraf": "^5.0.7",
     "typescript": "^5.4.5",
-    "vitest": "^1.6.0"
+    "vitest": "^3.2.7",
+    "@framers/agentos": "^0.10.40"
   },
+  "homepage": "https://github.com/framerslab/agentos-extensions/tree/master/registry/curated/tools/multi-channel-post#readme",
+  "bugs": {
+    "url": "https://github.com/framerslab/agentos-extensions/issues"
+  },
+  "files": [
+    "dist",
+    "manifest.json"
+  ],
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",
-    "test": "vitest run",
+    "test": "vitest run --passWithNoTests",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
-    "lint": "eslint src --ext .ts",
     "typecheck": "tsc --noEmit",
     "clean": "rimraf dist"
   }

package/src/MultiChannelPostTool.ts

@@ -1,491 +0,0 @@
-// @ts-nocheck
-/**
- * @fileoverview Multi-Channel Post Tool — publish adapted content to N platforms.
- *
- * This tool acts as an orchestrator that delegates to per-platform post tools
- * (twitterPost, instagramPost, linkedinPost, etc.) and aggregates results.
- * It adapts content for each platform's constraints before posting.
- */
-
-/* ------------------------------------------------------------------ */
-/*  Types                                                              */
-/* ------------------------------------------------------------------ */
-
-export interface MultiChannelPostInput {
-  /** Base content to publish. */
-  content: string;
-  /** Target platforms (e.g., ['twitter', 'linkedin', 'instagram']). */
-  platforms: string[];
-  /** Optional per-platform content overrides. */
-  adaptations?: Record<string, string>;
-  /** Optional media URLs to attach. */
-  mediaUrls?: string[];
-  /** Optional per-platform argument overrides passed to the platform tool. */
-  platformConfigs?: Record<string, Record<string, unknown>>;
-  /** Optional hashtags to include (adapted per platform). */
-  hashtags?: string[];
-  /** Optional: if true, don't actually post — just show adapted content. */
-  dryRun?: boolean;
-}
-
-export interface PlatformPostResult {
-  platform: string;
-  success: boolean;
-  postId?: string;
-  url?: string;
-  adaptedContent?: string;
-  error?: string;
-}
-
-export interface MultiChannelPostOutput {
-  totalPlatforms: number;
-  successful: number;
-  failed: number;
-  results: PlatformPostResult[];
-}
-
-/* ------------------------------------------------------------------ */
-/*  Tool executor callback type                                        */
-/* ------------------------------------------------------------------ */
-
-export type ToolExecutorFn = (
-  toolName: string,
-  args: Record<string, unknown>,
-) => Promise<{ success: boolean; data?: Record<string, unknown>; error?: string }>;
-
-/* ------------------------------------------------------------------ */
-/*  MultiChannelPostTool                                               */
-/* ------------------------------------------------------------------ */
-
-export class MultiChannelPostTool {
-  readonly id = 'multiChannelPost';
-  readonly name = 'multiChannelPost';
-  readonly displayName = 'Post to Multiple Platforms';
-  readonly description =
-    'Publish content to multiple social media platforms simultaneously with automatic ' +
-    'platform-specific content adaptation. Supports Twitter, Instagram, Reddit, YouTube, ' +
-    'TikTok, Pinterest, LinkedIn, Facebook, Threads, Bluesky, Mastodon.';
-  readonly category = 'social';
-  readonly version = '0.1.0';
-  readonly hasSideEffects = true;
-
-  readonly inputSchema = {
-    type: 'object' as const,
-    properties: {
-      content: {
-        type: 'string',
-        description: 'Base content text to publish across platforms',
-      },
-      platforms: {
-        type: 'array',
-        items: { type: 'string' },
-        description:
-          'Target platforms: twitter, instagram, reddit, youtube, tiktok, pinterest, linkedin, facebook, threads, bluesky, mastodon',
-      },
-      adaptations: {
-        type: 'object',
-        additionalProperties: { type: 'string' },
-        description: 'Optional per-platform content overrides (platform name -> custom text)',
-      },
-      mediaUrls: {
-        type: 'array',
-        items: { type: 'string' },
-        description: 'Media URLs or file paths to attach',
-      },
-      platformConfigs: {
-        type: 'object',
-        additionalProperties: {
-          type: 'object',
-          additionalProperties: true,
-        },
-        description:
-          'Optional per-platform tool argument overrides (e.g. subreddit, boardId, videoUrl, communityId).',
-      },
-      hashtags: {
-        type: 'array',
-        items: { type: 'string' },
-        description: 'Hashtags to include (adapted per platform conventions)',
-      },
-      dryRun: {
-        type: 'boolean',
-        description: 'If true, return adapted content without posting',
-      },
-    },
-    required: ['content', 'platforms'],
-  };
-
-  /* -------------------------------------------------------------- */
-  /*  Platform metadata                                              */
-  /* -------------------------------------------------------------- */
-
-  /** Platform character limits for basic truncation. */
-  private static readonly PLATFORM_LIMITS: Record<string, number> = {
-    twitter: 280,
-    threads: 500,
-    bluesky: 300,
-    mastodon: 500,
-    farcaster: 320,
-    instagram: 2200,
-    tiktok: 2200,
-    pinterest: 500,
-    linkedin: 3000,
-    facebook: 63206,
-    reddit: 40000,
-    youtube: 5000,
-    devto: 100000,
-    medium: 100000,
-  };
-
-  /** Platform hashtag conventions. */
-  private static readonly HASHTAG_STYLE: Record<string, 'inline' | 'footer' | 'none'> = {
-    twitter: 'inline',
-    instagram: 'footer',
-    linkedin: 'footer',
-    facebook: 'inline',
-    threads: 'inline',
-    mastodon: 'inline',
-    tiktok: 'inline',
-    reddit: 'none',
-    bluesky: 'none',
-    pinterest: 'none',
-    youtube: 'inline',
-  };
-
-  /** Platform name -> per-platform post tool name. */
-  private static readonly TOOL_NAME_MAP: Record<string, string> = {
-    twitter: 'twitterPost',
-    instagram: 'instagramPost',
-    reddit: 'redditSubmitPost',
-    youtube: 'youtubeUpload',
-    tiktok: 'tiktokUpload',
-    pinterest: 'pinterestPin',
-    linkedin: 'linkedinPost',
-    facebook: 'facebookPost',
-    threads: 'threadsPost',
-    bluesky: 'blueskyPost',
-    mastodon: 'mastodonPost',
-    farcaster: 'farcasterCast',
-    lemmy: 'lemmyPost',
-  };
-
-  /* -------------------------------------------------------------- */
-  /*  Tool executor — set by the orchestrator that loads this ext    */
-  /* -------------------------------------------------------------- */
-
-  private toolExecutor?: ToolExecutorFn;
-
-  setToolExecutor(executor: ToolExecutorFn): void {
-    this.toolExecutor = executor;
-  }
-
-  /* -------------------------------------------------------------- */
-  /*  execute()                                                      */
-  /* -------------------------------------------------------------- */
-
-  async execute(
-    args: MultiChannelPostInput,
-  ): Promise<{ success: boolean; data?: MultiChannelPostOutput; error?: string }> {
-    const results: PlatformPostResult[] = [];
-
-    for (const platform of args.platforms) {
-      const adaptedContent =
-        args.adaptations?.[platform] ??
-        this.adaptForPlatform(args.content, platform, args.hashtags);
-
-      // Dry-run mode: collect adapted content without posting.
-      if (args.dryRun) {
-        results.push({ platform, success: true, adaptedContent });
-        continue;
-      }
-
-      try {
-        const toolName = this.getPostToolName(platform);
-        const toolArgs = this.buildToolArgs(
-          platform,
-          adaptedContent,
-          args.mediaUrls,
-          args.platformConfigs?.[platform],
-        );
-
-        if (this.toolExecutor) {
-          const result = await this.toolExecutor(toolName, toolArgs);
-          results.push({
-            platform,
-            success: result.success,
-            postId: (result.data?.id ?? result.data?.postId) as string | undefined,
-            url: result.data?.url as string | undefined,
-            adaptedContent,
-            error: result.error,
-          });
-        } else {
-          results.push({
-            platform,
-            success: false,
-            adaptedContent,
-            error: `No tool executor available. Platform tool "${toolName}" cannot be invoked.`,
-          });
-        }
-      } catch (err: unknown) {
-        const message = err instanceof Error ? err.message : String(err);
-        results.push({
-          platform,
-          success: false,
-          adaptedContent,
-          error: message,
-        });
-      }
-    }
-
-    const successful = results.filter((r) => r.success).length;
-
-    return {
-      success: successful > 0,
-      data: {
-        totalPlatforms: args.platforms.length,
-        successful,
-        failed: args.platforms.length - successful,
-        results,
-      },
-    };
-  }
-
-  /* -------------------------------------------------------------- */
-  /*  Content adaptation                                             */
-  /* -------------------------------------------------------------- */
-
-  /** Adapt content for a specific platform's constraints and conventions. */
-  private adaptForPlatform(
-    content: string,
-    platform: string,
-    hashtags?: string[],
-  ): string {
-    const limit = MultiChannelPostTool.PLATFORM_LIMITS[platform] ?? 5000;
-    const hashtagStyle = MultiChannelPostTool.HASHTAG_STYLE[platform] ?? 'none';
-
-    let text = content;
-
-    // Append hashtags according to platform convention.
-    if (hashtags?.length && hashtagStyle !== 'none') {
-      const tags = hashtags.map((t) => (t.startsWith('#') ? t : `#${t}`));
-      if (hashtagStyle === 'footer') {
-        text = text + '\n\n' + tags.join(' ');
-      } else {
-        text = text + ' ' + tags.join(' ');
-      }
-    }
-
-    // Truncate if the text exceeds the platform limit.
-    if (text.length > limit) {
-      text = text.substring(0, limit - 3) + '...';
-    }
-
-    return text;
-  }
-
-  /* -------------------------------------------------------------- */
-  /*  Tool name / args mapping                                       */
-  /* -------------------------------------------------------------- */
-
-  /** Map platform to its per-platform post tool name. */
-  private getPostToolName(platform: string): string {
-    return MultiChannelPostTool.TOOL_NAME_MAP[platform] ?? `${platform}Post`;
-  }
-
-  /** Build platform-specific tool arguments. */
-  private buildToolArgs(
-    platform: string,
-    content: string,
-    mediaUrls?: string[],
-    platformConfig?: Record<string, unknown>,
-  ): Record<string, unknown> {
-    const config = platformConfig ?? {};
-    const mediaUrl = this.getOptionalString(config['mediaUrl']) ?? mediaUrls?.[0];
-    const mediaPath = this.getOptionalString(config['mediaPath']) ?? mediaUrl;
-
-    switch (platform) {
-      case 'twitter':
-        return { text: content, mediaPath };
-      case 'instagram':
-        return {
-          caption: content,
-          imageUrls: this.requireStringArray(
-            this.getOptionalStringArray(config['imageUrls']) ?? mediaUrls,
-            'instagram requires imageUrls (provide mediaUrls or platformConfigs.instagram.imageUrls)',
-          ),
-        };
-      case 'reddit': {
-        const type =
-          this.getOptionalString(config['type']) ??
-          (mediaUrl ? 'image' : 'text');
-        const title =
-          this.getOptionalString(config['title']) ??
-          content.substring(0, 300);
-        const bodyContent =
-          this.getOptionalString(config['content']) ??
-          (type === 'image' || type === 'link'
-            ? this.requireString(
-                mediaUrl,
-                `reddit ${type} post requires a URL (provide mediaUrls or platformConfigs.reddit.content)`,
-              )
-            : content);
-
-        return {
-          subreddit: this.getOptionalString(config['subreddit']) ?? 'self',
-          title,
-          content: bodyContent,
-          type,
-          pollOptions: this.getOptionalStringArray(config['pollOptions']),
-          pollDurationDays: this.getOptionalNumber(config['pollDurationDays']),
-          flairId: this.getOptionalString(config['flairId']),
-          nsfw: this.getOptionalBoolean(config['nsfw']),
-          spoiler: this.getOptionalBoolean(config['spoiler']),
-        };
-      }
-      case 'youtube':
-        return {
-          videoUrl: this.requireString(
-            this.getOptionalString(config['videoUrl']) ?? mediaUrl,
-            'youtube requires videoUrl (provide mediaUrls or platformConfigs.youtube.videoUrl)',
-          ),
-          title:
-            this.getOptionalString(config['title']) ??
-            content.substring(0, 100),
-          description:
-            this.getOptionalString(config['description']) ?? content,
-          tags: this.getOptionalStringArray(config['tags']),
-          categoryId: this.getOptionalString(config['categoryId']),
-          privacyStatus: this.getOptionalString(config['privacyStatus']),
-          mimeType: this.getOptionalString(config['mimeType']),
-        };
-      case 'tiktok':
-        return {
-          videoUrl: this.requireString(
-            this.getOptionalString(config['videoUrl']) ?? mediaUrl,
-            'tiktok requires videoUrl (provide mediaUrls or platformConfigs.tiktok.videoUrl)',
-          ),
-          caption: this.getOptionalString(config['caption']) ?? content,
-          hashtags: this.getOptionalStringArray(config['hashtags']),
-          privacyLevel: this.getOptionalString(config['privacyLevel']),
-          disableComment: this.getOptionalBoolean(config['disableComment']),
-          disableDuet: this.getOptionalBoolean(config['disableDuet']),
-          disableStitch: this.getOptionalBoolean(config['disableStitch']),
-          coverTimestampMs: this.getOptionalNumber(config['coverTimestampMs']),
-        };
-      case 'pinterest': {
-        const mediaUrlsForCarousel =
-          this.getOptionalStringArray(config['mediaUrls']);
-        return {
-          boardId: this.requireString(
-            this.getOptionalString(config['boardId']),
-            'pinterest requires boardId (provide platformConfigs.pinterest.boardId)',
-          ),
-          title:
-            this.getOptionalString(config['title']) ??
-            content.substring(0, 100),
-          description:
-            this.getOptionalString(config['description']) ?? content,
-          link: this.getOptionalString(config['link']),
-          mediaType:
-            this.getOptionalString(config['mediaType']) ??
-            (mediaUrlsForCarousel && mediaUrlsForCarousel.length > 1
-              ? 'carousel'
-              : 'image'),
-          mediaUrl: this.requireString(
-            this.getOptionalString(config['mediaUrl']) ?? mediaUrl,
-            'pinterest requires mediaUrl (provide mediaUrls or platformConfigs.pinterest.mediaUrl)',
-          ),
-          mediaUrls: mediaUrlsForCarousel,
-          coverImageUrl: this.getOptionalString(config['coverImageUrl']),
-          altText: this.getOptionalString(config['altText']),
-          hashtags: this.getOptionalStringArray(config['hashtags']),
-        };
-      }
-      case 'linkedin':
-        return { text: content, mediaPath };
-      case 'facebook':
-        return {
-          text: content,
-          mediaPath,
-          link: this.getOptionalString(config['link']),
-          mediaType: this.getOptionalString(config['mediaType']),
-          pageId: this.getOptionalString(config['pageId']),
-        };
-      case 'threads':
-        return {
-          text: content,
-          imageUrl: this.getOptionalString(config['imageUrl']) ?? mediaUrl,
-          videoUrl: this.getOptionalString(config['videoUrl']),
-          carouselItems: config['carouselItems'],
-        };
-      case 'bluesky':
-        return {
-          text: content,
-          imagePaths: this.getOptionalStringArray(config['imagePaths']),
-          langs: this.getOptionalStringArray(config['langs']),
-        };
-      case 'mastodon':
-        return {
-          text: content,
-          mediaPath,
-          spoilerText: this.getOptionalString(config['spoilerText']),
-          visibility: this.getOptionalString(config['visibility']),
-          sensitive: this.getOptionalBoolean(config['sensitive']),
-          language: this.getOptionalString(config['language']),
-        };
-      case 'farcaster':
-        return {
-          text: content,
-          embeds: this.getOptionalStringArray(config['embeds']) ??
-            (mediaUrl ? [mediaUrl] : undefined),
-          channelId: this.getOptionalString(config['channelId']),
-        };
-      case 'lemmy':
-        return {
-          communityId: this.requireNumber(
-            this.getOptionalNumber(config['communityId']),
-            'lemmy requires communityId (provide platformConfigs.lemmy.communityId)',
-          ),
-          name:
-            this.getOptionalString(config['name']) ??
-            content.substring(0, 200),
-          body: this.getOptionalString(config['body']) ?? content,
-          url: this.getOptionalString(config['url']) ?? mediaUrl,
-        };
-      default:
-        return { text: content, mediaPath };
-    }
-  }
-
-  private getOptionalString(value: unknown): string | undefined {
-    return typeof value === 'string' && value.trim() !== '' ? value : undefined;
-  }
-
-  private getOptionalStringArray(value: unknown): string[] | undefined {
-    if (!Array.isArray(value)) return undefined;
-    const values = value.filter((v): v is string => typeof v === 'string' && v.trim() !== '');
-    return values.length ? values : undefined;
-  }
-
-  private getOptionalNumber(value: unknown): number | undefined {
-    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
-  }
-
-  private getOptionalBoolean(value: unknown): boolean | undefined {
-    return typeof value === 'boolean' ? value : undefined;
-  }
-
-  private requireString(value: string | undefined, error: string): string {
-    if (!value) throw new Error(error);
-    return value;
-  }
-
-  private requireNumber(value: number | undefined, error: string): number {
-    if (typeof value !== 'number') throw new Error(error);
-    return value;
-  }
-
-  private requireStringArray(value: string[] | undefined, error: string): string[] {
-    if (!value || value.length === 0) throw new Error(error);
-    return value;
-  }
-}

package/src/index.ts

@@ -1,67 +0,0 @@
-// @ts-nocheck
-/**
- * Multi-Channel Post Extension Pack — publish adapted content to N social platforms.
- */
-
-import { MultiChannelPostTool } from './MultiChannelPostTool.js';
-
-/* ------------------------------------------------------------------ */
-/*  Extension pack types                                               */
-/* ------------------------------------------------------------------ */
-
-export interface ExtensionContext {
-  options?: Record<string, unknown>;
-  secrets?: Record<string, string>;
-  getSecret?: (key: string) => string | undefined;
-  logger?: { info: (msg: string) => void };
-}
-
-export interface ExtensionPack {
-  name: string;
-  version: string;
-  descriptors: Array<{
-    id: string;
-    kind: string;
-    priority?: number;
-    payload: unknown;
-  }>;
-  onActivate?: () => Promise<void>;
-  onDeactivate?: () => Promise<void>;
-}
-
-/* ------------------------------------------------------------------ */
-/*  Factory                                                            */
-/* ------------------------------------------------------------------ */
-
-export function createExtensionPack(context: ExtensionContext): ExtensionPack {
-  const tool = new MultiChannelPostTool();
-
-  return {
-    name: '@framers/agentos-ext-tool-multi-channel-post',
-    version: '0.1.0',
-    descriptors: [
-      {
-        id: tool.name,
-        kind: 'tool' as const,
-        priority: 50,
-        payload: tool,
-      },
-    ],
-    onActivate: async () => context.logger?.info('Multi-Channel Post Extension activated'),
-    onDeactivate: async () => context.logger?.info('Multi-Channel Post Extension deactivated'),
-  };
-}
-
-/* ------------------------------------------------------------------ */
-/*  Re-exports                                                         */
-/* ------------------------------------------------------------------ */
-
-export { MultiChannelPostTool } from './MultiChannelPostTool.js';
-export type {
-  MultiChannelPostInput,
-  MultiChannelPostOutput,
-  PlatformPostResult,
-  ToolExecutorFn,
-} from './MultiChannelPostTool.js';
-
-export default createExtensionPack;

package/test/MultiChannelPostTool.spec.ts

@@ -1,528 +0,0 @@
-// @ts-nocheck
-/**
- * @fileoverview Unit tests for MultiChannelPostTool.
- *
- * Tests cover: tool metadata, dry-run mode, multi-platform posting,
- * per-platform content overrides, partial failures, content adaptation
- * (character limits, hashtag placement), and missing executor handling.
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import {
-  MultiChannelPostTool,
-  type ToolExecutorFn,
-  type MultiChannelPostInput,
-} from '../src/MultiChannelPostTool.js';
-
-/* ------------------------------------------------------------------ */
-/*  Helpers                                                            */
-/* ------------------------------------------------------------------ */
-
-function createMockExecutor(
-  overrides?: Partial<Record<string, { success: boolean; data?: Record<string, unknown>; error?: string }>>,
-): ToolExecutorFn {
-  return vi.fn(async (toolName: string, _args: Record<string, unknown>) => {
-    if (overrides?.[toolName]) return overrides[toolName]!;
-    return {
-      success: true,
-      data: { id: `post-${toolName}-001`, url: `https://${toolName}.example.com/post/001` },
-    };
-  });
-}
-
-/* ------------------------------------------------------------------ */
-/*  Tests                                                              */
-/* ------------------------------------------------------------------ */
-
-describe('MultiChannelPostTool', () => {
-  let tool: MultiChannelPostTool;
-
-  beforeEach(() => {
-    tool = new MultiChannelPostTool();
-  });
-
-  /* ── Metadata ─────────────────────────────────────────────────── */
-
-  describe('metadata', () => {
-    it('should expose the correct id and name', () => {
-      expect(tool.id).toBe('multiChannelPost');
-      expect(tool.name).toBe('multiChannelPost');
-    });
-
-    it('should have a display name and description', () => {
-      expect(tool.displayName).toBe('Post to Multiple Platforms');
-      expect(tool.description).toContain('multiple social media platforms');
-    });
-
-    it('should declare the category as social', () => {
-      expect(tool.category).toBe('social');
-    });
-
-    it('should flag hasSideEffects as true', () => {
-      expect(tool.hasSideEffects).toBe(true);
-    });
-
-    it('should expose a valid inputSchema with required fields', () => {
-      expect(tool.inputSchema.type).toBe('object');
-      expect(tool.inputSchema.required).toEqual(['content', 'platforms']);
-      expect(tool.inputSchema.properties).toHaveProperty('content');
-      expect(tool.inputSchema.properties).toHaveProperty('platforms');
-      expect(tool.inputSchema.properties).toHaveProperty('adaptations');
-      expect(tool.inputSchema.properties).toHaveProperty('mediaUrls');
-      expect(tool.inputSchema.properties).toHaveProperty('platformConfigs');
-      expect(tool.inputSchema.properties).toHaveProperty('hashtags');
-      expect(tool.inputSchema.properties).toHaveProperty('dryRun');
-    });
-  });
-
-  /* ── Dry-run mode ─────────────────────────────────────────────── */
-
-  describe('dry-run mode', () => {
-    it('should return adapted content for each platform without posting', async () => {
-      const executor = createMockExecutor();
-      tool.setToolExecutor(executor);
-
-      const result = await tool.execute({
-        content: 'Hello world!',
-        platforms: ['twitter', 'linkedin'],
-        dryRun: true,
-      });
-
-      expect(result.success).toBe(true);
-      expect(result.data!.totalPlatforms).toBe(2);
-      expect(result.data!.successful).toBe(2);
-      expect(result.data!.failed).toBe(0);
-
-      // The executor should NOT have been called at all
-      expect(executor).not.toHaveBeenCalled();
-
-      // Each result should contain the adapted content
-      for (const r of result.data!.results) {
-        expect(r.success).toBe(true);
-        expect(r.adaptedContent).toBeDefined();
-        expect(r.postId).toBeUndefined();
-      }
-    });
-
-    it('should use per-platform overrides in dry-run mode', async () => {
-      const result = await tool.execute({
-        content: 'Default text',
-        platforms: ['twitter', 'linkedin'],
-        adaptations: { twitter: 'Custom tweet text' },
-        dryRun: true,
-      });
-
-      const twitterResult = result.data!.results.find((r) => r.platform === 'twitter')!;
-      const linkedinResult = result.data!.results.find((r) => r.platform === 'linkedin')!;
-
-      expect(twitterResult.adaptedContent).toBe('Custom tweet text');
-      expect(linkedinResult.adaptedContent).toBe('Default text');
-    });
-  });
-
-  /* ── Multi-platform posting ───────────────────────────────────── */
-
-  describe('posting to multiple platforms', () => {
-    it('should post to all specified platforms and aggregate results', async () => {
-      const executor = createMockExecutor();
-      tool.setToolExecutor(executor);
-
-      const result = await tool.execute({
-        content: 'Check out our new launch!',
-        platforms: ['twitter', 'linkedin', 'facebook'],
-      });
-
-      expect(result.success).toBe(true);
-      expect(result.data!.totalPlatforms).toBe(3);
-      expect(result.data!.successful).toBe(3);
-      expect(result.data!.failed).toBe(0);
-      expect(result.data!.results).toHaveLength(3);
-
-      // Verify correct tool names were called
-      expect(executor).toHaveBeenCalledTimes(3);
-      expect(executor).toHaveBeenCalledWith('twitterPost', expect.any(Object));
-      expect(executor).toHaveBeenCalledWith('linkedinPost', expect.any(Object));
-      expect(executor).toHaveBeenCalledWith('facebookPost', expect.any(Object));
-    });
-
-    it('should pass media URLs in tool args', async () => {
-      const executor = createMockExecutor();
-      tool.setToolExecutor(executor);
-
-      await tool.execute({
-        content: 'Photo post',
-        platforms: ['twitter'],
-        mediaUrls: ['https://example.com/photo.jpg'],
-      });
-
-      expect(executor).toHaveBeenCalledWith('twitterPost', {
-        text: expect.any(String),
-        mediaPath: 'https://example.com/photo.jpg',
-      });
-    });
-
-    it('should extract postId and url from executor results', async () => {
-      const executor = createMockExecutor({
-        twitterPost: {
-          success: true,
-          data: { id: 'tw-999', url: 'https://twitter.com/status/999' },
-        },
-      });
-      tool.setToolExecutor(executor);
-
-      const result = await tool.execute({
-        content: 'Hello',
-        platforms: ['twitter'],
-      });
-
-      const tResult = result.data!.results[0]!;
-      expect(tResult.postId).toBe('tw-999');
-      expect(tResult.url).toBe('https://twitter.com/status/999');
-    });
-
-    it('should extract postId from data.postId when data.id is absent', async () => {
-      const executor = createMockExecutor({
-        linkedinPost: {
-          success: true,
-          data: { postId: 'li-555', url: 'https://linkedin.com/post/555' },
-        },
-      });
-      tool.setToolExecutor(executor);
-
-      const result = await tool.execute({
-        content: 'LinkedIn update',
-        platforms: ['linkedin'],
-      });
-
-      expect(result.data!.results[0]!.postId).toBe('li-555');
-    });
-  });
-
-  /* ── Per-platform content overrides ───────────────────────────── */
-
-  describe('per-platform content adaptations', () => {
-    it('should use explicit per-platform overrides when provided', async () => {
-      const executor = createMockExecutor();
-      tool.setToolExecutor(executor);
-
-      await tool.execute({
-        content: 'Default content',
-        platforms: ['twitter', 'instagram'],
-        mediaUrls: ['https://cdn.example.com/adapt-image.jpg'],
-        adaptations: {
-          twitter: 'A short tweet',
-          instagram: 'A longer Instagram caption with details',
-        },
-      });
-
-      expect(executor).toHaveBeenCalledWith('twitterPost', expect.objectContaining({ text: 'A short tweet' }));
-      expect(executor).toHaveBeenCalledWith('instagramPost', expect.objectContaining({ caption: 'A longer Instagram caption with details' }));
-    });
-  });
-
-  /* ── Content adaptation (auto) ────────────────────────────────── */
-
-  describe('automatic content adaptation', () => {
-    it('should truncate content that exceeds platform character limit', async () => {
-      const longContent = 'A'.repeat(300); // exceeds Twitter's 280 limit
-      const result = await tool.execute({
-        content: longContent,
-        platforms: ['twitter'],
-        dryRun: true,
-      });
-
-      const adapted = result.data!.results[0]!.adaptedContent!;
-      expect(adapted.length).toBeLessThanOrEqual(280);
-      expect(adapted.endsWith('...')).toBe(true);
-    });
-
-    it('should not truncate content within platform limits', async () => {
-      const shortContent = 'Short post';
-      const result = await tool.execute({
-        content: shortContent,
-        platforms: ['twitter'],
-        dryRun: true,
-      });
-
-      expect(result.data!.results[0]!.adaptedContent).toBe('Short post');
-    });
-
-    it('should append hashtags inline for Twitter', async () => {
-      const result = await tool.execute({
-        content: 'Great day',
-        platforms: ['twitter'],
-        hashtags: ['awesome', '#blessed'],
-        dryRun: true,
-      });
-
-      const adapted = result.data!.results[0]!.adaptedContent!;
-      expect(adapted).toBe('Great day #awesome #blessed');
-    });
-
-    it('should append hashtags as footer for Instagram', async () => {
-      const result = await tool.execute({
-        content: 'Check this out',
-        platforms: ['instagram'],
-        hashtags: ['photography', 'nature'],
-        dryRun: true,
-      });
-
-      const adapted = result.data!.results[0]!.adaptedContent!;
-      expect(adapted).toBe('Check this out\n\n#photography #nature');
-    });
-
-    it('should not append hashtags for platforms with none style', async () => {
-      const result = await tool.execute({
-        content: 'Reddit post',
-        platforms: ['reddit'],
-        hashtags: ['test'],
-        dryRun: true,
-      });
-
-      const adapted = result.data!.results[0]!.adaptedContent!;
-      expect(adapted).toBe('Reddit post');
-    });
-  });
-
-  /* ── Partial failures ─────────────────────────────────────────── */
-
-  describe('partial failures', () => {
-    it('should handle a mix of successes and failures', async () => {
-      const executor = createMockExecutor({
-        twitterPost: { success: true, data: { id: 'tw-1' } },
-        linkedinPost: { success: false, error: 'LinkedIn API is down' },
-        facebookPost: { success: true, data: { id: 'fb-1' } },
-      });
-      tool.setToolExecutor(executor);
-
-      const result = await tool.execute({
-        content: 'Hello',
-        platforms: ['twitter', 'linkedin', 'facebook'],
-      });
-
-      expect(result.success).toBe(true); // at least one succeeded
-      expect(result.data!.successful).toBe(2);
-      expect(result.data!.failed).toBe(1);
-
-      const linkedinResult = result.data!.results.find((r) => r.platform === 'linkedin')!;
-      expect(linkedinResult.success).toBe(false);
-      expect(linkedinResult.error).toBe('LinkedIn API is down');
-    });
-
-    it('should report success=false when ALL platforms fail', async () => {
-      const executor = createMockExecutor({
-        twitterPost: { success: false, error: 'Fail 1' },
-        linkedinPost: { success: false, error: 'Fail 2' },
-      });
-      tool.setToolExecutor(executor);
-
-      const result = await tool.execute({
-        content: 'Hello',
-        platforms: ['twitter', 'linkedin'],
-      });
-
-      expect(result.success).toBe(false);
-      expect(result.data!.successful).toBe(0);
-      expect(result.data!.failed).toBe(2);
-    });
-
-    it('should catch thrown errors from executor and report them gracefully', async () => {
-      const executor = vi.fn(async () => {
-        throw new Error('Network timeout');
-      });
-      tool.setToolExecutor(executor);
-
-      const result = await tool.execute({
-        content: 'Hello',
-        platforms: ['twitter'],
-      });
-
-      expect(result.success).toBe(false);
-      expect(result.data!.results[0]!.error).toBe('Network timeout');
-    });
-
-    it('should catch non-Error thrown values', async () => {
-      const executor = vi.fn(async () => {
-        throw 'string error'; // eslint-disable-line no-throw-literal
-      });
-      tool.setToolExecutor(executor);
-
-      const result = await tool.execute({
-        content: 'Hello',
-        platforms: ['twitter'],
-      });
-
-      expect(result.data!.results[0]!.error).toBe('string error');
-    });
-  });
-
-  /* ── Missing executor ─────────────────────────────────────────── */
-
-  describe('missing tool executor', () => {
-    it('should report per-platform errors when no executor is set', async () => {
-      const result = await tool.execute({
-        content: 'No executor available',
-        platforms: ['twitter', 'linkedin'],
-      });
-
-      expect(result.success).toBe(false);
-      expect(result.data!.failed).toBe(2);
-      for (const r of result.data!.results) {
-        expect(r.success).toBe(false);
-        expect(r.error).toContain('No tool executor available');
-      }
-    });
-  });
-
-  /* ── Tool name mapping ────────────────────────────────────────── */
-
-  describe('tool name mapping', () => {
-    it('should map known platforms to their expected tool names', async () => {
-      const executor = createMockExecutor();
-      tool.setToolExecutor(executor);
-
-      const platforms = ['twitter', 'instagram', 'reddit', 'youtube', 'bluesky', 'mastodon', 'threads'];
-      const expectedToolNames = [
-        'twitterPost', 'instagramPost', 'redditSubmitPost', 'youtubeUpload',
-        'blueskyPost', 'mastodonPost', 'threadsPost',
-      ];
-
-      await tool.execute({
-        content: 'Test',
-        platforms,
-        mediaUrls: ['https://cdn.example.com/tool-map-media.mp4'],
-      });
-
-      for (const expected of expectedToolNames) {
-        expect(executor).toHaveBeenCalledWith(expected, expect.any(Object));
-      }
-    });
-
-    it('should fallback to "<platform>Post" for unknown platforms', async () => {
-      const executor = createMockExecutor();
-      tool.setToolExecutor(executor);
-
-      await tool.execute({
-        content: 'Test',
-        platforms: ['myplatform'],
-      });
-
-      expect(executor).toHaveBeenCalledWith('myplatformPost', expect.any(Object));
-    });
-  });
-
-  /* ── Platform-specific arg building ───────────────────────────── */
-
-  describe('platform-specific tool arguments', () => {
-    it('should build twitter args with text field', async () => {
-      const executor = createMockExecutor();
-      tool.setToolExecutor(executor);
-      await tool.execute({ content: 'Tweet!', platforms: ['twitter'] });
-      expect(executor).toHaveBeenCalledWith('twitterPost', expect.objectContaining({ text: 'Tweet!' }));
-    });
-
-    it('should build instagram args with caption + imageUrls', async () => {
-      const executor = createMockExecutor();
-      tool.setToolExecutor(executor);
-      await tool.execute({
-        content: 'IG post',
-        platforms: ['instagram'],
-        mediaUrls: ['https://cdn.example.com/photo.jpg'],
-      });
-      expect(executor).toHaveBeenCalledWith(
-        'instagramPost',
-        expect.objectContaining({
-          caption: 'IG post',
-          imageUrls: ['https://cdn.example.com/photo.jpg'],
-        }),
-      );
-    });
-
-    it('should build reddit args with required content/type fields', async () => {
-      const executor = createMockExecutor();
-      tool.setToolExecutor(executor);
-      await tool.execute({ content: 'Reddit thread', platforms: ['reddit'] });
-      expect(executor).toHaveBeenCalledWith(
-        'redditSubmitPost',
-        expect.objectContaining({
-          subreddit: 'self',
-          title: expect.any(String),
-          content: 'Reddit thread',
-          type: 'text',
-        }),
-      );
-    });
-
-    it('should build youtube args with required videoUrl', async () => {
-      const executor = createMockExecutor();
-      tool.setToolExecutor(executor);
-      await tool.execute({
-        content: 'Video description',
-        platforms: ['youtube'],
-        mediaUrls: ['https://cdn.example.com/video.mp4'],
-      });
-      expect(executor).toHaveBeenCalledWith(
-        'youtubeUpload',
-        expect.objectContaining({
-          videoUrl: 'https://cdn.example.com/video.mp4',
-          title: expect.any(String),
-          description: 'Video description',
-        }),
-      );
-    });
-
-    it('should fail youtube post when no video URL is provided', async () => {
-      const executor = createMockExecutor();
-      tool.setToolExecutor(executor);
-
-      const result = await tool.execute({
-        content: 'Video description',
-        platforms: ['youtube'],
-      });
-
-      expect(result.success).toBe(false);
-      expect(result.data!.results[0]!.error).toContain('youtube requires videoUrl');
-      expect(executor).not.toHaveBeenCalled();
-    });
-
-    it('should allow platformConfigs overrides for pinterest', async () => {
-      const executor = createMockExecutor();
-      tool.setToolExecutor(executor);
-
-      await tool.execute({
-        content: 'Pin this',
-        platforms: ['pinterest'],
-        mediaUrls: ['https://cdn.example.com/image.jpg'],
-        platformConfigs: {
-          pinterest: {
-            boardId: 'board-123',
-            mediaType: 'image',
-          },
-        },
-      });
-
-      expect(executor).toHaveBeenCalledWith(
-        'pinterestPin',
-        expect.objectContaining({
-          boardId: 'board-123',
-          mediaType: 'image',
-          mediaUrl: 'https://cdn.example.com/image.jpg',
-        }),
-      );
-    });
-
-    it('should fail lemmy post when communityId is missing', async () => {
-      const executor = createMockExecutor();
-      tool.setToolExecutor(executor);
-
-      const result = await tool.execute({
-        content: 'Lemmy post',
-        platforms: ['lemmy'],
-      });
-
-      expect(result.success).toBe(false);
-      expect(result.data!.results[0]!.error).toContain('lemmy requires communityId');
-      expect(executor).not.toHaveBeenCalled();
-    });
-  });
-});

package/tsconfig.json

@@ -1,22 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "lib": ["ES2022"],
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "noEmitOnError": false,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "resolveJsonModule": true,
-    "moduleResolution": "Bundler",
-    "types": ["node"]
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "test"]
-}