@agnocon/piece-bluesky 0.1.6

package/src/lib/actions/find-post.ts

@@ -0,0 +1,76 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { blueskyAuth } from '../common/auth';
+import { createBlueskyAgent } from '../common/client';
+import { postUrlProperty, extractPostInfoFromUrl } from '../common/props';
+
+export const findPost = createAction({
+  auth: blueskyAuth,
+  name: 'findPost',
+  displayName: 'Find Post',
+  description: 'Get detailed information about a specific post',
+  audience: 'both',
+  aiMetadata: {
+    description: 'Retrieves a single Bluesky post with its content, author, and engagement counts (likes, reposts, replies, quotes), given a bsky.app post URL or AT-URI. Use to look up the current state or metadata of a known post. Read-only and idempotent.',
+    idempotent: true,
+  },
+  props: {
+    postUrl: postUrlProperty,
+  },
+  async run({ auth, propsValue }) {
+    const { postUrl } = propsValue;
+
+    try {
+      const agent = await createBlueskyAgent(auth.props);
+      
+      const postInfo = extractPostInfoFromUrl(postUrl);
+      let atUri = postInfo.uri;
+
+      if (!atUri && postInfo.handle && postInfo.postId) {
+        const didDoc = await agent.resolveHandle({ handle: postInfo.handle });
+        
+        if (didDoc.data?.did) {
+          atUri = `at://${didDoc.data.did}/app.bsky.feed.post/${postInfo.postId}`;
+        } else {
+          throw new Error(`Could not resolve handle: ${postInfo.handle}`);
+        }
+      }
+
+      if (!atUri) {
+        throw new Error('Could not parse the post URL. Please make sure you are using a valid Bluesky post URL like: https://bsky.app/profile/username.bsky.social/post/xxx');
+      }
+
+      if (!atUri.startsWith('at://')) {
+        throw new Error('Invalid URI format. Must be an AT-URI starting with "at://" or a valid Bluesky URL');
+      }
+
+      const response = await agent.getPosts({ uris: [atUri] });
+
+      if (!response.data?.posts || response.data.posts.length === 0) {
+        throw new Error('Post not found or not accessible');
+      }
+
+      const post = response.data.posts[0];
+      
+      return {
+        success: true,
+        uri: atUri,
+        cid: post.cid,
+        record: post.record,
+        author: post.author,
+        indexedAt: post.indexedAt,
+        replyCount: post.replyCount || 0,
+        repostCount: post.repostCount || 0,
+        likeCount: post.likeCount || 0,
+        quoteCount: post.quoteCount || 0,
+        embed: post.embed, 
+        labels: post.labels,
+        threadgate: post.threadgate,
+        viewer: post.viewer,
+        retrievedAt: new Date().toISOString(),
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      throw new Error(`Failed to find post: ${errorMessage}`);
+    }
+  },
+});

package/src/lib/actions/find-thread.ts

@@ -0,0 +1,121 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { blueskyAuth } from '../common/auth';
+import { createBlueskyAgent } from '../common/client';
+import { postUrlProperty, threadDepthDropdown, parentHeightDropdown, extractPostInfoFromUrl } from '../common/props';
+
+export const findThread = createAction({
+  auth: blueskyAuth,
+  name: 'findThread',
+  displayName: 'Find Thread',
+  description: 'Get a full conversation thread with replies',
+  audience: 'both',
+  aiMetadata: {
+    description: 'Retrieves the full conversation thread around a Bluesky post — parent posts and nested replies — given a bsky.app post URL or AT-URI, with configurable reply depth and parent height (each 0-1000). Use to read an entire discussion rather than a single post. Read-only and idempotent.',
+    idempotent: true,
+  },
+  props: {
+    postUrl: postUrlProperty,
+    depth: threadDepthDropdown,
+    parentHeight: parentHeightDropdown,
+  },
+  async run({ auth, propsValue }) {
+    const { postUrl, depth = 6, parentHeight = 80 } = propsValue;
+
+    try {
+      const agent = await createBlueskyAgent(auth.props);
+      
+      const postInfo = extractPostInfoFromUrl(postUrl); 
+      let atUri = postInfo.uri;
+
+      if (!atUri && postInfo.handle && postInfo.postId) {
+        const didDoc = await agent.resolveHandle({ handle: postInfo.handle });
+        
+        if (didDoc.data?.did) {
+          atUri = `at://${didDoc.data.did}/app.bsky.feed.post/${postInfo.postId}`;
+        } else {
+          throw new Error(`Could not resolve handle: ${postInfo.handle}`);
+        }
+      }
+
+      if (!atUri) {
+        throw new Error('Could not parse the post URL. Please make sure you are using a valid Bluesky post URL like: https://bsky.app/profile/username.bsky.social/post/xxx');
+      }
+
+      if (!atUri.startsWith('at://')) {
+        throw new Error('Invalid URI format. Must be an AT-URI starting with "at://" or a valid Bluesky URL');
+      }
+
+      const depthNum = parseInt(depth.toString(), 10);
+      const parentHeightNum = parseInt(parentHeight.toString(), 10);
+      
+      if (isNaN(depthNum) || depthNum < 0 || depthNum > 1000) {
+        throw new Error('Depth must be a number between 0 and 1000');
+      }
+      if (isNaN(parentHeightNum) || parentHeightNum < 0 || parentHeightNum > 1000) {
+        throw new Error('Parent height must be a number between 0 and 1000');
+      }
+
+      const response = await agent.getPostThread({
+        uri: atUri,
+        depth: depthNum,
+        parentHeight: parentHeightNum,
+      });
+
+      const stats = {
+        totalPosts: 0,
+        parentPosts: 0,
+        replyPosts: 0,
+        notFoundPosts: 0,
+        blockedPosts: 0,
+      };
+
+      const countPosts = (threadPost: any): void => {
+        if (!threadPost) return;
+
+        if (threadPost.$type === 'app.bsky.feed.defs#notFoundPost') {
+          stats.notFoundPosts++;
+        } else if (threadPost.$type === 'app.bsky.feed.defs#blockedPost') {
+          stats.blockedPosts++;
+        } else if (threadPost.post) {
+          stats.totalPosts++;
+        }
+
+        if (threadPost.parent) {
+          stats.parentPosts++;
+          countPosts(threadPost.parent);
+        }
+
+        if (threadPost.replies && Array.isArray(threadPost.replies)) {
+          stats.replyPosts += threadPost.replies.length;
+          threadPost.replies.forEach((reply: any) => countPosts(reply));
+        }
+      };
+
+      if (response.data.thread) {
+        countPosts(response.data.thread);
+        if (
+          response.data.thread.$type === 'app.bsky.feed.defs#threadViewPost' &&
+          'post' in response.data.thread &&
+          response.data.thread.post
+        ) {
+          stats.totalPosts = 1;
+        }
+      }
+
+      return {
+        success: true,
+        thread: response.data.thread,
+        requestedUri: atUri,
+        parameters: {
+          depth: depthNum,
+          parentHeight: parentHeightNum,
+        },
+        statistics: stats,
+        retrievedAt: new Date().toISOString(),
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      throw new Error(`Failed to find thread: ${errorMessage}`);
+    }
+  },
+});

package/src/lib/actions/like-post.ts

@@ -0,0 +1,128 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { blueskyAuth, BlueSkyAuthType } from '../common/auth';
+import { createBlueskyAgent } from '../common/client';
+import { parseBlueskyUrl } from '../common/props';
+
+
+export const likePost = createAction({
+  auth: blueskyAuth,
+  name: 'likePost',
+  displayName: 'Like Post',
+  description: 'Like a post on Bluesky',
+  audience: 'both',
+  aiMetadata: {
+    description: 'Adds a like from the authenticated account to a specific Bluesky post, identified either by an AT-URI / bsky.app post URL or by selecting from the recent timeline. Use to register approval of a post. Not idempotent — each call creates a separate like record.',
+    idempotent: false,
+  },
+  props: {
+    selectionMethod: Property.StaticDropdown({
+      displayName: 'Select Method',
+      description: 'How to choose the post',
+      required: true,
+      defaultValue: 'timeline',
+      options: {
+        options: [
+          { label: 'From my timeline', value: 'timeline' },
+          { label: 'Enter URL manually', value: 'manual' },
+        ],
+      },
+    }),
+    
+    postSelection: Property.Dropdown({
+      auth: blueskyAuth,
+      displayName: 'Select Post',
+      description: 'Choose from your recent timeline posts (only when "From my timeline" is selected above)',
+      required: false,
+      refreshers: ['auth'],
+      options: async ({ auth }) => {
+        try {
+          if (!auth) return { options: [] };
+            const agent = await createBlueskyAgent(auth.props);
+          const timeline = await agent.getTimeline({ limit: 50 });
+          
+          return {
+            options: timeline.data.feed.map(item => ({
+              label: `@${item.post.author.handle}: ${item.post.record['text'] ? String(item.post.record['text']).substring(0, 80) : 'Media post'}${String(item.post.record['text'] || '').length > 80 ? '...' : ''} (${new Date(item.post.indexedAt).toLocaleDateString()})`,
+              value: item.post.uri
+            }))
+          };
+        } catch (error) {
+          return { 
+            options: [{ label: 'Error loading posts', value: '' }] 
+          };
+        }
+      }
+    }),
+
+    postUrl: Property.ShortText({
+      displayName: 'Post URL',
+      description: 'Paste the Bluesky post URL',
+      required: false,
+    }),
+  },
+  async run({ auth, propsValue }) {
+    const { selectionMethod, postSelection, postUrl } = propsValue;
+
+    let postUri: string;
+    
+    if (selectionMethod === 'timeline') {
+      if (!postSelection) {
+        throw new Error('Please select a post from your timeline dropdown');
+      }
+      postUri = postSelection as string;
+    } else if (selectionMethod === 'manual') {
+      if (!postUrl || !postUrl.trim()) {
+        throw new Error('Post URL is required when using manual entry method');
+      }
+      
+      try {
+        const agent = await createBlueskyAgent(auth.props);
+        postUri = await parseBlueskyUrl(postUrl.trim(), agent);
+      } catch (error) {
+        throw new Error(`Invalid post URL: ${error instanceof Error ? error.message : 'Unknown error'}`);
+      }
+    } else {
+      throw new Error('Please select a post selection method');
+    }
+
+    try {
+      const agent = await createBlueskyAgent(auth.props);
+      
+      const postsResponse = await agent.getPosts({ uris: [postUri] });
+      
+      if (!postsResponse.data.posts || postsResponse.data.posts.length === 0) {
+        throw new Error('Post not found');
+      }
+      
+      const post = postsResponse.data.posts[0];
+      
+      const response = await agent.like(postUri, post.cid);
+
+      return {
+        success: true,
+        likeUri: response.uri,
+        likeCid: response.cid,
+        postUri: postUri,
+        postCid: post.cid,
+        postAuthor: post.author.handle,
+        postText: post.record['text'] ? String(post.record['text']).substring(0, 100) + (String(post.record['text']).length > 100 ? '...' : '') : 'No text available',
+        selectionMethod: selectionMethod,
+        likedAt: new Date().toISOString(),
+      };
+    } catch (error) {
+      if (error instanceof Error) {
+        if (error.message.includes('Post not found')) {
+          throw new Error('Post not found. Please check the URL and try again.');
+        }
+        if (error.message.includes('Invalid post URL format')) {
+          throw new Error('Invalid post URL format. Please use a valid Bluesky post URL or AT-URI.');
+        }
+        if (error.message.includes('Authentication')) {
+          throw new Error('Authentication failed. Please check your credentials.');
+        }
+        throw new Error(`Failed to like post: ${error.message}`);
+      }
+      throw new Error('Failed to like post: Unknown error occurred');
+    }
+  },
+});

package/src/lib/actions/repost.ts

@@ -0,0 +1,132 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { blueskyAuth, BlueSkyAuthType } from '../common/auth';
+import { createBlueskyAgent } from '../common/client';
+import { parseBlueskyUrl } from '../common/props';
+
+
+
+export const repostPost = createAction({
+  auth: blueskyAuth,
+  name: 'repostPost',
+  displayName: 'Repost Post',
+  description: 'Share someone else\'s post to your timeline',
+  audience: 'both',
+  aiMetadata: {
+    description: 'Reposts an existing Bluesky post to the authenticated account\'s timeline, identified by an AT-URI / bsky.app post URL or selected from the recent timeline. Use to amplify another user\'s post. Not idempotent — each call creates a separate repost record.',
+    idempotent: false,
+  },
+  props: {
+    selectionMethod: Property.StaticDropdown({
+      displayName: 'Select Method',
+      description: 'How to choose the post',
+      required: true,
+      defaultValue: 'timeline',
+      options: {
+        options: [
+          { label: 'From my timeline', value: 'timeline' },
+          { label: 'Enter URL manually', value: 'manual' },
+        ],
+      },
+    }),
+    
+    postSelection: Property.Dropdown({
+      auth: blueskyAuth,
+      displayName: 'Select Post',
+      description: 'Choose from your recent timeline posts (only when "From my timeline" is selected above)',
+      required: false,
+      refreshers: ['auth'],
+      options: async ({ auth }) => {
+        try {
+          if (!auth) return { options: [] };
+          const agent = await createBlueskyAgent(auth.props);
+          const timeline = await agent.getTimeline({ limit: 50 });
+          
+          return {
+            options: timeline.data.feed.map(item => ({
+              label: `@${item.post.author.handle}: ${item.post.record['text'] ? String(item.post.record['text']).substring(0, 80) : 'Media post'}${String(item.post.record['text'] || '').length > 80 ? '...' : ''} (${new Date(item.post.indexedAt).toLocaleDateString()})`,
+              value: item.post.uri
+            }))
+          };
+        } catch (error) {
+          return { 
+            options: [{ label: 'Error loading posts', value: '' }] 
+          };
+        }
+      }
+    }),
+
+    postUrl: Property.ShortText({
+      displayName: 'Post URL',
+      description: 'Paste the Bluesky post URL',
+      required: false,
+    }),
+  },
+  async run({ auth, propsValue }) {
+    const { selectionMethod, postSelection, postUrl } = propsValue;
+
+    let postUri: string;
+    
+    if (selectionMethod === 'timeline') {
+      if (!postSelection) {
+        throw new Error('Please select a post from your timeline dropdown');
+      }
+      postUri = postSelection as string;
+    } else if (selectionMethod === 'manual') {
+      if (!postUrl || !postUrl.trim()) {
+        throw new Error('Post URL is required when using manual entry method');
+      }
+      
+      try {
+        const agent = await createBlueskyAgent(auth.props);
+        postUri = await parseBlueskyUrl(postUrl.trim(), agent);
+      } catch (error) {
+        throw new Error(`Invalid post URL: ${error instanceof Error ? error.message : 'Unknown error'}`);
+      }
+    } else {
+      throw new Error('Please select a post selection method');
+    }
+
+    try {
+      const agent = await createBlueskyAgent(auth.props);
+      
+      const postsResponse = await agent.getPosts({ uris: [postUri] });
+      
+      if (!postsResponse.data.posts || postsResponse.data.posts.length === 0) {
+        throw new Error('Post not found');
+      }
+      
+      const post = postsResponse.data.posts[0];
+      
+      const response = await agent.repost(postUri, post.cid);
+
+      return {
+        success: true,
+        repostUri: response.uri,
+        repostCid: response.cid,
+        originalPost: {
+          uri: postUri,
+          cid: post.cid,
+          author: post.author.handle,
+          text: post.record['text'] ? String(post.record['text']).substring(0, 100) + (String(post.record['text']).length > 100 ? '...' : '') : 'No text available',
+          createdAt: post.record['createdAt'] || post.indexedAt,
+        },
+        selectionMethod: selectionMethod,
+        repostedAt: new Date().toISOString(),
+      };
+    } catch (error) {
+      if (error instanceof Error) {
+        if (error.message.includes('Post not found')) {
+          throw new Error('Post not found. Please check the URL and try again.');
+        }
+        if (error.message.includes('Invalid post URL format')) {
+          throw new Error('Invalid post URL format. Please use a valid Bluesky post URL or AT-URI.');
+        }
+        if (error.message.includes('Authentication')) {
+          throw new Error('Authentication failed. Please check your credentials.');
+        }
+        throw new Error(`Failed to repost: ${error.message}`);
+      }
+      throw new Error('Failed to repost: Unknown error occurred');
+    }
+  },
+});

package/src/lib/common/auth.ts

@@ -0,0 +1,74 @@
+import { PieceAuth, Property } from '@agnocon/pieces-framework';
+import { AtpAgent } from '@atproto/api';
+
+export interface BlueSkyAuthType {
+  pdsHost?: string;
+  identifier: string;
+  password: string;
+}
+
+const description = `
+To authenticate with Bluesky:
+
+1. **PDS Host**: The Personal Data Server host. Leave empty to use the default Bluesky network (https://bsky.social).
+2. **Identifier**: Your Bluesky handle (e.g., yourhandle.bsky.social) or email address.
+3. **Password**: Your Bluesky account password or app password.
+
+For enhanced security, consider using an app password from your Bluesky account settings.
+`;
+
+export const blueskyAuth = PieceAuth.CustomAuth({
+  description: description,
+  required: true,
+  props: {
+    pdsHost: Property.ShortText({
+      displayName: 'PDS Host',
+      description: 'The Personal Data Server host. Leave empty for default Bluesky network (https://bsky.social)',
+      required: false,
+      defaultValue: 'https://bsky.social',
+    }),
+    identifier: Property.ShortText({
+      displayName: 'Identifier',
+      description: 'Your Bluesky handle or email address',
+      required: true,
+    }),
+    password: PieceAuth.SecretText({
+      displayName: 'Password',
+      description: 'Your Bluesky account password or app password',
+      required: true,
+    }),
+  },
+  validate: async ({ auth }) => {
+    try {
+      const agent = new AtpAgent({
+        service: auth.pdsHost || 'https://bsky.social',
+      });
+
+      await agent.login({
+        identifier: auth.identifier,
+        password: auth.password,
+      });
+
+      return {
+        valid: true,
+      };
+    } catch (error: any) {
+      if (error.message?.includes('Invalid identifier or password')) {
+        return {
+          valid: false,
+          error: 'Invalid credentials. Please check your identifier and password.',
+        };
+      } else if (error.message?.includes('Invalid request')) {
+        return {
+          valid: false,
+          error: 'Invalid request. Please check your identifier format.',
+        };
+      } else {
+        return {
+          valid: false,
+          error: `Authentication failed: ${error.message || 'Unknown error'}`,
+        };
+      }
+    }
+  },
+});

package/src/lib/common/client.ts

@@ -0,0 +1,42 @@
+import { AtpAgent } from '@atproto/api';
+import { BlueSkyAuthType } from './auth';
+
+const agentCache = new Map<string, { agent: AtpAgent; expires: number }>();
+
+export async function createBlueskyAgent(auth: BlueSkyAuthType): Promise<AtpAgent> {
+  const cacheKey = `${auth.identifier}:${auth.pdsHost || 'https://bsky.social'}`;
+  const cached = agentCache.get(cacheKey);
+  
+  if (cached && Date.now() < cached.expires) {
+    return cached.agent;
+  }
+
+  try {
+    const agent = new AtpAgent({
+      service: auth.pdsHost || 'https://bsky.social',
+    });
+
+    await agent.login({
+      identifier: auth.identifier,
+      password: auth.password,
+    });
+
+    agentCache.set(cacheKey, {
+      agent,
+      expires: Date.now() + 50 * 60 * 1000,
+    });
+
+    return agent;
+  } catch (error: any) {
+    agentCache.delete(cacheKey);
+    throw new Error(`Failed to create Bluesky agent: ${error.message || 'Unknown error'}`);
+  }
+}
+
+export async function getCurrentSession(auth: BlueSkyAuthType) {
+  const agent = await createBlueskyAgent(auth);
+  return {
+    did: agent.session?.did,
+    handle: agent.session?.handle,
+  };
+}