@hasna/connectors 1.3.37 → 1.3.39

package/dist/social/index.js

@@ -1467,12 +1467,1070 @@ class BlueskyAdapter {
   }
 }
 
+// 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/facebook.ts
+var DEFAULT_BASE2 = "https://graph.facebook.com/v19.0";
+
+class FacebookAdapter {
+  accessToken;
+  pageId;
+  baseUrl;
+  fetchImpl;
+  constructor(creds, fetchImpl) {
+    if (!creds || !creds.accessToken) {
+      throw new Error("facebook credentials require `accessToken`");
+    }
+    if (!creds.pageId) {
+      throw new Error("facebook credentials require `pageId`");
+    }
+    this.accessToken = creds.accessToken;
+    this.pageId = creds.pageId;
+    this.baseUrl = (creds.baseUrl ?? DEFAULT_BASE2).replace(/\/+$/, "");
+    this.fetchImpl = resolveFetch(fetchImpl);
+  }
+  static fromCredentials(creds, fetchImpl) {
+    return new FacebookAdapter(creds, fetchImpl);
+  }
+  auth() {
+    return { access_token: this.accessToken };
+  }
+  async accountMe() {
+    const me = await jsonRequest(this.fetchImpl, `${this.baseUrl}/${encodeURIComponent(this.pageId)}`, { query: { fields: "id,name,link", ...this.auth() }, errorLabel: "Facebook" });
+    return {
+      id: me.id,
+      displayName: me.name,
+      url: me.link
+    };
+  }
+  async postCreate(input) {
+    const body = { access_token: this.accessToken };
+    if (input.text)
+      body.message = input.text;
+    if (input.link)
+      body.link = input.link;
+    if (input.mediaIds && input.mediaIds.length > 0) {
+      body.attached_media = JSON.stringify(input.mediaIds.map((id2) => ({ media_fbid: id2 })));
+    }
+    const res = await jsonRequest(this.fetchImpl, `${this.baseUrl}/${encodeURIComponent(this.pageId)}/feed`, { method: "POST", body: new URLSearchParams(body).toString(), headers: { "Content-Type": "application/x-www-form-urlencoded" }, errorLabel: "Facebook" });
+    const id = res.post_id ?? res.id;
+    return { id, url: `https://facebook.com/${id}` };
+  }
+  async postDelete(input) {
+    await jsonRequest(this.fetchImpl, `${this.baseUrl}/${encodeURIComponent(input.id)}`, { method: "DELETE", query: this.auth(), errorLabel: "Facebook" });
+    return { id: input.id, deleted: true };
+  }
+  async mediaUpload(input) {
+    const buffer = decodeBase64(input.dataBase64);
+    const bytes = Uint8Array.from(buffer);
+    const form = new FormData;
+    form.append("access_token", this.accessToken);
+    form.append("published", "false");
+    form.append("source", new Blob([bytes], { type: input.mimeType }), "upload");
+    const res = await jsonRequest(this.fetchImpl, `${this.baseUrl}/${encodeURIComponent(this.pageId)}/photos`, { method: "POST", body: form, errorLabel: "Facebook" });
+    return { mediaId: res.id };
+  }
+  async mentionsList(_input = {}) {
+    throw new ConnectorOperationNotSupported("facebook", "mentions.list (Page mentions require the deprecated/limited tagged edge; not modeled)");
+  }
+  async analyticsPost(input) {
+    const res = await jsonRequest(this.fetchImpl, `${this.baseUrl}/${encodeURIComponent(input.id)}`, {
+      query: { fields: "likes.summary(true),comments.summary(true),shares", ...this.auth() },
+      errorLabel: "Facebook"
+    });
+    const metrics = {
+      likes: res.likes?.summary?.total_count ?? 0,
+      comments: res.comments?.summary?.total_count ?? 0,
+      shares: res.shares?.count ?? 0
+    };
+    return { metrics };
+  }
+}
+
+// src/social/instagram.ts
+var DEFAULT_BASE3 = "https://graph.facebook.com/v19.0";
+
+class InstagramAdapter {
+  accessToken;
+  igUserId;
+  baseUrl;
+  fetchImpl;
+  constructor(creds, fetchImpl) {
+    if (!creds || !creds.accessToken) {
+      throw new Error("instagram credentials require `accessToken`");
+    }
+    if (!creds.igUserId) {
+      throw new Error("instagram credentials require `igUserId`");
+    }
+    this.accessToken = creds.accessToken;
+    this.igUserId = creds.igUserId;
+    this.baseUrl = (creds.baseUrl ?? DEFAULT_BASE3).replace(/\/+$/, "");
+    this.fetchImpl = resolveFetch(fetchImpl);
+  }
+  static fromCredentials(creds, fetchImpl) {
+    return new InstagramAdapter(creds, fetchImpl);
+  }
+  form(fields) {
+    const params = new URLSearchParams;
+    params.append("access_token", this.accessToken);
+    for (const [k, v] of Object.entries(fields)) {
+      if (v !== undefined && v !== "")
+        params.append(k, v);
+    }
+    return params.toString();
+  }
+  postForm(path, fields) {
+    return jsonRequest(this.fetchImpl, `${this.baseUrl}/${path}`, {
+      method: "POST",
+      body: this.form(fields),
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      errorLabel: "Instagram"
+    });
+  }
+  async createContainer(imageUrl, caption) {
+    const res = await this.postForm(`${encodeURIComponent(this.igUserId)}/media`, {
+      image_url: imageUrl,
+      caption
+    });
+    return res.id;
+  }
+  async accountMe() {
+    const me = await jsonRequest(this.fetchImpl, `${this.baseUrl}/${encodeURIComponent(this.igUserId)}`, { query: { fields: "id,username", access_token: this.accessToken }, errorLabel: "Instagram" });
+    return {
+      id: me.id,
+      username: me.username,
+      url: me.username ? `https://www.instagram.com/${me.username}/` : undefined
+    };
+  }
+  async postCreate(input) {
+    let creationId = input.mediaIds?.[0];
+    if (!creationId) {
+      if (!input.imageUrl) {
+        throw new ConnectorOperationNotSupported("instagram", "post.create requires an image or video (provide `imageUrl` or a `mediaIds` container)");
+      }
+      creationId = await this.createContainer(input.imageUrl, input.text);
+    }
+    const published = await this.postForm(`${encodeURIComponent(this.igUserId)}/media_publish`, { creation_id: creationId });
+    return {
+      id: published.id,
+      url: `https://www.instagram.com/p/${published.id}/`
+    };
+  }
+  async postDelete(_input) {
+    throw new ConnectorOperationNotSupported("instagram", "post.delete (the Instagram Graph API cannot delete published media)");
+  }
+  async mediaUpload(input) {
+    if (!input.sourceUrl) {
+      throw new ConnectorOperationNotSupported("instagram", "media.upload requires a public `sourceUrl` (IG builds containers from a URL, not raw bytes)");
+    }
+    const creationId = await this.createContainer(input.sourceUrl, input.caption);
+    return { mediaId: creationId };
+  }
+  async mentionsList(_input = {}) {
+    throw new ConnectorOperationNotSupported("instagram", "mentions.list (tagged/mentioned media require the dedicated mentions edge; not modeled)");
+  }
+  async analyticsPost(input) {
+    const res = await jsonRequest(this.fetchImpl, `${this.baseUrl}/${encodeURIComponent(input.id)}/insights`, {
+      query: { metric: "impressions,reach,likes,comments,saved", access_token: this.accessToken },
+      errorLabel: "Instagram"
+    });
+    const metrics = {};
+    for (const m of res.data ?? []) {
+      const v = m.values?.[0]?.value;
+      if (typeof v === "number")
+        metrics[m.name] = v;
+    }
+    return { metrics };
+  }
+}
+
+// src/social/threads.ts
+var DEFAULT_BASE4 = "https://graph.threads.net/v1.0";
+
+class ThreadsAdapter {
+  accessToken;
+  userId;
+  baseUrl;
+  fetchImpl;
+  cachedUsername;
+  constructor(creds, fetchImpl) {
+    if (!creds || !creds.accessToken) {
+      throw new Error("threads credentials require `accessToken`");
+    }
+    if (!creds.userId) {
+      throw new Error("threads credentials require `userId`");
+    }
+    this.accessToken = creds.accessToken;
+    this.userId = creds.userId;
+    this.baseUrl = (creds.baseUrl ?? DEFAULT_BASE4).replace(/\/+$/, "");
+    this.fetchImpl = resolveFetch(fetchImpl);
+  }
+  static fromCredentials(creds, fetchImpl) {
+    return new ThreadsAdapter(creds, fetchImpl);
+  }
+  form(fields) {
+    const params = new URLSearchParams;
+    params.append("access_token", this.accessToken);
+    for (const [k, v] of Object.entries(fields)) {
+      if (v !== undefined && v !== "")
+        params.append(k, v);
+    }
+    return params.toString();
+  }
+  postForm(path, fields) {
+    return jsonRequest(this.fetchImpl, `${this.baseUrl}/${path}`, {
+      method: "POST",
+      body: this.form(fields),
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      errorLabel: "Threads"
+    });
+  }
+  async accountMe() {
+    const me = await jsonRequest(this.fetchImpl, `${this.baseUrl}/${encodeURIComponent(this.userId)}`, { query: { fields: "id,username", access_token: this.accessToken }, errorLabel: "Threads" });
+    this.cachedUsername = me.username;
+    return {
+      id: me.id,
+      username: me.username,
+      url: me.username ? `https://www.threads.net/@${me.username}` : undefined
+    };
+  }
+  async postCreate(input) {
+    let creationId = input.mediaIds?.[0];
+    if (!creationId) {
+      const container = await this.postForm(`${encodeURIComponent(this.userId)}/threads`, { media_type: "TEXT", text: input.text, reply_to_id: input.replyToId });
+      creationId = container.id;
+    }
+    const published = await this.postForm(`${encodeURIComponent(this.userId)}/threads_publish`, { creation_id: creationId });
+    const url = this.cachedUsername ? `https://www.threads.net/@${this.cachedUsername}/post/${published.id}` : undefined;
+    return { id: published.id, url };
+  }
+  async postDelete(input) {
+    await jsonRequest(this.fetchImpl, `${this.baseUrl}/${encodeURIComponent(input.id)}`, {
+      method: "DELETE",
+      query: { access_token: this.accessToken },
+      errorLabel: "Threads"
+    });
+    return { id: input.id, deleted: true };
+  }
+  async mediaUpload(input) {
+    let fields;
+    if (input.sourceUrl) {
+      fields = { media_type: "IMAGE", image_url: input.sourceUrl, text: input.text };
+    } else if (input.videoUrl) {
+      fields = { media_type: "VIDEO", video_url: input.videoUrl, text: input.text };
+    } else {
+      throw new ConnectorOperationNotSupported("threads", "media.upload requires a public `sourceUrl` (image) or `videoUrl` (video)");
+    }
+    const container = await this.postForm(`${encodeURIComponent(this.userId)}/threads`, fields);
+    return { mediaId: container.id };
+  }
+  async mentionsList(input = {}) {
+    let res;
+    try {
+      res = await jsonRequest(this.fetchImpl, `${this.baseUrl}/${encodeURIComponent(this.userId)}/mentions`, {
+        query: {
+          fields: "id,text,username,timestamp",
+          limit: input.limit !== undefined ? String(input.limit) : undefined,
+          access_token: this.accessToken
+        },
+        errorLabel: "Threads"
+      });
+    } catch {
+      throw new ConnectorOperationNotSupported("threads", "mentions.list (the Threads mentions edge is not available for this account)");
+    }
+    const items = (res.data ?? []).map((m) => ({
+      id: m.id,
+      text: m.text ?? "",
+      authorHandle: m.username,
+      createdAt: m.timestamp
+    }));
+    return { items };
+  }
+  async analyticsPost(input) {
+    const res = await jsonRequest(this.fetchImpl, `${this.baseUrl}/${encodeURIComponent(input.id)}/insights`, {
+      query: { metric: "views,likes,replies,reposts,quotes", access_token: this.accessToken },
+      errorLabel: "Threads"
+    });
+    const metrics = {};
+    for (const m of res.data ?? []) {
+      const v = m.values?.[0]?.value;
+      if (typeof v === "number")
+        metrics[m.name] = v;
+    }
+    return { metrics };
+  }
+}
+
 // src/social/index.ts
