@agnocon/piece-bluesky 0.1.6

package/src/lib/triggers/new-post.ts

@@ -0,0 +1,225 @@
+import { createTrigger, TriggerStrategy, PiecePropValueSchema, Property, AppConnectionValueForAuthProperty } from '@agnocon/pieces-framework';
+import { DedupeStrategy, Polling, pollingHelper } from '@agnocon/pieces-common';
+import { blueskyAuth } from '../common/auth';
+import { createBlueskyAgent } from '../common/client';
+import { simpleLanguageDropdown } from '../common/props';
+import dayjs from 'dayjs';
+
+const polling: Polling<AppConnectionValueForAuthProperty<typeof blueskyAuth>, { 
+  searchQuery: string; 
+  searchLanguage?: string;
+  includeImages?: boolean;
+  includeVideos?: boolean;
+  sortBy?: string;
+}> = {
+  strategy: DedupeStrategy.TIMEBASED,
+  items: async ({ auth, propsValue, lastFetchEpochMS }) => {
+    const { searchQuery, searchLanguage, includeImages, includeVideos, sortBy } = propsValue;
+    
+    try {
+      if (!searchQuery || searchQuery.trim().length === 0) {
+        return [];
+      }
+
+      const agent = await createBlueskyAgent(auth.props);
+
+      const searchParams: any = {
+        q: searchQuery.trim(),
+        limit: 50,
+        sort: sortBy || 'latest'
+      };
+
+      if (searchLanguage && searchLanguage !== 'other') {
+        searchParams.lang = searchLanguage;
+      }
+
+      const response = await agent.api.app.bsky.feed.searchPosts(searchParams);
+
+      if (!response.data?.posts || !Array.isArray(response.data.posts)) {
+        return [];
+      }
+
+      const cutoffTime = lastFetchEpochMS || 0;
+
+      return response.data.posts
+        .filter((post: any) => {
+          if (!post.indexedAt) return false;
+          
+          const postTime = dayjs(post.indexedAt).valueOf();
+          if (postTime <= cutoffTime) return false;
+
+          if (includeImages === false && post.embed?.images) return false;
+          if (includeVideos === false && post.embed?.video) return false;
+          if (includeImages === true && !post.embed?.images) return false;
+          if (includeVideos === true && !post.embed?.video) return false;
+
+          return true;
+        })
+        .map((post: any) => ({
+          epochMilliSeconds: dayjs(post.indexedAt).valueOf(),
+          data: {
+            uri: post.uri,
+            cid: post.cid,
+            author: post.author,
+            record: post.record,
+            indexedAt: post.indexedAt,
+            
+            replyCount: post.replyCount || 0,
+            repostCount: post.repostCount || 0,
+            likeCount: post.likeCount || 0,
+            quoteCount: post.quoteCount || 0,
+            
+            labels: post.labels || [],
+            viewer: post.viewer || {},
+            embed: post.embed || null,
+            
+            searchContext: {
+              query: searchQuery,
+              language: searchLanguage || null,
+              matchedTerms: extractMatchedTerms(post.record?.text || '', searchQuery),
+              hasImages: !!(post.embed?.images),
+              hasVideo: !!(post.embed?.video),
+              hasExternalLink: !!(post.embed?.external)
+            }
+          }
+        }))
+        .sort((a: any, b: any) => b.epochMilliSeconds - a.epochMilliSeconds);
+
+    } catch (error) {
+      console.warn('Failed to search posts:', error instanceof Error ? error.message : 'Unknown error');
+      return [];
+    }
+  }
+};
+
+function extractMatchedTerms(text: string, query: string): string[] {
+  if (!text || !query) return [];
+  
+  const cleanQuery = query.toLowerCase()
+    .replace(/["']/g, '')
+    .replace(/\s+(or|and)\s+/gi, ' ');
+  
+  const terms = cleanQuery.split(/\s+/).filter(term => term.length > 0 && !['or', 'and'].includes(term.toLowerCase()));
+  const matchedTerms: string[] = [];
+  const lowerText = text.toLowerCase();
+  
+  terms.forEach(term => {
+    if (term.startsWith('#') || term.startsWith('@')) {
+      if (lowerText.includes(term)) {
+        matchedTerms.push(term);
+      }
+    } else if (lowerText.includes(term)) {
+      matchedTerms.push(term);
+    }
+  });
+  
+  return [...new Set(matchedTerms)];
+}
+
+export const newPost = createTrigger({
+  auth: blueskyAuth,
+  name: 'newPost',
+  displayName: 'New Post (with Search Options)',
+  description: 'Triggers when posts match your search criteria',
+  aiMetadata: {
+    description: 'Fires when a new public Bluesky post matches a configured search query (keywords, hashtags, or mentions), with optional language and media filters; each event represents one newly indexed matching post.',
+  },
+  props: {
+    searchQuery: Property.ShortText({
+      displayName: 'Search Query',
+      description: 'Keywords, hashtags (#example), or mentions (@handle) to find',
+      required: true
+    }),
+    searchLanguage: {
+      ...simpleLanguageDropdown,
+      displayName: 'Language Filter',
+      description: 'Filter by language',
+      required: false
+    },
+    includeImages: Property.Checkbox({
+      displayName: 'Filter by Images',
+      description: 'Only posts with/without images',
+      required: false,
+      defaultValue: undefined
+    }),
+    includeVideos: Property.Checkbox({
+      displayName: 'Filter by Videos',
+      description: 'Only posts with/without videos',
+      required: false,
+      defaultValue: undefined
+    }),
+    sortBy: Property.StaticDropdown({
+      displayName: 'Sort Order',
+      description: 'How to sort results',
+      required: false,
+      defaultValue: 'latest',
+      options: {
+        options: [
+          { label: 'Latest First', value: 'latest' },
+          { label: 'Most Popular', value: 'top' }
+        ]
+      }
+    })
+  },
+  sampleData: {
+    uri: 'at://did:plc:example123/app.bsky.feed.post/example456',
+    cid: 'bafyreib2rxk3vcfbqij7y6kzgy4knknc7ff4t5jn2m5fbn6jdl7czfqyqe',
+    author: {
+      did: 'did:plc:example123',
+      handle: 'searchauthor.bsky.social',
+      displayName: 'Search Result Author',
+      avatar: 'https://cdn.bsky.app/img/avatar/plain/did:plc:example123/example@jpeg',
+      viewer: {
+        muted: false,
+        blockedBy: false
+      }
+    },
+    record: {
+      $type: 'app.bsky.feed.post',
+      createdAt: '2024-01-01T12:00:00.000Z',
+      text: 'This post matches your search criteria! #automation #activepieces',
+      langs: ['en']
+    },
+    indexedAt: '2024-01-01T12:00:00.000Z',
+    
+    replyCount: 2,
+    repostCount: 5,
+    likeCount: 12,
+    quoteCount: 1,
+    
+    labels: [],
+    viewer: {
+      repost: null,
+      like: null
+    },
+    embed: null,
+    
+    searchContext: {
+      query: 'automation',
+      language: 'en',
+      matchedTerms: ['automation'],
+      hasImages: false,
+      hasVideo: false,
+      hasExternalLink: false
+    }
+  },
+  type: TriggerStrategy.POLLING,
+  
+  async test(context) {
+    return await pollingHelper.test(polling, context);
+  },
+  
+  async onEnable(context) {
+    const { store, auth, propsValue } = context;
+    await pollingHelper.onEnable(polling, { store, auth, propsValue });
+  },
+
+  async onDisable(context) {
+    const { store, auth, propsValue } = context;
+    await pollingHelper.onDisable(polling, { store, auth, propsValue });
+  },
+
+  async run(context) {
+    return await pollingHelper.poll(polling, context);
+  },
+});

package/src/lib/triggers/new-posts-by-author.ts

@@ -0,0 +1,252 @@
+import { createTrigger, TriggerStrategy, PiecePropValueSchema, Property, AppConnectionValueForAuthProperty } from '@agnocon/pieces-framework';
+import { DedupeStrategy, Polling, pollingHelper } from '@agnocon/pieces-common';
+import { blueskyAuth, BlueSkyAuthType } from '../common/auth';
+import { createBlueskyAgent } from '../common/client';
+import dayjs from 'dayjs';
+
+const polling: Polling<AppConnectionValueForAuthProperty<typeof blueskyAuth>, { 
+  authorSelection: string;
+  authorFromFollowing?: string;
+  authorHandle?: string;
+  includeReplies?: boolean;
+  includeReposts?: boolean;
+}> = {
+  strategy: DedupeStrategy.TIMEBASED,
+  items: async ({ auth, propsValue, lastFetchEpochMS }) => {
+    const { authorSelection, authorFromFollowing, authorHandle, includeReplies = false, includeReposts = false } = propsValue;
+    
+    let selectedAuthorHandle: string;
+    if (authorSelection === 'following') {
+      if (!authorFromFollowing) {
+        return [];
+      }
+      selectedAuthorHandle = authorFromFollowing;
+    } else if (authorSelection === 'manual') {
+      if (!authorHandle) {
+        return [];
+      }
+      selectedAuthorHandle = authorHandle;
+    } else {
+      return [];
+    }
+    
+    try {
+      if (!selectedAuthorHandle || selectedAuthorHandle.trim().length === 0) {
+        return [];
+      }
+
+      const agent = await createBlueskyAgent(auth.props);
+      
+      const normalizedHandle = selectedAuthorHandle.replace('@', '').trim();
+      
+      const response = await agent.getAuthorFeed({
+        actor: normalizedHandle,
+        limit: 50,
+        filter: 'posts_with_replies'
+      });
+
+      if (!response.data?.feed || !Array.isArray(response.data.feed)) {
+        return [];
+      }
+
+      const cutoffTime = lastFetchEpochMS || 0;
+
+      return response.data.feed
+        .filter((feedItem: any) => {
+          const post = feedItem.post;
+          if (!post || !post.indexedAt) return false;
+          
+          const postTime = dayjs(post.indexedAt).valueOf();
+          if (postTime <= cutoffTime) return false;
+
+          const isReply = post.record?.reply !== undefined;
+          const isRepost = feedItem.reason?.$type === 'app.bsky.feed.defs#reasonRepost';
+          
+          if (isReply && !includeReplies) return false;
+          if (isRepost && !includeReposts) return false;
+          
+          return post.author.handle === normalizedHandle || post.author.did === normalizedHandle;
+        })
+        .map((feedItem: any) => {
+          const post = feedItem.post;
+          return {
+            epochMilliSeconds: dayjs(post.indexedAt).valueOf(),
+            data: {
+              uri: post.uri,
+              cid: post.cid,
+              author: post.author,
+              record: post.record,
+              indexedAt: post.indexedAt,
+              
+              replyCount: post.replyCount || 0,
+              repostCount: post.repostCount || 0,
+              likeCount: post.likeCount || 0,
+              quoteCount: post.quoteCount || 0,
+              
+              labels: post.labels || [],
+              viewer: post.viewer || {},
+              embed: post.embed || null,
+              
+              postContext: {
+                authorHandle: normalizedHandle,
+                isReply: post.record?.reply !== undefined,
+                isRepost: feedItem.reason?.$type === 'app.bsky.feed.defs#reasonRepost',
+                replyTo: post.record?.reply?.parent?.uri || null,
+                hasImages: !!(post.embed?.images),
+                hasVideo: !!(post.embed?.video),
+                hasExternalLink: !!(post.embed?.external)
+              }
+            }
+          };
+        })
+        .sort((a: any, b: any) => b.epochMilliSeconds - a.epochMilliSeconds);
+
+    } catch (error) {
+      console.warn('Failed to fetch author posts:', error instanceof Error ? error.message : 'Unknown error');
+      return [];
+    }
+  }
+};
+
+export const newPostsByAuthor = createTrigger({
+  auth: blueskyAuth,
+  name: 'newPostsByAuthor',
+  displayName: 'New Posts by Author',
+  description: 'Triggers when a selected author creates a new post',
+  aiMetadata: {
+    description: 'Fires when a chosen Bluesky author (picked from your following list or by handle) publishes a new post; each event represents one new post by that author, optionally including their replies and reposts.',
+  },
+  props: {
+    authorSelection: Property.StaticDropdown({
+      displayName: 'How to select author?',
+      description: 'Choose how to select the author',
+      required: true,
+      defaultValue: 'following',
+      options: {
+        options: [
+          { label: 'From my following list', value: 'following' },
+          { label: 'Enter handle manually', value: 'manual' },
+        ],
+      },
+    }),
+    
+    authorFromFollowing: Property.Dropdown({
+      auth: blueskyAuth,
+      displayName: 'Select Author',
+      description: 'Choose from accounts you follow',
+      required: false,
+      refreshers: ['auth'],
+      options: async ({ auth }) => {
+        try {
+          if (!auth) return { options: [] };
+          const agent = await createBlueskyAgent(auth.props);
+          const session = agent.session;
+          
+          if (!session?.did) {
+            return { options: [{ label: 'Please authenticate first', value: '' }] };
+          }
+          
+          const followingResponse = await agent.getFollows({ 
+            actor: session.did, 
+            limit: 100 
+          });
+          
+          return {
+            options: followingResponse.data.follows.map(follow => ({
+              label: `${follow.displayName || follow.handle} (@${follow.handle})`,
+              value: follow.handle
+            }))
+          };
+        } catch (error) {
+          return { 
+            options: [{ label: 'Error loading following list', value: '' }] 
+          };
+        }
+      }
+    }),
+    
+    authorHandle: Property.ShortText({
+      displayName: 'Author Handle',
+      description: 'Enter the Bluesky username (e.g., username.bsky.social)',
+      required: false
+    }),
+    includeReplies: Property.Checkbox({
+      displayName: 'Include Replies',
+      description: 'Include reply posts by this author',
+      required: false,
+      defaultValue: false
+    }),
+    includeReposts: Property.Checkbox({
+      displayName: 'Include Reposts',
+      description: 'Include posts that this author reposted',
+      required: false,
+      defaultValue: false
+    })
+  },
+  sampleData: {
+    uri: 'at://did:plc:example123/app.bsky.feed.post/example456',
+    cid: 'bafyreib2rxk3vcfbqij7y6kzgy4knknc7ff4t5jn2m5fbn6jdl7czfqyqe',
+    author: {
+      did: 'did:plc:example123',
+      handle: 'author.bsky.social',
+      displayName: 'Example Author',
+      avatar: 'https://cdn.bsky.app/img/avatar/plain/did:plc:example123/example@jpeg',
+      followersCount: 1500,
+      followsCount: 300,
+      postsCount: 250,
+      viewer: {
+        muted: false,
+        blockedBy: false,
+        following: 'at://following-record-uri'
+      }
+    },
+    record: {
+      $type: 'app.bsky.feed.post',
+      createdAt: '2024-01-01T12:00:00.000Z',
+      text: 'Just posted something new! Excited to share this with everyone.',
+      langs: ['en']
+    },
+    indexedAt: '2024-01-01T12:00:00.000Z',
+    
+    replyCount: 3,
+    repostCount: 8,
+    likeCount: 25,
+    quoteCount: 2,
+    
+    labels: [],
+    viewer: {
+      repost: null,
+      like: null
+    },
+    embed: null,
+    
+    postContext: {
+      authorHandle: 'author.bsky.social',
+      isReply: false,
+      isRepost: false,
+      replyTo: null,
+      hasImages: false,
+      hasVideo: false,
+      hasExternalLink: false
+    }
+  },
+  type: TriggerStrategy.POLLING,
+  
+  async test(context) {
+    return await pollingHelper.test(polling, context);
+  },
+  
+  async onEnable(context) {
+    const { store, auth, propsValue } = context;
+    await pollingHelper.onEnable(polling, { store, auth, propsValue });
+  },
+
+  async onDisable(context) {
+    const { store, auth, propsValue } = context;
+    await pollingHelper.onDisable(polling, { store, auth, propsValue });
+  },
+
+  async run(context) {
+    return await pollingHelper.poll(polling, context);
+  },
+});

package/src/lib/triggers/new-timeline-posts.ts

@@ -0,0 +1,141 @@
+import { createTrigger, TriggerStrategy, PiecePropValueSchema, AppConnectionValueForAuthProperty } from '@agnocon/pieces-framework';
+import { DedupeStrategy, Polling, pollingHelper } from '@agnocon/pieces-common';
+import { blueskyAuth } from '../common/auth';
+import { createBlueskyAgent } from '../common/client';
+import dayjs from 'dayjs';
+
+const polling: Polling<AppConnectionValueForAuthProperty<typeof blueskyAuth>, Record<string, never>> = {
+  strategy: DedupeStrategy.TIMEBASED,
+  items: async ({ auth, lastFetchEpochMS }) => {
+    try {
+      const agent = await createBlueskyAgent(auth.props);
+      
+      const response = await agent.getTimeline({
+        limit: 50
+      });
+
+      if (!response.data?.feed || !Array.isArray(response.data.feed)) {
+        return [];
+      }
+
+      const cutoffTime = lastFetchEpochMS || 0;
+
+      return response.data.feed
+        .filter((item: any) => {
+          if (!item.post || !item.post.indexedAt) return false;
+          
+          const postTime = dayjs(item.post.indexedAt).valueOf();
+          return postTime > cutoffTime;
+        })
+        .map((item: any) => ({
+          epochMilliSeconds: dayjs(item.post.indexedAt).valueOf(),
+          data: {
+            uri: item.post.uri,
+            cid: item.post.cid,
+            author: item.post.author,
+            record: item.post.record,
+            indexedAt: item.post.indexedAt,
+            
+            replyCount: item.post.replyCount || 0,
+            repostCount: item.post.repostCount || 0,
+            likeCount: item.post.likeCount || 0,
+            quoteCount: item.post.quoteCount || 0,
+            
+            labels: item.post.labels || [],
+            viewer: item.post.viewer || {},
+            embed: item.post.embed || null,
+            
+            reason: item.reason || null,
+            reply: item.reply || null,
+            
+            feedContext: {
+              isRepost: !!item.reason,
+              repostBy: item.reason?.by || null,
+              isReply: !!item.reply,
+              replyToPost: item.reply?.parent || null,
+              replyToRoot: item.reply?.root || null
+            }
+          }
+        }))
+        .sort((a: any, b: any) => b.epochMilliSeconds - a.epochMilliSeconds);
+
+    } catch (error) {
+      console.warn('Failed to fetch timeline posts:', error instanceof Error ? error.message : 'Unknown error');
+      return [];
+    }
+  }
+};
+
+export const newTimelinePosts = createTrigger({
+  auth: blueskyAuth,
+  name: 'newTimelinePosts',
+  displayName: 'New Timeline Posts',
+  description: 'Triggers when new posts appear in your timeline',
+  aiMetadata: {
+    description: 'Fires when a new post appears in the authenticated account\'s home timeline (posts and reposts from accounts it follows); each event represents one such timeline item.',
+  },
+  props: {},
+  sampleData: {
+    uri: 'at://did:plc:example123/app.bsky.feed.post/example456',
+    cid: 'bafyreib2rxk3vcfbqij7y6kzgy4knknc7ff4t5jn2m5fbn6jdl7czfqyqe',
+    author: {
+      did: 'did:plc:example123',
+      handle: 'author.bsky.social',
+      displayName: 'Example Author',
+      avatar: 'https://cdn.bsky.app/img/avatar/plain/did:plc:example123/example@jpeg',
+      viewer: {
+        muted: false,
+        blockedBy: false,
+        following: 'at://did:plc:user456/app.bsky.graph.follow/example789'
+      }
+    },
+    record: {
+      $type: 'app.bsky.feed.post',
+      createdAt: '2024-01-01T12:00:00.000Z',
+      text: 'This is a new post in your timeline!',
+      langs: ['en']
+    },
+    indexedAt: '2024-01-01T12:00:00.000Z',
+    
+    replyCount: 3,
+    repostCount: 8,
+    likeCount: 15,
+    quoteCount: 2,
+    
+    labels: [],
+    viewer: {
+      repost: null,
+      like: null
+    },
+    embed: null,
+    
+    reason: null,
+    reply: null,
+    feedContext: {
+      isRepost: false,
+      repostBy: null,
+      isReply: false,
+      replyToPost: null,
+      replyToRoot: null
+    }
+  },
+  type: TriggerStrategy.POLLING,
+  
+  async test(context) {
+    return await pollingHelper.test(polling, context);
+  },
+  
+  async onEnable(context) {
+    const { store, auth, propsValue } = context;
+    await pollingHelper.onEnable(polling, { store, auth, propsValue });
+  },
+
+  async onDisable(context) {
+    const { store, auth, propsValue } = context;
+    await pollingHelper.onDisable(polling, { store, auth, propsValue });
+  },
+
+  async run(context) {
+    return await pollingHelper.poll(polling, context);
+  },
+});