@auxiora/connector-social 1.0.0 → 1.3.1

package/src/reddit.ts

@@ -1,268 +0,0 @@
-import { defineConnector } from '@auxiora/connectors';
-import type { TriggerEvent } from '@auxiora/connectors';
-
-const REDDIT_BASE = 'https://oauth.reddit.com';
-const REDDIT_UA = 'auxiora:v1.0.0 (by /u/auxiora)';
-
-async function redditGet(token: string, path: string): Promise<Record<string, unknown>> {
-  const res = await fetch(`${REDDIT_BASE}${path}`, {
-    headers: {
-      'Authorization': `Bearer ${token}`,
-      'User-Agent': REDDIT_UA,
-    },
-  });
-  if (!res.ok) throw new Error(`Reddit API error: ${res.status} ${await res.text().catch(() => res.statusText)}`);
-  return res.json() as Promise<Record<string, unknown>>;
-}
-
-async function redditPost(token: string, path: string, body: Record<string, string>): Promise<Record<string, unknown>> {
-  const res = await fetch(`${REDDIT_BASE}${path}`, {
-    method: 'POST',
-    headers: {
-      'Authorization': `Bearer ${token}`,
-      'User-Agent': REDDIT_UA,
-      'Content-Type': 'application/x-www-form-urlencoded',
-    },
-    body: new URLSearchParams(body).toString(),
-  });
-  if (!res.ok) throw new Error(`Reddit API error: ${res.status} ${await res.text().catch(() => res.statusText)}`);
-  return res.json() as Promise<Record<string, unknown>>;
-}
-
-function extractPosts(listing: Record<string, unknown>): unknown[] {
-  const data = listing.data as Record<string, unknown> | undefined;
-  const children = (data?.children ?? []) as Array<Record<string, unknown>>;
-  return children.map((c) => c.data);
-}
-
-export const redditConnector = defineConnector({
-  id: 'reddit',
-  name: 'Reddit',
-  description: 'Integration with Reddit for browsing, posting, and messaging',
-  version: '1.0.0',
-  category: 'social',
-  icon: 'reddit',
-
-  auth: {
-    type: 'oauth2',
-    oauth2: {
-      authUrl: 'https://www.reddit.com/api/v1/authorize',
-      tokenUrl: 'https://www.reddit.com/api/v1/access_token',
-      scopes: ['read', 'submit', 'privatemessages', 'vote', 'save', 'identity'],
-    },
-  },
-
-  actions: [
-    {
-      id: 'front-page',
-      name: 'Read Front Page',
-      description: 'Read posts from the Reddit front page',
-      trustMinimum: 1,
-      trustDomain: 'messaging',
-      reversible: false,
-      sideEffects: false,
-      params: {},
-    },
-    {
-      id: 'subreddit-read',
-      name: 'Read Subreddit',
-      description: 'Read posts from a specific subreddit',
-      trustMinimum: 1,
-      trustDomain: 'messaging',
-      reversible: false,
-      sideEffects: false,
-      params: {
-        subreddit: { type: 'string', description: 'Subreddit name', required: true },
-      },
-    },
-    {
-      id: 'post-submit',
-      name: 'Submit Post',
-      description: 'Submit a new post to a subreddit',
-      trustMinimum: 3,
-      trustDomain: 'messaging',
-      reversible: false,
-      sideEffects: true,
-      params: {
-        subreddit: { type: 'string', description: 'Subreddit name', required: true },
-        title: { type: 'string', description: 'Post title', required: true },
-        body: { type: 'string', description: 'Post body', required: true },
-      },
-    },
-    {
-      id: 'comment',
-      name: 'Post Comment',
-      description: 'Post a comment on a Reddit post',
-      trustMinimum: 3,
-      trustDomain: 'messaging',
-      reversible: false,
-      sideEffects: true,
-      params: {
-        postId: { type: 'string', description: 'Post ID to comment on', required: true },
-        body: { type: 'string', description: 'Comment body', required: true },
-      },
-    },
-    {
-      id: 'inbox-read',
-      name: 'Read Inbox',
-      description: 'Read Reddit inbox messages',
-      trustMinimum: 1,
-      trustDomain: 'messaging',
-      reversible: false,
-      sideEffects: false,
-      params: {},
-    },
-    {
-      id: 'search',
-      name: 'Search Reddit',
-      description: 'Search across Reddit',
-      trustMinimum: 1,
-      trustDomain: 'messaging',
-      reversible: false,
-      sideEffects: false,
-      params: {
-        query: { type: 'string', description: 'Search query', required: true },
-      },
-    },
-    {
-      id: 'save-post',
-      name: 'Save Post',
-      description: 'Save a Reddit post',
-      trustMinimum: 1,
-      trustDomain: 'messaging',
-      reversible: true,
-      sideEffects: true,
-      params: {
-        postId: { type: 'string', description: 'Post ID to save', required: true },
-      },
-    },
-    {
-      id: 'upvote',
-      name: 'Upvote',
-      description: 'Upvote or downvote a post',
-      trustMinimum: 2,
-      trustDomain: 'messaging',
-      reversible: true,
-      sideEffects: true,
-      params: {
-        postId: { type: 'string', description: 'Post ID to vote on', required: true },
-        direction: { type: 'string', description: 'Vote direction (up or down)', default: 'up' },
-      },
-    },
-  ],
-
-  triggers: [
-    {
-      id: 'new-inbox',
-      name: 'New Inbox Message',
-      description: 'Triggered when a new inbox message is received',
-      type: 'poll',
-      pollIntervalMs: 120_000,
-    },
-    {
-      id: 'subreddit-new',
-      name: 'New Subreddit Post',
-      description: 'Triggered when a new post appears in a monitored subreddit',
-      type: 'poll',
-      pollIntervalMs: 300_000,
-    },
-  ],
-
-  entities: [
-    {
-      id: 'post',
-      name: 'Post',
-      description: 'A Reddit post',
-      fields: { id: 'string', title: 'string', subreddit: 'string', author: 'string', score: 'number', commentCount: 'number' },
-    },
-    {
-      id: 'comment',
-      name: 'Comment',
-      description: 'A Reddit comment',
-      fields: { id: 'string', body: 'string', author: 'string', score: 'number', postId: 'string' },
-    },
-  ],
-
-  async executeAction(actionId: string, params: Record<string, unknown>, token: string): Promise<unknown> {
-    switch (actionId) {
-      case 'front-page': {
-        const res = await redditGet(token, '/best?limit=25');
-        return { posts: extractPosts(res) };
-      }
-      case 'subreddit-read': {
-        const sub = params.subreddit as string;
-        const res = await redditGet(token, `/r/${sub}/hot?limit=25`);
-        return { posts: extractPosts(res) };
-      }
-      case 'post-submit': {
-        const res = await redditPost(token, '/api/submit', {
-          sr: params.subreddit as string,
-          kind: 'self',
-          title: params.title as string,
-          text: params.body as string,
-        });
-        const json = res.json as Record<string, unknown> | undefined;
-        const data = json?.data as Record<string, unknown> | undefined;
-        return { postId: data?.id ?? data?.name, status: 'submitted' };
-      }
-      case 'comment': {
-        const postId = params.postId as string;
-        const thingId = postId.startsWith('t3_') ? postId : `t3_${postId}`;
-        const res = await redditPost(token, '/api/comment', {
-          thing_id: thingId,
-          text: params.body as string,
-        });
-        const json = res.json as Record<string, unknown> | undefined;
-        const data = json?.data as Record<string, unknown> | undefined;
-        const things = data?.things as Array<Record<string, unknown>> | undefined;
-        const commentData = things?.[0]?.data as Record<string, unknown> | undefined;
-        return { commentId: commentData?.id ?? commentData?.name, status: 'posted' };
-      }
-      case 'inbox-read': {
-        const res = await redditGet(token, '/message/inbox?limit=25');
-        return { messages: extractPosts(res) };
-      }
-      case 'search': {
-        const query = encodeURIComponent(params.query as string);
-        const res = await redditGet(token, `/search?q=${query}&limit=25`);
-        return { posts: extractPosts(res) };
-      }
-      case 'save-post': {
-        const postId = params.postId as string;
-        const fullId = postId.startsWith('t3_') ? postId : `t3_${postId}`;
-        await redditPost(token, '/api/save', { id: fullId });
-        return { postId: params.postId, status: 'saved' };
-      }
-      case 'upvote': {
-        const postId = params.postId as string;
-        const fullId = postId.startsWith('t3_') ? postId : `t3_${postId}`;
-        const direction = (params.direction as string) ?? 'up';
-        const dir = direction === 'up' ? '1' : '-1';
-        await redditPost(token, '/api/vote', { id: fullId, dir });
-        return { postId: params.postId, status: 'voted' };
-      }
-      default:
-        throw new Error(`Unknown action: ${actionId}`);
-    }
-  },
-
-  async pollTrigger(triggerId: string, token: string, _lastPollAt?: number): Promise<TriggerEvent[]> {
-    switch (triggerId) {
-      case 'new-inbox': {
-        const res = await redditGet(token, '/message/unread?limit=25');
-        const messages = extractPosts(res) as Array<Record<string, unknown>>;
-        return messages.map((m) => ({
-          triggerId: 'new-inbox',
-          connectorId: 'reddit',
-          data: m,
-          timestamp: typeof m.created_utc === 'number' ? (m.created_utc as number) * 1000 : Date.now(),
-        }));
-      }
-      case 'subreddit-new':
-        // Cannot poll specific subreddit without config
-        return [];
-      default:
-        return [];
-    }
-  },
-});

