@classytic/social 0.1.0

package/dist/providers/reddit.mjs

@@ -0,0 +1,657 @@
+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 RedditCredentialsSchema } from "../reddit-B10kS4Se.mjs";
+import { t as REDDIT_ERROR_HINTS } from "../types-CJrHMDV9.mjs";
+
+//#region src/providers/reddit/index.ts
+/**
+* Reddit Provider
+* ===============
+* Full Reddit API integration with OAuth 2.0.
+*
+* Supports:
+* - OAuth 2.0 (authorization code with permanent duration)
+* - Post CRUD (create text/link/image, get, delete, search)
+* - Comments (create, reply, delete, list)
+* - Voting (upvote, downvote, unvote)
+* - Subreddit info and rules
+* - User profile and public user data
+* - Subreddit browsing (hot, new, top, rising)
+*
+* @see https://www.reddit.com/dev/api/
+* @see https://github.com/reddit-archive/reddit/wiki/OAuth2
+*/
+const OAUTH_API = "https://oauth.reddit.com";
+const PUBLIC_API = "https://www.reddit.com";
+const AUTH_URL = "https://www.reddit.com/api/v1/authorize";
+const TOKEN_URL = "https://www.reddit.com/api/v1/access_token";
+const REVOKE_URL = "https://www.reddit.com/api/v1/revoke_token";
+const USER_AGENT = "web:com.classytic.social:v0.1.0 (by /u/classytic)";
+const DEFAULT_SCOPES = [
+	"identity",
+	"edit",
+	"history",
+	"mysubreddits",
+	"read",
+	"save",
+	"submit",
+	"vote",
+	"subscribe",
+	"privatemessages",
+	"flair"
+];
+const SCOPE_DESCRIPTIONS = {
+	"identity": "Access your Reddit username and account information",
+	"edit": "Edit your posts and comments",
+	"history": "Access your voting and browsing history",
+	"mysubreddits": "View your subscribed subreddits",
+	"read": "Read posts, comments, and subreddit information",
+	"save": "Save and unsave posts and comments",
+	"submit": "Create new posts and comments",
+	"vote": "Upvote and downvote content",
+	"subscribe": "Subscribe and unsubscribe from subreddits",
+	"privatemessages": "Read and send private messages",
+	"flair": "Set and manage flair on posts"
+};
+var RedditProvider = class extends PlatformProvider {
+	constructor(config = {}) {
+		super(config);
+		this.name = "reddit";
+		this.displayName = "Reddit";
+		this.authType = "oauth2";
+	}
+	getAuthUrl(state, credData, options) {
+		const clientId = credData?.clientId;
+		if (!clientId) throw new SocialError("reddit", "Client ID is required", { statusCode: 400 });
+		const redirectUri = credData?.redirectUri || this.config.redirectUri || `http://localhost:${this.config.port || 8060}/api/oauth/reddit/callback`;
+		return `${AUTH_URL}?${new URLSearchParams({
+			client_id: clientId,
+			response_type: "code",
+			state,
+			redirect_uri: redirectUri,
+			duration: "permanent",
+			scope: DEFAULT_SCOPES.join(" ")
+		}).toString()}`;
+	}
+	async exchangeCode(code, credData) {
+		const clientId = credData?.clientId;
+		const clientSecret = credData?.clientSecret;
+		if (!clientId || !clientSecret) throw new SocialError("reddit", "Client ID and Client Secret are required for token exchange", { statusCode: 400 });
+		const redirectUri = credData?.redirectUri || this.config.redirectUri || `http://localhost:${this.config.port || 8060}/api/oauth/reddit/callback`;
+		const body = new URLSearchParams({
+			grant_type: "authorization_code",
+			code,
+			redirect_uri: redirectUri
+		});
+		const response = await fetch(TOKEN_URL, {
+			method: "POST",
+			headers: {
+				"Authorization": `Basic ${btoa(`${clientId}:${clientSecret}`)}`,
+				"Content-Type": "application/x-www-form-urlencoded",
+				"User-Agent": USER_AGENT
+			},
+			body: body.toString()
+		});
+		const data = await response.json();
+		if (!response.ok || data.error) throw new SocialError("reddit", `Token exchange failed: ${data.error || response.statusText}`, {
+			statusCode: response.status,
+			errorCode: data.error,
+			hint: REDDIT_ERROR_HINTS["INVALID_GRANT"] || "Ensure your Client ID, Client Secret, and redirect URI are correct.",
+			originalError: new Error(JSON.stringify(data))
+		});
+		return {
+			access_token: data.access_token,
+			refresh_token: data.refresh_token,
+			expires_in: data.expires_in,
+			token_type: data.token_type,
+			scope: data.scope
+		};
+	}
+	async refreshToken(refreshToken, credData) {
+		const clientId = credData?.clientId;
+		const clientSecret = credData?.clientSecret;
+		if (!clientId || !clientSecret) throw new SocialError("reddit", "Client ID and Client Secret are required for token refresh", { statusCode: 400 });
+		const body = new URLSearchParams({
+			grant_type: "refresh_token",
+			refresh_token: refreshToken
+		});
+		const response = await fetch(TOKEN_URL, {
+			method: "POST",
+			headers: {
+				"Authorization": `Basic ${btoa(`${clientId}:${clientSecret}`)}`,
+				"Content-Type": "application/x-www-form-urlencoded",
+				"User-Agent": USER_AGENT
+			},
+			body: body.toString()
+		});
+		const data = await response.json();
+		if (!response.ok || data.error) throw new SocialError("reddit", `Token refresh failed: ${data.error || response.statusText}`, {
+			statusCode: response.status,
+			errorCode: data.error,
+			hint: "The refresh token may have been revoked. Re-authenticate."
+		});
+		return {
+			access_token: data.access_token,
+			refresh_token: data.refresh_token,
+			expires_in: data.expires_in,
+			token_type: data.token_type,
+			scope: data.scope
+		};
+	}
+	async revokeToken(accessToken, credData) {
+		const clientId = credData?.clientId;
+		const clientSecret = credData?.clientSecret;
+		if (!clientId || !clientSecret) return;
+		const body = new URLSearchParams({
+			token: accessToken,
+			token_type_hint: "access_token"
+		});
+		await fetch(REVOKE_URL, {
+			method: "POST",
+			headers: {
+				"Authorization": `Basic ${btoa(`${clientId}:${clientSecret}`)}`,
+				"Content-Type": "application/x-www-form-urlencoded",
+				"User-Agent": USER_AGENT
+			},
+			body: body.toString()
+		}).catch(() => {});
+	}
+	async getAccountInfo(accessToken) {
+		const data = await this._api("GET", "/api/v1/me", accessToken);
+		return {
+			id: data.id,
+			name: data.name,
+			username: data.name,
+			profileImage: data.icon_img?.split("?")[0] ?? null,
+			linkKarma: data.link_karma,
+			commentKarma: data.comment_karma,
+			totalKarma: data.total_karma,
+			createdUtc: data.created_utc,
+			hasVerifiedEmail: data.has_verified_email,
+			isGold: data.is_gold,
+			isMod: data.is_mod
+		};
+	}
+	async testCredential(credentialData) {
+		try {
+			const tokenData = typeof credentialData.oauthTokenData === "string" ? JSON.parse(credentialData.oauthTokenData) : credentialData.oauthTokenData;
+			if (!tokenData?.access_token) return {
+				status: "Error",
+				message: "No access token found. Complete OAuth authorization first."
+			};
+			const info = await this.getAccountInfo(tokenData.access_token);
+			return {
+				status: "OK",
+				message: `Connected as u/${info.name} (${info.totalKarma} karma)`,
+				data: {
+					id: info.id,
+					name: info.name,
+					username: info.name
+				}
+			};
+		} catch (err) {
+			return {
+				status: "Error",
+				message: err instanceof Error ? err.message : String(err)
+			};
+		}
+	}
+	/**
+	* Create a post (text, link, or image).
+	*/
+	async createPost(accessToken, params) {
+		const body = {
+			api_type: "json",
+			sr: params.subreddit,
+			title: params.title,
+			kind: params.kind,
+			resubmit: String(params.resubmit ?? true),
+			send_replies: String(params.sendReplies ?? true)
+		};
+		if (params.kind === "self" && params.text) body.text = params.text;
+		if ((params.kind === "link" || params.kind === "image") && params.url) body.url = params.url;
+		if (params.nsfw) body.nsfw = "true";
+		if (params.spoiler) body.spoiler = "true";
+		if (params.flairId) body.flair_id = params.flairId;
+		if (params.flairText) body.flair_text = params.flairText;
+		const json = (await this._api("POST", "/api/submit", accessToken, body, true)).json;
+		if (json?.errors?.length) {
+			const [errorCode, errorMsg] = json.errors[0];
+			throw new SocialError("reddit", `Post creation failed: ${errorMsg}`, {
+				statusCode: 400,
+				errorCode,
+				hint: REDDIT_ERROR_HINTS[errorCode] || null
+			});
+		}
+		const postData = json?.data;
+		return {
+			id: postData?.id ?? "",
+			name: postData?.name ?? "",
+			url: postData?.url ?? `https://reddit.com${postData?.permalink ?? ""}`
+		};
+	}
+	/**
+	* Get a single post with its comments.
+	*/
+	async getPost(accessToken, subreddit, postId) {
+		const data = await this._api("GET", `/r/${subreddit}/comments/${postId}.json`, accessToken);
+		const postRaw = data[0]?.data?.children?.[0]?.data;
+		if (!postRaw) throw new SocialError("reddit", `Post ${postId} not found in r/${subreddit}`, {
+			statusCode: 404,
+			hint: REDDIT_ERROR_HINTS["NOT_FOUND"]
+		});
+		const comments = (data[1]?.data?.children || []).filter((c) => c.kind === "t1").map((c) => this._parseComment(c.data));
+		return {
+			post: this._parsePost(postRaw),
+			comments
+		};
+	}
+	/**
+	* Delete a post or comment by fullname (t3_ or t1_ prefix).
+	*/
+	async deleteContent(accessToken, fullname) {
+		await this._api("POST", "/api/del", accessToken, { id: fullname }, true);
+		return { success: true };
+	}
+	async deletePost(accessToken, fullname) {
+		return this.deleteContent(accessToken, fullname);
+	}
+	/**
+	* Get posts from a subreddit.
+	*/
+	async getSubredditPosts(accessToken, subreddit, params = {}) {
+		const sort = params.sort || "hot";
+		const qs = new URLSearchParams();
+		if (params.limit) qs.set("limit", String(Math.min(params.limit, 100)));
+		if (params.after) qs.set("after", params.after);
+		if (params.before) qs.set("before", params.before);
+		if (params.time && (sort === "top" || sort === "controversial")) qs.set("t", params.time);
+		const queryStr = qs.toString();
+		const endpoint = `/r/${subreddit}/${sort}.json${queryStr ? `?${queryStr}` : ""}`;
+		const data = await this._api("GET", endpoint, accessToken);
+		return {
+			items: (data.data?.children || []).map((c) => this._parsePost(c.data)),
+			after: data.data?.after ?? null,
+			before: data.data?.before ?? null
+		};
+	}
+	/**
+	* Search posts across Reddit or within a specific subreddit.
+	*/
+	async searchPosts(accessToken, params) {
+		const qs = new URLSearchParams({
+			q: params.query,
+			sort: params.sort || "relevance",
+			t: params.time || "all",
+			limit: String(params.limit || 25),
+			type: params.type || "link",
+			restrict_sr: params.subreddit ? "true" : "false"
+		});
+		if (params.after) qs.set("after", params.after);
+		const base = params.subreddit ? `/r/${params.subreddit}` : "";
+		const data = await this._api("GET", `${base}/search.json?${qs.toString()}`, accessToken);
+		return {
+			items: (data.data?.children || []).map((c) => this._parsePost(c.data)),
+			after: data.data?.after ?? null,
+			before: data.data?.before ?? null
+		};
+	}
+	/**
+	* Create a comment on a post or reply to a comment.
+	*/
+	async createComment(accessToken, params) {
+		const json = (await this._api("POST", "/api/comment", accessToken, {
+			api_type: "json",
+			thing_id: params.parentFullname,
+			text: params.text
+		}, true)).json;
+		if (json?.errors?.length) {
+			const [errorCode, errorMsg] = json.errors[0];
+			throw new SocialError("reddit", `Comment creation failed: ${errorMsg}`, {
+				statusCode: 400,
+				errorCode,
+				hint: REDDIT_ERROR_HINTS[errorCode] || null
+			});
+		}
+		const commentData = json?.data?.things?.[0]?.data;
+		if (!commentData) throw new SocialError("reddit", "Unexpected response format from Reddit API", { statusCode: 502 });
+		return this._parseComment(commentData);
+	}
+	/**
+	* Get comments for a post.
+	*/
+	async getPostComments(accessToken, subreddit, postId, params = {}) {
+		const qs = new URLSearchParams();
+		if (params.limit) qs.set("limit", String(Math.min(params.limit, 100)));
+		if (params.sort) qs.set("sort", params.sort);
+		const queryStr = qs.toString();
+		return ((await this._api("GET", `/r/${subreddit}/comments/${postId}.json${queryStr ? `?${queryStr}` : ""}`, accessToken))[1]?.data?.children || []).filter((c) => c.kind === "t1").map((c) => this._parseComment(c.data));
+	}
+	/**
+	* Vote on a post or comment.
+	* @param dir - 1 = upvote, 0 = unvote, -1 = downvote
+	*/
+	async vote(accessToken, fullname, dir) {
+		await this._api("POST", "/api/vote", accessToken, {
+			id: fullname,
+			dir: String(dir)
+		}, true);
+		return { success: true };
+	}
+	/**
+	* Get subreddit information.
+	*/
+	async getSubredditInfo(accessToken, subreddit) {
+		const data = await this._api("GET", `/r/${subreddit}/about.json`, accessToken);
+		return this._parseSubreddit(data.data);
+	}
+	/**
+	* Get subreddit rules.
+	*/
+	async getSubredditRules(accessToken, subreddit) {
+		return ((await this._api("GET", `/r/${subreddit}/about/rules.json`, accessToken)).rules || []).map((r) => ({
+			kind: r.kind,
+			shortName: r.short_name,
+			description: r.description,
+			violationReason: r.violation_reason,
+			priority: r.priority,
+			createdUtc: r.created_utc
+		}));
+	}
+	/**
+	* Search for subreddits.
+	*/
+	async searchSubreddits(accessToken, query, opts = {}) {
+		const qs = new URLSearchParams({
+			query,
+			limit: String(opts.limit || 25)
+		});
+		return ((await this._api("POST", `/api/search_subreddits.json?${qs.toString()}`, accessToken, {}, true)).subreddits || []).map((s) => ({
+			id: s.name,
+			name: s.name,
+			displayName: s.name,
+			displayNamePrefixed: `r/${s.name}`,
+			title: s.name,
+			publicDescription: "",
+			subscribers: s.subscriber_count ?? 0,
+			activeUserCount: s.active_user_count ?? 0,
+			createdUtc: 0,
+			over18: false,
+			subredditType: "public",
+			iconImg: s.icon_img,
+			url: `/r/${s.name}/`
+		}));
+	}
+	/**
+	* Get authenticated user's profile details.
+	*/
+	async getProfile(accessToken, detail = "identity") {
+		if (detail === "identity") {
+			const data = await this._api("GET", "/api/v1/me", accessToken);
+			return {
+				id: data.id,
+				name: data.name,
+				iconImg: data.icon_img?.split("?")[0],
+				createdUtc: data.created_utc,
+				linkKarma: data.link_karma,
+				commentKarma: data.comment_karma,
+				totalKarma: data.total_karma,
+				isGold: data.is_gold,
+				isMod: data.is_mod,
+				hasVerifiedEmail: data.has_verified_email
+			};
+		}
+		if (detail === "karma") return {
+			id: "",
+			name: "",
+			createdUtc: 0,
+			linkKarma: 0,
+			commentKarma: 0,
+			totalKarma: 0,
+			isGold: false,
+			isMod: false,
+			hasVerifiedEmail: false,
+			subredditKarma: ((await this._api("GET", "/api/v1/me/karma", accessToken)).data || []).map((k) => ({
+				subreddit: k.sr,
+				linkKarma: k.link_karma,
+				commentKarma: k.comment_karma
+			}))
+		};
+		return {
+			id: "",
+			name: "",
+			createdUtc: 0,
+			linkKarma: 0,
+			commentKarma: 0,
+			totalKarma: 0,
+			isGold: false,
+			isMod: false,
+			hasVerifiedEmail: false,
+			...await this._api("GET", {
+				trophies: "/api/v1/me/trophies",
+				friends: "/api/v1/me/friends",
+				blocked: "/api/v1/me/blocked",
+				prefs: "/api/v1/me/prefs",
+				saved: "/user/me/saved.json"
+			}[detail], accessToken)
+		};
+	}
+	/**
+	* Get a public user's information.
+	*/
+	async getUser(accessToken, username) {
+		const user = (await this._api("GET", `/user/${username}/about.json`, accessToken)).data;
+		return {
+			id: user.id,
+			name: user.name,
+			iconImg: user.icon_img?.split("?")[0],
+			createdUtc: user.created_utc,
+			linkKarma: user.link_karma,
+			commentKarma: user.comment_karma,
+			totalKarma: (user.link_karma ?? 0) + (user.comment_karma ?? 0),
+			isGold: user.is_gold ?? false,
+			isMod: user.is_mod ?? false,
+			hasVerifiedEmail: user.has_verified_email ?? false
+		};
+	}
+	async saveContent(accessToken, fullname) {
+		await this._api("POST", "/api/save", accessToken, { id: fullname }, true);
+		return { success: true };
+	}
+	async unsaveContent(accessToken, fullname) {
+		await this._api("POST", "/api/unsave", accessToken, { id: fullname }, true);
+		return { success: true };
+	}
+	async uploadPhoto(params) {
+		const { tokens, title, caption, description } = params;
+		const imageUrl = params.videoUrl || params.imageUrl || params.url;
+		if (!imageUrl) throw new SocialError("reddit", "Image URL is required for Reddit image posts", { statusCode: 400 });
+		if (!params.subreddit) throw new SocialError("reddit", "Subreddit is required for Reddit posts", { statusCode: 400 });
+		const result = await this.createPost(tokens.access_token, {
+			subreddit: params.subreddit,
+			title: title || caption || description || "Image Post",
+			kind: "image",
+			url: imageUrl
+		});
+		return {
+			platformPostId: result.id,
+			platformUrl: result.url,
+			status: "published",
+			uploadedAt: /* @__PURE__ */ new Date()
+		};
+	}
+	async sendMessage(accessToken, subreddit, text) {
+		return this.createPost(accessToken, {
+			subreddit,
+			title: text.substring(0, 300),
+			kind: "self",
+			text
+		});
+	}
+	getCredentialZodSchema() {
+		return RedditCredentialsSchema;
+	}
+	getCredentialSchema() {
+		return [{
+			name: "clientId",
+			displayName: "Client ID",
+			type: "text",
+			required: true,
+			description: "Reddit app Client ID from reddit.com/prefs/apps",
+			placeholder: "abc123..."
+		}, {
+			name: "clientSecret",
+			displayName: "Client Secret",
+			type: "password",
+			required: true,
+			description: "Reddit app Client Secret",
+			placeholder: "secret..."
+		}];
+	}
+	getMetadata() {
+		return {
+			name: this.name,
+			displayName: this.displayName,
+			authType: this.authType,
+			icon: "reddit",
+			brandColor: "#FF4500",
+			description: "Post to Reddit communities, browse subreddits, and manage content",
+			scopes: DEFAULT_SCOPES,
+			scopeDescriptions: SCOPE_DESCRIPTIONS,
+			setupGuide: [
+				{
+					step: 1,
+					title: "Create a Reddit App",
+					description: "Go to reddit.com/prefs/apps → \"Create another app\". Select \"web app\" type."
+				},
+				{
+					step: 2,
+					title: "Set redirect URI",
+					description: "Set the redirect URI to your callback URL (e.g., http://localhost:8060/api/oauth/reddit/callback)."
+				},
+				{
+					step: 3,
+					title: "Copy credentials",
+					description: "The Client ID is shown under the app name. The Client Secret is labeled \"secret\"."
+				},
+				{
+					step: 4,
+					title: "User-Agent",
+					description: "Reddit requires a descriptive User-Agent header. This is handled automatically by the provider."
+				}
+			],
+			supportsScheduling: false,
+			supportsEnvironment: false,
+			redirectUriPattern: "/api/oauth/reddit/callback",
+			credentialSchema: this.getCredentialSchema()
+		};
+	}
+	/**
+	* Core API request helper.
+	* Uses OAuth endpoint for authenticated requests, public endpoint otherwise.
+	*/
+	async _api(method, endpoint, accessToken, body, isForm = false) {
+		const baseUrl = accessToken ? OAUTH_API : PUBLIC_API;
+		const url = endpoint.startsWith("http") ? endpoint : `${baseUrl}${endpoint}`;
+		const result = await httpRequest("reddit", {
+			method: method.toUpperCase(),
+			url,
+			bearer: accessToken || void 0,
+			headers: { "User-Agent": USER_AGENT },
+			json: body && !isForm ? body : void 0,
+			urlencoded: body && isForm ? body : void 0,
+			timeout: 3e4,
+			retry: { attempts: 2 },
+			parseError: (raw, status) => {
+				if (raw && typeof raw === "object") {
+					const r = raw;
+					const errorReason = r.reason;
+					return {
+						message: r.message || r.error || `Reddit API error (${status})`,
+						errorCode: errorReason || r.error || null,
+						hint: REDDIT_ERROR_HINTS[String(status)] || (errorReason ? REDDIT_ERROR_HINTS[errorReason] : null) || null
+					};
+				}
+				return null;
+			}
+		});
+		return result.status === 204 ? { success: true } : result.data;
+	}
+	_parsePost(raw) {
+		return {
+			id: raw.id,
+			name: raw.name,
+			title: raw.title,
+			author: raw.author,
+			subreddit: raw.subreddit,
+			subredditId: raw.subreddit_id,
+			selftext: raw.selftext || "",
+			selftextHtml: raw.selftext_html,
+			url: raw.url,
+			permalink: `https://reddit.com${raw.permalink}`,
+			domain: raw.domain,
+			score: raw.score ?? 0,
+			ups: raw.ups ?? 0,
+			downs: raw.downs ?? 0,
+			numComments: raw.num_comments ?? 0,
+			createdUtc: raw.created_utc,
+			isSelf: raw.is_self ?? false,
+			isVideo: raw.is_video ?? false,
+			over18: raw.over_18 ?? false,
+			spoiler: raw.spoiler ?? false,
+			stickied: raw.stickied ?? false,
+			locked: raw.locked ?? false,
+			archived: raw.archived ?? false,
+			thumbnail: raw.thumbnail !== "self" && raw.thumbnail !== "default" ? raw.thumbnail : void 0,
+			linkFlairText: raw.link_flair_text,
+			authorFlairText: raw.author_flair_text,
+			mediaUrl: raw.url_overridden_by_dest || raw.url
+		};
+	}
+	_parseComment(raw) {
+		return {
+			id: raw.id,
+			name: raw.name,
+			author: raw.author,
+			body: raw.body,
+			bodyHtml: raw.body_html,
+			score: raw.score ?? 0,
+			ups: raw.ups ?? 0,
+			downs: raw.downs ?? 0,
+			createdUtc: raw.created_utc,
+			parentId: raw.parent_id,
+			linkId: raw.link_id,
+			subreddit: raw.subreddit,
+			depth: raw.depth ?? 0,
+			isSubmitter: raw.is_submitter ?? false,
+			stickied: raw.stickied ?? false,
+			edited: raw.edited ?? false,
+			permalink: `https://reddit.com${raw.permalink || ""}`
+		};
+	}
+	_parseSubreddit(raw) {
+		return {
+			id: raw.id,
+			name: raw.name,
+			displayName: raw.display_name,
+			displayNamePrefixed: raw.display_name_prefixed,
+			title: raw.title,
+			publicDescription: raw.public_description,
+			description: raw.description,
+			subscribers: raw.subscribers ?? 0,
+			activeUserCount: raw.active_user_count,
+			createdUtc: raw.created_utc,
+			over18: raw.over18 ?? false,
+			subredditType: raw.subreddit_type || "public",
+			iconImg: raw.icon_img?.split("?")[0],
+			bannerImg: raw.banner_background_image?.split("?")[0],
+			communityIcon: raw.community_icon?.split("?")[0],
+			url: raw.url
+		};
+	}
+};
+
+//#endregion
+export { RedditProvider };
+//# sourceMappingURL=reddit.mjs.map