-var SUPPORTED_CONNECTORS = ["x", "mastodon", "bluesky"];
+var SUPPORTED_CONNECTORS = [
+  "x",
+  "mastodon",
+  "bluesky",
+  "linkedin",
+  "reddit",
+  "tiktok",
+  "youtube",
+  "pinterest",
+  "googlebusinessprofile",
+  "facebook",
+  "instagram",
+  "threads"
+];
+var ALL_OPS = [
+  "account.me",
+  "post.create",
+  "post.delete",
+  "media.upload",
+  "mentions.list",
+  "analytics.post"
+];
 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"]
+  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"],
+  facebook: ["account.me", "post.create", "post.delete", "media.upload", "analytics.post"],
+  instagram: ["account.me", "post.create", "media.upload", "analytics.post"],
+  threads: ["account.me", "post.create", "post.delete", "media.upload", "mentions.list", "analytics.post"]
 };
 function listSocialConnectors() {
   return [...SUPPORTED_CONNECTORS];
@@ -1492,6 +2550,24 @@ function buildAdapter(connector, credentials) {
       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);
+    case "facebook":
+      return FacebookAdapter.fromCredentials(credentials);
+    case "instagram":
+      return InstagramAdapter.fromCredentials(credentials);
+    case "threads":
+      return ThreadsAdapter.fromCredentials(credentials);
     default:
       throw new ConnectorOperationNotSupported(connector, "*");
   }