@auxiora/connector-social 1.0.0 → 1.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@auxiora/connector-social",
-  "version": "1.0.0",
+  "version": "1.3.1",
   "description": "Social media connectors: Twitter/X, LinkedIn, Reddit, Instagram",
   "type": "module",
   "main": "dist/index.js",
@@ -12,11 +12,17 @@
     }
   },
   "dependencies": {
-    "@auxiora/connectors": "1.0.0"
+    "@auxiora/connectors": "1.3.1"
   },
   "engines": {
     "node": ">=22.0.0"
   },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist/"
+  ],
   "scripts": {
     "build": "tsc",
     "clean": "rm -rf dist",

package/src/index.ts

@@ -1,4 +0,0 @@
-export { twitterConnector } from './twitter.js';
-export { linkedinConnector } from './linkedin.js';
-export { redditConnector } from './reddit.js';
-export { instagramConnector } from './instagram.js';

package/src/instagram.ts

@@ -1,212 +0,0 @@
-import { defineConnector } from '@auxiora/connectors';
-import type { TriggerEvent } from '@auxiora/connectors';
-
-async function instagramFetch(token: string, path: string, options?: { method?: string; body?: unknown }) {
-  const url = new URL(`https://graph.instagram.com${path}`);
-  if (!options?.method || options.method === 'GET') {
-    url.searchParams.set('access_token', token);
-  }
-  const res = await fetch(url.toString(), {
-    method: options?.method ?? 'GET',
-    headers: options?.body ? { 'Content-Type': 'application/json', 'Authorization': `Bearer ${token}` } : { 'Authorization': `Bearer ${token}` },
-    body: options?.body ? JSON.stringify(options.body) : undefined,
-  });
-  if (!res.ok) throw new Error(`Instagram API error: ${res.status} ${await res.text().catch(() => res.statusText)}`);
-  return res.json() as Promise<Record<string, unknown>>;
-}
-
-export const instagramConnector = defineConnector({
-  id: 'instagram',
-  name: 'Instagram',
-  description: 'Integration with Instagram for posts, stories, and direct messages',
-  version: '1.0.0',
-  category: 'social',
-  icon: 'instagram',
-
-  auth: {
-    type: 'oauth2',
-    oauth2: {
-      authUrl: 'https://api.instagram.com/oauth/authorize',
-      tokenUrl: 'https://api.instagram.com/oauth/access_token',
-      scopes: ['user_profile', 'user_media', 'instagram_basic', 'instagram_manage_messages'],
-    },
-  },
-
-  actions: [
-    {
-      id: 'feed-read',
-      name: 'Read Feed',
-      description: 'Read the Instagram feed',
-      trustMinimum: 1,
-      trustDomain: 'messaging',
-      reversible: false,
-      sideEffects: false,
-      params: {},
-    },
-    {
-      id: 'stories-read',
-      name: 'Read Stories',
-      description: 'Read Instagram stories',
-      trustMinimum: 1,
-      trustDomain: 'messaging',
-      reversible: false,
-      sideEffects: false,
-      params: {},
-    },
-    {
-      id: 'dm-list',
-      name: 'List Direct Messages',
-      description: 'List Instagram direct messages',
-      trustMinimum: 1,
-      trustDomain: 'messaging',
-      reversible: false,
-      sideEffects: false,
-      params: {},
-    },
-    {
-      id: 'dm-send',
-      name: 'Send Direct Message',
-      description: 'Send an Instagram direct message',
-      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 },
-      },
-    },
-    {
-      id: 'post-schedule',
-      name: 'Schedule Post',
-      description: 'Schedule a post on Instagram',
-      trustMinimum: 3,
-      trustDomain: 'messaging',
-      reversible: false,
-      sideEffects: true,
-      params: {
-        caption: { type: 'string', description: 'Post caption', required: true },
-        mediaUrl: { type: 'string', description: 'Media URL', required: true },
-        scheduledAt: { type: 'string', description: 'Scheduled time (ISO 8601)' },
-      },
-    },
-    {
-      id: 'profile-get',
-      name: 'Get Profile',
-      description: 'Get an Instagram profile',
-      trustMinimum: 1,
-      trustDomain: 'messaging',
-      reversible: false,
-      sideEffects: false,
-      params: {
-        userId: { type: 'string', description: 'User ID (default: authenticated user)' },
-      },
-    },
-  ],
-
-  triggers: [
-    {
-      id: 'new-dm',
-      name: 'New Direct Message',
-      description: 'Triggered when a new direct message is received',
-      type: 'poll',
-      pollIntervalMs: 120_000,
-    },
-    {
-      id: 'new-comment',
-      name: 'New Comment',
-      description: 'Triggered when a new comment is posted on your content',
-      type: 'poll',
-      pollIntervalMs: 300_000,
-    },
-  ],
-
-  entities: [
-    {
-      id: 'post',
-      name: 'Post',
-      description: 'An Instagram post',
-      fields: { id: 'string', caption: 'string', mediaUrl: 'string', likeCount: 'number', commentCount: 'number' },
-    },
-    {
-      id: 'story',
-      name: 'Story',
-      description: 'An Instagram story',
-      fields: { id: 'string', mediaUrl: 'string', expiresAt: 'string' },
-    },
-  ],
-
-  async executeAction(actionId: string, params: Record<string, unknown>, token: string): Promise<unknown> {
-    switch (actionId) {
-      case 'feed-read': {
-        const res = await instagramFetch(token, '/me/media?fields=id,caption,media_url,timestamp,like_count,comments_count');
-        return { posts: res.data };
-      }
-      case 'stories-read': {
-        const res = await instagramFetch(token, '/me/stories?fields=id,media_url,timestamp');
-        return { stories: res.data };
-      }
-      case 'dm-list': {
-        return { messages: [], note: 'Instagram Messaging API requires approved app access' };
-      }
-      case 'dm-send': {
-        return { error: 'Instagram Messaging API requires approved app access', status: 'unavailable' };
-      }
-      case 'post-schedule': {
-        // Step 1: Create media container
-        const container = await instagramFetch(token, '/me/media', {
-          method: 'POST',
-          body: {
-            caption: params.caption,
-            image_url: params.mediaUrl,
-          },
-        });
-        const creationId = container.id as string;
-        // Step 2: Publish the media
-        const published = await instagramFetch(token, '/me/media_publish', {
-          method: 'POST',
-          body: { creation_id: creationId },
-        });
-        return { postId: published.id, status: 'published' };
-      }
-      case 'profile-get': {
-        const userId = (params.userId as string | undefined) ?? 'me';
-        const fields = 'id,username,name,biography,media_count,followers_count,follows_count';
-        const res = await instagramFetch(token, `/${userId}?fields=${fields}`);
-        return res;
-      }
-      default:
-        throw new Error(`Unknown action: ${actionId}`);
-    }
-  },
-
-  async pollTrigger(triggerId: string, token: string, lastPollAt?: number): Promise<TriggerEvent[]> {
-    switch (triggerId) {
-      case 'new-dm':
-        // Instagram Messaging API requires approved access
-        return [];
-      case 'new-comment': {
-        const media = await instagramFetch(token, '/me/media?fields=id&limit=10');
-        const posts = (media.data ?? []) as Array<Record<string, unknown>>;
-        const events: TriggerEvent[] = [];
-        const since = lastPollAt ? new Date(lastPollAt).toISOString() : undefined;
-        for (const post of posts) {
-          const sinceParam = since ? `&since=${since}` : '';
-          const commentsRes = await instagramFetch(token, `/${post.id as string}/comments?fields=id,text,username,timestamp${sinceParam}`);
-          const comments = (commentsRes.data ?? []) as Array<Record<string, unknown>>;
-          for (const comment of comments) {
-            events.push({
-              triggerId: 'new-comment',
-              connectorId: 'instagram',
-              data: { ...comment, mediaId: post.id },
-              timestamp: comment.timestamp ? new Date(comment.timestamp as string).getTime() : Date.now(),
-            });
-          }
-        }
-        return events;
-      }
-      default:
-        return [];
-    }
-  },
-});

package/src/linkedin.ts

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