@happyvertical/social 0.74.8

package/dist/index.js

@@ -0,0 +1,2695 @@
+import { randomUUID, createHmac, createHash } from "node:crypto";
+import { createLogger } from "@happyvertical/logger";
+async function resolveMediaData(file, options = {}) {
+  const explicitMimeType = normalizeMimeType(options.explicitMimeType);
+  if (Buffer.isBuffer(file)) {
+    return {
+      data: file,
+      mimeType: explicitMimeType ?? detectMimeType(file) ?? options.fallbackMimeType ?? "application/octet-stream"
+    };
+  }
+  const response = await fetch(file);
+  if (!response.ok) {
+    const snippet = await response.text();
+    throw new Error(
+      `Failed to fetch media from ${file}: ${response.status} ${response.statusText}${snippet ? ` - ${snippet.slice(0, 200)}` : ""}`
+    );
+  }
+  const data = Buffer.from(await response.arrayBuffer());
+  return {
+    data,
+    mimeType: explicitMimeType ?? normalizeMimeType(response.headers.get("content-type")) ?? detectMimeType(data) ?? options.fallbackMimeType ?? "application/octet-stream"
+  };
+}
+function normalizeMimeType(value) {
+  const mimeType = value?.split(";")[0]?.trim().toLowerCase();
+  if (!mimeType || !/^[a-z0-9.+-]+\/[a-z0-9.+-]+$/.test(mimeType)) {
+    return void 0;
+  }
+  return mimeType;
+}
+function detectMimeType(data) {
+  if (data.length >= 8 && data.subarray(0, 8).equals(PNG_SIGNATURE)) {
+    return "image/png";
+  }
+  if (data.length >= 3 && data[0] === 255 && data[1] === 216) {
+    return "image/jpeg";
+  }
+  const header = data.subarray(0, 12).toString("ascii");
+  if (header.startsWith("GIF87a") || header.startsWith("GIF89a")) {
+    return "image/gif";
+  }
+  if (header.startsWith("RIFF") && header.slice(8, 12) === "WEBP") {
+    return "image/webp";
+  }
+  if (data.length >= 12 && data.subarray(4, 8).toString("ascii") === "ftyp") {
+    const brand = data.subarray(8, 12).toString("ascii");
+    return brand === "qt  " ? "video/quicktime" : "video/mp4";
+  }
+  if (data.length >= 4 && data[0] === 26 && data[1] === 69 && data[2] === 223 && data[3] === 163) {
+    return "video/webm";
+  }
+  return void 0;
+}
+const PNG_SIGNATURE = Buffer.from([
+  137,
+  80,
+  78,
+  71,
+  13,
+  10,
+  26,
+  10
+]);
+function resolvePublishMode(config) {
+  return config.publishMode ?? "public";
+}
+function isPublicPublishMode(mode) {
+  return mode === "public";
+}
+function createSafetyResult(options) {
+  const status = options.mode === "dry_run" ? "dry_run" : "staged";
+  const id = options.remoteId ?? `${options.platform}-${status}-${randomUUID()}`;
+  return {
+    id,
+    url: "",
+    status,
+    metadata: {
+      publishMode: options.mode,
+      safety: true,
+      staged: options.staged ?? status === "staged",
+      postType: options.postType,
+      remoteId: options.remoteId,
+      payload: options.payload,
+      note: options.note,
+      ...options.metadata
+    }
+  };
+}
+class SocialError extends Error {
+  constructor(message, code, platform, statusCode) {
+    super(message);
+    this.code = code;
+    this.platform = platform;
+    this.statusCode = statusCode;
+    this.name = "SocialError";
+  }
+}
+class SocialRateLimitError extends SocialError {
+  constructor(platform, retryAfter) {
+    super(
+      `Rate limit exceeded${retryAfter ? `, retry after ${retryAfter}s` : ""}`,
+      "RATE_LIMIT",
+      platform,
+      429
+    );
+    this.retryAfter = retryAfter;
+    this.name = "SocialRateLimitError";
+  }
+}
+class SocialAuthError extends SocialError {
+  constructor(platform, message = "Authentication failed") {
+    super(message, "AUTH_ERROR", platform, 401);
+    this.name = "SocialAuthError";
+  }
+}
+const DEFAULT_PDS = "https://bsky.social";
+class BlueskyAdapter {
+  platform = "bluesky";
+  config;
+  session;
+  constructor(config) {
+    this.config = config;
+  }
+  get pdsUrl() {
+    return this.config.pdsUrl ?? DEFAULT_PDS;
+  }
+  async authenticate() {
+    const response = await fetch(
+      `${this.pdsUrl}/xrpc/com.atproto.server.createSession`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          identifier: this.config.identifier,
+          password: this.config.password
+        })
+      }
+    );
+    if (!response.ok) {
+      const error = await response.json();
+      throw new SocialAuthError(
+        "bluesky",
+        error.message ?? "Authentication failed"
+      );
+    }
+    const data = await response.json();
+    this.session = {
+      did: data.did,
+      handle: data.handle,
+      accessJwt: data.accessJwt,
+      refreshJwt: data.refreshJwt
+    };
+    return {
+      accessToken: data.accessJwt,
+      refreshToken: data.refreshJwt
+    };
+  }
+  async refreshToken(refreshJwt) {
+    const response = await fetch(
+      `${this.pdsUrl}/xrpc/com.atproto.server.refreshSession`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${refreshJwt}`
+        }
+      }
+    );
+    if (!response.ok) {
+      throw new SocialAuthError("bluesky", "Session refresh failed");
+    }
+    const data = await response.json();
+    this.session = {
+      did: data.did,
+      handle: data.handle,
+      accessJwt: data.accessJwt,
+      refreshJwt: data.refreshJwt
+    };
+    return {
+      accessToken: data.accessJwt,
+      refreshToken: data.refreshJwt
+    };
+  }
+  async publishVideo(_video) {
+    throw new SocialError(
+      "Bluesky video publishing is not supported yet",
+      "NOT_SUPPORTED",
+      "bluesky"
+    );
+  }
+  async publishImage(image) {
+    const publishMode = resolvePublishMode(this.config);
+    const text = this.buildPostText(
+      image.description,
+      image.tags,
+      image.linkUrl
+    );
+    if (publishMode === "dry_run") {
+      return createSafetyResult({
+        platform: this.platform,
+        mode: publishMode,
+        postType: "image",
+        payload: {
+          text,
+          altText: image.altText,
+          linkUrl: image.linkUrl
+        },
+        note: "Bluesky dry run: blob was not uploaded and no post was created."
+      });
+    }
+    if (!this.session) {
+      await this.authenticate();
+    }
+    const imageData = await resolveMediaData(image.file, {
+      explicitMimeType: image.mimeType,
+      fallbackMimeType: "image/png"
+    });
+    const blobResponse = await fetch(
+      `${this.pdsUrl}/xrpc/com.atproto.repo.uploadBlob`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.session?.accessJwt}`,
+          "Content-Type": imageData.mimeType
+        },
+        body: new Uint8Array(imageData.data)
+      }
+    );
+    if (!blobResponse.ok) {
+      await this.handleError(blobResponse);
+    }
+    const blobData = await blobResponse.json();
+    if (!isPublicPublishMode(publishMode)) {
+      return createSafetyResult({
+        platform: this.platform,
+        mode: publishMode,
+        postType: "image",
+        payload: {
+          text,
+          altText: image.altText,
+          blob: blobData.blob,
+          linkUrl: image.linkUrl,
+          mimeType: imageData.mimeType
+        },
+        remoteId: blobData.blob?.ref?.$link ?? blobData.blob?.cid,
+        staged: true,
+        note: "Bluesky blob uploaded but no post record was created."
+      });
+    }
+    const record = {
+      $type: "app.bsky.feed.post",
+      text,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      embed: {
+        $type: "app.bsky.embed.images",
+        images: [
+          {
+            alt: image.altText ?? "",
+            image: blobData.blob
+          }
+        ]
+      }
+    };
+    return this.createPost(record);
+  }
+  async publishText(text) {
+    const publishMode = resolvePublishMode(this.config);
+    const postText = this.buildPostText(text.text, text.tags);
+    const record = {
+      $type: "app.bsky.feed.post",
+      text: postText,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (text.linkUrl) {
+      record.embed = {
+        $type: "app.bsky.embed.external",
+        external: {
+          uri: text.linkUrl,
+          title: "",
+          // Would need to fetch
+          description: ""
+        }
+      };
+      const urlStart = postText.indexOf(text.linkUrl);
+      if (urlStart >= 0) {
+        record.facets = [
+          {
+            index: {
+              byteStart: urlStart,
+              byteEnd: urlStart + text.linkUrl.length
+            },
+            features: [
+              {
+                $type: "app.bsky.richtext.facet#link",
+                uri: text.linkUrl
+              }
+            ]
+          }
+        ];
+      }
+    }
+    if (!isPublicPublishMode(publishMode)) {
+      return createSafetyResult({
+        platform: this.platform,
+        mode: publishMode,
+        postType: "text",
+        payload: record,
+        metadata: text.replyTo ? { replyTo: text.replyTo } : void 0,
+        note: publishMode === "dry_run" ? "Bluesky dry run: no post record was created." : "Bluesky has no non-public text staging endpoint; no post record was created."
+      });
+    }
+    if (!this.session) {
+      await this.authenticate();
+    }
+    if (text.replyTo) {
+      record.reply = await this.getReplyRef(text.replyTo);
+    }
+    return this.createPost(record);
+  }
+  async publishLink(link) {
+    const publishMode = resolvePublishMode(this.config);
+    const postText = this.buildPostText(
+      link.text ?? link.title ?? link.description ?? link.url,
+      link.tags
+    );
+    const record = {
+      $type: "app.bsky.feed.post",
+      text: postText,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      embed: {
+        $type: "app.bsky.embed.external",
+        external: {
+          uri: link.url,
+          title: link.title ?? link.url,
+          description: link.description ?? ""
+        }
+      }
+    };
+    if (!isPublicPublishMode(publishMode)) {
+      return createSafetyResult({
+        platform: this.platform,
+        mode: publishMode,
+        postType: "link",
+        payload: record,
+        note: publishMode === "dry_run" ? "Bluesky dry run: no post record was created." : "Bluesky has no non-public link staging endpoint; no post record was created."
+      });
+    }
+    if (!this.session) {
+      await this.authenticate();
+    }
+    return this.createPost(record);
+  }
+  async createPost(record) {
+    const response = await fetch(
+      `${this.pdsUrl}/xrpc/com.atproto.repo.createRecord`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.session?.accessJwt}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          repo: this.session?.did,
+          collection: "app.bsky.feed.post",
+          record
+        })
+      }
+    );
+    if (!response.ok) {
+      await this.handleError(response);
+    }
+    const data = await response.json();
+    const postId = data.uri.split("/").pop();
+    return {
+      id: data.uri,
+      url: `https://bsky.app/profile/${this.session?.handle}/post/${postId}`,
+      status: "published",
+      publishedAt: /* @__PURE__ */ new Date(),
+      metadata: { publishMode: resolvePublishMode(this.config) }
+    };
+  }
+  async getPost(postId) {
+    if (!this.session) {
+      await this.authenticate();
+    }
+    const uri = postId.startsWith("at://") ? postId : `at://${this.session?.did}/app.bsky.feed.post/${postId}`;
+    const response = await fetch(
+      `${this.pdsUrl}/xrpc/app.bsky.feed.getPostThread?uri=${encodeURIComponent(uri)}&depth=0`,
+      {
+        headers: { Authorization: `Bearer ${this.session?.accessJwt}` }
+      }
+    );
+    if (!response.ok) {
+      await this.handleError(response);
+    }
+    const data = await response.json();
+    const post = data.thread.post;
+    return {
+      id: post.uri,
+      url: `https://bsky.app/profile/${post.author.handle}/post/${post.uri.split("/").pop()}`,
+      type: "text",
+      description: post.record.text,
+      publishedAt: new Date(post.record.createdAt),
+      visibility: "public",
+      analytics: {
+        likes: post.likeCount,
+        shares: post.repostCount,
+        comments: post.replyCount,
+        lastUpdated: /* @__PURE__ */ new Date(),
+        raw: {
+          likeCount: post.likeCount,
+          repostCount: post.repostCount,
+          replyCount: post.replyCount,
+          quoteCount: post.quoteCount
+        }
+      }
+    };
+  }
+  async deletePost(postId) {
+    if (!this.session) {
+      await this.authenticate();
+    }
+    const rkey = postId.includes("/") ? postId.split("/").pop() : postId;
+    const response = await fetch(
+      `${this.pdsUrl}/xrpc/com.atproto.repo.deleteRecord`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.session?.accessJwt}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          repo: this.session?.did,
+          collection: "app.bsky.feed.post",
+          rkey
+        })
+      }
+    );
+    if (!response.ok) {
+      await this.handleError(response);
+    }
+  }
+  async getAnalytics(postId) {
+    const post = await this.getPost(postId);
+    return post.analytics ?? {};
+  }
+  getCapabilities() {
+    return {
+      video: false,
+      // Limited video support
+      image: true,
+      text: true,
+      link: true,
+      linkAttachment: true,
+      scheduling: false,
+      analytics: true,
+      rawAnalytics: true,
+      publishModes: ["dry_run", "stage_remote", "public"],
+      staging: true,
+      privatePublishing: false,
+      maxVideoLength: 0,
+      maxVideoSize: 0,
+      supportedVideoFormats: [],
+      aspectRatios: ["1:1", "16:9", "4:3"],
+      maxTextLength: 300,
+      maxHashtags: void 0,
+      // No limit
+      supportedPostTypes: ["text", "image", "link"]
+    };
+  }
+  /**
+   * Get reply reference for threading
+   */
+  async getReplyRef(parentUri) {
+    const response = await fetch(
+      `${this.pdsUrl}/xrpc/app.bsky.feed.getPostThread?uri=${encodeURIComponent(parentUri)}&depth=0`,
+      {
+        headers: { Authorization: `Bearer ${this.session?.accessJwt}` }
+      }
+    );
+    if (!response.ok) {
+      throw new SocialError(
+        "Failed to get parent post",
+        "NOT_FOUND",
+        "bluesky"
+      );
+    }
+    const data = await response.json();
+    const parent = data.thread.post;
+    const root = parent.record.reply?.root ?? {
+      uri: parent.uri,
+      cid: parent.cid
+    };
+    return {
+      root,
+      parent: {
+        uri: parent.uri,
+        cid: parent.cid
+      }
+    };
+  }
+  /**
+   * Build post text with hashtags
+   */
+  buildPostText(text, tags, linkUrl) {
+    let result = text ?? "";
+    if (linkUrl && !result.includes(linkUrl)) {
+      result += `
+
+${linkUrl}`;
+    }
+    if (tags && tags.length > 0) {
+      const hashtags = tags.map((t) => t.startsWith("#") ? t : `#${t}`);
+      result += `
+
+${hashtags.join(" ")}`;
+    }
+    if (result.length > 300) {
+      result = `${result.substring(0, 297)}...`;
+    }
+    return result;
+  }
+  /**
+   * Handle API errors
+   */
+  async handleError(response) {
+    const text = await response.text();
+    let error;
+    try {
+      error = JSON.parse(text);
+    } catch {
+      error = { message: text };
+    }
+    if (response.status === 401) {
+      throw new SocialAuthError("bluesky", error.message ?? "Unauthorized");
+    }
+    if (response.status === 429) {
+      throw new SocialRateLimitError("bluesky");
+    }
+    throw new SocialError(
+      error.message ?? "API request failed",
+      error.error ?? "API_ERROR",
+      "bluesky",
+      response.status
+    );
+  }
+}
+class FacebookPageAdapter {
+  platform = "facebook";
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  get graphUrl() {
+    return `https://graph.facebook.com/${this.config.apiVersion ?? "v24.0"}`;
+  }
+  async authenticate() {
+    const response = await fetch(
+      `${this.graphUrl}/${this.config.pageId}?fields=id,name,link&access_token=${encodeURIComponent(this.config.accessToken)}`
+    );
+    if (!response.ok) {
+      await this.handleError(response);
+    }
+    return {
+      accessToken: this.config.accessToken
+    };
+  }
+  async refreshToken(_refreshToken) {
+    throw new SocialError(
+      "Facebook Page access tokens are refreshed through Meta OAuth",
+      "NOT_IMPLEMENTED",
+      "facebook"
+    );
+  }
+  async publishText(text) {
+    const publishMode = resolvePublishMode(this.config);
+    if (publishMode === "dry_run") {
+      return createSafetyResult({
+        platform: this.platform,
+        mode: publishMode,
+        postType: "text",
+        payload: {
+          message: this.buildPostText(text.text, text.tags),
+          link: text.linkUrl
+        }
+      });
+    }
+    return this.createFeedPost(
+      {
+        message: this.buildPostText(text.text, text.tags),
+        ...text.linkUrl ? { link: text.linkUrl } : {},
+        ...this.safetyFeedFields(publishMode, text.scheduledAt)
+      },
+      publishMode
+    );
+  }
+  async publishLink(link) {
+    const publishMode = resolvePublishMode(this.config);
+    const payload = {
+      message: this.buildPostText(
+        link.text ?? link.title ?? link.description ?? "",
+        link.tags
+      ),
+      link: link.url,
+      ...this.safetyFeedFields(publishMode, link.scheduledAt)
+    };
+    if (publishMode === "dry_run") {
+      return createSafetyResult({
+        platform: this.platform,
+        mode: publishMode,
+        postType: "link",
+        payload
+      });
+    }
+    return this.createFeedPost(payload, publishMode);
+  }
+  async publishImage(image) {
+    const publishMode = resolvePublishMode(this.config);
+    if (publishMode === "dry_run") {
+      return createSafetyResult({
+        platform: this.platform,
+        mode: publishMode,
+        postType: "image",
+        payload: {
+          caption: this.buildPostText(
+            image.description,
+            image.tags,
+            image.linkUrl
+          ),
+          url: typeof image.file === "string" ? image.file : void 0,
+          link: image.linkUrl
+        }
+      });
+    }
+    const form = new FormData();
+    form.set("access_token", this.config.accessToken);
+    form.set(
+      "caption",
+      this.buildPostText(image.description, image.tags, image.linkUrl)
+    );
+    for (const [key, value] of Object.entries(
+      this.safetyFeedFields(publishMode, image.scheduledAt)
+    )) {
+      if (value !== void 0) form.set(key, value);
+    }
+    if (typeof image.file === "string") {
+      form.set("url", image.file);
+    } else {
+      form.set("source", new Blob([new Uint8Array(image.file)]));
+    }
+    const response = await fetch(
+      `${this.graphUrl}/${this.config.pageId}/photos`,
+      {
+        method: "POST",
+        body: form
+      }
+    );
+    if (!response.ok) {
+      await this.handleError(response);
+    }
+    const data = await response.json();
+    return this.toPostResult(
+      data.post_id ?? data.id,
+      this.safetyResultStatus(publishMode, image.scheduledAt),
+      publishMode
+    );
+  }
+  async publishVideo(video) {
+    const publishMode = resolvePublishMode(this.config);
+    if (publishMode === "dry_run") {
+      return createSafetyResult({
+        platform: this.platform,
+        mode: publishMode,
+        postType: "video",
+        payload: {
+          title: video.title,
+          description: this.buildPostText(
+            video.description,
+            video.tags,
+            video.linkUrl
+          ),
+          fileUrl: typeof video.file === "string" ? video.file : void 0,
+          link: video.linkUrl,
+          scheduledAt: video.scheduledAt?.toISOString()
+        }
+      });
+    }
+    const form = new FormData();
+    form.set("access_token", this.config.accessToken);
+    form.set(
+      "description",
+      this.buildPostText(video.description, video.tags, video.linkUrl)
+    );
+    for (const [key, value] of Object.entries(
+      this.safetyFeedFields(publishMode, video.scheduledAt)
+    )) {
+      if (value !== void 0) form.set(key, value);
+    }
+    if (video.title) {
+      form.set("title", video.title);
+    }
+    if (video.linkUrl) {
+      form.set("embeddable", "true");
+    }
+    if (typeof video.file === "string") {
+      form.set("file_url", video.file);
+    } else {
+      form.set("source", new Blob([new Uint8Array(video.file)]));
+    }
+    const response = await fetch(
+      `${this.graphUrl}/${this.config.pageId}/videos`,
+      {
+        method: "POST",
+        body: form
+      }
+    );
+    if (!response.ok) {
+      await this.handleError(response);
+    }
+    const data = await response.json();
+    return this.toPostResult(
+      data.id,
+      this.safetyResultStatus(publishMode, video.scheduledAt, "processing"),
+      publishMode
+    );
+  }
+  async getPost(postId) {
+    const response = await fetch(
+      `${this.graphUrl}/${postId}?fields=id,message,created_time,permalink_url,attachments{media_type},insights.metric(post_impressions,post_clicks,post_reactions_by_type_total,post_comments,post_shares)&access_token=${encodeURIComponent(this.config.accessToken)}`
+    );
+    if (!response.ok) {
+      await this.handleError(response);
+    }
+    const data = await response.json();
+    const mediaType = data.attachments?.data?.[0]?.media_type;
+    return {
+      id: data.id,
+      url: data.permalink_url ?? `https://www.facebook.com/${data.id}`,
+      type: mediaType === "video" ? "video" : mediaType === "photo" ? "image" : mediaType === "share" ? "link" : "text",
+      description: data.message,
+      publishedAt: data.created_time ? new Date(data.created_time) : /* @__PURE__ */ new Date(),
+      visibility: "public",
+      analytics: this.parseInsights(data.insights?.data ?? [])
+    };
+  }
+  async deletePost(postId) {
+    const response = await fetch(
+      `${this.graphUrl}/${postId}?access_token=${encodeURIComponent(this.config.accessToken)}`,
+      { method: "DELETE" }
+    );
+    if (!response.ok) {
+      await this.handleError(response);
+    }
+  }
+  async getAnalytics(postId) {
+    const post = await this.getPost(postId);
+    return post.analytics ?? {};
+  }
+  getCapabilities() {
+    return {
+      video: true,
+      image: true,
+      text: true,
+      link: true,
+      linkAttachment: true,
+      scheduling: true,
+      analytics: true,
+      rawAnalytics: true,
+      publishModes: [
+        "dry_run",
+        "stage_remote",
+        "private_or_scheduled",
+        "public"
+      ],
+      staging: true,
+      privatePublishing: true,
+      maxVideoLength: 240 * 60,
+      maxVideoSize: 10 * 1024 * 1024 * 1024,
+      supportedVideoFormats: ["mp4", "mov"],
+      aspectRatios: ["16:9", "1:1", "9:16", "4:5"],
+      maxTextLength: 63206,
+      maxHashtags: void 0,
+      supportedPostTypes: ["text", "image", "video", "link"]
+    };
+  }
+  async createFeedPost(fields, publishMode = "public") {
+    const body = new URLSearchParams();
+    body.set("access_token", this.config.accessToken);
+    for (const [key, value] of Object.entries(fields)) {
+      if (value !== void 0 && value !== "") {
+        body.set(key, value);
+      }
+    }
+    const response = await fetch(
+      `${this.graphUrl}/${this.config.pageId}/feed`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body
+      }
+    );
+    if (!response.ok) {
+      await this.handleError(response);
+    }
+    const data = await response.json();
+    const status = fields.published === "false" && fields.scheduled_publish_time ? "scheduled" : fields.published === "false" ? "staged" : "published";
+    return this.toPostResult(data.id, status, publishMode);
+  }
+  toPostResult(id, status, publishMode = "public") {
+    return {
+      id,
+      url: `https://www.facebook.com/${id}`,
+      status,
+      publishedAt: status === "published" ? /* @__PURE__ */ new Date() : void 0,
+      metadata: {
+        publishMode,
+        safety: publishMode !== "public"
+      }
+    };
+  }
+  safetyFeedFields(publishMode, scheduledAt) {
+    if (isPublicPublishMode(publishMode)) {
+      return {};
+    }
+    return {
+      published: "false",
+      ...scheduledAt ? {
+        scheduled_publish_time: Math.floor(
+          scheduledAt.getTime() / 1e3
+        ).toString()
+      } : {}
+    };
+  }
+  safetyResultStatus(publishMode, scheduledAt, publicStatus = "published") {
+    if (isPublicPublishMode(publishMode)) return publicStatus;
+    return scheduledAt ? "scheduled" : "staged";
+  }
+  buildPostText(text, tags, linkUrl) {
+    let result = text ?? "";
+    if (linkUrl && !result.includes(linkUrl)) {
+      result += result.length > 0 ? `
+
+${linkUrl}` : linkUrl;
+    }
+    if (tags && tags.length > 0) {
+      const hashtags = tags.map(
+        (tag) => tag.startsWith("#") ? tag : `#${tag}`
+      );
+      result += result.length > 0 ? `
+
+${hashtags.join(" ")}` : hashtags.join(" ");
+    }
+    return result;
+  }
+  parseInsights(insights) {
+    const analytics = { lastUpdated: /* @__PURE__ */ new Date(), raw: insights };
+    for (const insight of insights) {
+      const value = insight.values?.[0]?.value;
+      switch (insight.name) {
+        case "post_impressions":
+          analytics.views = typeof value === "number" ? value : void 0;
+          analytics.impressions = analytics.views;
+          break;
+        case "post_clicks":
+          analytics.clicks = typeof value === "number" ? value : void 0;
+          break;
+        case "post_comments":
+          analytics.comments = typeof value === "number" ? value : void 0;
+          break;
+        case "post_shares":
+          analytics.shares = typeof value === "number" ? value : void 0;
+          break;
+        case "post_reactions_by_type_total":
+          analytics.likes = typeof value === "object" && value !== null ? this.sumPositiveReactions(value) : void 0;
+          break;
+      }
+    }
+    return analytics;
+  }
+  sumPositiveReactions(reactions) {
+    return ["like", "love", "haha", "wow"].reduce((sum, key) => {
+      const count = reactions[key];
+      return sum + (typeof count === "number" ? count : 0);
+    }, 0);
+  }
+  async handleError(response) {
+    const text = await response.text();
+    let error;
+    try {
+      error = JSON.parse(text);
+    } catch {
+      error = { error: { message: text } };
+    }
+    if (response.status === 401 || error.error?.code === 190) {
+      throw new SocialAuthError(
+        "facebook",
+        error.error?.message ?? "Unauthorized"
+      );
+    }
+    if (response.status === 429 || error.error?.code === 4) {
+      throw new SocialRateLimitError("facebook");
+    }
+    throw new SocialError(
+      error.error?.message ?? "API request failed",
+      error.error?.code?.toString() ?? "API_ERROR",
+      "facebook",
+      response.status
+    );
+  }
+}
+const THREADS_API_URL = "https://graph.threads.net/v1.0";
+class ThreadsAdapter {
+  platform = "threads";
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async authenticate() {
+    const response = await fetch(
+      `${THREADS_API_URL}/${this.config.userId}?fields=id,username`,
+      {
+        headers: {
+          Authorization: `Bearer ${this.config.accessToken}`
+        }
+      }
+    );
+    if (!response.ok) {
+      const error = await response.json();
+      throw new SocialAuthError(
+        "threads",
+        error.error?.message ?? "Authentication failed"
+      );
+    }
+    return {
+      accessToken: this.config.accessToken
+    };
+  }
+  async refreshToken(_refreshToken) {
+    throw new SocialError(
+      "Use Meta OAuth token exchange for refresh",
+      "NOT_IMPLEMENTED",
+      "threads"
+    );
+  }
+  async publishVideo(video) {
+    const publishMode = resolvePublishMode(this.config);
+    const text = this.buildPostText(video.description, video.tags);
+    const dryRunPayload = {
+      media_type: "VIDEO",
+      ...typeof video.file === "string" ? { video_url: video.file } : {},
+      text,
+      ...video.linkUrl ? { link_attachment: video.linkUrl } : {}
+    };
+    if (publishMode === "dry_run") {
+      return createSafetyResult({
+        platform: this.platform,
+        mode: publishMode,
+        postType: "video",
+        payload: dryRunPayload,
+        note: "Threads dry run: media container was not created."
+      });
+    }
+    const videoUrl = Buffer.isBuffer(video.file) ? await this.uploadToTempStorage(video.file, "video/mp4") : video.file;
+    const payload = {
+      media_type: "VIDEO",
+      video_url: videoUrl,
+      text,
+      ...video.linkUrl ? { link_attachment: video.linkUrl } : {}
+    };
+    const containerResponse = await fetch(
+      `${THREADS_API_URL}/${this.config.userId}/threads`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.config.accessToken}`
+        },
+        body: JSON.stringify(payload)
+      }
+    );
+    if (!containerResponse.ok) {
+      await this.handleError(containerResponse);
+    }
+    const containerData = await containerResponse.json();
+    const containerId = containerData.id;
+    await this.waitForContainer(containerId);
+    if (!isPublicPublishMode(publishMode)) {
+      return createSafetyResult({
+        platform: this.platform,
+        mode: publishMode,
+        postType: "video",
+        payload,
+        remoteId: containerId,
+        staged: true,
+        note: "Threads media container created but not published."
+      });
+    }
+    return this.publishContainer(containerId, publishMode);
+  }
+  async publishImage(image) {
+    const publishMode = resolvePublishMode(this.config);
+    const text = this.buildPostText(image.description, image.tags);
+    const dryRunPayload = {
+      media_type: "IMAGE",
+      ...typeof image.file === "string" ? { image_url: image.file } : {},
+      text,
+      ...image.linkUrl ? { link_attachment: image.linkUrl } : {}
+    };
+    if (publishMode === "dry_run") {
+      return createSafetyResult({
+        platform: this.platform,
+        mode: publishMode,
+        postType: "image",
+        payload: dryRunPayload,
+        note: "Threads dry run: media container was not created."
+      });
+    }
+    const imageUrl = Buffer.isBuffer(image.file) ? await this.uploadToTempStorage(image.file, "image/png") : image.file;
+    const payload = {
+      media_type: "IMAGE",
+      image_url: imageUrl,
+      text,
+      ...image.linkUrl ? { link_attachment: image.linkUrl } : {}
+    };
+    const containerResponse = await fetch(
+      `${THREADS_API_URL}/${this.config.userId}/threads`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.config.accessToken}`
+        },
+        body: JSON.stringify(payload)
+      }
+    );
+    if (!containerResponse.ok) {
+      await this.handleError(containerResponse);
+    }
+    const containerData = await containerResponse.json();
+    const containerId = containerData.id;
+    await this.waitForContainer(containerId);
+    if (!isPublicPublishMode(publishMode)) {
+      return createSafetyResult({
+        platform: this.platform,
+        mode: publishMode,
+        postType: "image",
+        payload,
+        remoteId: containerId,
+        staged: true,
+        note: "Threads media container created but not published."
+      });
+    }
+    return this.publishContainer(containerId, publishMode);
+  }
+  async publishText(text) {
+    const publishMode = resolvePublishMode(this.config);
+    const postText = this.buildPostText(text.text, text.tags);
+    const body = {
+      media_type: "TEXT",
+      text: postText
+    };
+    if (text.linkUrl) {
+      body.link_attachment = text.linkUrl;
+    }
+    if (text.replyTo) {
+      body.reply_to_id = text.replyTo;
+    }
+    if (publishMode === "dry_run") {
+      return createSafetyResult({
+        platform: this.platform,
+        mode: publishMode,
+        postType: "text",
+        payload: body,
+        note: "Threads dry run: text container was not created."
+      });
+    }
+    const containerResponse = await fetch(
+      `${THREADS_API_URL}/${this.config.userId}/threads`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.config.accessToken}`
+        },
+        body: JSON.stringify(body)
+      }
+    );
+    if (!containerResponse.ok) {
+      await this.handleError(containerResponse);
+    }
+    const containerData = await containerResponse.json();
+    const containerId = containerData.id;
+    if (!isPublicPublishMode(publishMode)) {
+      return createSafetyResult({
+        platform: this.platform,
+        mode: publishMode,
+        postType: "text",
+        payload: body,
+        remoteId: containerId,
+        staged: true,
+        note: "Threads text container created but not published."
+      });
+    }
+    return this.publishContainer(containerId, publishMode);
+  }
+  async publishLink(link) {
+    return this.publishText({
+      text: link.text ?? link.title ?? link.description ?? link.url,
+      tags: link.tags,
+      linkUrl: link.url,
+      scheduledAt: link.scheduledAt,
+      linkBehavior: link.linkBehavior
+    });
+  }
+  /**
+   * Wait for media container to finish processing
+   */
+  async waitForContainer(containerId) {
+    let checkCount = 0;
+    const maxChecks = 60;
+    while (checkCount < maxChecks) {
+      const statusResponse = await fetch(
+        `${THREADS_API_URL}/${containerId}?fields=status`,
+        {
+          headers: {
+            Authorization: `Bearer ${this.config.accessToken}`
+          }
+        }
+      );
+      if (!statusResponse.ok) {
+        throw new SocialError(
+          "Failed to check container status",
+          "STATUS_CHECK_FAILED",
+          "threads"
+        );
+      }
+      const statusData = await statusResponse.json();
+      if (statusData.status === "FINISHED") {
+        return;
+      }
+      if (statusData.status === "ERROR") {
+        throw new SocialError(
+          "Media processing failed",
+          "PROCESSING_FAILED",
+          "threads"
+        );
+      }
+      await new Promise((resolve) => setTimeout(resolve, 5e3));
+      checkCount++;
+    }
+    throw new SocialError(
+      "Media processing timeout",
+      "PROCESSING_TIMEOUT",
+      "threads"
+    );
+  }
+  /**
+   * Publish a prepared container
+   */
+  async publishContainer(containerId, publishMode = "public") {
+    const publishResponse = await fetch(
+      `${THREADS_API_URL}/${this.config.userId}/threads_publish`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.config.accessToken}`
+        },
+        body: JSON.stringify({
+          creation_id: containerId
+        })
+      }
+    );
+    if (!publishResponse.ok) {
+      await this.handleError(publishResponse);
+    }
+    const publishData = await publishResponse.json();
+    const threadResponse = await fetch(
+      `${THREADS_API_URL}/${publishData.id}?fields=id,permalink`,
+      {
+        headers: {
+          Authorization: `Bearer ${this.config.accessToken}`
+        }
+      }
+    );
+    const threadData = await threadResponse.json();
+    return {
+      id: publishData.id,
+      url: threadData.permalink ?? `https://www.threads.net/@${this.config.userId}/post/${publishData.id}`,
+      status: "published",
+      publishedAt: /* @__PURE__ */ new Date(),
+      metadata: { publishMode }
+    };
+  }
+  /**
+   * Upload buffer to temporary storage and return URL
+   * Note: In production, this would upload to a CDN or storage service
+   */
+  async uploadToTempStorage(_buffer, _mimeType) {
+    throw new SocialError(
+      "Buffer upload requires external storage configuration. Provide a URL instead.",
+      "NOT_IMPLEMENTED",
+      "threads"
+    );
+  }
+  async getPost(postId) {
+    const response = await fetch(
+      `${THREADS_API_URL}/${postId}?fields=id,text,timestamp,media_type,permalink`,
+      {
+        headers: {
+          Authorization: `Bearer ${this.config.accessToken}`
+        }
+      }
+    );
+    if (!response.ok) {
+      await this.handleError(response);
+    }
+    const data = await response.json();
+    let analytics = {};
+    try {
+      const insightsResponse = await fetch(
+        `${THREADS_API_URL}/${postId}/insights?metric=views,likes,replies,reposts`,
+        {
+          headers: {
+            Authorization: `Bearer ${this.config.accessToken}`
+          }
+        }
+      );
+      if (insightsResponse.ok) {
+        const insightsData = await insightsResponse.json();
+        analytics = this.parseInsights(insightsData.data);
+      }
+    } catch {
+    }
+    return {
+      id: data.id,
+      url: data.permalink,
+      type: this.mapMediaType(data.media_type),
+      description: data.text,
+      publishedAt: new Date(data.timestamp),
+      visibility: "public",
+      analytics
+    };
+  }
+  async deletePost(_postId) {
+    throw new SocialError(
+      "Threads does not support programmatic post deletion",
+      "NOT_SUPPORTED",
+      "threads"
+    );
+  }
+  async getAnalytics(postId) {
+    const response = await fetch(
+      `${THREADS_API_URL}/${postId}/insights?metric=views,likes,replies,reposts,quotes`,
+      {
+        headers: {
+          Authorization: `Bearer ${this.config.accessToken}`
+        }
+      }
+    );
+    if (!response.ok) {
+      await this.handleError(response);
+    }
+    const data = await response.json();
+    return this.parseInsights(data.data);
+  }
+  getCapabilities() {
+    return {
+      video: true,
+      image: true,
+      text: true,
+      link: true,
+      linkAttachment: true,
+      scheduling: false,
+      analytics: true,
+      rawAnalytics: true,
+      requiresPublicMediaUrl: true,
+      publishModes: ["dry_run", "stage_remote", "public"],
+      staging: true,
+      privatePublishing: false,
+      maxVideoLength: 300,
+      // 5 minutes
+      maxVideoSize: 1024 * 1024 * 1024,
+      // 1GB
+      supportedVideoFormats: ["mp4", "mov"],
+      aspectRatios: ["1:1", "4:5", "9:16"],
+      maxTextLength: 500,
+      maxHashtags: void 0,
+      supportedPostTypes: ["text", "image", "video", "link"]
+    };
+  }
+  /**
+   * Build post text with hashtags and link
+   */
+  buildPostText(text, tags) {
+    let result = text ?? "";
+    if (tags && tags.length > 0) {
+      const hashtags = tags.map((t) => t.startsWith("#") ? t : `#${t}`);
+      result += `
+
+${hashtags.join(" ")}`;
+    }
+    if (result.length > 500) {
+      result = `${result.substring(0, 497)}...`;
+    }
+    return result;
+  }
+  /**
+   * Parse insights data into PostAnalytics
+   */
+  parseInsights(insights) {
+    const analytics = {};
+    for (const insight of insights) {
+      const value = insight.values?.[0]?.value;
+      switch (insight.name) {
+        case "views":
+          analytics.views = typeof value === "number" ? value : void 0;
+          analytics.impressions = analytics.views;
+          break;
+        case "likes":
+          analytics.likes = typeof value === "number" ? value : void 0;
+          break;
+        case "replies":
+          analytics.comments = typeof value === "number" ? value : void 0;
+          break;
+        case "reposts":
+        case "quotes":
+          if (typeof value === "number") {
+            analytics.shares = (analytics.shares ?? 0) + value;
+          }
+          break;
+      }
+    }
+    analytics.lastUpdated = /* @__PURE__ */ new Date();
+    analytics.raw = insights;
+    return analytics;
+  }
+  /**
+   * Map Threads media type to our type
+   */
+  mapMediaType(mediaType) {
+    switch (mediaType) {
+      case "VIDEO":
+        return "video";
+      case "IMAGE":
+      case "CAROUSEL_ALBUM":
+        return "image";
+      default:
+        return "text";
+    }
+  }
+  /**
+   * Handle API errors
+   */
+  async handleError(response) {
+    const text = await response.text();
+    let error;
+    try {
+      error = JSON.parse(text);
+    } catch {
+      error = { error: { message: text } };
+    }
+    if (response.status === 401 || error.error?.code === 190) {
+      throw new SocialAuthError(
+        "threads",
+        error.error?.message ?? "Unauthorized"
+      );
+    }
+    if (response.status === 429 || error.error?.code === 4) {
+      throw new SocialRateLimitError("threads");
+    }
+    throw new SocialError(
+      error.error?.message ?? "API request failed",
+      error.error?.code?.toString() ?? "API_ERROR",
+      "threads",
+      response.status
+    );
+  }
+}
+const X_API_URL = "https://api.twitter.com/2";
+const X_UPLOAD_URL = "https://upload.twitter.com/1.1";
+const X_API_MEDIA_UPLOAD_URL = "https://api.x.com/2/media/upload";
+const X_API_MEDIA_METADATA_URL = "https://api.x.com/2/media/metadata";
+const X_OAUTH_TOKEN_URL = "https://api.x.com/2/oauth2/token";
+class XAdapter {
+  platform = "x";
+  config;
+  logger;
+  constructor(config) {
+    this.config = config;
+    this.logger = createLogger({ level: "info" });
+  }
+  /**
+   * Generate OAuth 1.0a signature for request
+   */
+  generateOAuthSignature(method, url, params) {
+    const { apiKey, apiSecret, accessSecret } = this.requireOAuth1Config();
+    const oauthParams = {
+      oauth_consumer_key: apiKey,
+      oauth_nonce: this.generateNonce(),
+      oauth_signature_method: "HMAC-SHA1",
+      oauth_timestamp: Math.floor(Date.now() / 1e3).toString(),
+      oauth_token: this.config.accessToken,
+      oauth_version: "1.0",
+      ...params
+    };
+    const sortedParams = Object.keys(oauthParams).sort().map(
+      (k) => `${this.percentEncode(k)}=${this.percentEncode(oauthParams[k])}`
+    ).join("&");
+    const signatureBase = [
+      method.toUpperCase(),
+      this.percentEncode(url),
+      this.percentEncode(sortedParams)
+    ].join("&");
+    const signingKey = `${this.percentEncode(apiSecret)}&${this.percentEncode(accessSecret)}`;
+    const signature = this.hmacSha1(signatureBase, signingKey);
+    const authParams = {
+      ...oauthParams,
+      oauth_signature: signature
+    };
+    return "OAuth " + Object.keys(authParams).filter((k) => k.startsWith("oauth_")).sort().map(
+      (k) => `${this.percentEncode(k)}="${this.percentEncode(authParams[k])}"`
+    ).join(", ");
+  }
+  generateNonce() {
+    return randomUUID().replace(/-/g, "");
+  }
+  percentEncode(str) {
+    return encodeURIComponent(str).replace(
+      /[!'()*]/g,
+      (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`
+    );
+  }
+  hmacSha1(data, key) {
+    return createHmac("sha1", key).update(data).digest("base64");
+  }
+  async authenticate() {
+    const response = await this.makeRequest(
+      "GET",
+      `${X_API_URL}/users/me?user.fields=username,name`
+    );
+    if (!response.ok) {
+      throw new SocialAuthError("x", "Invalid credentials");
+    }
+    return {
+      accessToken: this.config.accessToken,
+      refreshToken: this.config.refreshToken
+    };
+  }
+  async refreshToken(refreshToken) {
+    if (!this.usesOAuth2()) {
+      throw new SocialError(
+        "OAuth 1.0a does not support token refresh",
+        "NOT_SUPPORTED",
+        "x"
+      );
+    }
+    if (!this.config.clientId || !this.config.clientSecret) {
+      throw new SocialAuthError("x", "Missing OAuth 2.0 client credentials");
+    }
+    const response = await fetch(X_OAUTH_TOKEN_URL, {
+      method: "POST",
+      headers: {
+        Authorization: this.basicAuthHeader(
+          this.config.clientId,
+          this.config.clientSecret
+        ),
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: new URLSearchParams({
+        grant_type: "refresh_token",
+        refresh_token: refreshToken
+      })
+    });
+    if (!response.ok) {
+      await this.handleError(response);
+    }
+    const token = await response.json();
+    return {
+      accessToken: token.access_token,
+      refreshToken: token.refresh_token,
+      expiresAt: typeof token.expires_in === "number" ? new Date(Date.now() + token.expires_in * 1e3) : void 0,
+      tokenType: token.token_type,
+      scopes: typeof token.scope === "string" ? token.scope.split(" ") : void 0
+    };
+  }
+  basicAuthHeader(clientId, clientSecret) {
+    return `Basic ${Buffer.from(`${clientId}:${clientSecret}`).toString(
+      "base64"
+    )}`;
+  }
+  async publishVideo(video) {
+    const publishMode = resolvePublishMode(this.config);
+    const linkBehavior = this.resolveLinkBehavior(video.linkBehavior);
+    const text = this.buildPostText(
+      video.description,
+      video.tags,
+      video.linkUrl,
+      linkBehavior
+    );
+    const payload = { text, linkBehavior, tags: video.tags };
+    if (publishMode === "dry_run") {
+      return createSafetyResult({
+        platform: this.platform,
+        mode: publishMode,
+        postType: "video",
+        payload,
+        note: "X dry run: media was not uploaded and no post was created."
+      });
+    }
+    const mediaId = await this.uploadMedia(video.file, "video", video.mimeType);
+    if (!isPublicPublishMode(publishMode)) {
+      return createSafetyResult({
+        platform: this.platform,
+        mode: publishMode,
+        postType: "video",
+        payload: { ...payload, mediaId },
+        remoteId: mediaId,
+        staged: true,
+        note: "X media uploaded but no post was created."
+      });
+    }
+    const response = await this.makeRequest("POST", `${X_API_URL}/tweets`, {
+      text,
+      media: { media_ids: [mediaId] }
+    });
+    if (!response.ok) {
+      await this.handleError(response);
+    }
+    const data = await response.json();
+    if (video.linkUrl && linkBehavior === "reply") {
+      await this.postLinkReply(data.data.id, video.linkUrl);
+    }
+    return {
+      id: data.data.id,
+      url: `https://x.com/i/status/${data.data.id}`,
+      status: "published",
+      publishedAt: /* @__PURE__ */ new Date(),
+      metadata: { publishMode }
+    };
+  }
+  async publishImage(image) {
+    const publishMode = resolvePublishMode(this.config);
+    const linkBehavior = this.resolveLinkBehavior(image.linkBehavior);
+    const text = this.buildPostText(
+      image.description,
+      image.tags,
+      image.linkUrl,
+      linkBehavior
+    );
+    const payload = {
+      text,
+      linkBehavior,
+      tags: image.tags,
+      altText: image.altText
+    };
+    if (publishMode === "dry_run") {
+      return createSafetyResult({
+        platform: this.platform,
+        mode: publishMode,
+        postType: "image",
+        payload,
+        note: "X dry run: media was not uploaded and no post was created."
+      });
+    }
+    const mediaId = await this.uploadMedia(image.file, "image", image.mimeType);
+    if (!isPublicPublishMode(publishMode)) {
+      if (image.altText) {
+        await this.setMediaAltText(mediaId, image.altText);
+      }
+      return createSafetyResult({
+        platform: this.platform,
+        mode: publishMode,
+        postType: "image",
+        payload: { ...payload, mediaId },
+        remoteId: mediaId,
+        staged: true,
+        note: "X media uploaded but no post was created."
+      });
+    }
+    const body = {
+      text,
+      media: { media_ids: [mediaId] }
+    };
+    if (image.altText) {
+      await this.setMediaAltText(mediaId, image.altText);
+    }
+    const response = await this.makeRequest(
+      "POST",
+      `${X_API_URL}/tweets`,
+      body
+    );
+    if (!response.ok) {
+      await this.handleError(response);
+    }
+    const data = await response.json();
+    if (image.linkUrl && linkBehavior === "reply") {
+      await this.postLinkReply(data.data.id, image.linkUrl);
+    }
+    return {
+      id: data.data.id,
+      url: `https://x.com/i/status/${data.data.id}`,
+      status: "published",
+      publishedAt: /* @__PURE__ */ new Date(),
+      metadata: { publishMode }
+    };
+  }
+  async publishText(text) {
+    const publishMode = resolvePublishMode(this.config);
+    const linkBehavior = this.resolveLinkBehavior(text.linkBehavior);
+    const postText = this.buildPostText(
+      text.text,
+      text.tags,
+      text.linkUrl,
+      linkBehavior
+    );
+    const body = { text: postText };
+    if (text.replyTo) {
+      body.reply = { in_reply_to_tweet_id: text.replyTo };
+    }
+    if (!isPublicPublishMode(publishMode)) {
+      return createSafetyResult({
+        platform: this.platform,
+        mode: publishMode,
+        postType: "text",
+        payload: body,
+        note: publishMode === "dry_run" ? "X dry run: no post was created." : "X has no non-public text staging endpoint; no post was created."
+      });
+    }
+    const response = await this.makeRequest(
+      "POST",
+      `${X_API_URL}/tweets`,
+      body
+    );
+    if (!response.ok) {
+      await this.handleError(response);
+    }
+    const data = await response.json();
+    if (text.linkUrl && linkBehavior === "reply" && !text.replyTo) {
+      await this.postLinkReply(data.data.id, text.linkUrl);
+    }
+    return {
+      id: data.data.id,
+      url: `https://x.com/i/status/${data.data.id}`,
+      status: "published",
+      publishedAt: /* @__PURE__ */ new Date(),
+      metadata: { publishMode }
+    };
+  }
+  async publishLink(link) {
+    return this.publishText({
+      text: link.text ?? link.title ?? link.description ?? link.url,
+      tags: link.tags,
+      linkUrl: link.url,
+      scheduledAt: link.scheduledAt,
+      linkBehavior: link.linkBehavior
+    });
+  }
+  /**
+   * Upload media to Twitter
+   */
+  async uploadMedia(file, type, mimeType) {
+    if (this.usesOAuth2()) {
+      return this.uploadMediaV2(file, type, mimeType);
+    }
+    return this.uploadMediaOAuth1(file, type, mimeType);
+  }
+  async readMediaData(file, type, mimeType) {
+    return resolveMediaData(file, {
+      explicitMimeType: mimeType,
+      fallbackMimeType: type === "video" ? "video/mp4" : "image/png"
+    });
+  }
+  /**
+   * Upload media using X API v2 and OAuth 2.0 user context.
+   */
+  async uploadMediaV2(file, type, mimeType) {
+    const mediaData = await this.readMediaData(file, type, mimeType);
+    const mediaType = mediaData.mimeType;
+    const mediaCategory = type === "video" ? "tweet_video" : "tweet_image";
+    const initResponse = await this.makeBearerUploadRequest("POST", {
+      command: "INIT",
+      total_bytes: String(mediaData.data.length),
+      media_type: mediaType,
+      media_category: mediaCategory
+    });
+    if (!initResponse.ok) {
+      throw new SocialError("Media upload init failed", "UPLOAD_FAILED", "x");
+    }
+    const initData = await initResponse.json();
+    const mediaId = initData.data?.id;
+    if (!mediaId) {
+      throw new SocialError(
+        "Media upload init did not return a media id",
+        "UPLOAD_FAILED",
+        "x"
+      );
+    }
+    const chunkSize = 5 * 1024 * 1024;
+    let segmentIndex = 0;
+    for (let offset = 0; offset < mediaData.data.length; offset += chunkSize) {
+      const chunk = mediaData.data.subarray(offset, offset + chunkSize);
+      const formData = new FormData();
+      formData.append("command", "APPEND");
+      formData.append("media_id", mediaId);
+      formData.append("segment_index", segmentIndex.toString());
+      formData.append(
+        "media",
+        new Blob([new Uint8Array(chunk)], { type: mediaType })
+      );
+      const appendResponse = await this.makeBearerUploadRequest(
+        "POST",
+        formData
+      );
+      if (!appendResponse.ok) {
+        throw new SocialError(
+          "Media upload append failed",
+          "UPLOAD_FAILED",
+          "x"
+        );
+      }
+      segmentIndex++;
+    }
+    const finalizeResponse = await this.makeBearerUploadRequest("POST", {
+      command: "FINALIZE",
+      media_id: mediaId
+    });
+    if (!finalizeResponse.ok) {
+      throw new SocialError(
+        "Media upload finalize failed",
+        "UPLOAD_FAILED",
+        "x"
+      );
+    }
+    const finalizeData = await finalizeResponse.json();
+    if (type === "video" && finalizeData.data?.processing_info) {
+      await this.waitForProcessing(mediaId);
+    }
+    return mediaId;
+  }
+  /**
+   * Upload media using legacy OAuth 1.0a upload endpoints.
+   */
+  async uploadMediaOAuth1(file, type, mimeType) {
+    const mediaData = await this.readMediaData(file, type, mimeType);
+    const mediaType = mediaData.mimeType;
+    const mediaCategory = type === "video" ? "tweet_video" : "tweet_image";
+    const initResponse = await this.makeUploadRequest(
+      "POST",
+      `${X_UPLOAD_URL}/media/upload.json`,
+      {
+        command: "INIT",
+        total_bytes: mediaData.data.length,
+        media_type: mediaType,
+        media_category: mediaCategory
+      }
+    );
+    if (!initResponse.ok) {
+      throw new SocialError("Media upload init failed", "UPLOAD_FAILED", "x");
+    }
+    const initData = await initResponse.json();
+    const mediaId = initData.media_id_string;
+    const chunkSize = 5 * 1024 * 1024;
+    let segmentIndex = 0;
+    for (let offset = 0; offset < mediaData.data.length; offset += chunkSize) {
+      const chunk = mediaData.data.subarray(offset, offset + chunkSize);
+      const formData = new FormData();
+      formData.append("command", "APPEND");
+      formData.append("media_id", mediaId);
+      formData.append("segment_index", segmentIndex.toString());
+      formData.append(
+        "media",
+        new Blob([new Uint8Array(chunk)], { type: mediaType })
+      );
+      const appendResponse = await this.makeUploadRequest(
+        "POST",
+        `${X_UPLOAD_URL}/media/upload.json`,
+        formData,
+        true
+      );
+      if (!appendResponse.ok) {
+        throw new SocialError(
+          "Media upload append failed",
+          "UPLOAD_FAILED",
+          "x"
+        );
+      }
+      segmentIndex++;
+    }
+    const finalizeResponse = await this.makeUploadRequest(
+      "POST",
+      `${X_UPLOAD_URL}/media/upload.json`,
+      {
+        command: "FINALIZE",
+        media_id: mediaId
+      }
+    );
+    if (!finalizeResponse.ok) {
+      throw new SocialError(
+        "Media upload finalize failed",
+        "UPLOAD_FAILED",
+        "x"
+      );
+    }
+    const finalizeData = await finalizeResponse.json();
+    if (type === "video" && finalizeData.processing_info) {
+      await this.waitForProcessing(mediaId);
+    }
+    return mediaId;
+  }
+  /**
+   * Wait for media processing to complete
+   */
+  async waitForProcessing(mediaId) {
+    let checkCount = 0;
+    const maxChecks = 60;
+    while (checkCount < maxChecks) {
+      const statusResponse = this.usesOAuth2() ? await this.makeBearerUploadRequest("GET", {
+        command: "STATUS",
+        media_id: mediaId
+      }) : await this.makeUploadRequest(
+        "GET",
+        `${X_UPLOAD_URL}/media/upload.json`,
+        {
+          command: "STATUS",
+          media_id: mediaId
+        }
+      );
+      const statusData = await statusResponse.json();
+      const processingInfo = statusData.processing_info ?? statusData.data?.processing_info;
+      if (!processingInfo || processingInfo.state === "succeeded") {
+        return;
+      }
+      if (processingInfo.state === "failed") {
+        throw new SocialError(
+          processingInfo.error?.message ?? "Media processing failed",
+          "PROCESSING_FAILED",
+          "x"
+        );
+      }
+      const waitTime = (processingInfo.check_after_secs ?? 5) * 1e3;
+      await new Promise((resolve) => setTimeout(resolve, waitTime));
+      checkCount++;
+    }
+    throw new SocialError(
+      "Media processing timeout",
+      "PROCESSING_TIMEOUT",
+      "x"
+    );
+  }
+  /**
+   * Set alt text for uploaded media
+   * Uses JSON body as required by metadata/create endpoint
+   */
+  async setMediaAltText(mediaId, altText) {
+    if (this.usesOAuth2()) {
+      const response2 = await this.makeRequest(
+        "POST",
+        X_API_MEDIA_METADATA_URL,
+        {
+          id: mediaId,
+          metadata: {
+            alt_text: { text: altText }
+          }
+        }
+      );
+      if (!response2.ok) {
+        await this.handleError(response2);
+      }
+      return;
+    }
+    const url = `${X_UPLOAD_URL}/media/metadata/create.json`;
+    const authHeader = this.generateOAuthSignature("POST", url, {});
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: authHeader,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        media_id: mediaId,
+        alt_text: { text: altText }
+      })
+    });
+    if (!response.ok) {
+      await this.handleError(response);
+    }
+  }
+  /**
+   * Post link as reply (algorithm-friendly pattern)
+   */
+  async postLinkReply(parentId, linkUrl) {
+    await this.makeRequest("POST", `${X_API_URL}/tweets`, {
+      text: linkUrl,
+      reply: { in_reply_to_tweet_id: parentId }
+    });
+  }
+  async getPost(postId) {
+    const response = await this.makeRequest(
+      "GET",
+      `${X_API_URL}/tweets/${postId}?tweet.fields=created_at,public_metrics,attachments&expansions=attachments.media_keys&media.fields=type`
+    );
+    if (!response.ok) {
+      await this.handleError(response);
+    }
+    const data = await response.json();
+    const tweet = data.data;
+    return {
+      id: tweet.id,
+      url: `https://x.com/i/status/${tweet.id}`,
+      type: this.resolvePostType(tweet, data.includes?.media),
+      description: tweet.text,
+      publishedAt: new Date(tweet.created_at),
+      visibility: "public",
+      analytics: {
+        likes: tweet.public_metrics?.like_count,
+        shares: tweet.public_metrics?.retweet_count,
+        comments: tweet.public_metrics?.reply_count,
+        views: tweet.public_metrics?.impression_count,
+        impressions: tweet.public_metrics?.impression_count,
+        lastUpdated: /* @__PURE__ */ new Date(),
+        raw: tweet.public_metrics
+      }
+    };
+  }
+  async deletePost(postId) {
+    const response = await this.makeRequest(
+      "DELETE",
+      `${X_API_URL}/tweets/${postId}`
+    );
+    if (!response.ok && response.status !== 200) {
+      await this.handleError(response);
+    }
+  }
+  async getAnalytics(postId) {
+    const post = await this.getPost(postId);
+    return post.analytics ?? {};
+  }
+  getCapabilities() {
+    return {
+      video: true,
+      image: true,
+      text: true,
+      link: true,
+      linkAttachment: false,
+      scheduling: false,
+      // Would need Twitter Ads API
+      analytics: true,
+      rawAnalytics: true,
+      publishModes: ["dry_run", "stage_remote", "public"],
+      staging: true,
+      privatePublishing: false,
+      maxVideoLength: 140,
+      // 2 minutes 20 seconds
+      maxVideoSize: 512 * 1024 * 1024,
+      // 512MB
+      supportedVideoFormats: ["mp4", "mov"],
+      aspectRatios: ["16:9", "1:1", "9:16"],
+      maxTextLength: 280,
+      maxHashtags: void 0,
+      // No hard limit
+      supportedPostTypes: ["text", "image", "video", "link"]
+    };
+  }
+  resolveLinkBehavior(override) {
+    return override ?? this.config.linkBehavior ?? "inline";
+  }
+  usesOAuth2() {
+    if (this.config.authType) {
+      return this.config.authType === "oauth2";
+    }
+    return !this.config.accessSecret;
+  }
+  requireOAuth1Config() {
+    if (!this.config.apiKey || !this.config.apiSecret || !this.config.accessSecret) {
+      throw new SocialAuthError("x", "Missing OAuth 1.0a credentials");
+    }
+    return {
+      apiKey: this.config.apiKey,
+      apiSecret: this.config.apiSecret,
+      accessSecret: this.config.accessSecret
+    };
+  }
+  /**
+   * Build post text with hashtags
+   */
+  buildPostText(text, tags, linkUrl, linkBehavior = "inline") {
+    let result = text ?? "";
+    const suffixParts = [];
+    if (linkUrl && linkBehavior === "inline") {
+      result = result.replace(linkUrl, "").trim();
+      suffixParts.push(linkUrl);
+    }
+    if (tags && tags.length > 0) {
+      const hashtags = tags.map((t) => t.startsWith("#") ? t : `#${t}`);
+      suffixParts.push(hashtags.join(" "));
+    }
+    const suffix = suffixParts.join("\n\n");
+    if (!suffix) {
+      return this.truncatePostText(result, 280);
+    }
+    const separator = result.length > 0 ? "\n\n" : "";
+    const suffixBudget = suffix.length + separator.length;
+    if (suffixBudget >= 280) {
+      return this.truncatePostText(suffix, 280);
+    }
+    const textBudget = 280 - suffixBudget;
+    const truncatedText = this.truncatePostText(result, textBudget);
+    return truncatedText ? `${truncatedText}${separator}${suffix}` : suffix;
+  }
+  truncatePostText(text, maxLength) {
+    if (text.length <= maxLength) {
+      return text;
+    }
+    if (maxLength <= 3) {
+      return text.slice(0, maxLength);
+    }
+    return `${text.slice(0, maxLength - 3)}...`;
+  }
+  resolvePostType(tweet, media) {
+    const mediaKey = tweet.attachments?.media_keys?.[0];
+    if (!mediaKey) {
+      return "text";
+    }
+    const mediaType = media?.find((item) => item.media_key === mediaKey)?.type ?? this.inferMediaTypeFromKey(mediaKey);
+    if (mediaType === "video" || mediaType === "animated_gif") {
+      return "video";
+    }
+    return "image";
+  }
+  inferMediaTypeFromKey(mediaKey) {
+    if (mediaKey.startsWith("13_")) return "video";
+    if (mediaKey.startsWith("7_")) return "animated_gif";
+    if (mediaKey.startsWith("3_")) return "photo";
+    return void 0;
+  }
+  /**
+   * Make authenticated request to Twitter API v2
+   */
+  async makeRequest(method, url, body) {
+    const parsedUrl = new URL(url);
+    const signatureParams = Object.fromEntries(parsedUrl.searchParams);
+    const signingUrl = `${parsedUrl.origin}${parsedUrl.pathname}`;
+    const authHeader = this.usesOAuth2() ? `Bearer ${this.config.accessToken}` : this.generateOAuthSignature(method, signingUrl, signatureParams);
+    const options = {
+      method,
+      headers: {
+        Authorization: authHeader,
+        "Content-Type": "application/json"
+      }
+    };
+    if (body) {
+      options.body = JSON.stringify(body);
+    }
+    return fetch(url, options);
+  }
+  async makeBearerUploadRequest(method, params) {
+    let url = X_API_MEDIA_UPLOAD_URL;
+    const options = {
+      method,
+      headers: {
+        Authorization: `Bearer ${this.config.accessToken}`
+      }
+    };
+    if (method === "GET" && !(params instanceof FormData)) {
+      url = `${url}?${new URLSearchParams(params).toString()}`;
+    } else if (params instanceof FormData) {
+      options.body = params;
+    } else {
+      const formData = new FormData();
+      for (const [key, value] of Object.entries(params)) {
+        formData.append(key, value);
+      }
+      options.body = formData;
+    }
+    return fetch(url, options);
+  }
+  /**
+   * Make authenticated request to Twitter Upload API
+   */
+  async makeUploadRequest(method, url, params, isFormData = false) {
+    const stringParams = params instanceof FormData ? {} : Object.fromEntries(
+      Object.entries(params).map(([k, v]) => [k, String(v)])
+    );
+    const queryParams = method === "GET" || !isFormData && !(params instanceof FormData) ? stringParams : {};
+    const authHeader = this.generateOAuthSignature(method, url, queryParams);
+    const options = {
+      method,
+      headers: {
+        Authorization: authHeader
+      }
+    };
+    if (method === "GET") {
+      const queryString = new URLSearchParams(stringParams).toString();
+      url = `${url}?${queryString}`;
+    } else if (isFormData && params instanceof FormData) {
+      options.body = params;
+    } else if (!(params instanceof FormData)) {
+      options.headers = {
+        ...options.headers,
+        "Content-Type": "application/x-www-form-urlencoded"
+      };
+      options.body = new URLSearchParams(stringParams).toString();
+    }
+    return fetch(url, options);
+  }
+  /**
+   * Handle API errors
+   */
+  async handleError(response) {
+    const text = await response.text();
+    let error;
+    try {
+      error = JSON.parse(text);
+    } catch {
+      error = { detail: text };
+    }
+    if (response.status === 401) {
+      throw new SocialAuthError("x", error.detail ?? "Unauthorized");
+    }
+    if (response.status === 429) {
+      const resetTime = response.headers.get("x-rate-limit-reset");
+      const retryAfter = resetTime ? parseInt(resetTime, 10) - Math.floor(Date.now() / 1e3) : void 0;
+      throw new SocialRateLimitError("x", retryAfter);
+    }
+    throw new SocialError(
+      error.detail ?? error.title ?? "API request failed",
+      error.type ?? "API_ERROR",
+      "x",
+      response.status
+    );
+  }
+}
+const YOUTUBE_AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth";
+const YOUTUBE_TOKEN_URL = "https://oauth2.googleapis.com/token";
+const YOUTUBE_API_URL = "https://www.googleapis.com/youtube/v3";
+const YOUTUBE_UPLOAD_URL = "https://www.googleapis.com/upload/youtube/v3";
+const YOUTUBE_CATEGORIES = {
+  NEWS_POLITICS: "25"
+};
+const DEFAULT_CATEGORY_ID = YOUTUBE_CATEGORIES.NEWS_POLITICS;
+const DEFAULT_SCOPES = [
+  "https://www.googleapis.com/auth/youtube.upload",
+  "https://www.googleapis.com/auth/youtube.readonly"
+];
+class YouTubeAdapter {
+  platform = "youtube";
+  config;
+  logger;
+  currentAccessToken;
+  constructor(config) {
+    this.config = config;
+    this.currentAccessToken = config.accessToken;
+    this.logger = createLogger({ level: "info" });
+  }
+  /**
+   * Generate OAuth authorization URL
+   */
+  getAuthorizationUrl(options = {}) {
+    const state = options.state ?? randomUUID();
+    const scopes = options.scopes ?? DEFAULT_SCOPES;
+    const codeVerifier = options.codeVerifier ?? this.generateCodeVerifier();
+    const codeChallenge = this.generateCodeChallenge(codeVerifier);
+    const params = new URLSearchParams({
+      client_id: this.config.clientId,
+      redirect_uri: options.redirectUri ?? this.config.redirectUri ?? "",
+      response_type: "code",
+      scope: scopes.join(" "),
+      state,
+      code_challenge: codeChallenge,
+      code_challenge_method: "S256",
+      access_type: "offline",
+      prompt: "consent"
+    });
+    return {
+      url: `${YOUTUBE_AUTH_URL}?${params}`,
+      state,
+      codeVerifier
+    };
+  }
+  /**
+   * Exchange authorization code for tokens
+   */
+  async exchangeCode(params) {
+    const body = new URLSearchParams({
+      client_id: this.config.clientId,
+      client_secret: this.config.clientSecret,
+      code: params.code,
+      grant_type: "authorization_code",
+      redirect_uri: params.redirectUri ?? this.config.redirectUri ?? ""
+    });
+    if (params.codeVerifier) {
+      body.set("code_verifier", params.codeVerifier);
+    }
+    const response = await fetch(YOUTUBE_TOKEN_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new SocialAuthError("youtube", `Token exchange failed: ${error}`);
+    }
+    const data = await response.json();
+    this.currentAccessToken = data.access_token;
+    return {
+      accessToken: data.access_token,
+      refreshToken: data.refresh_token,
+      expiresAt: data.expires_in ? new Date(Date.now() + data.expires_in * 1e3) : void 0,
+      tokenType: data.token_type,
+      scopes: data.scope?.split(" ")
+    };
+  }
+  async authenticate() {
+    if (!this.config.accessToken) {
+      throw new SocialAuthError("youtube", "No access token configured");
+    }
+    const response = await fetch(
+      `https://www.googleapis.com/oauth2/v1/tokeninfo?access_token=${this.config.accessToken}`
+    );
+    if (!response.ok) {
+      if (this.config.refreshToken) {
+        return this.refreshToken(this.config.refreshToken);
+      }
+      throw new SocialAuthError("youtube", "Invalid access token");
+    }
+    const data = await response.json();
+    return {
+      accessToken: this.config.accessToken,
+      expiresAt: data.expires_in ? new Date(Date.now() + data.expires_in * 1e3) : void 0,
+      scopes: data.scope?.split(" ")
+    };
+  }
+  async refreshToken(refreshToken) {
+    const body = new URLSearchParams({
+      client_id: this.config.clientId,
+      client_secret: this.config.clientSecret,
+      refresh_token: refreshToken,
+      grant_type: "refresh_token"
+    });
+    const response = await fetch(YOUTUBE_TOKEN_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new SocialAuthError("youtube", `Token refresh failed: ${error}`);
+    }
+    const data = await response.json();
+    this.currentAccessToken = data.access_token;
+    return {
+      accessToken: data.access_token,
+      refreshToken: data.refresh_token ?? refreshToken,
+      expiresAt: data.expires_in ? new Date(Date.now() + data.expires_in * 1e3) : void 0,
+      tokenType: data.token_type
+    };
+  }
+  async publishVideo(video) {
+    const publishMode = resolvePublishMode(this.config);
+    const safeVisibility = isPublicPublishMode(publishMode) ? video.visibility ?? "public" : "private";
+    if (publishMode === "dry_run") {
+      return createSafetyResult({
+        platform: this.platform,
+        mode: publishMode,
+        postType: "video",
+        payload: {
+          title: video.title ?? "Untitled",
+          description: this.buildDescription(video),
+          tags: video.tags,
+          categoryId: video.categoryId ?? DEFAULT_CATEGORY_ID,
+          privacyStatus: safeVisibility,
+          isShort: video.isShort ?? false,
+          scheduledAt: video.scheduledAt?.toISOString()
+        },
+        note: "YouTube dry run: no video was uploaded."
+      });
+    }
+    const accessToken = this.currentAccessToken ?? this.config.accessToken;
+    if (!accessToken) {
+      throw new SocialAuthError("youtube", "No access token");
+    }
+    const metadata = {
+      snippet: {
+        title: video.title ?? "Untitled",
+        description: this.buildDescription(video),
+        tags: video.tags,
+        categoryId: video.categoryId ?? DEFAULT_CATEGORY_ID
+      },
+      status: {
+        privacyStatus: safeVisibility,
+        selfDeclaredMadeForKids: false,
+        ...video.scheduledAt && {
+          publishAt: video.scheduledAt.toISOString(),
+          privacyStatus: "private"
+          // Must be private for scheduling
+        }
+      }
+    };
+    const videoData = await resolveMediaData(video.file, {
+      explicitMimeType: video.mimeType,
+      fallbackMimeType: "video/mp4"
+    });
+    const initResponse = await fetch(
+      `${YOUTUBE_UPLOAD_URL}/videos?uploadType=resumable&part=snippet,status`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json",
+          "X-Upload-Content-Type": videoData.mimeType,
+          "X-Upload-Content-Length": videoData.data.length.toString()
+        },
+        body: JSON.stringify(metadata)
+      }
+    );
+    if (!initResponse.ok) {
+      await this.handleError(initResponse);
+    }
+    const uploadUrl = initResponse.headers.get("Location");
+    if (!uploadUrl) {
+      throw new SocialError(
+        "Failed to get upload URL",
+        "UPLOAD_INIT_FAILED",
+        "youtube"
+      );
+    }
+    const uploadResponse = await fetch(uploadUrl, {
+      method: "PUT",
+      headers: {
+        "Content-Type": videoData.mimeType,
+        "Content-Length": videoData.data.length.toString()
+      },
+      body: new Uint8Array(videoData.data)
+    });
+    if (!uploadResponse.ok) {
+      await this.handleError(uploadResponse);
+    }
+    const result = await uploadResponse.json();
+    if (video.thumbnail) {
+      await this.uploadThumbnail(
+        result.id,
+        video.thumbnail,
+        accessToken,
+        video.thumbnailMimeType
+      );
+    }
+    const status = video.scheduledAt ? "scheduled" : isPublicPublishMode(publishMode) ? "processing" : "staged";
+    return {
+      id: result.id,
+      url: `https://youtube.com/watch?v=${result.id}`,
+      status,
+      publishedAt: status === "processing" ? /* @__PURE__ */ new Date() : void 0,
+      scheduledAt: video.scheduledAt,
+      metadata: {
+        channelId: result.snippet?.channelId,
+        channelTitle: result.snippet?.channelTitle,
+        publishMode,
+        privacyStatus: metadata.status.privacyStatus,
+        safety: !isPublicPublishMode(publishMode)
+      }
+    };
+  }
+  /**
+   * Upload custom thumbnail
+   * @returns true if upload succeeded, false otherwise
+   */
+  async uploadThumbnail(videoId, thumbnail, accessToken, thumbnailMimeType) {
+    try {
+      const thumbnailData = await resolveMediaData(thumbnail, {
+        explicitMimeType: thumbnailMimeType,
+        fallbackMimeType: "image/png"
+      });
+      const response = await fetch(
+        `${YOUTUBE_UPLOAD_URL}/thumbnails/set?videoId=${videoId}`,
+        {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${accessToken}`,
+            "Content-Type": thumbnailData.mimeType
+          },
+          body: new Uint8Array(thumbnailData.data)
+        }
+      );
+      if (!response.ok) {
+        const errorText = await response.text();
+        this.logger.warn("Failed to upload thumbnail", {
+          videoId,
+          status: response.status,
+          error: errorText
+        });
+        return false;
+      }
+      return true;
+    } catch (error) {
+      this.logger.warn("Thumbnail upload error", {
+        videoId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return false;
+    }
+  }
+  async publishImage(_image) {
+    throw new SocialError(
+      "YouTube does not support image-only posts",
+      "NOT_SUPPORTED",
+      "youtube"
+    );
+  }
+  async publishText(_text) {
+    throw new SocialError(
+      "YouTube does not support text-only posts",
+      "NOT_SUPPORTED",
+      "youtube"
+    );
+  }
+  async publishLink(_link) {
+    throw new SocialError(
+      "YouTube does not support link-only posts",
+      "NOT_SUPPORTED",
+      "youtube"
+    );
+  }
+  async getPost(postId) {
+    const accessToken = this.currentAccessToken ?? this.config.accessToken;
+    if (!accessToken) {
+      throw new SocialAuthError("youtube", "No access token");
+    }
+    const response = await fetch(
+      `${YOUTUBE_API_URL}/videos?id=${postId}&part=snippet,status,statistics`,
+      {
+        headers: { Authorization: `Bearer ${accessToken}` }
+      }
+    );
+    if (!response.ok) {
+      await this.handleError(response);
+    }
+    const data = await response.json();
+    const video = data.items?.[0];
+    if (!video) {
+      throw new SocialError("Video not found", "NOT_FOUND", "youtube", 404);
+    }
+    const statistics = video.statistics ?? {};
+    return {
+      id: video.id,
+      url: `https://youtube.com/watch?v=${video.id}`,
+      type: "video",
+      title: video.snippet.title,
+      description: video.snippet.description,
+      publishedAt: new Date(video.snippet.publishedAt),
+      visibility: video.status.privacyStatus,
+      analytics: {
+        views: this.parseMetric(statistics.viewCount),
+        likes: this.parseMetric(statistics.likeCount),
+        comments: this.parseMetric(statistics.commentCount),
+        lastUpdated: /* @__PURE__ */ new Date(),
+        raw: statistics
+      }
+    };
+  }
+  async deletePost(postId) {
+    const accessToken = this.currentAccessToken ?? this.config.accessToken;
+    if (!accessToken) {
+      throw new SocialAuthError("youtube", "No access token");
+    }
+    const response = await fetch(`${YOUTUBE_API_URL}/videos?id=${postId}`, {
+      method: "DELETE",
+      headers: { Authorization: `Bearer ${accessToken}` }
+    });
+    if (!response.ok && response.status !== 204) {
+      await this.handleError(response);
+    }
+  }
+  async getAnalytics(postId) {
+    const post = await this.getPost(postId);
+    return post.analytics ?? {};
+  }
+  getCapabilities() {
+    return {
+      video: true,
+      image: false,
+      text: false,
+      link: false,
+      scheduling: true,
+      analytics: true,
+      rawAnalytics: true,
+      publishModes: ["dry_run", "private_or_scheduled", "public"],
+      staging: false,
+      privatePublishing: true,
+      maxVideoLength: 60 * 60 * 12,
+      // 12 hours (with verification)
+      maxVideoSize: 256 * 1024 * 1024 * 1024,
+      // 256GB
+      supportedVideoFormats: ["mp4", "mov", "avi", "wmv", "flv", "webm"],
+      aspectRatios: ["16:9", "9:16", "1:1", "4:3"],
+      maxTextLength: 5e3,
+      // Description
+      maxHashtags: 15,
+      supportedPostTypes: ["video"]
+    };
+  }
+  /**
+   * Build description with link and hashtags
+   */
+  buildDescription(video) {
+    let description = video.description ?? "";
+    if (video.linkUrl) {
+      description += `
+
+${video.linkUrl}`;
+    }
+    const tags = video.isShort ? Array.from(/* @__PURE__ */ new Set([...video.tags ?? [], "Shorts"])) : video.tags;
+    if (tags && tags.length > 0) {
+      const hashtags = tags.map((t) => t.startsWith("#") ? t : `#${t}`);
+      description += `
+
+${hashtags.join(" ")}`;
+    }
+    return description;
+  }
+  parseMetric(value) {
+    if (value === void 0 || value === null || value === "") return void 0;
+    const parsed = Number.parseInt(String(value), 10);
+    return Number.isFinite(parsed) ? parsed : void 0;
+  }
+  /**
+   * Handle API errors
+   */
+  async handleError(response) {
+    const text = await response.text();
+    let error;
+    try {
+      error = JSON.parse(text);
+    } catch {
+      error = { error: { message: text } };
+    }
+    if (response.status === 401) {
+      throw new SocialAuthError(
+        "youtube",
+        error.error?.message ?? "Unauthorized"
+      );
+    }
+    if (response.status === 429) {
+      const retryAfter = response.headers.get("Retry-After");
+      throw new SocialRateLimitError(
+        "youtube",
+        retryAfter ? parseInt(retryAfter, 10) : void 0
+      );
+    }
+    throw new SocialError(
+      error.error?.message ?? "API request failed",
+      error.error?.code?.toString() ?? "API_ERROR",
+      "youtube",
+      response.status
+    );
+  }
+  /**
+   * Generate PKCE code verifier
+   */
+  generateCodeVerifier() {
+    const array = new Uint8Array(32);
+    crypto.getRandomValues(array);
+    return btoa(String.fromCharCode(...array)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+  }
+  /**
+   * Generate PKCE code challenge from verifier using S256
+   */
+  generateCodeChallenge(verifier) {
+    const hash = createHash("sha256").update(verifier).digest();
+    return Buffer.from(hash).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+  }
+}
+async function getSocial(config) {
+  let adapter;
+  switch (config.type) {
+    case "youtube":
+      adapter = new YouTubeAdapter(config);
+      break;
+    case "threads":
+      adapter = new ThreadsAdapter(config);
+      break;
+    case "facebook":
+      adapter = new FacebookPageAdapter(config);
+      break;
+    case "x":
+      adapter = new XAdapter(config);
+      break;
+    case "bluesky":
+      adapter = new BlueskyAdapter(config);
+      break;
+    default:
+      throw new SocialError(
+        `Unknown platform type: ${config.type}`,
+        "UNKNOWN_PLATFORM"
+      );
+  }
+  return adapter;
+}
+async function getSocialMulti(configs) {
+  return Promise.all(configs.map(getSocial));
+}
+async function publishToAll(adapters, content) {
+  const results = /* @__PURE__ */ new Map();
+  await Promise.all(
+    adapters.map(async (adapter) => {
+      try {
+        let result;
+        switch (content.type) {
+          case "text":
+            result = await adapter.publishText({
+              text: content.text ?? content.description ?? "",
+              linkUrl: content.linkUrl,
+              tags: content.tags
+            });
+            break;
+          case "link": {
+            const url = content.url ?? content.linkUrl;
+            if (!url) {
+              throw new SocialError(
+                "Link URL required",
+                "MISSING_LINK_URL",
+                adapter.platform
+              );
+            }
+            result = await adapter.publishLink({
+              url,
+              text: content.text,
+              title: content.title,
+              description: content.description,
+              tags: content.tags
+            });
+            break;
+          }
+          case "image":
+            if (!content.file) {
+              throw new SocialError(
+                "Image file required",
+                "MISSING_FILE",
+                adapter.platform
+              );
+            }
+            result = await adapter.publishImage({
+              file: content.file,
+              description: content.description ?? content.text,
+              linkUrl: content.linkUrl,
+              tags: content.tags,
+              altText: content.altText,
+              mimeType: content.mimeType
+            });
+            break;
+          case "video":
+            if (!content.file) {
+              throw new SocialError(
+                "Video file required",
+                "MISSING_FILE",
+                adapter.platform
+              );
+            }
+            result = await adapter.publishVideo({
+              file: content.file,
+              title: content.title,
+              description: content.description ?? content.text,
+              linkUrl: content.linkUrl,
+              tags: content.tags,
+              mimeType: content.mimeType,
+              thumbnail: content.thumbnail,
+              thumbnailMimeType: content.thumbnailMimeType
+            });
+            break;
+        }
+        results.set(adapter.platform, { success: true, result });
+      } catch (error) {
+        results.set(adapter.platform, {
+          success: false,
+          error: error instanceof Error ? error : new Error(String(error))
+        });
+      }
+    })
+  );
+  return results;
+}
+export {
+  BlueskyAdapter,
+  FacebookPageAdapter,
+  SocialAuthError,
+  SocialError,
+  SocialRateLimitError,
+  ThreadsAdapter,
+  XAdapter,
+  YouTubeAdapter,
+  getSocial,
+  getSocialMulti,
+  publishToAll
+};
+//# sourceMappingURL=index.js.map