vidspotai-shared 1.0.82-dev.0 → 1.0.83

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

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkedInPublisher = void 0;
+const types_1 = require("../../globals/types");
+const logger_1 = require("../../utils/logger");
+/**
+ * LinkedIn publisher — Phase 6. Member-feed video via the versioned Videos +
+ * Posts REST API:
+ *   1. POST /rest/videos?action=initializeUpload → video URN + upload URL(s)
+ *   2. PUT the bytes to each upload URL → collect ETags
+ *   3. POST /rest/videos?action=finalizeUpload (uploadedPartIds = ETags)
+ *   4. POST /rest/posts (author, commentary, content.media = video URN)
+ *
+ * Author = urn:li:person:{providerAccountId}. Company-page posting (author =
+ * urn:li:organization:{id}) is a business-tier follow-on. No native scheduling.
+ *
+ * Config (env): LINKEDIN_API_VERSION (optional, default "202401").
+ */
+const REST_BASE = "https://api.linkedin.com/rest";
+function apiVersion() {
+    return process.env.LINKEDIN_API_VERSION || "202401";
+}
+function headers(token) {
+    return {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json",
+        "LinkedIn-Version": apiVersion(),
+        "X-Restli-Protocol-Version": "2.0.0",
+    };
+}
+class LinkedInPublisher {
+    constructor() {
+        this.provider = types_1.ESocialProvider.LINKEDIN;
+    }
+    async publish(input) {
+        const memberId = input.providerAccountId;
+        if (!memberId) {
+            throw new Error("LinkedInPublisher: missing providerAccountId (member id)");
+        }
+        const author = `urn:li:person:${memberId}`;
+        const token = input.accessToken;
+        // 0. Fetch the media bytes (worker passes a public/rendered URL).
+        const mediaResp = await fetch(input.mediaUrl);
+        if (!mediaResp.ok) {
+            throw new Error(`LinkedInPublisher: media fetch ${mediaResp.status}`);
+        }
+        const bytes = Buffer.from(await mediaResp.arrayBuffer());
+        // 1. Initialize the upload.
+        const initResp = await fetch(`${REST_BASE}/videos?action=initializeUpload`, {
+            method: "POST",
+            headers: headers(token),
+            body: JSON.stringify({
+                initializeUploadRequest: {
+                    owner: author,
+                    fileSizeBytes: bytes.length,
+                    uploadCaptions: false,
+                    uploadThumbnail: false,
+                },
+            }),
+        });
+        const init = (await initResp.json());
+        const videoUrn = init.value?.video;
+        const instructions = init.value?.uploadInstructions ?? [];
+        if (!initResp.ok || !videoUrn || instructions.length === 0) {
+            throw new Error(`LinkedInPublisher: initializeUpload ${initResp.status} ${init.error?.message ?? ""}`.trim());
+        }
+        // 2. Upload each byte range; collect ETags in order.
+        const uploadedPartIds = [];
+        for (const instr of instructions) {
+            if (!instr.uploadUrl)
+                continue;
+            const first = instr.firstByte ?? 0;
+            const last = instr.lastByte ?? bytes.length - 1;
+            const chunk = bytes.subarray(first, last + 1);
+            const putResp = await fetch(instr.uploadUrl, {
+                method: "PUT",
+                headers: { Authorization: `Bearer ${token}` },
+                body: chunk,
+            });
+            if (!putResp.ok) {
+                throw new Error(`LinkedInPublisher: chunk upload ${putResp.status}`);
+            }
+            const etag = putResp.headers.get("etag");
+            if (etag)
+                uploadedPartIds.push(etag.replace(/"/g, ""));
+        }
+        // 3. Finalize the upload.
+        const finalizeResp = await fetch(`${REST_BASE}/videos?action=finalizeUpload`, {
+            method: "POST",
+            headers: headers(token),
+            body: JSON.stringify({
+                finalizeUploadRequest: { video: videoUrn, uploadToken: "", uploadedPartIds },
+            }),
+        });
+        if (!finalizeResp.ok) {
+            const text = await finalizeResp.text();
+            throw new Error(`LinkedInPublisher: finalizeUpload ${finalizeResp.status} ${text}`);
+        }
+        // 4. Create the post referencing the video URN.
+        const postResp = await fetch(`${REST_BASE}/posts`, {
+            method: "POST",
+            headers: headers(token),
+            body: JSON.stringify({
+                author,
+                commentary: this.buildCommentary(input),
+                visibility: this.resolveVisibility(input),
+                distribution: {
+                    feedDistribution: "MAIN_FEED",
+                    targetEntities: [],
+                    thirdPartyDistributionChannels: [],
+                },
+                content: { media: { id: videoUrn, title: (input.title ?? "").slice(0, 200) } },
+                lifecycleState: "PUBLISHED",
+                isReshareDisabledByAuthor: false,
+            }),
+        });
+        if (!postResp.ok) {
+            const text = await postResp.text();
+            throw new Error(`LinkedInPublisher: create post ${postResp.status} ${text}`);
+        }
+        // The new post URN is returned in the x-restli-id (or x-linkedin-id) header.
+        const postUrn = postResp.headers.get("x-restli-id") ??
+            postResp.headers.get("x-linkedin-id") ??
+            videoUrn;
+        logger_1.logger.info("LinkedInPublisher: published", { postUrn });
+        return {
+            providerPostId: postUrn,
+            publishedUrl: `https://www.linkedin.com/feed/update/${postUrn}`,
+        };
+    }
+    resolveVisibility(input) {
+        const p = (input.privacy ?? "public").toUpperCase();
+        return p === "CONNECTIONS" ? "CONNECTIONS" : "PUBLIC";
+    }
+    buildCommentary(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, 3000);
+    }
+}
+exports.LinkedInPublisher = LinkedInPublisher;

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

@@ -0,0 +1,28 @@
+import { ESocialProvider } from "../../globals/types";
+import { ISocialPublisher, PublishInput, PublishResult } from "./types";
+/**
+ * Instagram publisher — Reels via the two-step container flow:
+ *   1. POST /{ig-user-id}/media (media_type=REELS, video_url, caption) → container
+ *   2. Poll /{container-id}?fields=status_code until FINISHED
+ *   3. POST /{ig-user-id}/media_publish (creation_id) → media id
+ * IG has no native API scheduling — the worker schedules via BullMQ delay, so we
+ * always publish immediately here.
+ */
+export declare class InstagramPublisher implements ISocialPublisher {
+    readonly provider = ESocialProvider.INSTAGRAM;
+    private readonly maxPolls;
+    private readonly pollDelayMs;
+    publish(input: PublishInput): Promise<PublishResult>;
+    private waitForContainer;
+    private resolvePermalink;
+}
+/**
+ * Facebook Page publisher — posts a video to the Page via /{page-id}/videos with
+ * a hosted `file_url` (Graph downloads it). Supports native scheduling through
+ * `published=false` + `scheduled_publish_time` (unix seconds, 10m–6mo out).
+ */
+export declare class FacebookPublisher implements ISocialPublisher {
+    readonly provider = ESocialProvider.FACEBOOK;
+    publish(input: PublishInput): Promise<PublishResult>;
+}
+//# sourceMappingURL=meta.publish.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"meta.publish.d.ts","sourceRoot":"","sources":["../../../src/services/socialPublish/meta.publish.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEtD,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AA+DxE;;;;;;;GAOG;AACH,qBAAa,kBAAmB,YAAW,gBAAgB;IACzD,QAAQ,CAAC,QAAQ,6BAA6B;IAE9C,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;YAsC5C,gBAAgB;YAyBhB,gBAAgB;CAgB/B;AAED;;;;GAIG;AACH,qBAAa,iBAAkB,YAAW,gBAAgB;IACxD,QAAQ,CAAC,QAAQ,4BAA4B;IAEvC,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,aAAa,CAAC;CAmC3D"}

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

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FacebookPublisher = exports.InstagramPublisher = void 0;
+const types_1 = require("../../globals/types");
+const logger_1 = require("../../utils/logger");
+/**
+ * Meta publishers — Phase 3. Instagram and Facebook both run on the Graph API
+ * but with different publish flows, so they are separate ISocialPublisher impls
+ * (registered under INSTAGRAM / FACEBOOK).
+ *
+ * Both take the managing Page access token (provided by MetaOAuthProvider) and
+ * the account's providerAccountId (IG user id / FB Page id) via PublishInput.
+ *
+ * Config (env): META_GRAPH_VERSION (optional, default v21.0).
+ */
+const DEFAULT_GRAPH_VERSION = "v21.0";
+function graphVersion() {
+    return process.env.META_GRAPH_VERSION || DEFAULT_GRAPH_VERSION;
+}
+function graph(path) {
+    return `https://graph.facebook.com/${graphVersion()}${path}`;
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function buildCaption(input) {
+    const tags = input.hashtags && input.hashtags.length
+        ? "\n\n" +
+            input.hashtags.map((h) => (h.startsWith("#") ? h : `#${h}`)).join(" ")
+        : "";
+    return `${input.caption ?? ""}${tags}`.trim();
+}
+async function postForm(url, form) {
+    const resp = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: form.toString(),
+    });
+    const json = (await resp.json());
+    if (!resp.ok || json.error || !json.id) {
+        throw new Error(`Meta graph POST ${resp.status} ${json.error?.message ?? "no id returned"}`);
+    }
+    return json;
+}
+/**
+ * Instagram publisher — Reels via the two-step container flow:
+ *   1. POST /{ig-user-id}/media (media_type=REELS, video_url, caption) → container
+ *   2. Poll /{container-id}?fields=status_code until FINISHED
+ *   3. POST /{ig-user-id}/media_publish (creation_id) → media id
+ * IG has no native API scheduling — the worker schedules via BullMQ delay, so we
+ * always publish immediately here.
+ */
+class InstagramPublisher {
+    constructor() {
+        this.provider = types_1.ESocialProvider.INSTAGRAM;
+        this.maxPolls = 30;
+        this.pollDelayMs = 5000;
+    }
+    async publish(input) {
+        const igUserId = input.providerAccountId;
+        if (!igUserId) {
+            throw new Error("InstagramPublisher: missing providerAccountId (IG user id)");
+        }
+        // 1. Create the media container.
+        const container = await postForm(graph(`/${igUserId}/media`), new URLSearchParams({
+            media_type: "REELS",
+            video_url: input.mediaUrl,
+            caption: buildCaption(input),
+            access_token: input.accessToken,
+        }));
+        const creationId = container.id;
+        // 2. Poll until the upload/transcode finishes.
+        await this.waitForContainer(creationId, input.accessToken);
+        // 3. Publish the container.
+        const published = await postForm(graph(`/${igUserId}/media_publish`), new URLSearchParams({
+            creation_id: creationId,
+            access_token: input.accessToken,
+        }));
+        const mediaId = published.id;
+        logger_1.logger.info("InstagramPublisher: published", { igUserId, mediaId });
+        return {
+            providerPostId: mediaId,
+            publishedUrl: await this.resolvePermalink(mediaId, input.accessToken),
+        };
+    }
+    async waitForContainer(containerId, accessToken) {
+        for (let i = 0; i < this.maxPolls; i++) {
+            const resp = await fetch(graph(`/${containerId}?fields=status_code,status&access_token=${encodeURIComponent(accessToken)}`));
+            const json = (await resp.json());
+            const code = json.status_code;
+            if (code === "FINISHED")
+                return;
+            if (code === "ERROR" || code === "EXPIRED") {
+                throw new Error(`InstagramPublisher: container ${code} ${json.status ?? ""}`.trim());
+            }
+            await sleep(this.pollDelayMs);
+        }
+        throw new Error(`InstagramPublisher: container not ready after ${this.maxPolls} polls`);
+    }
+    async resolvePermalink(mediaId, accessToken) {
+        try {
+            const resp = await fetch(graph(`/${mediaId}?fields=permalink&access_token=${encodeURIComponent(accessToken)}`));
+            const json = (await resp.json());
+            return json.permalink;
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
+exports.InstagramPublisher = InstagramPublisher;
+/**
+ * Facebook Page publisher — posts a video to the Page via /{page-id}/videos with
+ * a hosted `file_url` (Graph downloads it). Supports native scheduling through
+ * `published=false` + `scheduled_publish_time` (unix seconds, 10m–6mo out).
+ */
+class FacebookPublisher {
+    constructor() {
+        this.provider = types_1.ESocialProvider.FACEBOOK;
+    }
+    async publish(input) {
+        const pageId = input.providerAccountId;
+        if (!pageId) {
+            throw new Error("FacebookPublisher: missing providerAccountId (Page id)");
+        }
+        const form = new URLSearchParams({
+            file_url: input.mediaUrl,
+            description: buildCaption(input),
+            access_token: input.accessToken,
+        });
+        if (input.title)
+            form.set("title", input.title);
+        // Native scheduling: FB requires published=false + a unix-seconds timestamp.
+        if (input.scheduledAt && input.scheduledAt > Date.now()) {
+            form.set("published", "false");
+            form.set("scheduled_publish_time", String(Math.floor(input.scheduledAt / 1000)));
+        }
+        const result = await postForm(graph(`/${pageId}/videos`), form);
+        const videoId = result.id;
+        logger_1.logger.info("FacebookPublisher: published", {
+            pageId,
+            videoId,
+            scheduled: Boolean(input.scheduledAt),
+        });
+        return {
+            providerPostId: videoId,
+            publishedUrl: `https://www.facebook.com/watch/?v=${videoId}`,
+        };
+    }
+}
+exports.FacebookPublisher = FacebookPublisher;

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

@@ -0,0 +1,13 @@
+import { ESocialProvider } from "../../globals/types";
+import { ISocialPublisher, PublishInput, PublishResult } from "./types";
+export declare class PinterestPublisher implements ISocialPublisher {
+    readonly provider = ESocialProvider.PINTEREST;
+    private readonly maxPolls;
+    private readonly pollDelayMs;
+    publish(input: PublishInput): Promise<PublishResult>;
+    private firstBoardId;
+    private pollMedia;
+    private json;
+    private buildDescription;
+}
+//# sourceMappingURL=pinterest.publish.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pinterest.publish.d.ts","sourceRoot":"","sources":["../../../src/services/socialPublish/pinterest.publish.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEtD,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAoCxE,qBAAa,kBAAmB,YAAW,gBAAgB;IACzD,QAAQ,CAAC,QAAQ,6BAA6B;IAE9C,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;YA0E5C,YAAY;YAgBZ,SAAS;YAiBT,IAAI;IAQlB,OAAO,CAAC,gBAAgB;CAQzB"}

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"}