vidspotai-shared 1.0.82 → 1.0.84

package/lib/services/socialPublish/pinterest.publish.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PinterestPublisher = void 0;
+const types_1 = require("../../globals/types");
+const logger_1 = require("../../utils/logger");
+/**
+ * Pinterest publisher (v5) — Phase 6. Video Pin flow:
+ *   1. POST /v5/media (media_type=video) → { media_id, upload_url, upload_parameters }
+ *   2. POST the bytes to the (S3) upload_url with the returned form parameters
+ *   3. Poll GET /v5/media/{media_id} until status=succeeded
+ *   4. POST /v5/pins { board_id, title, description, media_source }
+ *
+ * Two Pinterest-specific realities handled here:
+ * - A pin needs a BOARD. PublishInput carries none, so we pin to the account's
+ *   first board (GET /v5/boards). A board picker is a future enhancement.
+ * - A video pin REQUIRES a cover image. We use input.thumbnailUrl when the
+ *   worker provides it; the worker must populate it (videoJob poster) for
+ *   Pinterest to publish. (Documented in PublishInput + ACTION_PLAN.)
+ */
+const API = "https://api.pinterest.com/v5";
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+class PinterestPublisher {
+    constructor() {
+        this.provider = types_1.ESocialProvider.PINTEREST;
+        this.maxPolls = 30;
+        this.pollDelayMs = 4000;
+    }
+    async publish(input) {
+        const token = input.accessToken;
+        // 0. Resolve a destination board (first board for now).
+        const boardId = await this.firstBoardId(token);
+        // 1. Register the video upload.
+        const reg = await this.json(await fetch(`${API}/media`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${token}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ media_type: "video" }),
+        }), "register media");
+        if (!reg.media_id || !reg.upload_url || !reg.upload_parameters) {
+            throw new Error("PinterestPublisher: media register returned no upload target");
+        }
+        // 2. Upload the bytes to S3 with the supplied form parameters.
+        const mediaResp = await fetch(input.mediaUrl);
+        if (!mediaResp.ok) {
+            throw new Error(`PinterestPublisher: media fetch ${mediaResp.status}`);
+        }
+        const bytes = Buffer.from(await mediaResp.arrayBuffer());
+        const form = new FormData();
+        for (const [k, v] of Object.entries(reg.upload_parameters))
+            form.append(k, v);
+        form.append("file", new Blob([bytes]));
+        const s3Resp = await fetch(reg.upload_url, { method: "POST", body: form });
+        if (!s3Resp.ok) {
+            throw new Error(`PinterestPublisher: media upload ${s3Resp.status}`);
+        }
+        // 3. Poll until the media is processed.
+        await this.pollMedia(token, reg.media_id);
+        // 4. Create the pin.
+        const mediaSource = {
+            source_type: "video_id",
+            media_id: reg.media_id,
+        };
+        if (input.thumbnailUrl)
+            mediaSource.cover_image_url = input.thumbnailUrl;
+        else
+            mediaSource.cover_image_key_frame_time = 0;
+        const pin = await this.json(await fetch(`${API}/pins`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${token}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                board_id: boardId,
+                title: (input.title ?? input.caption ?? "VidSpot video").slice(0, 100),
+                description: this.buildDescription(input),
+                media_source: mediaSource,
+            }),
+        }), "create pin");
+        if (!pin.id) {
+            throw new Error(`PinterestPublisher: create pin failed ${pin.message ?? ""}`);
+        }
+        logger_1.logger.info("PinterestPublisher: published", { pinId: pin.id, boardId });
+        return {
+            providerPostId: pin.id,
+            publishedUrl: `https://www.pinterest.com/pin/${pin.id}/`,
+        };
+    }
+    async firstBoardId(token) {
+        const boards = await this.json(await fetch(`${API}/boards?page_size=1`, {
+            headers: { Authorization: `Bearer ${token}` },
+        }), "list boards");
+        const id = boards.items?.[0]?.id;
+        if (!id) {
+            throw new Error("PinterestPublisher: account has no board to pin to — create one first");
+        }
+        return id;
+    }
+    async pollMedia(token, mediaId) {
+        for (let i = 0; i < this.maxPolls; i++) {
+            await sleep(this.pollDelayMs);
+            const status = await this.json(await fetch(`${API}/media/${mediaId}`, {
+                headers: { Authorization: `Bearer ${token}` },
+            }), "media status");
+            if (status.status === "succeeded")
+                return;
+            if (status.status === "failed") {
+                throw new Error("PinterestPublisher: media processing failed");
+            }
+        }
+        throw new Error("PinterestPublisher: timed out waiting for media processing");
+    }
+    async json(resp, what) {
+        if (!resp.ok) {
+            const text = await resp.text();
+            throw new Error(`PinterestPublisher: ${what} ${resp.status} ${text}`);
+        }
+        return (await resp.json());
+    }
+    buildDescription(input) {
+        const tags = input.hashtags && input.hashtags.length
+            ? "\n\n" +
+                input.hashtags.map((h) => (h.startsWith("#") ? h : `#${h}`)).join(" ")
+            : "";
+        return `${input.caption ?? ""}${tags}`.trim().slice(0, 800);
+    }
+}
+exports.PinterestPublisher = PinterestPublisher;

