@hasna/connectors 1.3.36 → 1.3.37

package/dist/social/index.js

@@ -0,0 +1,1531 @@
+// @bun
+var __require = import.meta.require;
+
+// src/social/errors.ts
+class ConnectorOperationNotSupported extends Error {
+  connector;
+  operation;
+  constructor(connector, operation) {
+    super(`Connector "${connector}" does not support operation "${operation}"`);
+    this.name = "ConnectorOperationNotSupported";
+    this.connector = connector;
+    this.operation = operation;
+  }
+}
+
+// connectors/x/src/types/index.ts
+class XApiError extends Error {
+  statusCode;
+  errors;
+  constructor(message, statusCode, errors) {
+    super(message);
+    this.name = "XApiError";
+    this.statusCode = statusCode;
+    this.errors = errors;
+  }
+}
+
+// connectors/x/src/api/oauth.ts
+var TOKEN_URL = "https://api.twitter.com/2/oauth2/token";
+async function tokenRequest(url, body, config) {
+  body.append("client_id", config.clientId);
+  if (config.clientSecret) {
+    body.append("client_secret", config.clientSecret);
+  }
+  return fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: body.toString()
+  });
+}
+async function refreshAccessToken(config, refreshToken) {
+  const body = new URLSearchParams({
+    grant_type: "refresh_token",
+    refresh_token: refreshToken
+  });
+  const response = await tokenRequest(TOKEN_URL, body, config);
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Token refresh failed: ${errorText}`);
+  }
+  const data = await response.json();
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token || refreshToken,
+    expiresIn: data.expires_in,
+    expiresAt: Date.now() + data.expires_in * 1000,
+    scope: data.scope,
+    tokenType: data.token_type
+  };
+}
+
+// connectors/x/src/api/oauth1.ts
+import { createHmac, randomBytes } from "crypto";
+function generateNonce() {
+  return randomBytes(16).toString("hex");
+}
+function generateTimestamp() {
+  return Math.floor(Date.now() / 1000).toString();
+}
+function percentEncode(str) {
+  return encodeURIComponent(str).replace(/!/g, "%21").replace(/\*/g, "%2A").replace(/'/g, "%27").replace(/\(/g, "%28").replace(/\)/g, "%29");
+}
+function createSignatureBaseString(method, url, params) {
+  const sortedParams = Object.keys(params).sort().map((key) => `${percentEncode(key)}=${percentEncode(params[key])}`).join("&");
+  const baseUrl = url.split("?")[0];
+  return `${method.toUpperCase()}&${percentEncode(baseUrl)}&${percentEncode(sortedParams)}`;
+}
+function createSignature(baseString, consumerSecret, tokenSecret = "") {
+  const signingKey = `${percentEncode(consumerSecret)}&${percentEncode(tokenSecret)}`;
+  return createHmac("sha1", signingKey).update(baseString).digest("base64");
+}
+function buildOAuth1Header(config, method, url, additionalParams = {}) {
+  const oauthParams = {
+    oauth_consumer_key: config.consumerKey,
+    oauth_nonce: generateNonce(),
+    oauth_signature_method: "HMAC-SHA1",
+    oauth_timestamp: generateTimestamp(),
+    oauth_version: "1.0"
+  };
+  if (config.accessToken) {
+    oauthParams["oauth_token"] = config.accessToken;
+  }
+  const allParams = { ...oauthParams, ...additionalParams };
+  const baseString = createSignatureBaseString(method, url, allParams);
+  const signature = createSignature(baseString, config.consumerSecret, config.accessTokenSecret);
+  oauthParams["oauth_signature"] = signature;
+  const headerParams = Object.keys(oauthParams).sort().map((key) => `${percentEncode(key)}="${percentEncode(oauthParams[key])}"`).join(", ");
+  return `OAuth ${headerParams}`;
+}
+async function oauth1Request(config, method, url, body, additionalHeaders) {
+  let bodyParams = {};
+  let requestBody;
+  const headers = { ...additionalHeaders };
+  if (body) {
+    if (body instanceof FormData) {
+      requestBody = body;
+    } else if (typeof body === "string") {
+      requestBody = body;
+    } else {
+      bodyParams = body;
+      requestBody = new URLSearchParams(body).toString();
+      headers["Content-Type"] = "application/x-www-form-urlencoded";
+    }
+  }
+  const authHeader = buildOAuth1Header(config, method, url, bodyParams);
+  headers["Authorization"] = authHeader;
+  const response = await fetch(url, {
+    method,
+    headers,
+    body: requestBody
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`OAuth 1.0a request failed: ${response.status} - ${errorText}`);
+  }
+  const contentType = response.headers.get("content-type") || "";
+  if (contentType.includes("application/json")) {
+    return await response.json();
+  }
+  return await response.text();
+}
+
+class OAuth1Client {
+  config;
+  constructor(config) {
+    if (!config.consumerKey || !config.consumerSecret) {
+      throw new Error("Consumer key and secret are required");
+    }
+    this.config = config;
+  }
+  hasUserTokens() {
+    return !!(this.config.accessToken && this.config.accessTokenSecret);
+  }
+  setTokens(oauthToken, oauthTokenSecret) {
+    this.config.accessToken = oauthToken;
+    this.config.accessTokenSecret = oauthTokenSecret;
+  }
+  async get(url, params) {
+    const urlWithParams = params ? `${url}?${new URLSearchParams(params).toString()}` : url;
+    return oauth1Request(this.config, "GET", urlWithParams);
+  }
+  async post(url, body, headers) {
+    return oauth1Request(this.config, "POST", url, body, headers);
+  }
+  buildAuthHeader(method, url, params) {
+    return buildOAuth1Header(this.config, method, url, params);
+  }
+}
+
+// connectors/x/src/api/client.ts
+var DEFAULT_BASE_URL = "https://api.twitter.com";
+
+class XClient {
+  apiKey;
+  apiSecret;
+  bearerToken;
+  baseUrl;
+  accessToken;
+  refreshToken;
+  tokenExpiresAt;
+  clientId;
+  clientSecret;
+  oauth1Client;
+  onTokenRefresh;
+  constructor(config) {
+    if (!config.apiKey || !config.apiSecret) {
+      throw new Error("API key and API secret are required");
+    }
+    this.apiKey = config.apiKey;
+    this.apiSecret = config.apiSecret;
+    this.bearerToken = config.bearerToken;
+    this.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
+    this.accessToken = config.accessToken;
+    this.refreshToken = config.refreshToken;
+    this.tokenExpiresAt = config.tokenExpiresAt;
+    this.clientId = config.clientId;
+    this.clientSecret = config.clientSecret;
+    if (config.oauth1AccessToken && config.oauth1AccessTokenSecret) {
+      this.oauth1Client = new OAuth1Client({
+        consumerKey: config.apiKey,
+        consumerSecret: config.apiSecret,
+        accessToken: config.oauth1AccessToken,
+        accessTokenSecret: config.oauth1AccessTokenSecret
+      });
+    }
+  }
+  setTokenRefreshCallback(callback) {
+    this.onTokenRefresh = callback;
+  }
+  async getAppBearerToken() {
+    if (this.bearerToken) {
+      return this.bearerToken;
+    }
+    const credentials = Buffer.from(`${this.apiKey}:${this.apiSecret}`).toString("base64");
+    const response = await fetch(`${this.baseUrl}/oauth2/token`, {
+      method: "POST",
+      headers: {
+        Authorization: `Basic ${credentials}`,
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: "grant_type=client_credentials"
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new XApiError(`Failed to get bearer token: ${errorText}`, response.status);
+    }
+    const data = await response.json();
+    this.bearerToken = data.access_token;
+    return this.bearerToken;
+  }
+  isTokenExpired() {
+    if (!this.tokenExpiresAt)
+      return true;
+    return Date.now() > this.tokenExpiresAt - 5 * 60 * 1000;
+  }
+  async refreshUserToken() {
+    if (!this.refreshToken || !this.clientId) {
+      throw new Error("Cannot refresh token: missing refresh token or client ID");
+    }
+    const oauth2Config = {
+      clientId: this.clientId,
+      clientSecret: this.clientSecret,
+      redirectUri: "http://localhost:3000/callback"
+    };
+    const tokens = await refreshAccessToken(oauth2Config, this.refreshToken);
+    this.accessToken = tokens.accessToken;
+    this.refreshToken = tokens.refreshToken || this.refreshToken;
+    this.tokenExpiresAt = tokens.expiresAt;
+    if (this.onTokenRefresh) {
+      this.onTokenRefresh({
+        accessToken: tokens.accessToken,
+        refreshToken: tokens.refreshToken,
+        expiresAt: tokens.expiresAt
+      });
+    }
+    return this.accessToken;
+  }
+  async getAccessToken(preferUser = true) {
+    if (preferUser && this.accessToken) {
+      if (this.isTokenExpired() && this.refreshToken && this.clientId) {
+        const token2 = await this.refreshUserToken();
+        return { token: token2, isUserContext: true };
+      }
+      if (!this.isTokenExpired()) {
+        return { token: this.accessToken, isUserContext: true };
+      }
+    }
+    const token = await this.getAppBearerToken();
+    return { token, isUserContext: false };
+  }
+  getAuthMethod() {
+    if (this.accessToken && !this.isTokenExpired()) {
+      return "oauth2-user";
+    }
+    if (this.oauth1Client?.hasUserTokens()) {
+      return "oauth1-user";
+    }
+    return "app-only";
+  }
+  getAuthStatus() {
+    const method = this.getAuthMethod();
+    return {
+      method,
+      isAuthenticated: method !== "app-only",
+      expiresAt: this.tokenExpiresAt,
+      hasOAuth1: this.oauth1Client?.hasUserTokens()
+    };
+  }
+  hasUserContext() {
+    return !!(this.accessToken && !this.isTokenExpired());
+  }
+  hasOAuth1() {
+    return this.oauth1Client?.hasUserTokens() ?? false;
+  }
+  getOAuth1Client() {
+    return this.oauth1Client;
+  }
+  setUserTokens(tokens) {
+    this.accessToken = tokens.accessToken;
+    this.refreshToken = tokens.refreshToken;
+    this.tokenExpiresAt = tokens.expiresAt;
+  }
+  setOAuth1Tokens(oauthToken, oauthTokenSecret) {
+    this.oauth1Client = new OAuth1Client({
+      consumerKey: this.apiKey,
+      consumerSecret: this.apiSecret,
+      accessToken: oauthToken,
+      accessTokenSecret: oauthTokenSecret
+    });
+  }
+  buildUrl(path, params) {
+    const url = new URL(`${this.baseUrl}${path}`);
+    if (params) {
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== undefined && value !== null && value !== "") {
+          if (Array.isArray(value)) {
+            url.searchParams.append(key, value.join(","));
+          } else {
+            url.searchParams.append(key, String(value));
+          }
+        }
+      });
+    }
+    return url.toString();
+  }
+  async request(path, options = {}) {
+    const { method = "GET", params, body, headers = {}, authMethod } = options;
+    const preferUser = authMethod === "oauth2-user" || authMethod === "oauth1-user" || ["POST", "PUT", "PATCH", "DELETE"].includes(method);
+    const url = this.buildUrl(path, params);
+    const isWriteOp = ["POST", "PUT", "PATCH", "DELETE"].includes(method);
+    const useOAuth1 = authMethod === "oauth1-user" || isWriteOp && !this.accessToken && this.oauth1Client?.hasUserTokens();
+    let requestHeaders;
+    if (useOAuth1 && this.oauth1Client) {
+      const oauth1Header = this.oauth1Client.buildAuthHeader(method, url);
+      requestHeaders = {
+        Authorization: oauth1Header,
+        Accept: "application/json",
+        ...headers
+      };
+    } else {
+      const { token } = await this.getAccessToken(preferUser);
+      requestHeaders = {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/json",
+        ...headers
+      };
+    }
+    if (body && ["POST", "PUT", "PATCH"].includes(method)) {
+      requestHeaders["Content-Type"] = "application/json";
+    }
+    const fetchOptions = {
+      method,
+      headers: requestHeaders
+    };
+    if (body && ["POST", "PUT", "PATCH"].includes(method)) {
+      fetchOptions.body = typeof body === "string" ? body : JSON.stringify(body);
+    }
+    const response = await fetch(url, fetchOptions);
+    if (response.status === 204) {
+      return {};
+    }
+    let data;
+    const contentType = response.headers.get("content-type") || "";
+    if (contentType.includes("application/json")) {
+      const text = await response.text();
+      if (text) {
+        try {
+          data = JSON.parse(text);
+        } catch {
+          data = text;
+        }
+      }
+    } else {
+      data = await response.text();
+    }
+    if (!response.ok) {
+      const errorMessage = typeof data === "object" && data !== null ? JSON.stringify(data) : String(data || response.statusText);
+      throw new XApiError(errorMessage, response.status);
+    }
+    return data;
+  }
+  async get(path, params) {
+    return this.request(path, { method: "GET", params });
+  }
+  async post(path, body, params) {
+    return this.request(path, { method: "POST", body, params });
+  }
+  async delete(path, params) {
+    return this.request(path, { method: "DELETE", params });
+  }
+  getApiKeyPreview() {
+    if (this.apiKey.length > 10) {
+      return `${this.apiKey.substring(0, 6)}...${this.apiKey.substring(this.apiKey.length - 4)}`;
+    }
+    return "***";
+  }
+  hasBearerToken() {
+    return !!this.bearerToken;
+  }
+}
+
+// connectors/x/src/api/tweets.ts
+class TweetsApi {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async get(id, options) {
+    const params = {};
+    if (options?.tweetFields?.length) {
+      params["tweet.fields"] = options.tweetFields.join(",");
+    }
+    if (options?.userFields?.length) {
+      params["user.fields"] = options.userFields.join(",");
+    }
+    if (options?.expansions?.length) {
+      params["expansions"] = options.expansions.join(",");
+    }
+    if (options?.mediaFields?.length) {
+      params["media.fields"] = options.mediaFields.join(",");
+    }
+    return this.client.get(`/2/tweets/${id}`, params);
+  }
+  async getMany(ids, options) {
+    const params = {
+      ids: ids.join(",")
+    };
+    if (options?.tweetFields?.length) {
+      params["tweet.fields"] = options.tweetFields.join(",");
+    }
+    if (options?.userFields?.length) {
+      params["user.fields"] = options.userFields.join(",");
+    }
+    if (options?.expansions?.length) {
+      params["expansions"] = options.expansions.join(",");
+    }
+    if (options?.mediaFields?.length) {
+      params["media.fields"] = options.mediaFields.join(",");
+    }
+    return this.client.get("/2/tweets", params);
+  }
+  async searchRecent(options) {
+    const params = {
+      query: options.query,
+      max_results: options.maxResults || 10,
+      next_token: options.nextToken,
+      start_time: options.startTime,
+      end_time: options.endTime,
+      since_id: options.sinceId,
+      until_id: options.untilId,
+      sort_order: options.sortOrder,
+      "tweet.fields": "id,text,author_id,created_at,public_metrics,source,lang",
+      expansions: "author_id",
+      "user.fields": "id,name,username,profile_image_url"
+    };
+    return this.client.get("/2/tweets/search/recent", params);
+  }
+  async countRecent(query, options) {
+    const params = {
+      query,
+      start_time: options?.startTime,
+      end_time: options?.endTime,
+      granularity: options?.granularity || "hour"
+    };
+    return this.client.get("/2/tweets/counts/recent", params);
+  }
+  async getUserTimeline(userId, options) {
+    const exclude = [];
+    if (options?.excludeReplies)
+      exclude.push("replies");
+    if (options?.excludeRetweets)
+      exclude.push("retweets");
+    const params = {
+      max_results: options?.maxResults || 10,
+      pagination_token: options?.paginationToken,
+      start_time: options?.startTime,
+      end_time: options?.endTime,
+      since_id: options?.sinceId,
+      until_id: options?.untilId,
+      exclude: exclude.length ? exclude.join(",") : undefined,
+      "tweet.fields": "id,text,author_id,created_at,public_metrics,source,lang",
+      expansions: "author_id",
+      "user.fields": "id,name,username,profile_image_url"
+    };
+    return this.client.get(`/2/users/${userId}/tweets`, params);
+  }
+  async getUserMentions(userId, options) {
+    const params = {
+      max_results: options?.maxResults || 10,
+      pagination_token: options?.paginationToken,
+      start_time: options?.startTime,
+      end_time: options?.endTime,
+      since_id: options?.sinceId,
+      until_id: options?.untilId,
+      "tweet.fields": "id,text,author_id,created_at,public_metrics,source,lang",
+      expansions: "author_id",
+      "user.fields": "id,name,username,profile_image_url"
+    };
+    return this.client.get(`/2/users/${userId}/mentions`, params);
+  }
+  async getLikingUsers(tweetId, options) {
+    const params = {
+      max_results: options?.maxResults || 100,
+      pagination_token: options?.paginationToken,
+      "user.fields": "id,name,username,profile_image_url,public_metrics"
+    };
+    return this.client.get(`/2/tweets/${tweetId}/liking_users`, params);
+  }
+  async getRetweetedBy(tweetId, options) {
+    const params = {
+      max_results: options?.maxResults || 100,
+      pagination_token: options?.paginationToken,
+      "user.fields": "id,name,username,profile_image_url,public_metrics"
+    };
+    return this.client.get(`/2/tweets/${tweetId}/retweeted_by`, params);
+  }
+  async getQuoteTweets(tweetId, options) {
+    const params = {
+      max_results: options?.maxResults || 10,
+      pagination_token: options?.paginationToken,
+      "tweet.fields": "id,text,author_id,created_at,public_metrics,source,lang",
+      expansions: "author_id",
+      "user.fields": "id,name,username,profile_image_url"
+    };
+    return this.client.get(`/2/tweets/${tweetId}/quote_tweets`, params);
+  }
+  async create(options) {
+    const body = {
+      text: options.text
+    };
+    if (options.mediaIds?.length) {
+      body.media = { media_ids: options.mediaIds };
+    }
+    if (options.replyToTweetId) {
+      body.reply = { in_reply_to_tweet_id: options.replyToTweetId };
+    }
+    if (options.quoteTweetId) {
+      body.quote_tweet_id = options.quoteTweetId;
+    }
+    if (options.pollOptions?.length) {
+      body.poll = {
+        options: options.pollOptions,
+        duration_minutes: options.pollDurationMinutes || 1440
+      };
+    }
+    return this.client.post("/2/tweets", body);
+  }
+  async delete(tweetId) {
+    return this.client.delete(`/2/tweets/${tweetId}`);
+  }
+  async like(userId, tweetId) {
+    return this.client.post(`/2/users/${userId}/likes`, {
+      tweet_id: tweetId
+    });
+  }
+  async unlike(userId, tweetId) {
+    return this.client.delete(`/2/users/${userId}/likes/${tweetId}`);
+  }
+  async retweet(userId, tweetId) {
+    return this.client.post(`/2/users/${userId}/retweets`, {
+      tweet_id: tweetId
+    });
+  }
+  async unretweet(userId, tweetId) {
+    return this.client.delete(`/2/users/${userId}/retweets/${tweetId}`);
+  }
+  async getBookmarks(userId, options) {
+    return this.client.request(`/2/users/${userId}/bookmarks`, {
+      method: "GET",
+      params: {
+        max_results: options?.maxResults || 10,
+        pagination_token: options?.paginationToken,
+        "tweet.fields": "id,text,author_id,created_at,public_metrics,source,lang",
+        expansions: "author_id",
+        "user.fields": "id,name,username,profile_image_url"
+      },
+      authMethod: "oauth2-user"
+    });
+  }
+  async bookmark(userId, tweetId) {
+    return this.client.post(`/2/users/${userId}/bookmarks`, {
+      tweet_id: tweetId
+    });
+  }
+  async removeBookmark(userId, tweetId) {
+    return this.client.delete(`/2/users/${userId}/bookmarks/${tweetId}`);
+  }
+}
+
+// connectors/x/src/api/users.ts
+class UsersApi {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async getById(id, options) {
+    const params = {};
+    if (options?.userFields?.length) {
+      params["user.fields"] = options.userFields.join(",");
+    }
+    if (options?.tweetFields?.length) {
+      params["tweet.fields"] = options.tweetFields.join(",");
+    }
+    if (options?.expansions?.length) {
+      params["expansions"] = options.expansions.join(",");
+    }
+    return this.client.get(`/2/users/${id}`, params);
+  }
+  async getByUsername(username, options) {
+    const params = {
+      "user.fields": "id,name,username,created_at,description,profile_image_url,public_metrics,verified,protected,location,url"
+    };
+    if (options?.userFields?.length) {
+      params["user.fields"] = options.userFields.join(",");
+    }
+    if (options?.tweetFields?.length) {
+      params["tweet.fields"] = options.tweetFields.join(",");
+    }
+    if (options?.expansions?.length) {
+      params["expansions"] = options.expansions.join(",");
+    }
+    return this.client.get(`/2/users/by/username/${username}`, params);
+  }
+  async getMany(ids, options) {
+    const params = {
+      ids: ids.join(","),
+      "user.fields": "id,name,username,created_at,description,profile_image_url,public_metrics,verified,protected"
+    };
+    if (options?.userFields?.length) {
+      params["user.fields"] = options.userFields.join(",");
+    }
+    if (options?.tweetFields?.length) {
+      params["tweet.fields"] = options.tweetFields.join(",");
+    }
+    if (options?.expansions?.length) {
+      params["expansions"] = options.expansions.join(",");
+    }
+    return this.client.get("/2/users", params);
+  }
+  async getManyByUsernames(usernames, options) {
+    const params = {
+      usernames: usernames.join(","),
+      "user.fields": "id,name,username,created_at,description,profile_image_url,public_metrics,verified,protected"
+    };
+    if (options?.userFields?.length) {
+      params["user.fields"] = options.userFields.join(",");
+    }
+    if (options?.tweetFields?.length) {
+      params["tweet.fields"] = options.tweetFields.join(",");
+    }
+    if (options?.expansions?.length) {
+      params["expansions"] = options.expansions.join(",");
+    }
+    return this.client.get("/2/users/by", params);
+  }
+  async getFollowers(userId, options) {
+    const params = {
+      max_results: options?.maxResults || 100,
+      pagination_token: options?.paginationToken,
+      "user.fields": "id,name,username,created_at,description,profile_image_url,public_metrics,verified"
+    };
+    return this.client.get(`/2/users/${userId}/followers`, params);
+  }
+  async getFollowing(userId, options) {
+    const params = {
+      max_results: options?.maxResults || 100,
+      pagination_token: options?.paginationToken,
+      "user.fields": "id,name,username,created_at,description,profile_image_url,public_metrics,verified"
+    };
+    return this.client.get(`/2/users/${userId}/following`, params);
+  }
+  async getLikedTweets(userId, options) {
+    return this.client.request(`/2/users/${userId}/liked_tweets`, {
+      method: "GET",
+      params: {
+        max_results: options?.maxResults || 10,
+        pagination_token: options?.paginationToken,
+        "tweet.fields": "id,text,author_id,created_at,public_metrics,source,lang",
+        expansions: "author_id",
+        "user.fields": "id,name,username,profile_image_url"
+      },
+      authMethod: "oauth2-user"
+    });
+  }
+  async getOwnedLists(userId, options) {
+    const params = {
+      max_results: options?.maxResults || 100,
+      pagination_token: options?.paginationToken,
+      "list.fields": "id,name,description,follower_count,member_count,private,owner_id,created_at"
+    };
+    return this.client.get(`/2/users/${userId}/owned_lists`, params);
+  }
+  async getListMemberships(userId, options) {
+    const params = {
+      max_results: options?.maxResults || 100,
+      pagination_token: options?.paginationToken,
+      "list.fields": "id,name,description,follower_count,member_count,private,owner_id,created_at"
+    };
+    return this.client.get(`/2/users/${userId}/list_memberships`, params);
+  }
+  async me() {
+    return this.client.request("/2/users/me", {
+      method: "GET",
+      params: {
+        "user.fields": "id,name,username,created_at,description,profile_image_url,public_metrics,verified,protected,location,url"
+      },
+      authMethod: "oauth2-user"
+    });
+  }
+  async follow(userId, targetUserId) {
+    return this.client.post(`/2/users/${userId}/following`, { target_user_id: targetUserId });
+  }
+  async unfollow(userId, targetUserId) {
+    return this.client.delete(`/2/users/${userId}/following/${targetUserId}`);
+  }
+  async block(userId, targetUserId) {
+    return this.client.post(`/2/users/${userId}/blocking`, { target_user_id: targetUserId });
+  }
+  async unblock(userId, targetUserId) {
+    return this.client.delete(`/2/users/${userId}/blocking/${targetUserId}`);
+  }
+  async mute(userId, targetUserId) {
+    return this.client.post(`/2/users/${userId}/muting`, { target_user_id: targetUserId });
+  }
+  async unmute(userId, targetUserId) {
+    return this.client.delete(`/2/users/${userId}/muting/${targetUserId}`);
+  }
+}
+
+// connectors/x/src/api/media.ts
+var UPLOAD_URL = "https://upload.twitter.com/1.1/media/upload.json";
+var MIME_TYPES = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".mp4": "video/mp4",
+  ".mov": "video/quicktime"
+};
+var MAX_SIZES = {
+  image: 5 * 1024 * 1024,
+  gif: 15 * 1024 * 1024,
+  video: 512 * 1024 * 1024
+};
+var CHUNK_SIZE = 5 * 1024 * 1024;
+function getMimeType(filePath) {
+  const ext = filePath.toLowerCase().match(/\.[^.]+$/)?.[0] || "";
+  return MIME_TYPES[ext] || "application/octet-stream";
+}
+function getMediaCategory(mimeType) {
+  if (mimeType.startsWith("video/")) {
+    return "tweet_video";
+  }
+  if (mimeType === "image/gif") {
+    return "tweet_gif";
+  }
+  return "tweet_image";
+}
+function requiresChunkedUpload(mimeType, fileSize) {
+  if (mimeType.startsWith("video/")) {
+    return true;
+  }
+  if (mimeType === "image/gif" && fileSize > 5 * 1024 * 1024) {
+    return true;
+  }
+  return false;
+}
+async function simpleUpload(oauth1Client, fileData, mimeType) {
+  const base64Data = fileData.toString("base64");
+  const result = await oauth1Client.post(UPLOAD_URL, {
+    media_data: base64Data
+  });
+  return result;
+}
+async function chunkedUpload(oauth1Client, fileData, mimeType, category) {
+  const totalBytes = fileData.length;
+  const initResult = await oauth1Client.post(UPLOAD_URL, {
+    command: "INIT",
+    total_bytes: totalBytes.toString(),
+    media_type: mimeType,
+    media_category: category
+  });
+  const mediaId = initResult.media_id_string;
+  let segmentIndex = 0;
+  let offset = 0;
+  while (offset < totalBytes) {
+    const chunk = fileData.subarray(offset, Math.min(offset + CHUNK_SIZE, totalBytes));
+    const chunkBase64 = chunk.toString("base64");
+    await oauth1Client.post(UPLOAD_URL, {
+      command: "APPEND",
+      media_id: mediaId,
+      media_data: chunkBase64,
+      segment_index: segmentIndex.toString()
+    });
+    offset += CHUNK_SIZE;
+    segmentIndex++;
+  }
+  const finalizeResult = await oauth1Client.post(UPLOAD_URL, {
+    command: "FINALIZE",
+    media_id: mediaId
+  });
+  return finalizeResult;
+}
+async function waitForProcessing(oauth1Client, mediaId, maxWaitMs = 60000) {
+  const startTime = Date.now();
+  while (Date.now() - startTime < maxWaitMs) {
+    const status = await oauth1Client.get(UPLOAD_URL, {
+      command: "STATUS",
+      media_id: mediaId
+    });
+    if (!status.processing_info) {
+      return status;
+    }
+    const { state, check_after_secs, error } = status.processing_info;
+    if (state === "succeeded") {
+      return status;
+    }
+    if (state === "failed") {
+      throw new Error(`Media processing failed: ${error?.message || "Unknown error"}`);
+    }
+    const waitMs = (check_after_secs || 5) * 1000;
+    await new Promise((resolve) => setTimeout(resolve, waitMs));
+  }
+  throw new Error("Media processing timed out");
+}
+async function addAltText(oauth1Client, mediaId, altText) {
+  const url = "https://upload.twitter.com/1.1/media/metadata/create.json";
+  await oauth1Client.post(url, JSON.stringify({
+    media_id: mediaId,
+    alt_text: { text: altText }
+  }), { "Content-Type": "application/json" });
+}
+
+class MediaApi {
+  oauth1Client;
+  constructor(oauth1Client) {
+    this.oauth1Client = oauth1Client;
+  }
+  async uploadFile(filePath, options = {}) {
+    const { readFileSync } = await import("fs");
+    const fileData = readFileSync(filePath);
+    const mimeType = getMimeType(filePath);
+    return this.uploadBuffer(fileData, mimeType, {
+      ...options,
+      category: options.category || getMediaCategory(mimeType)
+    });
+  }
+  async uploadBuffer(data, mimeType, options = {}) {
+    const fileSize = data.length;
+    const category = options.category || getMediaCategory(mimeType);
+    const maxSize = mimeType.startsWith("video/") ? MAX_SIZES.video : mimeType === "image/gif" ? MAX_SIZES.gif : MAX_SIZES.image;
+    if (fileSize > maxSize) {
+      throw new Error(`File size ${fileSize} exceeds maximum ${maxSize} bytes for ${mimeType}`);
+    }
+    let result;
+    if (requiresChunkedUpload(mimeType, fileSize)) {
+      result = await chunkedUpload(this.oauth1Client, data, mimeType, category);
+      if (result.processing_info) {
+        result = await waitForProcessing(this.oauth1Client, result.media_id_string);
+      }
+    } else {
+      result = await simpleUpload(this.oauth1Client, data, mimeType);
+    }
+    if (options.altText) {
+      await addAltText(this.oauth1Client, result.media_id_string, options.altText);
+    }
+    return result;
+  }
+  async uploadFromUrl(url, options = {}) {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch media from URL: ${response.statusText}`);
+    }
+    const buffer = Buffer.from(await response.arrayBuffer());
+    const contentType = response.headers.get("content-type") || "application/octet-stream";
+    return this.uploadBuffer(buffer, contentType, options);
+  }
+}
+
+// connectors/x/src/api/index.ts
+class X {
+  client;
+  mediaApi;
+  tweets;
+  users;
+  constructor(config) {
+    this.client = new XClient(config);
+    this.tweets = new TweetsApi(this.client);
+    this.users = new UsersApi(this.client);
+    if (config.oauth1AccessToken && config.oauth1AccessTokenSecret) {
+      const oauth1Client = new OAuth1Client({
+        consumerKey: config.apiKey,
+        consumerSecret: config.apiSecret,
+        accessToken: config.oauth1AccessToken,
+        accessTokenSecret: config.oauth1AccessTokenSecret
+      });
+      this.mediaApi = new MediaApi(oauth1Client);
+    }
+  }
+  get media() {
+    return this.mediaApi;
+  }
+  hasMediaUpload() {
+    return !!this.mediaApi;
+  }
+  static fromEnv() {
+    const apiKey = process.env.X_API_KEY;
+    const apiSecret = process.env.X_API_SECRET;
+    const bearerToken = process.env.X_BEARER_TOKEN;
+    const accessToken = process.env.X_ACCESS_TOKEN;
+    const refreshToken = process.env.X_REFRESH_TOKEN;
+    const clientId = process.env.X_CLIENT_ID;
+    const clientSecret = process.env.X_CLIENT_SECRET;
+    const oauth1AccessToken = process.env.X_OAUTH1_ACCESS_TOKEN;
+    const oauth1AccessTokenSecret = process.env.X_OAUTH1_ACCESS_TOKEN_SECRET;
+    if (!apiKey || !apiSecret) {
+      throw new Error("X_API_KEY and X_API_SECRET environment variables are required");
+    }
+    return new X({
+      apiKey,
+      apiSecret,
+      bearerToken,
+      accessToken,
+      refreshToken,
+      clientId,
+      clientSecret,
+      oauth1AccessToken,
+      oauth1AccessTokenSecret
+    });
+  }
+  getApiKeyPreview() {
+    return this.client.getApiKeyPreview();
+  }
+  hasBearerToken() {
+    return this.client.hasBearerToken();
+  }
+  hasUserContext() {
+    return this.client.hasUserContext();
+  }
+  hasOAuth1() {
+    return this.client.hasOAuth1();
+  }
+  getAuthStatus() {
+    return this.client.getAuthStatus();
+  }
+  setUserTokens(tokens) {
+    this.client.setUserTokens(tokens);
+  }
+  setOAuth1Tokens(oauthToken, oauthTokenSecret) {
+    this.client.setOAuth1Tokens(oauthToken, oauthTokenSecret);
+    const oauth1Client = this.client.getOAuth1Client();
+    if (oauth1Client) {
+      this.mediaApi = new MediaApi(oauth1Client);
+    }
+  }
+  setTokenRefreshCallback(callback) {
+    this.client.setTokenRefreshCallback(callback);
+  }
+  getClient() {
+    return this.client;
+  }
+}
+
+// src/social/util.ts
+function decodeBase64(dataBase64) {
+  if (typeof dataBase64 !== "string" || dataBase64.length === 0) {
+    throw new Error("media.upload requires a non-empty base64 string in `dataBase64`");
+  }
+  return Buffer.from(dataBase64, "base64");
+}
+
+// src/social/x.ts
+class XAdapter {
+  x;
+  me;
+  constructor(x) {
+    this.x = x;
+  }
+  static fromCredentials(creds) {
+    if (!creds || !creds.apiKey || !creds.apiSecret) {
+      throw new Error("x credentials require `apiKey` and `apiSecret`");
+    }
+    const x = new X({
+      apiKey: creds.apiKey,
+      apiSecret: creds.apiSecret,
+      bearerToken: creds.bearerToken,
+      accessToken: creds.accessToken,
+      refreshToken: creds.refreshToken,
+      clientId: creds.clientId,
+      clientSecret: creds.clientSecret,
+      oauth1AccessToken: creds.oauth1AccessToken,
+      oauth1AccessTokenSecret: creds.oauth1AccessTokenSecret
+    });
+    return new XAdapter(x);
+  }
+  async resolveMe() {
+    if (this.me)
+      return this.me;
+    const res = await this.x.users.me();
+    this.me = { id: res.data.id, username: res.data.username, displayName: res.data.name };
+    return this.me;
+  }
+  async accountMe() {
+    const me = await this.resolveMe();
+    return {
+      id: me.id,
+      username: me.username,
+      displayName: me.displayName,
+      url: `https://x.com/${me.username}`
+    };
+  }
+  async postCreate(input) {
+    const res = await this.x.tweets.create({
+      text: input.text,
+      replyToTweetId: input.replyToId,
+      mediaIds: input.mediaIds
+    });
+    const id = res.data.id;
+    const me = await this.resolveMe();
+    return { id, url: `https://x.com/${me.username}/status/${id}` };
+  }
+  async postDelete(input) {
+    const res = await this.x.tweets.delete(input.id);
+    return { id: input.id, deleted: Boolean(res.data.deleted) };
+  }
+  async mediaUpload(input) {
+    if (!this.x.media) {
+      throw new ConnectorOperationNotSupported("x", "media.upload (requires OAuth 1.0a credentials: oauth1AccessToken + oauth1AccessTokenSecret)");
+    }
+    const buffer = decodeBase64(input.dataBase64);
+    const res = await this.x.media.uploadBuffer(buffer, input.mimeType, {
+      altText: input.altText
+    });
+    return { mediaId: res.media_id_string };
+  }
+  async mentionsList(input = {}) {
+    const me = await this.resolveMe();
+    const res = await this.x.tweets.getUserMentions(me.id, {
+      sinceId: input.sinceId,
+      maxResults: input.limit
+    });
+    const handleById = new Map;
+    for (const u of res.includes?.users ?? []) {
+      handleById.set(u.id, u.username);
+    }
+    const items = (res.data ?? []).map((t) => ({
+      id: t.id,
+      text: t.text,
+      authorId: t.author_id,
+      authorHandle: t.author_id ? handleById.get(t.author_id) : undefined,
+      createdAt: t.created_at
+    }));
+    return { items };
+  }
+  async analyticsPost(input) {
+    const res = await this.x.tweets.get(input.id, {
+      tweetFields: ["public_metrics"]
+    });
+    const metrics = res.data.public_metrics ?? {};
+    return { metrics };
+  }
+}
+
+// src/social/mastodon.ts
+class MastodonAdapter {
+  accessToken;
+  baseUrl;
+  fetchImpl;
+  constructor(creds, fetchImpl) {
+    if (!creds || !creds.accessToken || !creds.baseUrl) {
+      throw new Error("mastodon credentials require `accessToken` and `baseUrl`");
+    }
+    this.accessToken = creds.accessToken;
+    this.baseUrl = creds.baseUrl.replace(/\/+$/, "");
+    this.fetchImpl = fetchImpl ?? globalThis.fetch;
+  }
+  static fromCredentials(creds, fetchImpl) {
+    return new MastodonAdapter(creds, fetchImpl);
+  }
+  async call(path, options = {}) {
+    const { method = "GET", body, query } = options;
+    let url = `${this.baseUrl}${path}`;
+    if (query) {
+      const qs = new URLSearchParams;
+      for (const [k, v] of Object.entries(query)) {
+        if (v !== undefined && v !== null && v !== "")
+          qs.append(k, String(v));
+      }
+      const s = qs.toString();
+      if (s)
+        url += `?${s}`;
+    }
+    const headers = {
+      Authorization: `Bearer ${this.accessToken}`,
+      Accept: "application/json"
+    };
+    let serializedBody;
+    if (body !== undefined && method !== "GET") {
+      headers["Content-Type"] = "application/json";
+      serializedBody = JSON.stringify(body);
+    }
+    const res = await this.fetchImpl(url, { method, headers, body: serializedBody });
+    const text = await res.text();
+    const data = text ? JSON.parse(text) : {};
+    if (!res.ok) {
+      const message = data && (data.error || data.message) || res.statusText || "Mastodon request failed";
+      throw new Error(`Mastodon ${res.status}: ${message}`);
+    }
+    return data;
+  }
+  async accountMe() {
+    const acct = await this.call("/api/v1/accounts/verify_credentials");
+    return {
+      id: acct.id,
+      username: acct.username,
+      displayName: acct.display_name,
+      url: acct.url
+    };
+  }
+  async postCreate(input) {
+    const body = { status: input.text };
+    if (input.replyToId)
+      body.in_reply_to_id = input.replyToId;
+    if (input.mediaIds && input.mediaIds.length > 0)
+      body.media_ids = input.mediaIds;
+    const status = await this.call("/api/v1/statuses", {
+      method: "POST",
+      body
+    });
+    return { id: status.id, url: status.url };
+  }
+  async postDelete(input) {
+    await this.call(`/api/v1/statuses/${input.id}`, { method: "DELETE" });
+    return { id: input.id, deleted: true };
+  }
+  async mediaUpload(input) {
+    const buffer = decodeBase64(input.dataBase64);
+    const form = new FormData;
+    const bytes = Uint8Array.from(buffer);
+    const blob = new Blob([bytes], { type: input.mimeType });
+    form.append("file", blob);
+    if (input.altText)
+      form.append("description", input.altText);
+    const res = await this.fetchImpl(`${this.baseUrl}/api/v2/media`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${this.accessToken}`, Accept: "application/json" },
+      body: form
+    });
+    const text = await res.text();
+    const data = text ? JSON.parse(text) : {};
+    if (!res.ok) {
+      const message = data && (data.error || data.message) || res.statusText || "media upload failed";
+      throw new Error(`Mastodon ${res.status}: ${message}`);
+    }
+    return { mediaId: String(data.id) };
+  }
+  async mentionsList(input = {}) {
+    const notifications = await this.call("/api/v1/notifications", {
+      query: { types: "mention", since_id: input.sinceId, limit: input.limit }
+    });
+    const items = notifications.filter((n) => n.type === "mention" && n.status).map((n) => ({
+      id: n.status.id,
+      text: stripHtml(n.status.content ?? ""),
+      authorId: n.status.account?.id,
+      authorHandle: n.status.account?.acct,
+      createdAt: n.status.created_at
+    }));
+    return { items };
+  }
+  async analyticsPost(input) {
+    const status = await this.call(`/api/v1/statuses/${input.id}`);
+    return {
+      metrics: {
+        reblogsCount: status.reblogs_count ?? 0,
+        favouritesCount: status.favourites_count ?? 0,
+        repliesCount: status.replies_count ?? 0
+      }
+    };
+  }
+}
+function stripHtml(html) {
+  return html.replace(/<[^>]*>/g, "").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").trim();
+}
+
+// connectors/bluesky/src/types/index.ts
+class BlueskyApiError extends Error {
+  statusCode;
+  errorCode;
+  constructor(message, statusCode, errorCode) {
+    super(message);
+    this.name = "BlueskyApiError";
+    this.statusCode = statusCode;
+    this.errorCode = errorCode;
+  }
+}
+
+// connectors/bluesky/src/api/client.ts
+var DEFAULT_PDS = "https://bsky.social";
+
+class BlueskyClient {
+  identifier;
+  appPassword;
+  pds;
+  session;
+  constructor(config) {
+    if (!config?.identifier || !config?.appPassword) {
+      throw new Error("bluesky credentials require `identifier` and `appPassword`");
+    }
+    this.identifier = config.identifier;
+    this.appPassword = config.appPassword;
+    this.pds = (config.pds || DEFAULT_PDS).replace(/\/+$/, "");
+  }
+  async xrpc(nsid, options = {}) {
+    const { method = "GET", params, body, auth = true, contentType, rawBody } = options;
+    const url = new URL(`${this.pds}/xrpc/${nsid}`);
+    if (params) {
+      for (const [k, v] of Object.entries(params)) {
+        if (v !== undefined && v !== null && v !== "")
+          url.searchParams.append(k, String(v));
+      }
+    }
+    const headers = { Accept: "application/json" };
+    if (auth) {
+      const session = await this.ensureSession();
+      headers.Authorization = `Bearer ${session.accessJwt}`;
+    }
+    const init = { method, headers };
+    if (rawBody !== undefined) {
+      headers["Content-Type"] = contentType || "application/octet-stream";
+      init.body = rawBody;
+    } else if (body !== undefined && method !== "GET") {
+      headers["Content-Type"] = contentType || "application/json";
+      init.body = JSON.stringify(body);
+    }
+    const response = await fetch(url.toString(), init);
+    if (response.status === 204)
+      return {};
+    let data;
+    const text = await response.text();
+    if (text) {
+      try {
+        data = JSON.parse(text);
+      } catch {
+        data = text;
+      }
+    }
+    if (!response.ok) {
+      const errBody = typeof data === "object" && data !== null ? data : {};
+      const message = errBody.message || errBody.error || response.statusText || "Request failed";
+      throw new BlueskyApiError(message, response.status, errBody.error);
+    }
+    return data;
+  }
+  async ensureSession() {
+    if (this.session)
+      return this.session;
+    const session = await this.xrpc("com.atproto.server.createSession", {
+      method: "POST",
+      auth: false,
+      body: { identifier: this.identifier, password: this.appPassword }
+    });
+    this.session = session;
+    return session;
+  }
+  async createRecord(collection, record) {
+    const session = await this.ensureSession();
+    return this.xrpc("com.atproto.repo.createRecord", {
+      method: "POST",
+      body: { repo: session.did, collection, record }
+    });
+  }
+  async deleteRecord(uri) {
+    const session = await this.ensureSession();
+    const parsed = parseAtUri(uri);
+    await this.xrpc("com.atproto.repo.deleteRecord", {
+      method: "POST",
+      body: { repo: session.did, collection: parsed.collection, rkey: parsed.rkey }
+    });
+  }
+  async uploadBlob(data, mimeType) {
+    return this.xrpc("com.atproto.repo.uploadBlob", {
+      method: "POST",
+      rawBody: data,
+      contentType: mimeType || "application/octet-stream"
+    });
+  }
+  async listNotifications(options) {
+    return this.xrpc("app.bsky.notification.listNotifications", {
+      method: "GET",
+      params: { limit: options?.limit, cursor: options?.cursor }
+    });
+  }
+  async getPosts(uris) {
+    const url = new URL(`${this.pds}/xrpc/app.bsky.feed.getPosts`);
+    for (const u of uris)
+      url.searchParams.append("uris", u);
+    const session = await this.ensureSession();
+    const response = await fetch(url.toString(), {
+      headers: { Accept: "application/json", Authorization: `Bearer ${session.accessJwt}` }
+    });
+    const text = await response.text();
+    const data = text ? JSON.parse(text) : {};
+    if (!response.ok) {
+      throw new BlueskyApiError(data?.message || data?.error || response.statusText, response.status, data?.error);
+    }
+    return data;
+  }
+  getSession() {
+    return this.session;
+  }
+}
+function parseAtUri(uri) {
+  const match = /^at:\/\/([^/]+)\/([^/]+)\/(.+)$/.exec(uri);
+  if (!match) {
+    throw new Error(`Invalid at:// URI: ${uri}`);
+  }
+  return { repo: match[1], collection: match[2], rkey: match[3] };
+}
+
+// connectors/bluesky/src/api/index.ts
+var POST_COLLECTION = "app.bsky.feed.post";
+
+class Bluesky {
+  client;
+  constructor(config) {
+    this.client = new BlueskyClient(config);
+  }
+  static fromEnv() {
+    const identifier = process.env.BLUESKY_IDENTIFIER;
+    const appPassword = process.env.BLUESKY_APP_PASSWORD;
+    const pds = process.env.BLUESKY_PDS;
+    if (!identifier || !appPassword) {
+      throw new Error("BLUESKY_IDENTIFIER and BLUESKY_APP_PASSWORD environment variables are required");
+    }
+    return new Bluesky({ identifier, appPassword, pds });
+  }
+  async me() {
+    return this.client.ensureSession();
+  }
+  async createPost(options) {
+    const record = {
+      $type: POST_COLLECTION,
+      text: options.text,
+      createdAt: options.createdAt || new Date().toISOString()
+    };
+    if (options.embed) {
+      record.embed = options.embed;
+    }
+    if (options.replyToUri) {
+      const { parent, root } = await this.resolveReplyRefs(options.replyToUri);
+      record.reply = { root, parent };
+    }
+    return this.client.createRecord(POST_COLLECTION, record);
+  }
+  async deletePost(uri) {
+    return this.client.deleteRecord(uri);
+  }
+  async uploadBlob(data, mimeType) {
+    const res = await this.client.uploadBlob(data, mimeType);
+    return res.blob;
+  }
+  async listNotifications(options) {
+    return this.client.listNotifications(options);
+  }
+  async getPosts(uris) {
+    return this.client.getPosts(uris);
+  }
+  getClient() {
+    return this.client;
+  }
+  async resolveReplyRefs(parentUri) {
+    parseAtUri(parentUri);
+    const posts = await this.client.getPosts([parentUri]);
+    const match = posts.posts.find((p) => p.uri === parentUri);
+    if (!match || !match.cid) {
+      throw new Error(`Cannot resolve parent post for reply: ${parentUri}`);
+    }
+    const parent = { uri: match.uri, cid: match.cid };
+    const root = match.record?.reply?.root ?? parent;
+    return { parent, root };
+  }
+}
+
+// src/social/bluesky.ts
+function postUrl(handle, uri) {
+  const m = /^at:\/\/[^/]+\/app\.bsky\.feed\.post\/(.+)$/.exec(uri);
+  if (!m)
+    return;
+  return `https://bsky.app/profile/${handle}/post/${m[1]}`;
+}
+
+class BlueskyAdapter {
+  bsky;
+  handle;
+  constructor(bsky) {
+    this.bsky = bsky;
+  }
+  static fromCredentials(creds) {
+    if (!creds || !creds.identifier || !creds.appPassword) {
+      throw new Error("bluesky credentials require `identifier` and `appPassword`");
+    }
+    const bsky = new Bluesky({
+      identifier: creds.identifier,
+      appPassword: creds.appPassword,
+      pds: creds.pds
+    });
+    return new BlueskyAdapter(bsky);
+  }
+  async resolveHandle() {
+    if (this.handle)
+      return this.handle;
+    const me = await this.bsky.me();
+    this.handle = me.handle;
+    return this.handle;
+  }
+  async accountMe() {
+    const me = await this.bsky.me();
+    this.handle = me.handle;
+    return {
+      id: me.did,
+      username: me.handle,
+      displayName: me.handle,
+      url: `https://bsky.app/profile/${me.handle}`
+    };
+  }
+  async postCreate(input) {
+    let embed;
+    if (input.mediaIds && input.mediaIds.length > 0) {
+      const images = input.mediaIds.map((m) => {
+        const blob = JSON.parse(m);
+        return { alt: "", image: blob };
+      });
+      embed = { $type: "app.bsky.embed.images", images };
+    }
+    const res = await this.bsky.createPost({
+      text: input.text,
+      replyToUri: input.replyToId,
+      embed
+    });
+    const handle = await this.resolveHandle();
+    return { id: res.uri, url: postUrl(handle, res.uri) };
+  }
+  async postDelete(input) {
+    await this.bsky.deletePost(input.id);
+    return { id: input.id, deleted: true };
+  }
+  async mediaUpload(input) {
+    const buffer = decodeBase64(input.dataBase64);
+    const blob = await this.bsky.uploadBlob(buffer, input.mimeType);
+    return { mediaId: JSON.stringify(blob) };
+  }
+  async mentionsList(input = {}) {
+    const res = await this.bsky.listNotifications({ limit: input.limit });
+    const items = res.notifications.filter((n) => n.reason === "mention" || n.reason === "reply").map((n) => ({
+      id: n.uri,
+      text: n.record?.text ?? "",
+      authorId: n.author?.did,
+      authorHandle: n.author?.handle,
+      createdAt: n.record?.createdAt ?? n.indexedAt
+    }));
+    return { items };
+  }
+  async analyticsPost(input) {
+    const res = await this.bsky.getPosts([input.id]);
+    const post = res.posts.find((p) => p.uri === input.id) ?? res.posts[0];
+    if (!post) {
+      throw new ConnectorOperationNotSupported("bluesky", `analytics.post (post not found: ${input.id})`);
+    }
+    const metrics = {
+      likeCount: post.likeCount ?? 0,
+      repostCount: post.repostCount ?? 0,
+      replyCount: post.replyCount ?? 0,
+      quoteCount: post.quoteCount ?? 0
+    };
+    return { metrics };
+  }
+}
+
+// src/social/index.ts
+var SUPPORTED_CONNECTORS = ["x", "mastodon", "bluesky"];
+var SUPPORTED_OPERATIONS = {
+  x: ["account.me", "post.create", "post.delete", "media.upload", "mentions.list", "analytics.post"],
+  mastodon: ["account.me", "post.create", "post.delete", "media.upload", "mentions.list", "analytics.post"],
+  bluesky: ["account.me", "post.create", "post.delete", "media.upload", "mentions.list", "analytics.post"]
+};
+function listSocialConnectors() {
+  return [...SUPPORTED_CONNECTORS];
+}
+function getSocialOperations(connector) {
+  const ops = SUPPORTED_OPERATIONS[connector];
+  if (!ops) {
+    throw new ConnectorOperationNotSupported(connector, "*");
+  }
+  return [...ops];
+}
+function buildAdapter(connector, credentials) {
+  switch (connector) {
+    case "x":
+      return XAdapter.fromCredentials(credentials);
+    case "mastodon":
+      return MastodonAdapter.fromCredentials(credentials);
+    case "bluesky":
+      return BlueskyAdapter.fromCredentials(credentials);
+    default:
+      throw new ConnectorOperationNotSupported(connector, "*");
+  }
+}
+async function runSocialOperation(args) {
+  const { connector, operation, input = {}, credentials = {} } = args;
+  if (!SUPPORTED_CONNECTORS.includes(connector)) {
+    throw new ConnectorOperationNotSupported(connector, operation);
+  }
+  const supported = SUPPORTED_OPERATIONS[connector] ?? [];
+  if (!supported.includes(operation)) {
+    throw new ConnectorOperationNotSupported(connector, operation);
+  }
+  const adapter = buildAdapter(connector, credentials);
+  switch (operation) {
+    case "account.me":
+      return adapter.accountMe(input);
+    case "post.create":
+      return adapter.postCreate(input);
+    case "post.delete":
+      return adapter.postDelete(input);
+    case "media.upload":
+      return adapter.mediaUpload(input);
+    case "mentions.list":
+      return adapter.mentionsList(input);
+    case "analytics.post":
+      return adapter.analyticsPost(input);
+    default:
+      throw new ConnectorOperationNotSupported(connector, operation);
+  }
+}
+export {
+  runSocialOperation,
+  listSocialConnectors,
+  getSocialOperations,
+  ConnectorOperationNotSupported
+};