@classytic/social 0.1.0

package/dist/providers/tiktok.mjs

@@ -0,0 +1,676 @@
+import { t as PlatformProvider } from "../base-Bw7e52V8.mjs";
+import { t as SocialError } from "../errors-Cm6LeKf7.mjs";
+import { t as httpRequest } from "../http-DpcLSR1M.mjs";
+import { t as PkceStore } from "../pkce-jq5II68b.mjs";
+import { t as pollUntilComplete } from "../polling-DZ1apXtA.mjs";
+import { t as TikTokCredentialsSchema } from "../tiktok-B_bMk4G-.mjs";
+import { createReadStream } from "fs";
+import { stat } from "fs/promises";
+import { Readable } from "stream";
+import { createHash, randomBytes } from "crypto";
+
+//#region src/providers/tiktok/index.ts
+/**
+* TikTok Platform Provider
+* ========================
+* TikTok integration with OAuth2 and Content Posting API.
+*
+* Features:
+* - OAuth2 authorization flow (TikTok Login Kit)
+* - Video upload with 3-step process (init → binary PUT → poll status)
+* - Photo post support (via URL)
+* - Draft mode via SELF_ONLY privacy level
+* - Credential validation
+*
+* TikTok API Quirks:
+* - Uses `client_key` instead of `client_id`
+* - Token endpoint requires application/x-www-form-urlencoded
+* - Scopes are comma-separated (not space-separated)
+* - Token response includes `open_id` and `refresh_expires_in`
+* - No true draft API — SELF_ONLY privacy is the closest equivalent
+*/
+const TIKTOK_AUTH_URL = "https://www.tiktok.com/v2/auth/authorize";
+const TIKTOK_TOKEN_URL = "https://open.tiktokapis.com/v2/oauth/token/";
+const TIKTOK_USER_INFO_URL = "https://open.tiktokapis.com/v2/user/info/";
+const TIKTOK_VIDEO_INIT_URL = "https://open.tiktokapis.com/v2/post/publish/video/init/";
+const TIKTOK_CONTENT_INIT_URL = "https://open.tiktokapis.com/v2/post/publish/content/init/";
+const TIKTOK_STATUS_URL = "https://open.tiktokapis.com/v2/post/publish/status/fetch/";
+const TIKTOK_VIDEO_LIST_URL = "https://open.tiktokapis.com/v2/video/list/";
+const TIKTOK_VIDEO_QUERY_URL = "https://open.tiktokapis.com/v2/video/query/";
+const PRIVACY_MAP = {
+	public: "PUBLIC_TO_EVERYONE",
+	private: "SELF_ONLY",
+	unlisted: "SELF_ONLY",
+	followers: "FOLLOWER_OF_CREATOR",
+	friends: "MUTUAL_FOLLOW_FRIENDS"
+};
+const VIDEO_QUERY_FIELDS = "id,title,video_description,create_time,cover_image_url,share_url,duration,like_count,comment_count,share_count,view_count";
+function generateCodeVerifier() {
+	return randomBytes(32).toString("base64url");
+}
+function generateCodeChallenge(verifier) {
+	return createHash("sha256").update(verifier).digest("base64url");
+}
+var TikTokProvider = class extends PlatformProvider {
+	defaultRedirectUri;
+	scopes;
+	/**
+	* PKCE verifier store keyed by `state`. TTL'd to 10 minutes; entries are
+	* single-use. For multi-instance deployments, persist verifiers alongside
+	* `state` (session/Redis) and pass them back via `exchangeCode(code, creds, state)`.
+	*/
+	codeVerifiers = new PkceStore(600 * 1e3);
+	constructor(cfg = {}) {
+		super(cfg);
+		this.name = "tiktok";
+		this.displayName = "TikTok";
+		this.authType = "oauth2";
+		this.defaultRedirectUri = cfg.redirectUri || `http://localhost:${cfg.port || 8060}/api/oauth/tiktok/callback`;
+		this.scopes = [
+			"user.info.profile",
+			"video.upload",
+			"video.publish"
+		];
+	}
+	/**
+	* Get TikTok OAuth authorization URL
+	* Quirk: uses `client_key` (not `client_id`), comma-separated scopes
+	*
+	* @param options.environment - Both sandbox and production request the same scopes.
+	*   Sandbox apps with "Direct Post" enabled support video.publish for test users.
+	*/
+	getAuthUrl(state, credentials = {}, options) {
+		const codeVerifier = generateCodeVerifier();
+		const codeChallenge = generateCodeChallenge(codeVerifier);
+		this.codeVerifiers.set(state, codeVerifier);
+		return `${TIKTOK_AUTH_URL}?${new URLSearchParams({
+			client_key: credentials.clientKey?.trim(),
+			redirect_uri: credentials.redirectUri || this.defaultRedirectUri,
+			scope: [
+				"user.info.profile",
+				"video.upload",
+				"video.publish"
+			].join(","),
+			response_type: "code",
+			state,
+			code_challenge: codeChallenge,
+			code_challenge_method: "S256"
+		}).toString()}`;
+	}
+	/**
+	* Exchange authorization code for tokens
+	* Quirk: form-urlencoded body with client_key/client_secret (not Basic auth)
+	*/
+	async exchangeCode(code, credentials = {}, state) {
+		const bodyParams = {
+			client_key: credentials.clientKey?.trim(),
+			client_secret: credentials.clientSecret?.trim(),
+			code,
+			grant_type: "authorization_code",
+			redirect_uri: credentials.redirectUri || this.defaultRedirectUri
+		};
+		if (state) {
+			const verifier = this.codeVerifiers.take(state);
+			if (verifier) bodyParams.code_verifier = verifier;
+		}
+		const { data } = await httpRequest("tiktok", {
+			method: "POST",
+			url: TIKTOK_TOKEN_URL,
+			urlencoded: bodyParams,
+			timeout: 3e4,
+			retry: { attempts: 1 },
+			parseError: (raw) => {
+				if (raw && typeof raw === "object") {
+					const r = raw;
+					const message = r.error_description || r.error || "TikTok token exchange failed";
+					const isScopeError = String(message).toLowerCase().includes("scope");
+					return {
+						message,
+						errorCode: r.error ?? null,
+						hint: isScopeError ? "Your TikTok app may not have the required scopes approved. Try connecting with Sandbox environment, or submit your app for TikTok audit to enable video.publish." : null
+					};
+				}
+				return null;
+			}
+		});
+		if (data.error || !data.access_token) {
+			const message = data.error_description || data.error || "TikTok token exchange failed";
+			throw new SocialError("tiktok", message, {
+				statusCode: 401,
+				hint: String(message).toLowerCase().includes("scope") ? "Your TikTok app may not have the required scopes approved. Try connecting with Sandbox environment, or submit your app for TikTok audit to enable video.publish." : void 0
+			});
+		}
+		return {
+			access_token: data.access_token,
+			refresh_token: data.refresh_token,
+			expires_in: data.expires_in,
+			open_id: data.open_id,
+			scope: data.scope,
+			token_type: data.token_type,
+			refresh_expires_in: data.refresh_expires_in
+		};
+	}
+	/**
+	* Refresh access token
+	*/
+	async refreshToken(refreshToken, credentials = {}) {
+		const { data } = await httpRequest("tiktok", {
+			method: "POST",
+			url: TIKTOK_TOKEN_URL,
+			urlencoded: {
+				client_key: credentials.clientKey,
+				client_secret: credentials.clientSecret,
+				grant_type: "refresh_token",
+				refresh_token: refreshToken
+			},
+			timeout: 3e4,
+			retry: { attempts: 2 }
+		});
+		if (data.error || !data.access_token) throw new SocialError("tiktok", data.error_description || data.error || "TikTok token refresh failed", { statusCode: 401 });
+		return {
+			access_token: data.access_token,
+			refresh_token: data.refresh_token,
+			expires_in: data.expires_in,
+			open_id: data.open_id,
+			scope: data.scope,
+			token_type: data.token_type,
+			refresh_expires_in: data.refresh_expires_in
+		};
+	}
+	/**
+	* Revoke TikTok access token.
+	* Forces fresh consent screen on next authorization — ensures newly
+	* enabled scopes (e.g. video.publish after enabling Direct Post) are granted.
+	*/
+	async revokeToken(accessToken, credData) {
+		if (!accessToken) throw new SocialError("tiktok", "Access token is required to revoke", { statusCode: 400 });
+		if (!credData?.clientKey || !credData?.clientSecret) throw new SocialError("tiktok", "clientKey and clientSecret are required to revoke", { statusCode: 400 });
+		await httpRequest("tiktok", {
+			method: "POST",
+			url: "https://open.tiktokapis.com/v2/oauth/revoke/",
+			urlencoded: {
+				client_key: credData.clientKey,
+				client_secret: credData.clientSecret,
+				token: accessToken
+			},
+			timeout: 15e3
+		});
+	}
+	/**
+	* Get TikTok user profile
+	* Quirk: requires explicit `fields` query param
+	*/
+	async getAccountInfo(accessToken) {
+		const { data: result } = await httpRequest("tiktok", {
+			method: "GET",
+			url: TIKTOK_USER_INFO_URL,
+			query: { fields: "open_id,avatar_large_url,avatar_url,display_name,username,bio_description" },
+			bearer: accessToken,
+			timeout: 3e4,
+			retry: { attempts: 2 }
+		});
+		if (result.error?.code && result.error.code !== "ok") throw new SocialError("tiktok", result.error?.message || "Failed to get TikTok account info");
+		const user = result.data?.user;
+		if (!user) throw new SocialError("tiktok", "No user data returned from TikTok");
+		return {
+			id: user.open_id,
+			name: user.display_name || user.username,
+			username: user.username,
+			profileImage: user.avatar_large_url || user.avatar_url,
+			bio: user.bio_description
+		};
+	}
+	/**
+	* Test credential validity
+	*/
+	async testCredential(credentialData) {
+		try {
+			if (credentialData.oauthTokenData) {
+				const tokenData = typeof credentialData.oauthTokenData === "string" ? JSON.parse(credentialData.oauthTokenData) : credentialData.oauthTokenData;
+				const accountInfo = await this.getAccountInfo(tokenData.access_token);
+				return {
+					status: "OK",
+					message: "TikTok credential is valid",
+					data: {
+						channelId: accountInfo.id,
+						channelTitle: accountInfo.name,
+						profileImage: accountInfo.profileImage
+					}
+				};
+			}
+			if (!credentialData.clientKey || !credentialData.clientSecret) return {
+				status: "Error",
+				message: "TikTok credentials not configured — clientKey and clientSecret are required"
+			};
+			return {
+				status: "Pending",
+				message: "Credential needs OAuth authorization. Click \"Connect Account\" to link your TikTok."
+			};
+		} catch (error) {
+			return {
+				status: "Error",
+				message: error.message || "Failed to validate TikTok credential"
+			};
+		}
+	}
+	/**
+	* Upload video to TikTok
+	*
+	* Smart mode selection:
+	* - videoUrl → tries PULL_FROM_URL first (zero server load, TikTok fetches directly)
+	*   → falls back to FILE_UPLOAD if domain not verified (url_ownership_unverified)
+	* - filePath → always FILE_UPLOAD (local file, no URL to pull from)
+	*
+	* FILE_UPLOAD uses stream-through: fetch(url) → pipe to TikTok (no server buffering).
+	*/
+	async uploadVideo(params) {
+		const { filePath, videoUrl, title = "", description = "", privacy = "private", tokens, scheduledAt, onProgress } = params;
+		if (!filePath && !videoUrl) throw new SocialError("tiktok", "uploadVideo requires either filePath or videoUrl", { statusCode: 400 });
+		const accessToken = tokens.access_token;
+		const privacyLevel = PRIVACY_MAP[privacy] || "SELF_ONLY";
+		if (scheduledAt) throw new SocialError("tiktok", "Scheduling is not supported by TikTok Content Posting API. Post immediately or use TikTok Business API (requires separate approval).", {
+			statusCode: 400,
+			retryable: false
+		});
+		const postInfo = {
+			title: (title || description || "").substring(0, 2200),
+			privacy_level: privacyLevel,
+			disable_duet: false,
+			disable_stitch: false,
+			disable_comment: false,
+			video_cover_timestamp_ms: 1e3
+		};
+		if (videoUrl && !filePath) {
+			const pullResult = await this._tryPullFromUrl(accessToken, videoUrl, postInfo, onProgress);
+			if (pullResult) return {
+				...pullResult,
+				status: scheduledAt ? "scheduled" : privacyLevel === "SELF_ONLY" ? "draft" : "published",
+				uploadedAt: /* @__PURE__ */ new Date(),
+				scheduledAt: scheduledAt ? new Date(scheduledAt) : null,
+				metadata: {
+					title,
+					privacy: privacyLevel,
+					uploadMode: "PULL_FROM_URL",
+					publishId: pullResult.platformVideoId,
+					...pullResult.metadata || {}
+				}
+			};
+		}
+		return this._uploadViaFile(accessToken, postInfo, {
+			filePath,
+			videoUrl,
+			title,
+			privacy: privacyLevel,
+			scheduledAt,
+			onProgress
+		});
+	}
+	/**
+	* Attempt PULL_FROM_URL upload. Returns result on success, null if domain not verified.
+	* Throws on any other error.
+	*/
+	async _tryPullFromUrl(accessToken, videoUrl, postInfo, onProgress) {
+		const initBody = {
+			post_info: postInfo,
+			source_info: {
+				source: "PULL_FROM_URL",
+				video_url: videoUrl
+			}
+		};
+		const initData = await (await fetch(TIKTOK_VIDEO_INIT_URL, {
+			method: "POST",
+			headers: {
+				Authorization: `Bearer ${accessToken}`,
+				"Content-Type": "application/json; charset=UTF-8"
+			},
+			body: JSON.stringify(initBody)
+		})).json();
+		const errorCode = initData.error?.code;
+		if (errorCode === "url_ownership_unverified") return null;
+		if (errorCode && errorCode !== "ok") {
+			const hint = errorCode === "unaudited_client_can_only_post_to_private_accounts" ? "Sandbox apps require the TikTok account to be set to Private. Go to TikTok > Settings > Privacy > Private Account. Or submit your app for TikTok audit to remove this restriction." : void 0;
+			throw new SocialError("tiktok", initData.error?.message || `PULL_FROM_URL init failed (${errorCode})`, {
+				errorCode,
+				hint
+			});
+		}
+		const publish_id = initData.data.publish_id;
+		if (onProgress) onProgress(10);
+		const publishResult = await this._pollPublishStatus(accessToken, publish_id);
+		if (onProgress) onProgress(100);
+		return {
+			platformVideoId: publish_id,
+			platformUrl: null,
+			metadata: publishResult || {}
+		};
+	}
+	/**
+	* FILE_UPLOAD with stream-through (fetch URL → pipe to TikTok, or local file → stream).
+	*/
+	async _uploadViaFile(accessToken, postInfo, opts) {
+		const { filePath, videoUrl, title, privacy, scheduledAt, onProgress } = opts;
+		let videoStream;
+		let videoSize;
+		if (filePath) {
+			videoSize = (await stat(filePath)).size;
+			videoStream = createReadStream(filePath);
+		} else {
+			const fetchResponse = await fetch(videoUrl);
+			if (!fetchResponse.ok) throw new SocialError("tiktok", `Failed to fetch video from URL: ${fetchResponse.status} ${fetchResponse.statusText}`, {
+				statusCode: 502,
+				hint: "Ensure the video URL is publicly accessible"
+			});
+			const contentLength = fetchResponse.headers.get("content-length");
+			if (!contentLength) throw new SocialError("tiktok", "Video URL did not return Content-Length header (required for TikTok FILE_UPLOAD)", {
+				statusCode: 502,
+				hint: "GCS and S3 always return Content-Length — ensure the URL points to cloud storage"
+			});
+			videoSize = parseInt(contentLength, 10);
+			videoStream = Readable.fromWeb(fetchResponse.body);
+		}
+		const initBody = {
+			post_info: postInfo,
+			source_info: {
+				source: "FILE_UPLOAD",
+				video_size: videoSize,
+				chunk_size: videoSize,
+				total_chunk_count: 1
+			}
+		};
+		const initData = await (await fetch(TIKTOK_VIDEO_INIT_URL, {
+			method: "POST",
+			headers: {
+				Authorization: `Bearer ${accessToken}`,
+				"Content-Type": "application/json; charset=UTF-8"
+			},
+			body: JSON.stringify(initBody)
+		})).json();
+		if (initData.error?.code && initData.error.code !== "ok") throw new SocialError("tiktok", initData.error?.message || `Upload init failed (${initData.error?.code})`, { errorCode: initData.error?.code });
+		const publish_id = initData.data.publish_id;
+		const { upload_url } = initData.data;
+		if (onProgress) onProgress(10);
+		const uploadResponse = await fetch(upload_url, {
+			method: "PUT",
+			headers: {
+				"Content-Type": "video/mp4",
+				"Content-Length": String(videoSize),
+				"Content-Range": `bytes 0-${videoSize - 1}/${videoSize}`
+			},
+			body: videoStream,
+			duplex: "half"
+		});
+		if (!uploadResponse.ok) {
+			const errText = await uploadResponse.text().catch(() => "");
+			throw new SocialError("tiktok", `Video upload failed (HTTP ${uploadResponse.status}): ${errText}`, { statusCode: uploadResponse.status });
+		}
+		if (onProgress) onProgress(80);
+		const publishResult = await this._pollPublishStatus(accessToken, publish_id);
+		if (onProgress) onProgress(100);
+		return {
+			platformVideoId: publish_id,
+			platformUrl: null,
+			status: scheduledAt ? "scheduled" : privacy === "SELF_ONLY" ? "draft" : "published",
+			uploadedAt: /* @__PURE__ */ new Date(),
+			scheduledAt: scheduledAt ? new Date(scheduledAt) : null,
+			metadata: {
+				title,
+				privacy,
+				uploadMode: "FILE_UPLOAD",
+				publishId: publish_id,
+				...publishResult || {}
+			}
+		};
+	}
+	/**
+	* Create a photo post on TikTok
+	* TikTok-specific — not in the base class.
+	*
+	* Restrictions:
+	* - Only JPG/JPEG/WEBP (no PNG)
+	* - Max 35 images per post
+	* - Images must be publicly accessible URLs
+	*
+	* @param params
+	* @param params.imageUrls - Array of public image URLs
+	* @param params.title - Post title (max 150 chars)
+	* @param params.privacy - 'public' | 'private' | 'followers' | 'friends'
+	* @param params.tokens - { access_token }
+	*/
+	async uploadPhoto(params) {
+		const { imageUrls, title = "", privacy = "private", tokens } = params;
+		if (!imageUrls || imageUrls.length === 0) throw new SocialError("tiktok", "Photo post requires at least one image URL", { statusCode: 400 });
+		const validFormats = [
+			"jpg",
+			"jpeg",
+			"webp"
+		];
+		for (const url of imageUrls) {
+			const ext = url.split("?")[0].split(".").pop()?.toLowerCase();
+			if (ext && !validFormats.includes(ext)) throw new SocialError("tiktok", `Unsupported image format .${ext} — only JPG, JPEG, WEBP are allowed`, { statusCode: 400 });
+		}
+		const accessToken = tokens.access_token;
+		const privacyLevel = PRIVACY_MAP[privacy] || "SELF_ONLY";
+		const body = {
+			post_info: {
+				title: (title || "").substring(0, 2200),
+				privacy_level: privacyLevel,
+				disable_comment: false
+			},
+			source_info: {
+				source: "PULL_FROM_URL",
+				photo_cover_index: 0,
+				photo_images: imageUrls.slice(0, 35)
+			},
+			media_type: "PHOTO"
+		};
+		const data = await (await fetch(TIKTOK_CONTENT_INIT_URL, {
+			method: "POST",
+			headers: {
+				Authorization: `Bearer ${accessToken}`,
+				"Content-Type": "application/json; charset=UTF-8"
+			},
+			body: JSON.stringify(body)
+		})).json();
+		if (data.error?.code && data.error.code !== "ok") throw new SocialError("tiktok", data.error?.message || `Photo post failed (${data.error?.code})`, { errorCode: data.error?.code });
+		const publish_id = data.data?.publish_id;
+		await this._pollPublishStatus(accessToken, publish_id);
+		return {
+			platformVideoId: publish_id,
+			platformUrl: null,
+			status: privacyLevel === "SELF_ONLY" ? "draft" : "published"
+		};
+	}
+	/**
+	* List videos for the authenticated user (cursor-based pagination).
+	* Requires scope: `video.list`
+	*
+	* @param accessToken - OAuth access token
+	* @param options.maxCount - Number of videos per page (1-20, default 20)
+	* @param options.cursor - Pagination cursor from a previous response
+	*/
+	async listVideos(accessToken, options) {
+		const maxCount = Math.min(Math.max(options?.maxCount ?? 20, 1), 20);
+		const url = `${TIKTOK_VIDEO_LIST_URL}?fields=${VIDEO_QUERY_FIELDS}`;
+		try {
+			const response = await fetch(url, {
+				method: "POST",
+				headers: {
+					Authorization: `Bearer ${accessToken}`,
+					"Content-Type": "application/json"
+				},
+				body: JSON.stringify({
+					max_count: maxCount,
+					...options?.cursor != null ? { cursor: options.cursor } : {}
+				})
+			});
+			const result = await response.json();
+			if (result.error?.code && result.error.code !== "ok") throw new SocialError("tiktok", result.error?.message || "Failed to list TikTok videos", {
+				statusCode: response.status >= 400 ? response.status : 502,
+				errorCode: result.error.code
+			});
+			return {
+				videos: (result.data?.videos || []).map((v) => this._parseVideoItem(v)),
+				cursor: result.data?.cursor ?? null,
+				hasMore: result.data?.has_more ?? false
+			};
+		} catch (error) {
+			if (error instanceof SocialError) throw error;
+			throw new SocialError("tiktok", error.message || "Failed to list TikTok videos", { originalError: error });
+		}
+	}
+	/**
+	* Query specific videos by their IDs.
+	*
+	* @param accessToken - OAuth access token
+	* @param videoIds - Array of TikTok video IDs to fetch
+	*/
+	async getVideos(accessToken, videoIds) {
+		if (!videoIds.length) return [];
+		const url = `${TIKTOK_VIDEO_QUERY_URL}?fields=${VIDEO_QUERY_FIELDS}`;
+		try {
+			const response = await fetch(url, {
+				method: "POST",
+				headers: {
+					Authorization: `Bearer ${accessToken}`,
+					"Content-Type": "application/json"
+				},
+				body: JSON.stringify({ filters: { video_ids: videoIds } })
+			});
+			const result = await response.json();
+			if (result.error?.code && result.error.code !== "ok") throw new SocialError("tiktok", result.error?.message || "Failed to query TikTok videos", {
+				statusCode: response.status >= 400 ? response.status : 502,
+				errorCode: result.error.code
+			});
+			const videos = result.data?.videos;
+			if (!videos) throw new SocialError("tiktok", "No video data returned from TikTok", { statusCode: 404 });
+			return videos.map((v) => this._parseVideoItem(v));
+		} catch (error) {
+			if (error instanceof SocialError) throw error;
+			throw new SocialError("tiktok", error.message || "Failed to query TikTok videos", { originalError: error });
+		}
+	}
+	getCredentialZodSchema() {
+		return TikTokCredentialsSchema;
+	}
+	getCredentialSchema() {
+		return [{
+			name: "clientKey",
+			displayName: "Client Key",
+			type: "text",
+			required: true,
+			description: "TikTok App Client Key from TikTok Developer Portal"
+		}, {
+			name: "clientSecret",
+			displayName: "Client Secret",
+			type: "password",
+			required: true,
+			description: "TikTok App Client Secret"
+		}];
+	}
+	getMetadata() {
+		return {
+			name: this.name,
+			displayName: this.displayName,
+			authType: this.authType,
+			icon: "tiktok",
+			brandColor: "#000000",
+			supportsScheduling: true,
+			supportsEnvironment: true,
+			description: "Share short-form videos on TikTok",
+			scopes: this.scopes,
+			scopeDescriptions: {
+				"user.info.profile": "View your TikTok profile info (display name, username, avatar, bio)",
+				"video.upload": "Upload videos to your TikTok account",
+				"video.publish": "Publish videos directly (requires TikTok audit approval)"
+			},
+			setupGuide: [
+				{
+					step: 1,
+					title: "Create TikTok Developer Account",
+					description: "Go to developers.tiktok.com and sign up or log in with your TikTok account"
+				},
+				{
+					step: 2,
+					title: "Create an App",
+					description: "Click \"Manage apps\" → \"Connect an app\". Fill in the app name and description"
+				},
+				{
+					step: 3,
+					title: "Add Login Kit",
+					description: "In your app, go to \"Add products\" and enable \"Login Kit\". Set the redirect URI shown below"
+				},
+				{
+					step: 4,
+					title: "Add Content Posting API",
+					description: "Enable \"Content Posting API\" product to allow video and photo uploads"
+				},
+				{
+					step: 5,
+					title: "Set Redirect URI",
+					description: `Add this as a redirect URI in your TikTok app settings: ${this.defaultRedirectUri}`
+				},
+				{
+					step: 6,
+					title: "Copy Credentials",
+					description: "Copy your Client Key and Client Secret from the app dashboard and paste them above"
+				},
+				{
+					step: 7,
+					title: "Unaudited App Limitations",
+					description: "Before TikTok audit approval: posts are limited to SELF_ONLY (private/draft) privacy, max 5 users per day, and all test users must have private TikTok profiles"
+				}
+			],
+			redirectUriPattern: this.defaultRedirectUri,
+			credentialSchema: this.getCredentialSchema()
+		};
+	}
+	/**
+	* Parse a raw TikTok video API item into a normalized TikTokVideo object.
+	* @private
+	*/
+	_parseVideoItem(item) {
+		return {
+			id: item.id,
+			title: item.title || "",
+			description: item.video_description || "",
+			createTime: item.create_time ?? 0,
+			coverImageUrl: item.cover_image_url ?? null,
+			shareUrl: item.share_url ?? null,
+			duration: item.duration ?? null,
+			viewCount: item.view_count ?? null,
+			likeCount: item.like_count ?? null,
+			commentCount: item.comment_count ?? null,
+			shareCount: item.share_count ?? null
+		};
+	}
+	/**
+	* Poll TikTok publish status until complete or failed
+	* @private
+	*/
+	async _pollPublishStatus(accessToken, publishId, maxAttempts = 15, intervalMs = 5e3) {
+		return (await pollUntilComplete({
+			fn: async () => {
+				return (await fetch(TIKTOK_STATUS_URL, {
+					method: "POST",
+					headers: {
+						Authorization: `Bearer ${accessToken}`,
+						"Content-Type": "application/json"
+					},
+					body: JSON.stringify({ publish_id: publishId })
+				})).json();
+			},
+			isComplete: (data) => data.data?.status === "PUBLISH_COMPLETE",
+			getError: (data) => {
+				if (data.data?.status === "FAILED") return new SocialError("tiktok", `Publish failed: ${data.data?.fail_reason || "Unknown reason"}`);
+				return null;
+			},
+			maxAttempts,
+			intervalMs,
+			label: "TikTokProvider"
+		}))?.data || null;
+	}
+};
+
+//#endregion
+export { TikTokProvider };
+//# sourceMappingURL=tiktok.mjs.map