package/lib/services/socialPublish/threads.publish.d.ts

@@ -0,0 +1,12 @@
+import { ESocialProvider } from "../../globals/types";
+import { ISocialPublisher, PublishInput, PublishResult } from "./types";
+export declare class ThreadsPublisher implements ISocialPublisher {
+    readonly provider = ESocialProvider.THREADS;
+    private readonly maxPolls;
+    private readonly pollDelayMs;
+    publish(input: PublishInput): Promise<PublishResult>;
+    private pollContainer;
+    private fetchPermalink;
+    private buildText;
+}
+//# sourceMappingURL=threads.publish.d.ts.map

package/lib/services/socialPublish/threads.publish.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"threads.publish.d.ts","sourceRoot":"","sources":["../../../src/services/socialPublish/threads.publish.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEtD,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AA6BxE,qBAAa,gBAAiB,YAAW,gBAAgB;IACvD,QAAQ,CAAC,QAAQ,2BAA2B;IAE5C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAM;IAC/B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAQ;IAE9B,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,aAAa,CAAC;YAmD5C,aAAa;YAiBb,cAAc;IAe5B,OAAO,CAAC,SAAS;CAQlB"}

package/lib/services/socialPublish/threads.publish.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThreadsPublisher = void 0;
+const types_1 = require("../../globals/types");
+const logger_1 = require("../../utils/logger");
+/**
+ * Threads publisher — Phase 6. Two-step container flow (same shape as IG Reels):
+ *   1. POST /v1.0/{user-id}/threads (media_type=VIDEO, video_url, text) → creation_id
+ *   2. Poll /v1.0/{creation_id}?fields=status until FINISHED
+ *   3. POST /v1.0/{user-id}/threads_publish (creation_id) → media id
+ *   4. GET /v1.0/{media-id}?fields=permalink for the public URL
+ *
+ * Threads has no native scheduling — the worker schedules via BullMQ delay.
+ */
+const API_BASE = "https://graph.threads.net/v1.0";
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+class ThreadsPublisher {
+    constructor() {
+        this.provider = types_1.ESocialProvider.THREADS;
+        this.maxPolls = 30;
+        this.pollDelayMs = 4000;
+    }
+    async publish(input) {
+        const userId = input.providerAccountId;
+        if (!userId) {
+            throw new Error("ThreadsPublisher: missing providerAccountId (Threads user id)");
+        }
+        const token = input.accessToken;
+        const text = this.buildText(input);
+        // 1. Create the media container.
+        const createResp = await fetch(`${API_BASE}/${userId}/threads`, {
+            method: "POST",
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body: new URLSearchParams({
+                media_type: "VIDEO",
+                video_url: input.mediaUrl,
+                text,
+                access_token: token,
+            }).toString(),
+        });
+        const created = (await createResp.json());
+        if (!createResp.ok || created.error || !created.id) {
+            throw new Error(`ThreadsPublisher: create container ${createResp.status} ${created.error?.message ?? ""}`.trim());
+        }
+        const creationId = created.id;
+        // 2. Poll until the container finishes processing.
+        await this.pollContainer(creationId, token);
+        // 3. Publish the container.
+        const pubResp = await fetch(`${API_BASE}/${userId}/threads_publish`, {
+            method: "POST",
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body: new URLSearchParams({
+                creation_id: creationId,
+                access_token: token,
+            }).toString(),
+        });
+        const published = (await pubResp.json());
+        if (!pubResp.ok || published.error || !published.id) {
+            throw new Error(`ThreadsPublisher: publish ${pubResp.status} ${published.error?.message ?? ""}`.trim());
+        }
+        logger_1.logger.info("ThreadsPublisher: published", { mediaId: published.id });
+        const permalink = await this.fetchPermalink(published.id, token);
+        return { providerPostId: published.id, publishedUrl: permalink };
+    }
+    async pollContainer(creationId, token) {
+        for (let i = 0; i < this.maxPolls; i++) {
+            await sleep(this.pollDelayMs);
+            const resp = await fetch(`${API_BASE}/${creationId}?fields=status,error_message&access_token=${encodeURIComponent(token)}`);
+            const json = (await resp.json());
+            if (json.status === "FINISHED")
+                return;
+            if (json.status === "ERROR" || json.status === "EXPIRED") {
+                throw new Error(`ThreadsPublisher: container ${json.status} — ${json.error_message ?? ""}`);
+            }
+        }
+        throw new Error("ThreadsPublisher: timed out waiting for container");
+    }
+    async fetchPermalink(mediaId, token) {
+        try {
+            const resp = await fetch(`${API_BASE}/${mediaId}?fields=permalink&access_token=${encodeURIComponent(token)}`);
+            const json = (await resp.json());
+            return json.permalink;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    buildText(input) {
+        const tags = input.hashtags && input.hashtags.length
+            ? "\n\n" +
+                input.hashtags.map((h) => (h.startsWith("#") ? h : `#${h}`)).join(" ")
+            : "";
+        return `${input.caption ?? ""}${tags}`.trim().slice(0, 500);
+    }
+}
+exports.ThreadsPublisher = ThreadsPublisher;

package/lib/services/socialPublish/tiktok.publish.d.ts

@@ -0,0 +1,13 @@
+import { ESocialProvider } from "../../globals/types";
+import { ISocialPublisher, PublishInput, PublishResult } from "./types";
+export declare class TikTokPublisher implements ISocialPublisher {
+    readonly provider = ESocialProvider.TIKTOK;
+    private readonly maxPolls;
+    private readonly pollDelayMs;
+    publish(input: PublishInput): Promise<PublishResult>;
+    private pollStatus;
+    /** TikTok caption ("title") max ~2200 chars; merge hashtags inline. */
+    private buildTitle;
+    private resolvePrivacy;
+}
+//# sourceMappingURL=tiktok.publish.d.ts.map

package/lib/services/socialPublish/tiktok.publish.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tiktok.publish.d.ts","sourceRoot":"","sources":["../../../src/services/socialPublish/tiktok.publish.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEtD,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAyCxE,qBAAa,eAAgB,YAAW,gBAAgB;IACtD,QAAQ,CAAC,QAAQ,0BAA0B;IAE3C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAM;IAC/B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAQ;IAE9B,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,aAAa,CAAC;YA6C5C,UAAU;IA6BxB,uEAAuE;IACvE,OAAO,CAAC,UAAU;IASlB,OAAO,CAAC,cAAc;CAQvB"}

package/lib/services/socialPublish/tiktok.publish.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TikTokPublisher = void 0;
+const types_1 = require("../../globals/types");
+const logger_1 = require("../../utils/logger");
+/**
+ * TikTok publisher — Content Posting API, PULL_FROM_URL direct post. Phase 6.
+ *
+ * Flow (plan §G, TikTok Content Posting API):
+ *   1. POST /v2/post/publish/video/init/  with source=PULL_FROM_URL + video_url
+ *      → { publish_id }
+ *   2. Poll /v2/post/publish/status/fetch/ until PUBLISH_COMPLETE / FAILED.
+ *
+ * Gates:
+ * - PULL_FROM_URL requires the media domain (our CDN) verified in the dev portal.
+ * - Until the Content Posting audit passes, `privacy_level` is forced to
+ *   SELF_ONLY (private) and the app can only post for test users. We map the
+ *   generic `privacy` to TikTok's enum and default to SELF_ONLY (safe pre-audit).
+ * - TikTok has NO native scheduling — the worker schedules via BullMQ delay.
+ */
+const INIT_ENDPOINT = "https://open.tiktokapis.com/v2/post/publish/video/init/";
+const STATUS_ENDPOINT = "https://open.tiktokapis.com/v2/post/publish/status/fetch/";
+const PRIVACY_VALUES = new Set([
+    "PUBLIC_TO_EVERYONE",
+    "MUTUAL_FOLLOW_FRIENDS",
+    "FOLLOWER_OF_CREATOR",
+    "SELF_ONLY",
+]);
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+class TikTokPublisher {
+    constructor() {
+        this.provider = types_1.ESocialProvider.TIKTOK;
+        this.maxPolls = 30;
+        this.pollDelayMs = 5000;
+    }
+    async publish(input) {
+        const title = this.buildTitle(input);
+        const privacyLevel = this.resolvePrivacy(input);
+        // 1. Init the direct post with PULL_FROM_URL.
+        const initResp = await fetch(INIT_ENDPOINT, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${input.accessToken}`,
+                "Content-Type": "application/json; charset=UTF-8",
+            },
+            body: JSON.stringify({
+                post_info: {
+                    title,
+                    privacy_level: privacyLevel,
+                    disable_duet: false,
+                    disable_comment: false,
+                    disable_stitch: false,
+                },
+                source_info: {
+                    source: "PULL_FROM_URL",
+                    video_url: input.mediaUrl,
+                },
+            }),
+        });
+        const init = (await initResp.json());
+        const publishId = init.data?.publish_id;
+        if (!initResp.ok || init.error?.code === "access_token_invalid" || !publishId) {
+            throw new Error(`TikTokPublisher: init ${initResp.status} ${init.error?.message ?? "no publish_id"}`);
+        }
+        // 2. Poll for completion.
+        const postId = await this.pollStatus(input.accessToken, publishId);
+        logger_1.logger.info("TikTokPublisher: published", { publishId, postId });
+        return {
+            providerPostId: postId ?? publishId,
+            // TikTok doesn't return a canonical web URL pre-audit; the worker can fill
+            // it once the post id resolves (profile-relative).
+            publishedUrl: undefined,
+        };
+    }
+    async pollStatus(accessToken, publishId) {
+        for (let i = 0; i < this.maxPolls; i++) {
+            await sleep(this.pollDelayMs);
+            const resp = await fetch(STATUS_ENDPOINT, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${accessToken}`,
+                    "Content-Type": "application/json; charset=UTF-8",
+                },
+                body: JSON.stringify({ publish_id: publishId }),
+            });
+            const json = (await resp.json());
+            const status = json.data?.status;
+            if (status === "PUBLISH_COMPLETE") {
+                return json.data?.publicaly_available_post_id?.[0];
+            }
+            if (status === "FAILED") {
+                throw new Error(`TikTokPublisher: publish failed — ${json.data?.fail_reason ?? "unknown"}`);
+            }
+            // PROCESSING_* / SEND_TO_USER_INBOX → keep polling.
+        }
+        throw new Error("TikTokPublisher: timed out waiting for publish completion");
+    }
+    /** TikTok caption ("title") max ~2200 chars; merge hashtags inline. */
+    buildTitle(input) {
+        const tags = input.hashtags && input.hashtags.length
+            ? " " +
+                input.hashtags.map((h) => (h.startsWith("#") ? h : `#${h}`)).join(" ")
+            : "";
+        return `${input.caption ?? ""}${tags}`.trim().slice(0, 2200);
+    }
+    resolvePrivacy(input) {
+        const p = (input.privacy ?? "").toUpperCase();
+        if (PRIVACY_VALUES.has(p))
+            return p;
+        // Map common generic values; default SELF_ONLY (audit-safe).
+        if (p === "PUBLIC")
+            return "PUBLIC_TO_EVERYONE";
+        if (p === "PRIVATE")
+            return "SELF_ONLY";
+        return "SELF_ONLY";
+    }
+}
+exports.TikTokPublisher = TikTokPublisher;

