@auxiora/connector-social 1.0.0

package/src/linkedin.ts

@@ -0,0 +1,243 @@
+import { defineConnector } from '@auxiora/connectors';
+import type { TriggerEvent } from '@auxiora/connectors';
+
+async function linkedinFetch(token: string, path: string, options?: { method?: string; body?: unknown }) {
+  const res = await fetch(`https://api.linkedin.com/v2${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(`LinkedIn API error: ${res.status} ${await res.text().catch(() => res.statusText)}`);
+  return res.json() as Promise<Record<string, unknown>>;
+}
+
+export const linkedinConnector = defineConnector({
+  id: 'linkedin',
+  name: 'LinkedIn',
+  description: 'Integration with LinkedIn for posts, connections, and messaging',
+  version: '1.0.0',
+  category: 'social',
+  icon: 'linkedin',
+
+  auth: {
+    type: 'oauth2',
+    oauth2: {
+      authUrl: 'https://www.linkedin.com/oauth/v2/authorization',
+      tokenUrl: 'https://www.linkedin.com/oauth/v2/accessToken',
+      scopes: ['r_liteprofile', 'r_emailaddress', 'w_member_social', 'r_basicprofile'],
+    },
+  },
+
+  actions: [
+    {
+      id: 'feed-read',
+      name: 'Read Feed',
+      description: 'Read the LinkedIn news feed',
+      trustMinimum: 1,
+      trustDomain: 'integrations',
+      reversible: false,
+      sideEffects: false,
+      params: {},
+    },
+    {
+      id: 'post-update',
+      name: 'Post Update',
+      description: 'Post a status update on LinkedIn',
+      trustMinimum: 3,
+      trustDomain: 'integrations',
+      reversible: false,
+      sideEffects: true,
+      params: {
+        text: { type: 'string', description: 'Post text', required: true },
+      },
+    },
+    {
+      id: 'post-article',
+      name: 'Post Article',
+      description: 'Share an article on LinkedIn',
+      trustMinimum: 3,
+      trustDomain: 'integrations',
+      reversible: false,
+      sideEffects: true,
+      params: {
+        title: { type: 'string', description: 'Article title', required: true },
+        url: { type: 'string', description: 'Article URL', required: true },
+        commentary: { type: 'string', description: 'Commentary text' },
+      },
+    },
+    {
+      id: 'connections-list',
+      name: 'List Connections',
+      description: 'List LinkedIn connections',
+      trustMinimum: 1,
+      trustDomain: 'integrations',
+      reversible: false,
+      sideEffects: false,
+      params: {},
+    },
+    {
+      id: 'messages-list',
+      name: 'List Messages',
+      description: 'List LinkedIn messages',
+      trustMinimum: 1,
+      trustDomain: 'messaging',
+      reversible: false,
+      sideEffects: false,
+      params: {},
+    },
+    {
+      id: 'message-send',
+      name: 'Send Message',
+      description: 'Send a message on LinkedIn',
+      trustMinimum: 3,
+      trustDomain: 'messaging',
+      reversible: false,
+      sideEffects: true,
+      params: {
+        recipientId: { type: 'string', description: 'Recipient profile ID', required: true },
+        text: { type: 'string', description: 'Message text', required: true },
+      },
+    },
+    {
+      id: 'profile-get',
+      name: 'Get Profile',
+      description: 'Get a LinkedIn profile',
+      trustMinimum: 1,
+      trustDomain: 'integrations',
+      reversible: false,
+      sideEffects: false,
+      params: {
+        profileId: { type: 'string', description: 'Profile ID (default: authenticated user)' },
+      },
+    },
+  ],
+
+  triggers: [
+    {
+      id: 'new-message',
+      name: 'New Message',
+      description: 'Triggered when a new LinkedIn message is received',
+      type: 'poll',
+      pollIntervalMs: 120_000,
+    },
+    {
+      id: 'post-engagement',
+      name: 'Post Engagement',
+      description: 'Triggered when a post receives engagement',
+      type: 'poll',
+      pollIntervalMs: 300_000,
+    },
+  ],
+
+  entities: [
+    {
+      id: 'post',
+      name: 'Post',
+      description: 'A LinkedIn post',
+      fields: { id: 'string', text: 'string', authorName: 'string', likes: 'number', comments: 'number', shares: 'number' },
+    },
+    {
+      id: 'connection',
+      name: 'Connection',
+      description: 'A LinkedIn connection',
+      fields: { id: 'string', name: 'string', headline: 'string', company: 'string' },
+    },
+  ],
+
+  async executeAction(actionId: string, params: Record<string, unknown>, token: string): Promise<unknown> {
+    switch (actionId) {
+      case 'feed-read': {
+        const me = await linkedinFetch(token, '/me');
+        const urn = `urn:li:person:${me.id as string}`;
+        try {
+          const posts = await linkedinFetch(token, `/ugcPosts?q=authors&authors=List(${encodeURIComponent(urn)})&count=10`);
+          return { posts: posts.elements };
+        } catch (err) {
+          return { posts: [], error: `Feed access restricted: ${(err as Error).message}` };
+        }
+      }
+      case 'post-update': {
+        const me = await linkedinFetch(token, '/me');
+        const authorUrn = `urn:li:person:${me.id as string}`;
+        const res = await linkedinFetch(token, '/ugcPosts', {
+          method: 'POST',
+          body: {
+            author: authorUrn,
+            lifecycleState: 'PUBLISHED',
+            specificContent: {
+              'com.linkedin.ugc.ShareContent': {
+                shareCommentary: { text: params.text },
+                shareMediaCategory: 'NONE',
+              },
+            },
+            visibility: { 'com.linkedin.ugc.MemberNetworkVisibility': 'PUBLIC' },
+          },
+        });
+        return { postId: res.id, status: 'posted' };
+      }
+      case 'post-article': {
+        const me = await linkedinFetch(token, '/me');
+        const authorUrn = `urn:li:person:${me.id as string}`;
+        const res = await linkedinFetch(token, '/ugcPosts', {
+          method: 'POST',
+          body: {
+            author: authorUrn,
+            lifecycleState: 'PUBLISHED',
+            specificContent: {
+              'com.linkedin.ugc.ShareContent': {
+                shareCommentary: { text: (params.commentary as string) ?? '' },
+                shareMediaCategory: 'ARTICLE',
+                media: [{
+                  status: 'READY',
+                  originalUrl: params.url,
+                  title: { text: params.title },
+                }],
+              },
+            },
+            visibility: { 'com.linkedin.ugc.MemberNetworkVisibility': 'PUBLIC' },
+          },
+        });
+        return { postId: res.id, status: 'shared' };
+      }
+      case 'connections-list': {
+        try {
+          const res = await linkedinFetch(token, '/connections?q=viewer&count=50');
+          return { connections: res.elements };
+        } catch (err) {
+          return { connections: [], error: `Connections access restricted: ${(err as Error).message}` };
+        }
+      }
+      case 'messages-list': {
+        try {
+          const res = await linkedinFetch(token, '/messages');
+          return { messages: res.elements };
+        } catch (err) {
+          return { messages: [], error: `Messages access restricted: ${(err as Error).message}` };
+        }
+      }
+      case 'message-send': {
+        const res = await linkedinFetch(token, '/messages', {
+          method: 'POST',
+          body: {
+            recipients: [`urn:li:person:${params.recipientId as string}`],
+            body: params.text,
+          },
+        });
+        return { messageId: res.id, status: 'sent' };
+      }
+      case 'profile-get': {
+        const profileId = params.profileId as string | undefined;
+        const path = profileId ? `/people/(id:${profileId})` : '/me';
+        const profile = await linkedinFetch(token, path);
+        return profile;
+      }
+      default:
+        throw new Error(`Unknown action: ${actionId}`);
+    }
+  },
+
+  // LinkedIn doesn't support efficient polling for triggers
+  async pollTrigger(_triggerId: string, _token: string, _lastPollAt?: number): Promise<TriggerEvent[]> {
+    return [];
+  },
+});

package/src/reddit.ts

@@ -0,0 +1,268 @@
+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 [];
+    }
+  },
+});