@classytic/social 0.1.0

package/dist/env-Bl0cwwjC.mjs

@@ -0,0 +1,955 @@
+import { t as SocialError } from "./errors-Cm6LeKf7.mjs";
+import { TwitterProvider } from "./providers/twitter.mjs";
+import { FacebookProvider } from "./providers/facebook.mjs";
+import { LinkedInProvider } from "./providers/linkedin.mjs";
+import { RedditProvider } from "./providers/reddit.mjs";
+import { InstagramProvider } from "./providers/instagram.mjs";
+import { YouTubeProvider } from "./providers/youtube.mjs";
+import { TikTokProvider } from "./providers/tiktok.mjs";
+import { TelegramProvider } from "./providers/telegram.mjs";
+import { WhatsAppProvider } from "./providers/whatsapp.mjs";
+import { SocialClient } from "./client/index.mjs";
+
+//#region src/client/twitter.ts
+/**
+* TwitterClient — credential-bound wrapper over `TwitterProvider`.
+*/
+var TwitterClient = class {
+	provider;
+	constructor(config, opts = {}) {
+		this.config = config;
+		this.provider = new TwitterProvider({
+			port: opts.port,
+			redirectUri: config.redirectUri,
+			environment: opts.environment
+		});
+	}
+	/** OAuth: get the consent URL. Async variant uses S256 PKCE (preferred). */
+	async authUrl(state) {
+		return this.provider.getAuthUrlAsync(state, this.config);
+	}
+	/** OAuth: exchange the callback code for tokens. Stores them on `this.config.tokens`. */
+	async exchangeCode(code, state) {
+		const tokens = await this.provider.exchangeCode(code, this.config, state);
+		this.config.tokens = tokens;
+		return tokens;
+	}
+	/** Refresh the access token. Stores updated tokens. */
+	async refresh() {
+		const refreshToken = this.config.tokens?.refresh_token;
+		if (!refreshToken) throw new SocialError("twitter", "No refresh_token available");
+		const tokens = await this.provider.refreshToken(refreshToken, this.config);
+		this.config.tokens = {
+			...this.config.tokens,
+			...tokens
+		};
+		return this.config.tokens;
+	}
+	/**
+	* Post a tweet (text + optional media).
+	*
+	* Twitter requires media to be pre-uploaded via the v1.1 chunked endpoint —
+	* pass each pre-uploaded media's ID as `media[i].id`. Items with only a
+	* `url` are skipped (no automatic upload). For end-to-end upload see
+	* `provider.uploadPhoto()` / `provider.uploadVideo()` on the underlying
+	* `TwitterProvider`.
+	*/
+	async post(input) {
+		try {
+			const accessToken = this.assertAccessToken();
+			const mediaIds = input.media?.map((m) => m.id).filter((id) => !!id);
+			if ((input.media?.length ?? 0) - (mediaIds?.length ?? 0) > 0 && mediaIds?.length === 0) throw new SocialError("twitter", "Twitter requires pre-uploaded media IDs. Upload via TwitterProvider.uploadPhoto/uploadVideo first, then pass `media[i].id`.", { statusCode: 400 });
+			const result = await this.provider.createTweet(accessToken, {
+				text: input.text ?? "",
+				mediaIds: mediaIds?.length ? mediaIds : void 0,
+				replyTo: input.perPlatform?.twitter?.replyTo,
+				quoteTweetId: input.perPlatform?.twitter?.quoteTweet
+			});
+			return {
+				platform: "twitter",
+				ok: true,
+				id: result.id,
+				url: result.id ? `https://twitter.com/i/status/${result.id}` : void 0,
+				raw: result
+			};
+		} catch (err) {
+			return errorResult("twitter", err);
+		}
+	}
+	/** Delete a tweet by ID. */
+	async delete(tweetId) {
+		const accessToken = this.assertAccessToken();
+		await this.provider.deleteTweet(accessToken, tweetId);
+	}
+	/** Get a tweet by ID. */
+	async get(tweetId) {
+		const accessToken = this.assertAccessToken();
+		return this.provider.getTweet(accessToken, tweetId);
+	}
+	/** Send a direct message. */
+	async sendDm(participantId, text) {
+		const accessToken = this.assertAccessToken();
+		return this.provider.sendDirectMessage(accessToken, {
+			participantId,
+			text
+		});
+	}
+	/** Get the authenticated user's profile. */
+	async me() {
+		const accessToken = this.assertAccessToken();
+		return this.provider.getAccountInfo(accessToken);
+	}
+	assertAccessToken() {
+		const t = this.config.tokens?.access_token;
+		if (!t) throw new SocialError("twitter", "Not authenticated. Call exchangeCode() first or pass tokens in config.", { statusCode: 401 });
+		return t;
+	}
+};
+function errorResult(platform, err) {
+	if (err instanceof SocialError) return {
+		platform,
+		ok: false,
+		error: {
+			message: err.message,
+			code: err.errorCode,
+			retryable: err.retryable
+		}
+	};
+	return {
+		platform,
+		ok: false,
+		error: { message: err instanceof Error ? err.message : String(err) }
+	};
+}
+
+//#endregion
+//#region src/client/facebook.ts
+/**
+* FacebookClient — credential-bound wrapper over `FacebookProvider`.
+*/
+var FacebookClient = class {
+	provider;
+	constructor(config, opts = {}) {
+		this.config = config;
+		this.provider = new FacebookProvider({
+			port: opts.port,
+			redirectUri: config.redirectUri,
+			environment: opts.environment
+		});
+	}
+	async authUrl(state) {
+		return this.provider.getAuthUrl(state, this.config);
+	}
+	async exchangeCode(code) {
+		const tokens = await this.provider.exchangeCode(code, this.config);
+		this.config.tokens = tokens;
+		return tokens;
+	}
+	async refresh() {
+		const refreshToken = this.config.tokens?.refresh_token ?? this.config.tokens?.access_token;
+		if (!refreshToken) throw new SocialError("facebook", "No refresh_token available");
+		const tokens = await this.provider.refreshToken(refreshToken, this.config);
+		this.config.tokens = {
+			...this.config.tokens,
+			...tokens
+		};
+		return this.config.tokens;
+	}
+	/**
+	* List Pages the authenticated user manages. Each result contains a
+	* page-level access token. Set `pageId` + `pageAccessToken` on the config to
+	* select a target page for posting.
+	*/
+	async listPages() {
+		return this.provider.getPages(this.userToken());
+	}
+	/**
+	* Convenience: pick a page by ID and bind its token to this client.
+	*/
+	async usePage(pageId) {
+		const match = (await this.listPages()).find((p) => p.id === pageId);
+		if (!match) throw new SocialError("facebook", `Page ${pageId} not found in /me/accounts`, { statusCode: 404 });
+		this.config.pageId = match.id;
+		this.config.pageAccessToken = match.access_token;
+	}
+	/** Create a Page post — text, link, or photo depending on input. */
+	async post(input) {
+		try {
+			const { pageId, token } = this.assertPage(input);
+			const scheduledAt = input.scheduledAt;
+			const photo = input.media?.find((m) => m.type === "image" && m.url);
+			if (photo?.url) {
+				const r = await this.provider.createPhotoPost(token, pageId, photo.url, {
+					caption: input.text,
+					scheduledAt
+				});
+				return {
+					platform: "facebook",
+					ok: true,
+					id: r.postId,
+					url: `https://facebook.com/${r.postId}`,
+					raw: r
+				};
+			}
+			if (input.link) {
+				const r = await this.provider.createLinkPost(token, pageId, input.link, {
+					message: input.text,
+					scheduledAt
+				});
+				return {
+					platform: "facebook",
+					ok: true,
+					id: r.postId,
+					url: `https://facebook.com/${r.postId}`,
+					raw: r
+				};
+			}
+			if (input.text) {
+				const r = await this.provider.createPost(token, pageId, input.text, { scheduledAt });
+				return {
+					platform: "facebook",
+					ok: true,
+					id: r.postId,
+					url: `https://facebook.com/${r.postId}`,
+					raw: r
+				};
+			}
+			throw new SocialError("facebook", "Provide either text, link, or photo media", { statusCode: 400 });
+		} catch (err) {
+			return errorResult("facebook", err);
+		}
+	}
+	async deletePost(postId) {
+		const { token } = this.assertPage();
+		await this.provider.deletePost(token, postId);
+	}
+	async getPost(postId) {
+		const { token } = this.assertPage();
+		return this.provider.getPost(token, postId);
+	}
+	async getFeed(limit) {
+		const { pageId, token } = this.assertPage();
+		return this.provider.getPageFeed(token, pageId, limit);
+	}
+	userToken() {
+		const t = this.config.tokens?.access_token;
+		if (!t) throw new SocialError("facebook", "Not authenticated. Call exchangeCode() first.", { statusCode: 401 });
+		return t;
+	}
+	assertPage(input) {
+		const pageId = input?.perPlatform?.facebook?.pageId ?? this.config.pageId;
+		const token = input?.perPlatform?.facebook?.pageAccessToken ?? this.config.pageAccessToken;
+		if (!pageId || !token) throw new SocialError("facebook", "No Page selected. Call usePage(pageId) or set pageId/pageAccessToken in config.", { statusCode: 400 });
+		return {
+			pageId,
+			token
+		};
+	}
+};
+
+//#endregion
+//#region src/client/linkedin.ts
+/**
+* LinkedInClient — credential-bound wrapper over `LinkedInProvider`.
+*/
+var LinkedInClient = class {
+	provider;
+	constructor(config, opts = {}) {
+		this.config = config;
+		this.provider = new LinkedInProvider({
+			port: opts.port,
+			redirectUri: config.redirectUri,
+			environment: opts.environment
+		});
+	}
+	async authUrl(state) {
+		return this.provider.getAuthUrl(state, this.config);
+	}
+	async exchangeCode(code) {
+		const tokens = await this.provider.exchangeCode(code, this.config);
+		this.config.tokens = tokens;
+		return tokens;
+	}
+	async refresh() {
+		const refreshToken = this.config.tokens?.refresh_token;
+		if (!refreshToken) throw new SocialError("linkedin", "No refresh_token available");
+		const tokens = await this.provider.refreshToken(refreshToken, this.config);
+		this.config.tokens = {
+			...this.config.tokens,
+			...tokens
+		};
+		return this.config.tokens;
+	}
+	/** Resolve and cache the authenticated user's URN. */
+	async resolveAuthor() {
+		if (this.config.authorUrn) return this.config.authorUrn;
+		const accessToken = this.assertAccessToken();
+		const info = await this.provider.getAccountInfo(accessToken);
+		if (!info?.id) throw new SocialError("linkedin", "Could not resolve author URN", { statusCode: 502 });
+		const urn = `urn:li:person:${info.id}`;
+		this.config.authorUrn = urn;
+		return urn;
+	}
+	/** Create a post (text, article, or image). */
+	async post(input) {
+		try {
+			const accessToken = this.assertAccessToken();
+			const author = input.perPlatform?.linkedin?.authorUrn ?? await this.resolveAuthor();
+			if (input.link) {
+				const r = await this.provider.createArticlePost(accessToken, author, input.text ?? "", input.link);
+				return {
+					platform: "linkedin",
+					ok: true,
+					id: r.postId,
+					raw: r
+				};
+			}
+			if (!input.text) throw new SocialError("linkedin", "Provide text for the post", { statusCode: 400 });
+			const r = await this.provider.createTextPost(accessToken, author, input.text);
+			return {
+				platform: "linkedin",
+				ok: true,
+				id: r.postId,
+				raw: r
+			};
+		} catch (err) {
+			return errorResult("linkedin", err);
+		}
+	}
+	async deletePost(postUrn) {
+		const accessToken = this.assertAccessToken();
+		await this.provider.deletePost(accessToken, postUrn);
+	}
+	async getPost(postUrn) {
+		const accessToken = this.assertAccessToken();
+		return this.provider.getPost(accessToken, postUrn);
+	}
+	assertAccessToken() {
+		const t = this.config.tokens?.access_token;
+		if (!t) throw new SocialError("linkedin", "Not authenticated. Call exchangeCode() first.", { statusCode: 401 });
+		return t;
+	}
+};
+
+//#endregion
+//#region src/client/reddit.ts
+/**
+* RedditClient — credential-bound wrapper over `RedditProvider`.
+*
+* Reddit posts always require a `subreddit` and `title`. Pass them via
+* `input.perPlatform.reddit`.
+*/
+var RedditClient = class {
+	provider;
+	constructor(config, opts = {}) {
+		this.config = config;
+		this.provider = new RedditProvider({
+			port: opts.port,
+			redirectUri: config.redirectUri,
+			environment: opts.environment
+		});
+	}
+	async authUrl(state) {
+		return this.provider.getAuthUrl(state, this.config);
+	}
+	async exchangeCode(code) {
+		const tokens = await this.provider.exchangeCode(code, this.config);
+		this.config.tokens = tokens;
+		return tokens;
+	}
+	async refresh() {
+		const refreshToken = this.config.tokens?.refresh_token;
+		if (!refreshToken) throw new SocialError("reddit", "No refresh_token available");
+		const tokens = await this.provider.refreshToken(refreshToken, this.config);
+		this.config.tokens = {
+			...this.config.tokens,
+			...tokens
+		};
+		return this.config.tokens;
+	}
+	/** Submit to a subreddit. Requires `subreddit` + `title` in `perPlatform.reddit`. */
+	async post(input) {
+		try {
+			const accessToken = this.assertAccessToken();
+			const r = input.perPlatform?.reddit;
+			if (!r?.subreddit || !r.title) throw new SocialError("reddit", "Reddit posts require `perPlatform.reddit.subreddit` and `perPlatform.reddit.title`", { statusCode: 400 });
+			const kind = r.kind ?? (input.link ? "link" : "self");
+			const result = await this.provider.createPost(accessToken, {
+				subreddit: r.subreddit,
+				title: r.title,
+				kind,
+				text: input.text,
+				url: input.link
+			});
+			return {
+				platform: "reddit",
+				ok: true,
+				id: result.id,
+				url: result.url,
+				raw: result
+			};
+		} catch (err) {
+			return errorResult("reddit", err);
+		}
+	}
+	async deletePost(fullname) {
+		const accessToken = this.assertAccessToken();
+		await this.provider.deleteContent(accessToken, fullname);
+	}
+	async getPost(subreddit, postId) {
+		const accessToken = this.assertAccessToken();
+		return this.provider.getPost(accessToken, subreddit, postId);
+	}
+	assertAccessToken() {
+		const t = this.config.tokens?.access_token;
+		if (!t) throw new SocialError("reddit", "Not authenticated. Call exchangeCode() first.", { statusCode: 401 });
+		return t;
+	}
+};
+
+//#endregion
+//#region src/client/instagram.ts
+/**
+* InstagramClient — credential-bound wrapper over `InstagramProvider`.
+*/
+var InstagramClient = class {
+	provider;
+	constructor(config, opts = {}) {
+		this.config = config;
+		this.provider = new InstagramProvider({
+			port: opts.port,
+			redirectUri: config.redirectUri,
+			environment: opts.environment
+		});
+	}
+	async authUrl(state) {
+		return this.provider.getAuthUrl(state, this.config);
+	}
+	async exchangeCode(code) {
+		const tokens = await this.provider.exchangeCode(code, this.config);
+		this.config.tokens = tokens;
+		return tokens;
+	}
+	async refresh() {
+		const refreshToken = this.config.tokens?.refresh_token ?? this.config.tokens?.access_token;
+		if (!refreshToken) throw new SocialError("instagram", "No refresh_token available");
+		const tokens = await this.provider.refreshToken(refreshToken);
+		this.config.tokens = {
+			...this.config.tokens,
+			...tokens
+		};
+		return this.config.tokens;
+	}
+	/** Resolve and cache the Instagram Business User ID. */
+	async resolveIgUser() {
+		if (this.config.igUserId) return this.config.igUserId;
+		const accessToken = this.assertAccessToken();
+		const info = await this.provider.getAccountInfo(accessToken);
+		if (!info?.id) throw new SocialError("instagram", "Could not resolve Instagram Business Account ID", { statusCode: 502 });
+		this.config.igUserId = info.id;
+		return info.id;
+	}
+	/**
+	* Post to Instagram. Behavior:
+	* - 1 image          → `uploadPhoto`
+	* - 1 video          → `uploadVideo` (Reel)
+	* - 2-10 mixed media → `uploadCarousel`
+	*
+	* Text-only posts are not supported by Instagram.
+	*/
+	async post(input) {
+		try {
+			const accessToken = this.assertAccessToken();
+			const igUserId = input.perPlatform?.instagram?.igUserId ?? await this.resolveIgUser();
+			const media = input.media ?? [];
+			if (media.length === 0) throw new SocialError("instagram", "Instagram requires at least one media item (image or video)", { statusCode: 400 });
+			if (media.length === 1) {
+				const m = media[0];
+				if (!m.url) throw new SocialError("instagram", "Instagram requires a public URL for each media item (no pre-uploaded media support)", { statusCode: 400 });
+				if (m.type === "image") {
+					const r = await this.provider.uploadPhoto({
+						imageUrl: m.url,
+						caption: input.text,
+						tokens: {
+							access_token: accessToken,
+							igUserId
+						}
+					});
+					return {
+						platform: "instagram",
+						ok: true,
+						id: r.mediaId,
+						raw: r
+					};
+				}
+				const r = await this.provider.uploadVideo({
+					videoUrl: m.url,
+					caption: input.text,
+					tokens: {
+						access_token: accessToken,
+						igUserId
+					}
+				});
+				return {
+					platform: "instagram",
+					ok: true,
+					id: r.platformVideoId ?? r.platformPostId,
+					raw: r
+				};
+			}
+			const items = media.filter((m) => !!m.url);
+			if (items.length !== media.length) throw new SocialError("instagram", "Instagram carousels require URLs for every media item", { statusCode: 400 });
+			const r = await this.provider.uploadCarousel({
+				items: items.map((m) => ({
+					type: m.type === "image" ? "IMAGE" : "VIDEO",
+					url: m.url
+				})),
+				caption: input.text,
+				tokens: {
+					access_token: accessToken,
+					igUserId
+				}
+			});
+			return {
+				platform: "instagram",
+				ok: true,
+				id: r.mediaId,
+				raw: r
+			};
+		} catch (err) {
+			return errorResult("instagram", err);
+		}
+	}
+	async getMedia(mediaId) {
+		const accessToken = this.assertAccessToken();
+		return this.provider.getMedia(accessToken, mediaId);
+	}
+	async listMedia(opts) {
+		const accessToken = this.assertAccessToken();
+		const igUserId = this.config.igUserId ?? await this.resolveIgUser();
+		return this.provider.listMedia(accessToken, igUserId, opts);
+	}
+	assertAccessToken() {
+		const t = this.config.tokens?.access_token;
+		if (!t) throw new SocialError("instagram", "Not authenticated. Call exchangeCode() first.", { statusCode: 401 });
+		return t;
+	}
+};
+
+//#endregion
+//#region src/client/youtube.ts
+/**
+* YouTubeClient — credential-bound wrapper over `YouTubeProvider`.
+*
+* YouTube doesn't support text-only posts; use `upload()` to publish videos.
+*/
+var YouTubeClient = class {
+	provider;
+	constructor(config, opts = {}) {
+		this.config = config;
+		this.provider = new YouTubeProvider({
+			port: opts.port,
+			redirectUri: config.redirectUri,
+			environment: opts.environment
+		});
+	}
+	authUrl(state) {
+		return this.provider.getAuthUrl(state, this.config);
+	}
+	async exchangeCode(code) {
+		const tokens = await this.provider.exchangeCode(code, this.config);
+		this.config.tokens = tokens;
+		return tokens;
+	}
+	async refresh() {
+		const refreshToken = this.config.tokens?.refresh_token;
+		if (!refreshToken) throw new SocialError("youtube", "No refresh_token available");
+		const tokens = await this.provider.refreshToken(refreshToken, this.config);
+		this.config.tokens = {
+			...this.config.tokens,
+			...tokens
+		};
+		return this.config.tokens;
+	}
+	/** Upload a video. */
+	async upload(input) {
+		try {
+			this.assertAccessToken();
+			const r = await this.provider.uploadVideo({
+				filePath: input.filePath,
+				videoUrl: input.videoUrl,
+				title: input.title ?? "",
+				description: input.description,
+				tags: input.tags,
+				privacy: input.privacy,
+				scheduledAt: input.scheduledAt,
+				credentials: this.config,
+				tokens: this.config.tokens
+			});
+			return {
+				platform: "youtube",
+				ok: true,
+				id: r.platformVideoId ?? r.platformPostId,
+				url: r.platformUrl ?? (r.platformVideoId ? `https://youtu.be/${r.platformVideoId}` : void 0),
+				raw: r
+			};
+		} catch (err) {
+			return errorResult("youtube", err);
+		}
+	}
+	async deleteVideo(videoId) {
+		const accessToken = this.assertAccessToken();
+		await this.provider.deleteVideo(accessToken, videoId, this.config);
+	}
+	async getVideo(videoId) {
+		const accessToken = this.assertAccessToken();
+		return this.provider.getVideo(accessToken, videoId, this.config);
+	}
+	async listVideos(opts) {
+		const accessToken = this.assertAccessToken();
+		return this.provider.listVideos(accessToken, this.config, opts);
+	}
+	assertAccessToken() {
+		const t = this.config.tokens?.access_token;
+		if (!t) throw new SocialError("youtube", "Not authenticated. Call exchangeCode() first.", { statusCode: 401 });
+		return t;
+	}
+};
+
+//#endregion
+//#region src/client/tiktok.ts
+/**
+* TikTokClient — credential-bound wrapper over `TikTokProvider`.
+*/
+var TikTokClient = class {
+	provider;
+	constructor(config, opts = {}) {
+		this.config = config;
+		this.provider = new TikTokProvider({
+			port: opts.port,
+			redirectUri: config.redirectUri,
+			environment: opts.environment
+		});
+	}
+	authUrl(state) {
+		return this.provider.getAuthUrl(state, this.config);
+	}
+	async exchangeCode(code, state) {
+		const tokens = await this.provider.exchangeCode(code, this.config, state);
+		this.config.tokens = tokens;
+		return tokens;
+	}
+	async refresh() {
+		const refreshToken = this.config.tokens?.refresh_token;
+		if (!refreshToken) throw new SocialError("tiktok", "No refresh_token available");
+		const tokens = await this.provider.refreshToken(refreshToken, this.config);
+		this.config.tokens = {
+			...this.config.tokens,
+			...tokens
+		};
+		return this.config.tokens;
+	}
+	/** Upload a video. */
+	async upload(input) {
+		try {
+			this.assertAccessToken();
+			const r = await this.provider.uploadVideo({
+				filePath: input.filePath,
+				videoUrl: input.videoUrl,
+				title: input.title ?? input.caption,
+				description: input.description ?? input.caption,
+				privacy: input.privacy,
+				scheduledAt: input.scheduledAt,
+				credentials: this.config,
+				tokens: this.config.tokens
+			});
+			return {
+				platform: "tiktok",
+				ok: true,
+				id: r.platformVideoId ?? r.platformPostId,
+				url: r.platformUrl ?? null,
+				raw: r
+			};
+		} catch (err) {
+			return errorResult("tiktok", err);
+		}
+	}
+	async listVideos(opts) {
+		const accessToken = this.assertAccessToken();
+		return this.provider.listVideos(accessToken, opts);
+	}
+	assertAccessToken() {
+		const t = this.config.tokens?.access_token;
+		if (!t) throw new SocialError("tiktok", "Not authenticated. Call exchangeCode() first.", { statusCode: 401 });
+		return t;
+	}
+};
+
+//#endregion
+//#region src/client/telegram.ts
+/**
+* TelegramClient — credential-bound wrapper over `TelegramProvider`.
+*
+* Telegram uses Bot Tokens (no OAuth). The bot must be added as admin to the
+* target channel/group.
+*/
+var TelegramClient = class {
+	provider;
+	constructor(config, opts = {}) {
+		this.config = config;
+		this.provider = new TelegramProvider({ port: opts.port });
+	}
+	/** Send a text message. Falls back to `config.chatId` if `to` is omitted. */
+	async send(text, to) {
+		try {
+			const chatId = this.assertChatId(to);
+			const result = await this.provider.sendMessage(this.config.botToken, chatId, text);
+			return {
+				platform: "telegram",
+				ok: true,
+				id: String(result.message_id ?? ""),
+				raw: result
+			};
+		} catch (err) {
+			return errorResultMsg$1(err);
+		}
+	}
+	async sendPhoto(photoUrl, opts = {}) {
+		const chatId = this.assertChatId(opts.to);
+		return this.provider.sendPhoto(this.config.botToken, chatId, photoUrl, { caption: opts.caption });
+	}
+	async sendVideo(videoUrl, opts = {}) {
+		const chatId = this.assertChatId(opts.to);
+		return this.provider.sendVideo(this.config.botToken, chatId, videoUrl, { caption: opts.caption });
+	}
+	async sendDocument(documentUrl, opts = {}) {
+		const chatId = this.assertChatId(opts.to);
+		return this.provider.sendDocument(this.config.botToken, chatId, documentUrl, { caption: opts.caption });
+	}
+	async deleteMessage(messageId, to) {
+		const chatId = this.assertChatId(to);
+		return this.provider.deleteMessage(this.config.botToken, chatId, Number(messageId));
+	}
+	async getChat(chatId) {
+		return this.provider.getChat(this.config.botToken, this.assertChatId(chatId));
+	}
+	async discoverChats() {
+		return this.provider.discoverChats(this.config.botToken);
+	}
+	async me() {
+		return this.provider.getAccountInfo(this.config.botToken);
+	}
+	assertChatId(to) {
+		const id = to ?? this.config.chatId;
+		if (id === void 0 || id === null || id === "") throw new SocialError("telegram", "No chat ID provided. Pass `to` or set `chatId` in config.", { statusCode: 400 });
+		return id;
+	}
+};
+function errorResultMsg$1(err) {
+	if (err instanceof SocialError) return {
+		platform: "telegram",
+		ok: false,
+		error: {
+			message: err.message,
+			code: err.errorCode
+		}
+	};
+	return {
+		platform: "telegram",
+		ok: false,
+		error: { message: err instanceof Error ? err.message : String(err) }
+	};
+}
+
+//#endregion
+//#region src/client/whatsapp.ts
+/**
+* WhatsAppClient — credential-bound wrapper over `WhatsAppProvider`.
+*
+* WhatsApp uses permanent System User tokens (no OAuth).
+*/
+var WhatsAppClient = class {
+	provider;
+	constructor(config, opts = {}) {
+		this.config = config;
+		this.provider = new WhatsAppProvider({ port: opts.port });
+	}
+	/** Send a text message to an E.164 phone number. */
+	async send(text, to) {
+		try {
+			const phoneNumberId = this.assertPhoneNumberId();
+			const result = await this.provider.sendMessage(this.config.accessToken, phoneNumberId, {
+				to,
+				type: "text",
+				text: { body: text }
+			});
+			return {
+				platform: "whatsapp",
+				ok: true,
+				id: result.messages?.[0]?.id,
+				raw: result
+			};
+		} catch (err) {
+			return errorResultMsg(err);
+		}
+	}
+	async sendImage(to, imageUrl, caption) {
+		const phoneNumberId = this.assertPhoneNumberId();
+		return this.provider.sendImage(this.config.accessToken, phoneNumberId, {
+			to,
+			imageUrl,
+			caption
+		});
+	}
+	async sendVideo(to, videoUrl, caption) {
+		const phoneNumberId = this.assertPhoneNumberId();
+		return this.provider.sendVideo(this.config.accessToken, phoneNumberId, {
+			to,
+			videoUrl,
+			caption
+		});
+	}
+	async sendDocument(to, documentUrl, opts = {}) {
+		const phoneNumberId = this.assertPhoneNumberId();
+		return this.provider.sendDocument(this.config.accessToken, phoneNumberId, {
+			to,
+			documentUrl,
+			caption: opts.caption,
+			filename: opts.filename
+		});
+	}
+	async listPhoneNumbers() {
+		return this.provider.getPhoneNumbers(this.config.accessToken, this.config.businessAccountId);
+	}
+	async listTemplates() {
+		return this.provider.getTemplates(this.config.accessToken, this.config.businessAccountId);
+	}
+	assertPhoneNumberId() {
+		if (!this.config.phoneNumberId) throw new SocialError("whatsapp", "phoneNumberId is required. Set it in config or call listPhoneNumbers() first.", { statusCode: 400 });
+		return this.config.phoneNumberId;
+	}
+};
+function errorResultMsg(err) {
+	if (err instanceof SocialError) return {
+		platform: "whatsapp",
+		ok: false,
+		error: {
+			message: err.message,
+			code: err.errorCode
+		}
+	};
+	return {
+		platform: "whatsapp",
+		ok: false,
+		error: { message: err instanceof Error ? err.message : String(err) }
+	};
+}
+
+//#endregion
+//#region src/client/env.ts
+/**
+* Auto-configure a `SocialClient` from environment variables.
+*
+* Recognized variables (every platform is optional):
+*
+*   YOUTUBE_CLIENT_ID, YOUTUBE_CLIENT_SECRET, YOUTUBE_REDIRECT_URI,
+*   YOUTUBE_ACCESS_TOKEN, YOUTUBE_REFRESH_TOKEN
+*
+*   TWITTER_CLIENT_ID, TWITTER_CLIENT_SECRET, TWITTER_REDIRECT_URI,
+*   TWITTER_ACCESS_TOKEN, TWITTER_REFRESH_TOKEN
+*
+*   FACEBOOK_APP_ID, FACEBOOK_APP_SECRET, FACEBOOK_REDIRECT_URI,
+*   FACEBOOK_ACCESS_TOKEN, FACEBOOK_PAGE_ID, FACEBOOK_PAGE_ACCESS_TOKEN
+*
+*   INSTAGRAM_APP_ID, INSTAGRAM_APP_SECRET, INSTAGRAM_REDIRECT_URI,
+*   INSTAGRAM_ACCESS_TOKEN, INSTAGRAM_USER_ID
+*
+*   LINKEDIN_CLIENT_ID, LINKEDIN_CLIENT_SECRET, LINKEDIN_REDIRECT_URI,
+*   LINKEDIN_ACCESS_TOKEN, LINKEDIN_AUTHOR_URN
+*
+*   REDDIT_CLIENT_ID, REDDIT_CLIENT_SECRET, REDDIT_USER_AGENT,
+*   REDDIT_REDIRECT_URI, REDDIT_ACCESS_TOKEN, REDDIT_REFRESH_TOKEN
+*
+*   TIKTOK_CLIENT_KEY, TIKTOK_CLIENT_SECRET, TIKTOK_REDIRECT_URI,
+*   TIKTOK_ACCESS_TOKEN, TIKTOK_REFRESH_TOKEN
+*
+*   TELEGRAM_BOT_TOKEN, TELEGRAM_CHAT_ID
+*
+*   WHATSAPP_ACCESS_TOKEN, WHATSAPP_BUSINESS_ACCOUNT_ID, WHATSAPP_PHONE_NUMBER_ID
+*/
+function tokensFrom(env, prefix) {
+	const access = env[`${prefix}_ACCESS_TOKEN`];
+	if (!access) return void 0;
+	return {
+		access_token: access,
+		refresh_token: env[`${prefix}_REFRESH_TOKEN`]
+	};
+}
+/**
+* Build a `SocialClient` from `process.env` (or any compatible record).
+* Only platforms whose required vars are present are enabled.
+*/
+function fromEnv(env = typeof process !== "undefined" ? process.env : {}, opts) {
+	const config = {};
+	if (env.YOUTUBE_CLIENT_ID && env.YOUTUBE_CLIENT_SECRET) config.youtube = {
+		clientId: env.YOUTUBE_CLIENT_ID,
+		clientSecret: env.YOUTUBE_CLIENT_SECRET,
+		redirectUri: env.YOUTUBE_REDIRECT_URI,
+		tokens: tokensFrom(env, "YOUTUBE")
+	};
+	if (env.TWITTER_CLIENT_ID) config.twitter = {
+		clientId: env.TWITTER_CLIENT_ID,
+		clientSecret: env.TWITTER_CLIENT_SECRET,
+		redirectUri: env.TWITTER_REDIRECT_URI,
+		tokens: tokensFrom(env, "TWITTER")
+	};
+	if (env.FACEBOOK_APP_ID && env.FACEBOOK_APP_SECRET) config.facebook = {
+		appId: env.FACEBOOK_APP_ID,
+		appSecret: env.FACEBOOK_APP_SECRET,
+		redirectUri: env.FACEBOOK_REDIRECT_URI,
+		tokens: tokensFrom(env, "FACEBOOK"),
+		pageId: env.FACEBOOK_PAGE_ID,
+		pageAccessToken: env.FACEBOOK_PAGE_ACCESS_TOKEN
+	};
+	if (env.INSTAGRAM_APP_ID && env.INSTAGRAM_APP_SECRET) config.instagram = {
+		appId: env.INSTAGRAM_APP_ID,
+		appSecret: env.INSTAGRAM_APP_SECRET,
+		redirectUri: env.INSTAGRAM_REDIRECT_URI,
+		tokens: tokensFrom(env, "INSTAGRAM"),
+		igUserId: env.INSTAGRAM_USER_ID
+	};
+	if (env.LINKEDIN_CLIENT_ID && env.LINKEDIN_CLIENT_SECRET) config.linkedin = {
+		clientId: env.LINKEDIN_CLIENT_ID,
+		clientSecret: env.LINKEDIN_CLIENT_SECRET,
+		redirectUri: env.LINKEDIN_REDIRECT_URI,
+		tokens: tokensFrom(env, "LINKEDIN"),
+		authorUrn: env.LINKEDIN_AUTHOR_URN
+	};
+	if (env.REDDIT_CLIENT_ID && env.REDDIT_CLIENT_SECRET && env.REDDIT_USER_AGENT) config.reddit = {
+		clientId: env.REDDIT_CLIENT_ID,
+		clientSecret: env.REDDIT_CLIENT_SECRET,
+		userAgent: env.REDDIT_USER_AGENT,
+		redirectUri: env.REDDIT_REDIRECT_URI,
+		tokens: tokensFrom(env, "REDDIT")
+	};
+	if (env.TIKTOK_CLIENT_KEY && env.TIKTOK_CLIENT_SECRET) config.tiktok = {
+		clientKey: env.TIKTOK_CLIENT_KEY,
+		clientSecret: env.TIKTOK_CLIENT_SECRET,
+		redirectUri: env.TIKTOK_REDIRECT_URI,
+		tokens: tokensFrom(env, "TIKTOK")
+	};
+	if (env.TELEGRAM_BOT_TOKEN) config.telegram = {
+		botToken: env.TELEGRAM_BOT_TOKEN,
+		chatId: env.TELEGRAM_CHAT_ID
+	};
+	if (env.WHATSAPP_ACCESS_TOKEN && env.WHATSAPP_BUSINESS_ACCOUNT_ID) config.whatsapp = {
+		accessToken: env.WHATSAPP_ACCESS_TOKEN,
+		businessAccountId: env.WHATSAPP_BUSINESS_ACCOUNT_ID,
+		phoneNumberId: env.WHATSAPP_PHONE_NUMBER_ID
+	};
+	return new SocialClient(config, opts);
+}
+
+//#endregion
+export { YouTubeClient as a, LinkedInClient as c, TikTokClient as i, FacebookClient as l, WhatsAppClient as n, InstagramClient as o, TelegramClient as r, RedditClient as s, fromEnv as t, TwitterClient as u };
+//# sourceMappingURL=env-Bl0cwwjC.mjs.map