package/lib/services/socialPublish/types.d.ts

@@ -0,0 +1,47 @@
+import { ESocialProvider } from "../../globals/types";
+/**
+ * X8 Social Suite — publisher abstraction. One implementation per platform turns
+ * a (mediaUrl, caption, options, accessToken) into a live post. The publish
+ * worker resolves a valid access token (refreshing if needed) and calls this.
+ * See notes/SOCIAL_SUITE_PLAN.md §4.
+ */
+export interface PublishInput {
+    /** Cleartext access token for the target account (already refreshed). */
+    accessToken: string;
+    /**
+     * The provider's account id (IG Business user id / FB Page id). Required by
+     * Meta publishers, which POST to `/{ig-user-id}/media` or `/{page-id}/videos`.
+     * YouTube ignores it (the access token already scopes to the channel).
+     */
+    providerAccountId?: string;
+    /** Public URL of the media to publish (rendered/cropped for the platform). */
+    mediaUrl: string;
+    /**
+     * Public URL of a poster/cover frame for the video. Optional and ignored by
+     * most publishers; Pinterest REQUIRES a cover image for video pins, so the
+     * worker should populate it (e.g. the videoJob's poster) when targeting
+     * Pinterest. When absent, the Pinterest publisher falls back to a key-frame.
+     */
+    thumbnailUrl?: string;
+    /** Caption / description text. */
+    caption: string;
+    /** Title (YouTube uses this; others ignore). */
+    title?: string;
+    /** Provider visibility value (e.g. "public" | "unlisted" | "private"). */
+    privacy?: string;
+    /** Unix ms for native scheduled publish where the platform supports it (YT). */
+    scheduledAt?: number;
+    /** Hashtags to merge into the caption per-platform convention. */
+    hashtags?: string[];
+}
+export interface PublishResult {
+    /** Provider's id for the new post. */
+    providerPostId: string;
+    /** Public URL of the live (or scheduled) post, when derivable. */
+    publishedUrl?: string;
+}
+export interface ISocialPublisher {
+    readonly provider: ESocialProvider;
+    publish(input: PublishInput): Promise<PublishResult>;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/services/socialPublish/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/services/socialPublish/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEtD;;;;;GAKG;AAEH,MAAM,WAAW,YAAY;IAC3B,yEAAyE;IACzE,WAAW,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,8EAA8E;IAC9E,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,kCAAkC;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,gDAAgD;IAChD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,0EAA0E;IAC1E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gFAAgF;IAChF,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,kEAAkE;IAClE,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAED,MAAM,WAAW,aAAa;IAC5B,sCAAsC;IACtC,cAAc,EAAE,MAAM,CAAC;IACvB,kEAAkE;IAClE,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAC;IACnC,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;CACtD"}

package/lib/services/socialPublish/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/services/socialPublish/x.publish.d.ts

@@ -0,0 +1,12 @@
+import { ESocialProvider } from "../../globals/types";
+import { ISocialPublisher, PublishInput, PublishResult } from "./types";
+export declare class XPublisher implements ISocialPublisher {
+    readonly provider = ESocialProvider.X;
+    private readonly maxPolls;
+    publish(input: PublishInput): Promise<PublishResult>;
+    private uploadForm;
+    private pollMediaStatus;
+    /** X has a hard 280-char limit; trim caption + as many hashtags as fit. */
+    private buildText;
+}
+//# sourceMappingURL=x.publish.d.ts.map

package/lib/services/socialPublish/x.publish.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x.publish.d.ts","sourceRoot":"","sources":["../../../src/services/socialPublish/x.publish.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEtD,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAkCxE,qBAAa,UAAW,YAAW,gBAAgB;IACjD,QAAQ,CAAC,QAAQ,qBAAqB;IAEtC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAM;IAEzB,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,aAAa,CAAC;YAoF5C,UAAU;YAoBV,eAAe;IAuB7B,2EAA2E;IAC3E,OAAO,CAAC,SAAS;CAalB"}

package/lib/services/socialPublish/x.publish.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XPublisher = void 0;
+const types_1 = require("../../globals/types");
+const logger_1 = require("../../utils/logger");
+/**
+ * X (Twitter) publisher — Phase 6. Chunked video upload (v1.1 media/upload,
+ * which accepts an OAuth 2.0 user-context bearer) then a v2 Tweet referencing
+ * the media id:
+ *   1. INIT     → media_id_string
+ *   2. APPEND   → upload each ≤5MB chunk (multipart)
+ *   3. FINALIZE → may return async processing_info
+ *   4. STATUS   → poll until state=succeeded
+ *   5. POST /2/tweets { text, media: { media_ids: [id] } }
+ *
+ * No native scheduling — the worker schedules via BullMQ delay. Caption is hard-
+ * capped at 280 chars (X's real limit), hashtags merged inline within that cap.
+ */
+const UPLOAD_ENDPOINT = "https://upload.twitter.com/1.1/media/upload.json";
+const TWEETS_ENDPOINT = "https://api.twitter.com/2/tweets";
+const CHUNK_SIZE = 5 * 1024 * 1024; // 5MB, X's per-APPEND limit
+const TWEET_MAX = 280;
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+class XPublisher {
+    constructor() {
+        this.provider = types_1.ESocialProvider.X;
+        this.maxPolls = 30;
+    }
+    async publish(input) {
+        const token = input.accessToken;
+        // 0. Fetch the media bytes.
+        const mediaResp = await fetch(input.mediaUrl);
+        if (!mediaResp.ok) {
+            throw new Error(`XPublisher: media fetch ${mediaResp.status}`);
+        }
+        const bytes = Buffer.from(await mediaResp.arrayBuffer());
+        // 1. INIT.
+        const init = (await this.uploadForm(token, {
+            command: "INIT",
+            total_bytes: String(bytes.length),
+            media_type: "video/mp4",
+            media_category: "tweet_video",
+        }));
+        const mediaId = init.media_id_string;
+        if (!mediaId) {
+            throw new Error(`XPublisher: INIT failed ${init.errors?.[0]?.message ?? ""}`);
+        }
+        // 2. APPEND each chunk.
+        let segment = 0;
+        for (let offset = 0; offset < bytes.length; offset += CHUNK_SIZE) {
+            const chunk = bytes.subarray(offset, offset + CHUNK_SIZE);
+            const form = new FormData();
+            form.append("command", "APPEND");
+            form.append("media_id", mediaId);
+            form.append("segment_index", String(segment));
+            form.append("media", new Blob([chunk]));
+            const resp = await fetch(UPLOAD_ENDPOINT, {
+                method: "POST",
+                headers: { Authorization: `Bearer ${token}` },
+                body: form,
+            });
+            if (!resp.ok) {
+                throw new Error(`XPublisher: APPEND segment ${segment} ${resp.status}`);
+            }
+            segment++;
+        }
+        // 3. FINALIZE.
+        const finalize = (await this.uploadForm(token, {
+            command: "FINALIZE",
+            media_id: mediaId,
+        }));
+        // 4. Poll async processing if needed.
+        if (finalize.processing_info && finalize.processing_info.state !== "succeeded") {
+            await this.pollMediaStatus(token, mediaId, finalize.processing_info.check_after_secs);
+        }
+        // 5. Create the Tweet.
+        const tweetResp = await fetch(TWEETS_ENDPOINT, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${token}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                text: this.buildText(input),
+                media: { media_ids: [mediaId] },
+            }),
+        });
+        const tweet = (await tweetResp.json());
+        const tweetId = tweet.data?.id;
+        if (!tweetResp.ok || !tweetId) {
+            throw new Error(`XPublisher: create tweet ${tweetResp.status} ${tweet.errors?.[0]?.message ?? tweet.detail ?? ""}`.trim());
+        }
+        logger_1.logger.info("XPublisher: published", { tweetId });
+        return {
+            providerPostId: tweetId,
+            publishedUrl: `https://x.com/i/web/status/${tweetId}`,
+        };
+    }
+    async uploadForm(token, fields) {
+        const form = new FormData();
+        for (const [k, v] of Object.entries(fields))
+            form.append(k, v);
+        const resp = await fetch(UPLOAD_ENDPOINT, {
+            method: "POST",
+            headers: { Authorization: `Bearer ${token}` },
+            body: form,
+        });
+        if (!resp.ok) {
+            const text = await resp.text();
+            throw new Error(`XPublisher: upload ${fields.command} ${resp.status} ${text}`);
+        }
+        return resp.json();
+    }
+    async pollMediaStatus(token, mediaId, firstDelaySecs) {
+        let delayMs = (firstDelaySecs ?? 3) * 1000;
+        for (let i = 0; i < this.maxPolls; i++) {
+            await sleep(delayMs);
+            const url = `${UPLOAD_ENDPOINT}?command=STATUS&media_id=${mediaId}`;
+            const resp = await fetch(url, {
+                headers: { Authorization: `Bearer ${token}` },
+            });
+            const json = (await resp.json());
+            const state = json.processing_info?.state;
+            if (state === "succeeded")
+                return;
+            if (state === "failed") {
+                throw new Error("XPublisher: media processing failed");
+            }
+            delayMs = (json.processing_info?.check_after_secs ?? 3) * 1000;
+        }
+        throw new Error("XPublisher: timed out waiting for media processing");
+    }
+    /** X has a hard 280-char limit; trim caption + as many hashtags as fit. */
+    buildText(input) {
+        const caption = (input.caption ?? "").trim();
+        const tags = (input.hashtags ?? []).map((h) => h.startsWith("#") ? h : `#${h}`);
+        let text = caption;
+        for (const tag of tags) {
+            const candidate = text ? `${text} ${tag}` : tag;
+            if (candidate.length > TWEET_MAX)
+                break;
+            text = candidate;
+        }
+        return text.slice(0, TWEET_MAX);
+    }
+}
+exports.XPublisher = XPublisher;

package/lib/services/socialPublish/youtube.publish.d.ts

@@ -0,0 +1,9 @@
+import { ESocialProvider } from "../../globals/types";
+import { ISocialPublisher, PublishInput, PublishResult } from "./types";
+export declare class YouTubePublisher implements ISocialPublisher {
+    readonly provider = ESocialProvider.YOUTUBE;
+    publish(input: PublishInput): Promise<PublishResult>;
+    private resolvePrivacy;
+    private buildDescription;
+}
+//# sourceMappingURL=youtube.publish.d.ts.map

package/lib/services/socialPublish/youtube.publish.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"youtube.publish.d.ts","sourceRoot":"","sources":["../../../src/services/socialPublish/youtube.publish.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEtD,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AA0BxE,qBAAa,gBAAiB,YAAW,gBAAgB;IACvD,QAAQ,CAAC,QAAQ,2BAA2B;IAEtC,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,aAAa,CAAC;IA+E1D,OAAO,CAAC,cAAc;IAOtB,OAAO,CAAC,gBAAgB;CAUzB"}