package/src/twitter.ts

@@ -1,253 +0,0 @@
-import { defineConnector } from '@auxiora/connectors';
-import type { TriggerEvent } from '@auxiora/connectors';
-
-async function twitterFetch(token: string, path: string, options?: { method?: string; body?: unknown }) {
-  const res = await fetch(`https://api.twitter.com/2${path}`, {
-    method: options?.method ?? 'GET',
-    headers: { 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' },
-    body: options?.body ? JSON.stringify(options.body) : undefined,
-  });
-  if (!res.ok) throw new Error(`Twitter API error: ${res.status} ${await res.text().catch(() => res.statusText)}`);
-  return res.json() as Promise<Record<string, unknown>>;
-}
-
-async function getMyUserId(token: string): Promise<string> {
-  const res = await twitterFetch(token, '/users/me');
-  const data = res.data as Record<string, unknown>;
-  return data.id as string;
-}
-
-export const twitterConnector = defineConnector({
-  id: 'twitter',
-  name: 'Twitter / X',
-  description: 'Integration with Twitter/X for tweets, mentions, and direct messages',
-  version: '1.0.0',
-  category: 'social',
-  icon: 'twitter',
-
-  auth: {
-    type: 'oauth2',
-    oauth2: {
-      authUrl: 'https://twitter.com/i/oauth2/authorize',
-      tokenUrl: 'https://api.twitter.com/2/oauth2/token',
-      scopes: ['tweet.read', 'tweet.write', 'users.read', 'dm.read', 'dm.write', 'offline.access'],
-    },
-  },
-
-  actions: [
-    {
-      id: 'timeline-read',
-      name: 'Read Timeline',
-      description: 'Read the authenticated user timeline',
-      trustMinimum: 1,
-      trustDomain: 'messaging',
-      reversible: false,
-      sideEffects: false,
-      params: {},
-    },
-    {
-      id: 'mentions-list',
-      name: 'List Mentions',
-      description: 'List recent mentions of the authenticated user',
-      trustMinimum: 1,
-      trustDomain: 'messaging',
-      reversible: false,
-      sideEffects: false,
-      params: {},
-    },
-    {
-      id: 'post-tweet',
-      name: 'Post Tweet',
-      description: 'Post a new tweet',
-      trustMinimum: 3,
-      trustDomain: 'messaging',
-      reversible: false,
-      sideEffects: true,
-      params: {
-        text: { type: 'string', description: 'Tweet text', required: true },
-      },
-    },
-    {
-      id: 'reply-tweet',
-      name: 'Reply to Tweet',
-      description: 'Reply to an existing tweet',
-      trustMinimum: 3,
-      trustDomain: 'messaging',
-      reversible: false,
-      sideEffects: true,
-      params: {
-        tweetId: { type: 'string', description: 'Tweet ID to reply to', required: true },
-        text: { type: 'string', description: 'Reply text', required: true },
-      },
-    },
-    {
-      id: 'delete-tweet',
-      name: 'Delete Tweet',
-      description: 'Delete an existing tweet',
-      trustMinimum: 3,
-      trustDomain: 'messaging',
-      reversible: false,
-      sideEffects: true,
-      params: {
-        tweetId: { type: 'string', description: 'Tweet ID to delete', required: true },
-      },
-    },
-    {
-      id: 'search-tweets',
-      name: 'Search Tweets',
-      description: 'Search for tweets matching a query',
-      trustMinimum: 1,
-      trustDomain: 'messaging',
-      reversible: false,
-      sideEffects: false,
-      params: {
-        query: { type: 'string', description: 'Search query', required: true },
-      },
-    },
-    {
-      id: 'dm-list',
-      name: 'List Direct Messages',
-      description: 'List recent direct messages',
-      trustMinimum: 1,
-      trustDomain: 'messaging',
-      reversible: false,
-      sideEffects: false,
-      params: {},
-    },
-    {
-      id: 'dm-send',
-      name: 'Send Direct Message',
-      description: 'Send a direct message to a user',
-      trustMinimum: 3,
-      trustDomain: 'messaging',
-      reversible: false,
-      sideEffects: true,
-      params: {
-        recipientId: { type: 'string', description: 'Recipient user ID', required: true },
-        text: { type: 'string', description: 'Message text', required: true },
-      },
-    },
-  ],
-
-  triggers: [
-    {
-      id: 'new-mention',
-      name: 'New Mention',
-      description: 'Triggered when the user is mentioned in a tweet',
-      type: 'poll',
-      pollIntervalMs: 60_000,
-    },
-    {
-      id: 'new-dm',
-      name: 'New Direct Message',
-      description: 'Triggered when a new direct message is received',
-      type: 'poll',
-      pollIntervalMs: 120_000,
-    },
-  ],
-
-  entities: [
-    {
-      id: 'tweet',
-      name: 'Tweet',
-      description: 'A tweet on Twitter/X',
-      fields: { id: 'string', text: 'string', authorId: 'string', createdAt: 'string', likeCount: 'number', retweetCount: 'number' },
-    },
-    {
-      id: 'direct-message',
-      name: 'Direct Message',
-      description: 'A direct message on Twitter/X',
-      fields: { id: 'string', text: 'string', senderId: 'string', createdAt: 'string' },
-    },
-  ],
-
-  async executeAction(actionId: string, params: Record<string, unknown>, token: string): Promise<unknown> {
-    switch (actionId) {
-      case 'timeline-read': {
-        const userId = await getMyUserId(token);
-        const res = await twitterFetch(token, `/users/${userId}/timelines/reverse_chronological`);
-        return { tweets: res.data };
-      }
-      case 'mentions-list': {
-        const userId = await getMyUserId(token);
-        const res = await twitterFetch(token, `/users/${userId}/mentions`);
-        return { mentions: res.data };
-      }
-      case 'post-tweet': {
-        const res = await twitterFetch(token, '/tweets', {
-          method: 'POST',
-          body: { text: params.text },
-        });
-        const data = res.data as Record<string, unknown>;
-        return { tweetId: data.id, status: 'posted' };
-      }
-      case 'reply-tweet': {
-        const res = await twitterFetch(token, '/tweets', {
-          method: 'POST',
-          body: { text: params.text, reply: { in_reply_to_tweet_id: params.tweetId } },
-        });
-        const data = res.data as Record<string, unknown>;
-        return { tweetId: data.id, status: 'replied' };
-      }
-      case 'delete-tweet': {
-        await twitterFetch(token, `/tweets/${params.tweetId as string}`, { method: 'DELETE' });
-        return { tweetId: params.tweetId, status: 'deleted' };
-      }
-      case 'search-tweets': {
-        const query = encodeURIComponent(params.query as string);
-        const res = await twitterFetch(token, `/tweets/search/recent?query=${query}`);
-        return { tweets: res.data };
-      }
-      case 'dm-list': {
-        const res = await twitterFetch(token, '/dm_events');
-        return { messages: res.data };
-      }
-      case 'dm-send': {
-        const res = await twitterFetch(token, `/dm_conversations/with/${params.recipientId as string}/messages`, {
-          method: 'POST',
-          body: { text: params.text },
-        });
-        const data = res.data as Record<string, unknown>;
-        return { messageId: data.dm_event_id ?? data.id, status: 'sent' };
-      }
-      default:
-        throw new Error(`Unknown action: ${actionId}`);
-    }
-  },
-
-  async pollTrigger(triggerId: string, token: string, lastPollAt?: number): Promise<TriggerEvent[]> {
-    switch (triggerId) {
-      case 'new-mention': {
-        const userId = await getMyUserId(token);
-        const startTime = lastPollAt ? new Date(lastPollAt).toISOString() : undefined;
-        const query = startTime ? `?start_time=${startTime}` : '';
-        const res = await twitterFetch(token, `/users/${userId}/mentions${query}`);
-        const mentions = (res.data ?? []) as Array<Record<string, unknown>>;
-        return mentions.map((m) => ({
-          triggerId: 'new-mention',
-          connectorId: 'twitter',
-          data: m,
-          timestamp: m.created_at ? new Date(m.created_at as string).getTime() : Date.now(),
-        }));
-      }
-      case 'new-dm': {
-        const res = await twitterFetch(token, '/dm_events?event_types=MessageCreate');
-        const events = (res.data ?? []) as Array<Record<string, unknown>>;
-        const cutoff = lastPollAt ?? 0;
-        return events
-          .filter((e) => {
-            const ts = e.created_at ? new Date(e.created_at as string).getTime() : 0;
-            return ts > cutoff;
-          })
-          .map((e) => ({
-            triggerId: 'new-dm',
-            connectorId: 'twitter',
-            data: e,
-            timestamp: e.created_at ? new Date(e.created_at as string).getTime() : Date.now(),
-          }));
-      }
-      default:
-        return [];
-    }
-  },
-});

package/tests/instagram.test.ts

@@ -1,108 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { instagramConnector } from '../src/instagram.js';
-
-let fetchMock: ReturnType<typeof vi.fn>;
-beforeEach(() => {
-  fetchMock = vi.fn();
-  vi.stubGlobal('fetch', fetchMock);
-});
-afterEach(() => {
-  vi.restoreAllMocks();
-});
-
-function mockResponse(body: unknown) {
-  return { ok: true, status: 200, json: async () => body, text: async () => JSON.stringify(body) };
-}
-
-describe('Instagram Connector', () => {
-  it('should have correct metadata', () => {
-    expect(instagramConnector.id).toBe('instagram');
-    expect(instagramConnector.name).toBe('Instagram');
-    expect(instagramConnector.version).toBe('1.0.0');
-    expect(instagramConnector.category).toBe('social');
-  });
-
-  it('should use OAuth2 authentication', () => {
-    expect(instagramConnector.auth.type).toBe('oauth2');
-    expect(instagramConnector.auth.oauth2).toBeDefined();
-    expect(instagramConnector.auth.oauth2!.authUrl).toBe('https://api.instagram.com/oauth/authorize');
-    expect(instagramConnector.auth.oauth2!.tokenUrl).toBe('https://api.instagram.com/oauth/access_token');
-    expect(instagramConnector.auth.oauth2!.scopes).toContain('instagram_basic');
-    expect(instagramConnector.auth.oauth2!.scopes.length).toBe(4);
-  });
-
-  it('should define all 6 actions', () => {
-    expect(instagramConnector.actions).toHaveLength(6);
-    const actionIds = instagramConnector.actions.map((a) => a.id);
-    expect(actionIds).toContain('feed-read');
-    expect(actionIds).toContain('stories-read');
-    expect(actionIds).toContain('dm-list');
-    expect(actionIds).toContain('dm-send');
-    expect(actionIds).toContain('post-schedule');
-    expect(actionIds).toContain('profile-get');
-  });
-
-  it('should have correct trust and side effect settings', () => {
-    const readAction = instagramConnector.actions.find((a) => a.id === 'feed-read');
-    expect(readAction!.trustMinimum).toBe(1);
-    expect(readAction!.sideEffects).toBe(false);
-
-    const dmAction = instagramConnector.actions.find((a) => a.id === 'dm-send');
-    expect(dmAction!.trustMinimum).toBe(3);
-    expect(dmAction!.sideEffects).toBe(true);
-  });
-
-  it('should execute feed-read action', async () => {
-    // GET /me/media?fields=... -> { data: [] }
-    fetchMock.mockResolvedValueOnce(mockResponse({ data: [] }));
-    const result = await instagramConnector.executeAction('feed-read', {}, 'token');
-    expect(result).toEqual({ posts: [] });
-  });
-
-  it('should execute dm-send action', async () => {
-    // dm-send returns unavailable status (Instagram Messaging API requires approved access)
-    const result = await instagramConnector.executeAction('dm-send', { recipientId: 'u1', text: 'Hi' }, 'token') as any;
-    expect(result.status).toBe('unavailable');
-  });
-
-  it('should execute post-schedule action', async () => {
-    // POST /me/media -> { id: 'container1' } (create media container)
-    fetchMock.mockResolvedValueOnce(mockResponse({ id: 'container1' }));
-    // POST /me/media_publish -> { id: 'post1' } (publish)
-    fetchMock.mockResolvedValueOnce(mockResponse({ id: 'post1' }));
-    const result = await instagramConnector.executeAction('post-schedule', { caption: 'Hello', mediaUrl: 'https://example.com/img.jpg' }, 'token') as any;
-    expect(result.status).toBe('published');
-    expect(result.postId).toBe('post1');
-  });
-
-  it('should execute profile-get action', async () => {
-    // GET /me?fields=... -> profile object
-    fetchMock.mockResolvedValueOnce(mockResponse({ id: 'me123', username: 'testuser', name: 'Test' }));
-    const result = await instagramConnector.executeAction('profile-get', {}, 'token') as any;
-    expect(result.id).toBe('me123');
-  });
-
-  it('should throw for unknown action', async () => {
-    await expect(instagramConnector.executeAction('unknown', {}, 'token')).rejects.toThrow('Unknown action');
-  });
-
-  it('should return empty events from pollTrigger', async () => {
-    // new-dm trigger returns [] directly without fetching
-    const events = await instagramConnector.pollTrigger!('new-dm', 'token');
-    expect(events).toEqual([]);
-  });
-
-  it('should define triggers', () => {
-    expect(instagramConnector.triggers).toHaveLength(2);
-    const triggerIds = instagramConnector.triggers.map((t) => t.id);
-    expect(triggerIds).toContain('new-dm');
-    expect(triggerIds).toContain('new-comment');
-  });
-
-  it('should define entities', () => {
-    expect(instagramConnector.entities).toHaveLength(2);
-    const entityIds = instagramConnector.entities.map((e) => e.id);
-    expect(entityIds).toContain('post');
-    expect(entityIds).toContain('story');
-  });
-});