@hasna/connectors 1.3.36 → 1.3.38

package/dist/social/index.js

@@ -0,0 +1,2303 @@
+// @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/http.ts
+function resolveFetch(fetchImpl) {
+  return fetchImpl ?? globalThis.fetch;
+}
+function appendQuery(url, query) {
+  if (!query)
+    return url;
+  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();
+  return s ? `${url}${url.includes("?") ? "&" : "?"}${s}` : url;
+}
+function extractError(data, fallback) {
+  if (data && typeof data === "object") {
+    const d = data;
+    const candidates = [
+      d.error_description,
+      typeof d.error === "string" ? d.error : undefined,
+      d.message,
+      d.error && typeof d.error === "object" ? d.error.message : undefined
+    ];
+    for (const c of candidates) {
+      if (typeof c === "string" && c)
+        return c;
+    }
+  }
+  return fallback;
+}
+async function jsonRequest(fetchImpl, url, options = {}) {
+  const { method = "GET", query, body } = options;
+  const finalUrl = appendQuery(url, query);
+  const headers = { Accept: "application/json", ...options.headers ?? {} };
+  let serialized;
+  if (body !== undefined && method !== "GET" && method !== "HEAD") {
+    if (typeof body === "string" || body instanceof FormData) {
+      serialized = body;
+    } else {
+      if (!headers["Content-Type"])
+        headers["Content-Type"] = "application/json";
+      serialized = JSON.stringify(body);
+    }
+  }
+  const res = await fetchImpl(finalUrl, { method, headers, body: serialized });
+  const text = await res.text();
+  const data = text ? safeJsonParse(text) : {};
+  if (!res.ok) {
+    const label = options.errorLabel ?? "request";
+    throw new Error(`${label} ${res.status}: ${extractError(data, res.statusText || "failed")}`);
+  }
+  return data;
+}
+function safeJsonParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return { raw: text };
+  }
+}
+
+// src/social/linkedin.ts
+var DEFAULT_BASE = "https://api.linkedin.com";
+
+class LinkedInAdapter {
+  accessToken;
+  baseUrl;
+  authorUrn;
+  fetchImpl;
+  constructor(creds, fetchImpl) {
+    if (!creds || !creds.accessToken) {
+      throw new Error("linkedin credentials require `accessToken`");
+    }
+    this.accessToken = creds.accessToken;
+    this.authorUrn = creds.authorUrn;
+    this.baseUrl = (creds.baseUrl ?? DEFAULT_BASE).replace(/\/+$/, "");
+    this.fetchImpl = resolveFetch(fetchImpl);
+  }
+  static fromCredentials(creds, fetchImpl) {
+    return new LinkedInAdapter(creds, fetchImpl);
+  }
+  headers(extra) {
+    return {
+      Authorization: `Bearer ${this.accessToken}`,
+      "X-Restli-Protocol-Version": "2.0.0",
+      ...extra ?? {}
+    };
+  }
+  async resolveAuthorUrn() {
+    if (this.authorUrn)
+      return this.authorUrn;
+    const me = await jsonRequest(this.fetchImpl, `${this.baseUrl}/v2/me`, {
+      headers: this.headers(),
+      errorLabel: "LinkedIn"
+    });
+    this.authorUrn = `urn:li:person:${me.id}`;
+    return this.authorUrn;
+  }
+  async accountMe() {
+    const me = await jsonRequest(this.fetchImpl, `${this.baseUrl}/v2/me`, { headers: this.headers(), errorLabel: "LinkedIn" });
+    this.authorUrn = `urn:li:person:${me.id}`;
+    const displayName = [me.localizedFirstName, me.localizedLastName].filter(Boolean).join(" ") || undefined;
+    return {
+      id: me.id,
+      username: me.vanityName ?? me.id,
+      displayName,
+      url: me.vanityName ? `https://www.linkedin.com/in/${me.vanityName}` : undefined
+    };
+  }
+  async postCreate(input) {
+    const author = await this.resolveAuthorUrn();
+    const visibility = input.visibility ?? "PUBLIC";
+    const hasMedia = Boolean(input.mediaIds && input.mediaIds.length > 0);
+    const shareContent = {
+      shareCommentary: { text: input.text },
+      shareMediaCategory: hasMedia ? "IMAGE" : "NONE"
+    };
+    if (hasMedia) {
+      shareContent.media = input.mediaIds.map((m) => ({ status: "READY", media: m }));
+    }
+    const body = {
+      author,
+      lifecycleState: "PUBLISHED",
+      specificContent: { "com.linkedin.ugc.ShareContent": shareContent },
+      visibility: { "com.linkedin.ugc.MemberNetworkVisibility": visibility }
+    };
+    const res = await jsonRequest(this.fetchImpl, `${this.baseUrl}/v2/ugcPosts`, {
+      method: "POST",
+      headers: this.headers(),
+      body,
+      errorLabel: "LinkedIn"
+    });
+    return {
+      id: res.id,
+      url: `https://www.linkedin.com/feed/update/${res.id}`
+    };
+  }
+  async postDelete(input) {
+    await jsonRequest(this.fetchImpl, `${this.baseUrl}/v2/ugcPosts/${encodeURIComponent(input.id)}`, {
+      method: "DELETE",
+      headers: this.headers(),
+      errorLabel: "LinkedIn"
+    });
+    return { id: input.id, deleted: true };
+  }
+  async mediaUpload(input) {
+    const author = await this.resolveAuthorUrn();
+    const register = await jsonRequest(this.fetchImpl, `${this.baseUrl}/v2/assets?action=registerUpload`, {
+      method: "POST",
+      headers: this.headers(),
+      body: {
+        registerUploadRequest: {
+          owner: author,
+          recipes: ["urn:li:digitalmediaRecipe:feedshare-image"],
+          serviceRelationships: [
+            { relationshipType: "OWNER", identifier: "urn:li:userGeneratedContent" }
+          ]
+        }
+      },
+      errorLabel: "LinkedIn"
+    });
+    const asset = register.value.asset;
+    const uploadUrl = register.value.uploadMechanism["com.linkedin.digitalmedia.uploading.MediaUploadHttpRequest"].uploadUrl;
+    const buffer = decodeBase64(input.dataBase64);
+    const bytes = Uint8Array.from(buffer);
+    const put = await this.fetchImpl(uploadUrl, {
+      method: "PUT",
+      headers: { Authorization: `Bearer ${this.accessToken}`, "Content-Type": input.mimeType },
+      body: bytes
+    });
+    if (!put.ok) {
+      throw new Error(`LinkedIn ${put.status}: media upload failed`);
+    }
+    return { mediaId: asset };
+  }
+  async mentionsList(_input = {}) {
+    throw new ConnectorOperationNotSupported("linkedin", "mentions.list (no public mentions/notifications endpoint)");
+  }
+  async analyticsPost(_input) {
+    throw new ConnectorOperationNotSupported("linkedin", "analytics.post (requires organization socialActions scope; not available for member shares)");
+  }
+}
+
+// src/social/reddit.ts
+var BASE = "https://oauth.reddit.com";
+function fullname(id) {
+  return id.startsWith("t3_") ? id : `t3_${id}`;
+}
+
+class RedditAdapter {
+  accessToken;
+  userAgent;
+  fetchImpl;
+  constructor(creds, fetchImpl) {
+    if (!creds || !creds.accessToken) {
+      throw new Error("reddit credentials require `accessToken`");
+    }
+    this.accessToken = creds.accessToken;
+    this.userAgent = creds.userAgent ?? "hasna-connectors/social";
+    this.fetchImpl = resolveFetch(fetchImpl);
+  }
+  static fromCredentials(creds, fetchImpl) {
+    return new RedditAdapter(creds, fetchImpl);
+  }
+  headers(extra) {
+    return {
+      Authorization: `Bearer ${this.accessToken}`,
+      "User-Agent": this.userAgent,
+      ...extra ?? {}
+    };
+  }
+  form(params) {
+    const qs = new URLSearchParams;
+    for (const [k, v] of Object.entries(params)) {
+      if (v !== undefined)
+        qs.append(k, v);
+    }
+    return qs.toString();
+  }
+  async accountMe() {
+    const me = await jsonRequest(this.fetchImpl, `${BASE}/api/v1/me`, { headers: this.headers(), errorLabel: "Reddit" });
+    return {
+      id: me.id,
+      username: me.name,
+      displayName: me.name,
+      url: `https://www.reddit.com/user/${me.name}`
+    };
+  }
+  async postCreate(input) {
+    if (!input.title) {
+      throw new Error("reddit post.create requires `title`");
+    }
+    if (!input.subreddit) {
+      throw new Error("reddit post.create requires `subreddit`");
+    }
+    const kind = input.kind ?? "self";
+    if (kind === "link" && !input.url) {
+      throw new Error('reddit post.create with kind "link" requires `url`');
+    }
+    const body = this.form({
+      sr: input.subreddit,
+      title: input.title,
+      kind,
+      text: kind === "self" ? input.text : undefined,
+      url: kind === "link" ? input.url : undefined,
+      api_type: "json"
+    });
+    const res = await jsonRequest(this.fetchImpl, `${BASE}/api/submit`, {
+      method: "POST",
+      headers: this.headers({ "Content-Type": "application/x-www-form-urlencoded" }),
+      body,
+      errorLabel: "Reddit"
+    });
+    const errors = res.json?.errors ?? [];
+    if (errors.length > 0) {
+      throw new Error(`Reddit submit failed: ${JSON.stringify(errors)}`);
+    }
+    const data = res.json?.data ?? {};
+    return { id: data.id ?? data.name ?? "", url: data.url };
+  }
+  async postDelete(input) {
+    await jsonRequest(this.fetchImpl, `${BASE}/api/del`, {
+      method: "POST",
+      headers: this.headers({ "Content-Type": "application/x-www-form-urlencoded" }),
+      body: this.form({ id: fullname(input.id) }),
+      errorLabel: "Reddit"
+    });
+    return { id: input.id, deleted: true };
+  }
+  async mediaUpload(_input) {
+    throw new ConnectorOperationNotSupported("reddit", "media.upload (image uploads require the media asset-lease flow; not supported by this SDK)");
+  }
+  async mentionsList(input = {}) {
+    const res = await jsonRequest(this.fetchImpl, `${BASE}/message/inbox`, {
+      headers: this.headers(),
+      query: { limit: input.limit, after: input.sinceId },
+      errorLabel: "Reddit"
+    });
+    const items = (res.data?.children ?? []).map((c) => ({
+      id: c.data.name ?? c.data.id,
+      text: c.data.body ?? "",
+      authorId: c.data.author_fullname,
+      authorHandle: c.data.author,
+      createdAt: c.data.created_utc ? new Date(c.data.created_utc * 1000).toISOString() : undefined
+    }));
+    return { items };
+  }
+  async analyticsPost(input) {
+    const res = await jsonRequest(this.fetchImpl, `${BASE}/api/info`, {
+      headers: this.headers(),
+      query: { id: fullname(input.id) },
+      errorLabel: "Reddit"
+    });
+    const post = res.data?.children?.[0]?.data;
+    if (!post) {
+      throw new ConnectorOperationNotSupported("reddit", `analytics.post (post not found: ${input.id})`);
+    }
+    return {
+      metrics: {
+        ups: post.ups ?? 0,
+        downs: post.downs ?? 0,
+        score: post.score ?? 0,
+        numComments: post.num_comments ?? 0,
+        upvoteRatio: post.upvote_ratio ?? 0
+      }
+    };
+  }
+}
+
+// src/social/tiktok.ts
+var BASE2 = "https://open.tiktokapis.com";
+
+class TikTokAdapter {
+  accessToken;
+  fetchImpl;
+  constructor(creds, fetchImpl) {
+    if (!creds || !creds.accessToken) {
+      throw new Error("tiktok credentials require `accessToken`");
+    }
+    this.accessToken = creds.accessToken;
+    this.fetchImpl = resolveFetch(fetchImpl);
+  }
+  static fromCredentials(creds, fetchImpl) {
+    return new TikTokAdapter(creds, fetchImpl);
+  }
+  headers(extra) {
+    return { Authorization: `Bearer ${this.accessToken}`, ...extra ?? {} };
+  }
+  async accountMe() {
+    const res = await jsonRequest(this.fetchImpl, `${BASE2}/v2/user/info/`, {
+      headers: this.headers(),
+      query: { fields: "open_id,union_id,display_name,profile_deep_link" },
+      errorLabel: "TikTok"
+    });
+    const user = res.data?.user ?? {};
+    return {
+      id: user.open_id ?? user.union_id ?? "",
+      username: user.display_name,
+      displayName: user.display_name,
+      url: user.profile_deep_link
+    };
+  }
+  async postCreate(input) {
+    const videoId = input.mediaIds?.[0];
+    if (!videoId) {
+      throw new ConnectorOperationNotSupported("tiktok", "post.create (TikTok is video-only: provide a video media id in `mediaIds` via media.upload)");
+    }
+    const body = {
+      post_info: {
+        title: input.text ?? "",
+        privacy_level: input.privacyLevel ?? "PUBLIC_TO_EVERYONE"
+      },
+      source_info: {
+        source: "FILE_UPLOAD",
+        video_id: videoId
+      }
+    };
+    const res = await jsonRequest(this.fetchImpl, `${BASE2}/v2/post/publish/video/init/`, { method: "POST", headers: this.headers({ "Content-Type": "application/json" }), body, errorLabel: "TikTok" });
+    return { id: res.data?.publish_id ?? videoId };
+  }
+  async postDelete(_input) {
+    throw new ConnectorOperationNotSupported("tiktok", "post.delete (the Content Posting API does not expose post deletion)");
+  }
+  async mediaUpload(input) {
+    const buffer = decodeBase64(input.dataBase64);
+    const size = buffer.byteLength;
+    const init = await jsonRequest(this.fetchImpl, `${BASE2}/v2/post/publish/inbox/video/init/`, {
+      method: "POST",
+      headers: this.headers({ "Content-Type": "application/json" }),
+      body: {
+        source_info: {
+          source: "FILE_UPLOAD",
+          video_size: size,
+          chunk_size: size,
+          total_chunk_count: 1
+        }
+      },
+      errorLabel: "TikTok"
+    });
+    const uploadUrl = init.data?.upload_url;
+    const publishId = init.data?.publish_id;
+    if (!uploadUrl || !publishId) {
+      throw new Error("TikTok media.upload: init did not return an upload_url/publish_id");
+    }
+    const bytes = Uint8Array.from(buffer);
+    const put = await this.fetchImpl(uploadUrl, {
+      method: "PUT",
+      headers: {
+        "Content-Type": input.mimeType,
+        "Content-Range": `bytes 0-${size - 1}/${size}`
+      },
+      body: bytes
+    });
+    if (!put.ok) {
+      throw new Error(`TikTok ${put.status}: video upload failed`);
+    }
+    return { mediaId: publishId };
+  }
+  async mentionsList(_input = {}) {
+    throw new ConnectorOperationNotSupported("tiktok", "mentions.list (no mentions endpoint in the Content Posting / Display API)");
+  }
+  async analyticsPost(_input) {
+    throw new ConnectorOperationNotSupported("tiktok", "analytics.post (per-post metrics require the Research/Business API, not available here)");
+  }
+}
+
+// src/social/youtube.ts
+var API = "https://www.googleapis.com/youtube/v3";
+var UPLOAD = "https://www.googleapis.com/upload/youtube/v3";
+
+class YouTubeAdapter {
+  accessToken;
+  fetchImpl;
+  constructor(creds, fetchImpl) {
+    if (!creds || !creds.accessToken) {
+      throw new Error("youtube credentials require `accessToken`");
+    }
+    this.accessToken = creds.accessToken;
+    this.fetchImpl = resolveFetch(fetchImpl);
+  }
+  static fromCredentials(creds, fetchImpl) {
+    return new YouTubeAdapter(creds, fetchImpl);
+  }
+  headers(extra) {
+    return { Authorization: `Bearer ${this.accessToken}`, ...extra ?? {} };
+  }
+  async accountMe() {
+    const res = await jsonRequest(this.fetchImpl, `${API}/channels`, {
+      headers: this.headers(),
+      query: { part: "snippet", mine: "true" },
+      errorLabel: "YouTube"
+    });
+    const channel = res.items?.[0];
+    if (!channel) {
+      throw new Error("YouTube account.me: no channel found for the authenticated user");
+    }
+    return {
+      id: channel.id,
+      username: channel.snippet?.customUrl ?? channel.snippet?.title,
+      displayName: channel.snippet?.title,
+      url: `https://www.youtube.com/channel/${channel.id}`
+    };
+  }
+  async postCreate(input) {
+    const videoId = input.mediaIds?.[0];
+    if (!videoId) {
+      throw new ConnectorOperationNotSupported("youtube", "post.create (YouTube is video-only: upload a video via media.upload and pass its id in `mediaIds`)");
+    }
+    const title = input.title ?? input.text ?? "";
+    const description = input.description ?? input.text ?? "";
+    await jsonRequest(this.fetchImpl, `${API}/videos`, {
+      method: "PUT",
+      headers: this.headers({ "Content-Type": "application/json" }),
+      query: { part: "snippet" },
+      body: {
+        id: videoId,
+        snippet: { title, description, categoryId: input.categoryId ?? "22" }
+      },
+      errorLabel: "YouTube"
+    });
+    return { id: videoId, url: `https://www.youtube.com/watch?v=${videoId}` };
+  }
+  async postDelete(input) {
+    await jsonRequest(this.fetchImpl, `${API}/videos`, {
+      method: "DELETE",
+      headers: this.headers(),
+      query: { id: input.id },
+      errorLabel: "YouTube"
+    });
+    return { id: input.id, deleted: true };
+  }
+  async mediaUpload(input) {
+    const buffer = decodeBase64(input.dataBase64);
+    const size = buffer.byteLength;
+    const start = await this.fetchImpl(`${UPLOAD}/videos?uploadType=resumable&part=snippet,status`, {
+      method: "POST",
+      headers: this.headers({
+        "Content-Type": "application/json",
+        "X-Upload-Content-Type": input.mimeType,
+        "X-Upload-Content-Length": String(size)
+      }),
+      body: JSON.stringify({
+        snippet: { title: input.title ?? input.altText ?? "Untitled", description: input.description ?? "" },
+        status: { privacyStatus: input.privacyStatus ?? "private" }
+      })
+    });
+    if (!start.ok) {
+      throw new Error(`YouTube ${start.status}: resumable upload init failed`);
+    }
+    const location = start.headers?.get("location");
+    if (!location) {
+      throw new Error("YouTube media.upload: resumable session did not return a Location header");
+    }
+    const bytes = Uint8Array.from(buffer);
+    const put = await this.fetchImpl(location, {
+      method: "PUT",
+      headers: { "Content-Type": input.mimeType, "Content-Length": String(size) },
+      body: bytes
+    });
+    const text = await put.text();
+    const data = text ? JSON.parse(text) : {};
+    if (!put.ok) {
+      throw new Error(`YouTube ${put.status}: video upload failed`);
+    }
+    return { mediaId: String(data.id) };
+  }
+  async mentionsList(_input = {}) {
+    throw new ConnectorOperationNotSupported("youtube", "mentions.list (no mentions endpoint in the YouTube Data API)");
+  }
+  async analyticsPost(input) {
+    const res = await jsonRequest(this.fetchImpl, `${API}/videos`, {
+      headers: this.headers(),
+      query: { part: "statistics", id: input.id },
+      errorLabel: "YouTube"
+    });
+    const stats = res.items?.[0]?.statistics;
+    if (!stats) {
+      throw new ConnectorOperationNotSupported("youtube", `analytics.post (video not found: ${input.id})`);
+    }
+    return {
+      metrics: {
+        viewCount: Number(stats.viewCount ?? 0),
+        likeCount: Number(stats.likeCount ?? 0),
+        commentCount: Number(stats.commentCount ?? 0),
+        favoriteCount: Number(stats.favoriteCount ?? 0)
+      }
+    };
+  }
+}
+
+// src/social/pinterest.ts
+var BASE3 = "https://api.pinterest.com";
+
+class PinterestAdapter {
+  accessToken;
+  defaultBoardId;
+  fetchImpl;
+  constructor(creds, fetchImpl) {
+    if (!creds || !creds.accessToken) {
+      throw new Error("pinterest credentials require `accessToken`");
+    }
+    this.accessToken = creds.accessToken;
+    this.defaultBoardId = creds.boardId;
+    this.fetchImpl = resolveFetch(fetchImpl);
+  }
+  static fromCredentials(creds, fetchImpl) {
+    return new PinterestAdapter(creds, fetchImpl);
+  }
+  headers(extra) {
+    return { Authorization: `Bearer ${this.accessToken}`, ...extra ?? {} };
+  }
+  async accountMe() {
+    const acct = await jsonRequest(this.fetchImpl, `${BASE3}/v5/user_account`, { headers: this.headers(), errorLabel: "Pinterest" });
+    return {
+      id: acct.username ?? "",
+      username: acct.username,
+      displayName: acct.username,
+      url: acct.username ? `https://www.pinterest.com/${acct.username}/` : undefined
+    };
+  }
+  async postCreate(input) {
+    const boardId = input.boardId ?? this.defaultBoardId;
+    if (!boardId) {
+      throw new Error("pinterest post.create requires `boardId` (in input or credentials)");
+    }
+    const mediaId = input.mediaIds?.[0];
+    let mediaSource;
+    if (mediaId) {
+      mediaSource = { source_type: "image_upload", media_id: mediaId };
+    } else if (input.imageUrl) {
+      mediaSource = { source_type: "image_url", url: input.imageUrl };
+    } else {
+      throw new Error("pinterest post.create requires an image: provide a `mediaIds` entry or `imageUrl`");
+    }
+    const body = {
+      board_id: boardId,
+      description: input.text,
+      media_source: mediaSource
+    };
+    if (input.title)
+      body.title = input.title;
+    if (input.link)
+      body.link = input.link;
+    const pin = await jsonRequest(this.fetchImpl, `${BASE3}/v5/pins`, {
+      method: "POST",
+      headers: this.headers({ "Content-Type": "application/json" }),
+      body,
+      errorLabel: "Pinterest"
+    });
+    return { id: pin.id, url: `https://www.pinterest.com/pin/${pin.id}/` };
+  }
+  async postDelete(input) {
+    await jsonRequest(this.fetchImpl, `${BASE3}/v5/pins/${encodeURIComponent(input.id)}`, {
+      method: "DELETE",
+      headers: this.headers(),
+      errorLabel: "Pinterest"
+    });
+    return { id: input.id, deleted: true };
+  }
+  async mediaUpload(input) {
+    const register = await jsonRequest(this.fetchImpl, `${BASE3}/v5/media`, {
+      method: "POST",
+      headers: this.headers({ "Content-Type": "application/json" }),
+      body: { media_type: "image" },
+      errorLabel: "Pinterest"
+    });
+    const buffer = decodeBase64(input.dataBase64);
+    const bytes = Uint8Array.from(buffer);
+    const form = new FormData;
+    for (const [k, v] of Object.entries(register.upload_parameters ?? {})) {
+      form.append(k, v);
+    }
+    form.append("file", new Blob([bytes], { type: input.mimeType }));
+    const put = await this.fetchImpl(register.upload_url, { method: "POST", body: form });
+    if (!put.ok) {
+      throw new Error(`Pinterest ${put.status}: media upload failed`);
+    }
+    return { mediaId: register.media_id };
+  }
+  async mentionsList(_input = {}) {
+    throw new ConnectorOperationNotSupported("pinterest", "mentions.list (no mentions endpoint in the Pinterest API)");
+  }
+  async analyticsPost(input) {
+    const res = await jsonRequest(this.fetchImpl, `${BASE3}/v5/pins/${encodeURIComponent(input.id)}/analytics`, {
+      headers: this.headers(),
+      query: { metric_types: "IMPRESSION,PIN_CLICK,SAVE,OUTBOUND_CLICK" },
+      errorLabel: "Pinterest"
+    });
+    const summary = res.all?.["DAILY"]?.summary_metrics ?? res.all?.["TOTAL"]?.summary_metrics ?? {};
+    const metrics = {};
+    for (const [k, v] of Object.entries(summary)) {
+      metrics[k] = typeof v === "number" ? v : Number(v) || 0;
+    }
+    return { metrics };
+  }
+}
+
+// src/social/googlebusinessprofile.ts
+var ACCT_MGMT = "https://mybusinessaccountmanagement.googleapis.com/v1";
+var V4 = "https://mybusiness.googleapis.com/v4";
+
+class GoogleBusinessProfileAdapter {
+  accessToken;
+  defaultAccountId;
+  defaultLocationId;
+  fetchImpl;
+  constructor(creds, fetchImpl) {
+    if (!creds || !creds.accessToken) {
+      throw new Error("googlebusinessprofile credentials require `accessToken`");
+    }
+    this.accessToken = creds.accessToken;
+    this.defaultAccountId = creds.accountId;
+    this.defaultLocationId = creds.locationId;
+    this.fetchImpl = resolveFetch(fetchImpl);
+  }
+  static fromCredentials(creds, fetchImpl) {
+    return new GoogleBusinessProfileAdapter(creds, fetchImpl);
+  }
+  headers(extra) {
+    return { Authorization: `Bearer ${this.accessToken}`, ...extra ?? {} };
+  }
+  resolveIds(input) {
+    const accountId = input.accountId ?? this.defaultAccountId;
+    const locationId = input.locationId ?? this.defaultLocationId;
+    if (!accountId)
+      throw new Error("googlebusinessprofile requires `accountId` (in input or credentials)");
+    if (!locationId)
+      throw new Error("googlebusinessprofile requires `locationId` (in input or credentials)");
+    return { accountId, locationId };
+  }
+  async accountMe() {
+    const res = await jsonRequest(this.fetchImpl, `${ACCT_MGMT}/accounts`, { headers: this.headers(), errorLabel: "GoogleBusinessProfile" });
+    const account = res.accounts?.[0];
+    if (!account) {
+      throw new Error("googlebusinessprofile account.me: no accounts found for the authenticated user");
+    }
+    const id = (account.name ?? "").replace(/^accounts\//, "");
+    return {
+      id,
+      username: account.accountName,
+      displayName: account.accountName,
+      url: undefined
+    };
+  }
+  async postCreate(input) {
+    const { accountId, locationId } = this.resolveIds(input);
+    const parent = `accounts/${accountId}/locations/${locationId}`;
+    const body = {
+      languageCode: "en-US",
+      summary: input.text,
+      topicType: "STANDARD"
+    };
+    if (input.cta) {
+      body.callToAction = { actionType: input.cta.actionType, url: input.cta.url };
+    }
+    if (input.mediaIds && input.mediaIds.length > 0) {
+      body.media = input.mediaIds.map((m) => ({ mediaFormat: "PHOTO", sourceUrl: m }));
+    }
+    const post = await jsonRequest(this.fetchImpl, `${V4}/${parent}/localPosts`, { method: "POST", headers: this.headers({ "Content-Type": "application/json" }), body, errorLabel: "GoogleBusinessProfile" });
+    return { id: post.name, url: post.searchUrl };
+  }
+  async postDelete(input) {
+    await jsonRequest(this.fetchImpl, `${V4}/${input.id}`, {
+      method: "DELETE",
+      headers: this.headers(),
+      errorLabel: "GoogleBusinessProfile"
+    });
+    return { id: input.id, deleted: true };
+  }
+  async mediaUpload(input) {
+    if (!input.sourceUrl) {
+      throw new ConnectorOperationNotSupported("googlebusinessprofile", "media.upload (provide a public `sourceUrl`; raw binary upload uses a separate resumable service)");
+    }
+    const { accountId, locationId } = this.resolveIds(input);
+    const parent = `accounts/${accountId}/locations/${locationId}`;
+    const media = await jsonRequest(this.fetchImpl, `${V4}/${parent}/media`, {
+      method: "POST",
+      headers: this.headers({ "Content-Type": "application/json" }),
+      body: {
+        mediaFormat: "PHOTO",
+        locationAssociation: { category: "ADDITIONAL" },
+        sourceUrl: input.sourceUrl
+      },
+      errorLabel: "GoogleBusinessProfile"
+    });
+    return { mediaId: media.name };
+  }
+  async mentionsList(_input = {}) {
+    throw new ConnectorOperationNotSupported("googlebusinessprofile", "mentions.list (no mentions concept; reviews are a separate surface)");
+  }
+  async analyticsPost(_input) {
+    throw new ConnectorOperationNotSupported("googlebusinessprofile", "analytics.post (per-localPost insights are not exposed; use location-level Performance API)");
+  }
+}
+
+// src/social/index.ts
+var SUPPORTED_CONNECTORS = [
+  "x",
+  "mastodon",
+  "bluesky",
+  "linkedin",
+  "reddit",
+  "tiktok",
+  "youtube",
+  "pinterest",
+  "googlebusinessprofile"
+];
+var ALL_OPS = [
+  "account.me",
+  "post.create",
+  "post.delete",
+  "media.upload",
+  "mentions.list",
+  "analytics.post"
+];
+var SUPPORTED_OPERATIONS = {
+  x: [...ALL_OPS],
+  mastodon: [...ALL_OPS],
+  bluesky: [...ALL_OPS],
+  linkedin: ["account.me", "post.create", "post.delete", "media.upload"],
+  reddit: ["account.me", "post.create", "post.delete", "mentions.list", "analytics.post"],
+  tiktok: ["account.me", "post.create", "media.upload"],
+  youtube: ["account.me", "post.create", "post.delete", "media.upload", "analytics.post"],
+  pinterest: ["account.me", "post.create", "post.delete", "media.upload", "analytics.post"],
+  googlebusinessprofile: ["account.me", "post.create", "post.delete", "media.upload"]
+};
+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);
+    case "linkedin":
+      return LinkedInAdapter.fromCredentials(credentials);
+    case "reddit":
+      return RedditAdapter.fromCredentials(credentials);
+    case "tiktok":
+      return TikTokAdapter.fromCredentials(credentials);
+    case "youtube":
+      return YouTubeAdapter.fromCredentials(credentials);
+    case "pinterest":
+      return PinterestAdapter.fromCredentials(credentials);
+    case "googlebusinessprofile":
+      return GoogleBusinessProfileAdapter.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
+};