@prmichaelsen/reddit-mcp 0.1.0

package/dist/tools/listings.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RedditClient } from "../client/reddit.js";
+export declare function registerListingTools(server: McpServer, client: RedditClient): void;
+//# sourceMappingURL=listings.d.ts.map

package/dist/tools/listings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"listings.d.ts","sourceRoot":"","sources":["../../src/tools/listings.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEpE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAiCxD,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,YAAY,GACnB,IAAI,CAmKN"}

package/dist/tools/search.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RedditClient } from "../client/reddit.js";
+export declare function registerSearchTools(server: McpServer, client: RedditClient): void;
+//# sourceMappingURL=search.d.ts.map

package/dist/tools/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../src/tools/search.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEpE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAcxD,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,YAAY,GACnB,IAAI,CAiEN"}

package/dist/transport/http.d.ts

@@ -0,0 +1,7 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export interface HttpTransportOptions {
+    port: number;
+    host: string;
+}
+export declare function startHttpTransport(server: McpServer, options: HttpTransportOptions): Promise<void>;
+//# sourceMappingURL=http.d.ts.map

package/dist/transport/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../src/transport/http.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEpE,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,SAAS,EACjB,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,IAAI,CAAC,CA+Bf"}

package/dist/types/index.d.ts

@@ -0,0 +1,78 @@
+export interface RedditAuthConfig {
+    clientId: string;
+    clientSecret: string;
+    redirectUri: string;
+    userAgent: string;
+    tokenStoragePath?: string;
+}
+export interface TokenData {
+    access_token: string;
+    refresh_token: string;
+    token_type: string;
+    expires_in: number;
+    scope: string;
+    obtained_at: number;
+}
+export interface RedditApiError {
+    status: number;
+    reason: string;
+    message: string;
+}
+export interface RedditListing<T> {
+    kind: "Listing";
+    data: {
+        after: string | null;
+        before: string | null;
+        children: Array<{
+            kind: string;
+            data: T;
+        }>;
+        dist: number;
+        modhash: string;
+    };
+}
+export interface RedditPost {
+    id: string;
+    name: string;
+    title: string;
+    author: string;
+    subreddit: string;
+    subreddit_name_prefixed: string;
+    selftext: string;
+    url: string;
+    permalink: string;
+    score: number;
+    ups: number;
+    downs: number;
+    num_comments: number;
+    created_utc: number;
+    is_self: boolean;
+    over_18: boolean;
+    spoiler: boolean;
+    locked: boolean;
+    stickied: boolean;
+    link_flair_text: string | null;
+    thumbnail: string;
+}
+export interface RedditComment {
+    id: string;
+    name: string;
+    body: string;
+    author: string;
+    subreddit: string;
+    score: number;
+    ups: number;
+    downs: number;
+    created_utc: number;
+    parent_id: string;
+    link_id: string;
+    is_submitter: boolean;
+    stickied: boolean;
+    distinguished: string | null;
+}
+export interface RateLimitInfo {
+    remaining: number;
+    used: number;
+    resetSeconds: number;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,SAAS;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,aAAa,CAAC,CAAC;IAC9B,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE;QACJ,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;QACrB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;QACtB,QAAQ,EAAE,KAAK,CAAC;YACd,IAAI,EAAE,MAAM,CAAC;YACb,IAAI,EAAE,CAAC,CAAC;SACT,CAAC,CAAC;QACH,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;CACH;AAED,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,uBAAuB,EAAE,MAAM,CAAC;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,EAAE,OAAO,CAAC;IAClB,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,OAAO,CAAC;IACtB,QAAQ,EAAE,OAAO,CAAC;IAClB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B;AAED,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;CACtB"}

package/esbuild.build.js

@@ -0,0 +1,21 @@
+import { build } from "esbuild";
+import { execSync } from "child_process";
+
+await build({
+  entryPoints: ["src/index.ts", "src/server.ts", "src/factory.ts"],
+  bundle: true,
+  platform: "node",
+  target: "node20",
+  format: "esm",
+  outdir: "dist",
+  sourcemap: true,
+  external: [],
+  banner: {
+    js: "import { createRequire } from 'module'; const require = createRequire(import.meta.url);",
+  },
+});
+
+// Generate .d.ts declaration files
+execSync("tsc --emitDeclarationOnly", { stdio: "inherit" });
+
+console.log("Build complete");

package/jest.config.js

@@ -0,0 +1,18 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+export default {
+  preset: "ts-jest/presets/default-esm",
+  testEnvironment: "node",
+  extensionsToTreatAsEsm: [".ts"],
+  moduleNameMapper: {
+    "^(\\.{1,2}/.*)\\.js$": "$1",
+  },
+  transform: {
+    "^.+\\.tsx?$": [
+      "ts-jest",
+      {
+        useESM: true,
+      },
+    ],
+  },
+  testMatch: ["**/tests/**/*.test.ts"],
+};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@prmichaelsen/reddit-mcp",
+  "version": "0.1.0",
+  "description": "MCP server wrapping the Reddit API for AI agents",
+  "main": "dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js"
+    },
+    "./factory": {
+      "types": "./dist/factory.d.ts",
+      "import": "./dist/factory.js"
+    }
+  },
+  "type": "module",
+  "scripts": {
+    "build": "node esbuild.build.js",
+    "dev": "tsx watch src/index.ts",
+    "start": "node dist/index.js",
+    "test": "node --experimental-vm-modules node_modules/.bin/jest",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "reddit",
+    "reddit-api",
+    "ai-agent"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/node": "^25.4.0",
+    "esbuild": "^0.27.3",
+    "jest": "^30.2.0",
+    "ts-jest": "^29.4.6",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  }
+}

package/src/auth/oauth.ts

@@ -0,0 +1,200 @@
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { dirname } from "node:path";
+import type { RedditAuthConfig, TokenData } from "../types/index.js";
+
+export class RedditAuth {
+  private config: RedditAuthConfig;
+  private tokenData: TokenData | null = null;
+
+  constructor(config: RedditAuthConfig) {
+    this.config = config;
+  }
+
+  getAuthUrl(scopes: string[]): string {
+    const params = new URLSearchParams({
+      client_id: this.config.clientId,
+      response_type: "code",
+      state: crypto.randomUUID(),
+      redirect_uri: this.config.redirectUri,
+      duration: "permanent",
+      scope: scopes.join(" "),
+    });
+    return `https://www.reddit.com/api/v1/authorize?${params.toString()}`;
+  }
+
+  async exchangeCode(code: string): Promise<TokenData> {
+    const response = await fetch(
+      "https://www.reddit.com/api/v1/access_token",
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          Authorization: `Basic ${Buffer.from(`${this.config.clientId}:${this.config.clientSecret}`).toString("base64")}`,
+          "User-Agent": this.config.userAgent,
+        },
+        body: new URLSearchParams({
+          grant_type: "authorization_code",
+          code,
+          redirect_uri: this.config.redirectUri,
+        }),
+      },
+    );
+
+    if (!response.ok) {
+      throw new Error(
+        `Token exchange failed: ${response.status} ${response.statusText}`,
+      );
+    }
+
+    const data = (await response.json()) as Record<string, unknown>;
+
+    if (data.error) {
+      throw new Error(`Token exchange error: ${data.error}`);
+    }
+
+    this.tokenData = {
+      access_token: data.access_token as string,
+      refresh_token: data.refresh_token as string,
+      token_type: data.token_type as string,
+      expires_in: data.expires_in as number,
+      scope: data.scope as string,
+      obtained_at: Date.now(),
+    };
+
+    await this.storeTokens();
+    return this.tokenData;
+  }
+
+  async getAccessToken(): Promise<string> {
+    if (!this.tokenData) {
+      await this.loadStoredTokens();
+    }
+
+    if (!this.tokenData) {
+      throw new Error(
+        "No credentials available. Run OAuth authorization flow first.",
+      );
+    }
+
+    // Refresh if token expires within 5 minutes
+    const expiresAt =
+      this.tokenData.obtained_at + this.tokenData.expires_in * 1000;
+    const fiveMinutes = 5 * 60 * 1000;
+
+    if (Date.now() > expiresAt - fiveMinutes) {
+      await this.refreshToken();
+    }
+
+    return this.tokenData.access_token;
+  }
+
+  hasStoredCredentials(): boolean {
+    const storagePath =
+      this.config.tokenStoragePath || "./.tokens/reddit.json";
+    return existsSync(storagePath);
+  }
+
+  private async refreshToken(): Promise<void> {
+    if (!this.tokenData?.refresh_token) {
+      throw new Error("No refresh token available");
+    }
+
+    const response = await fetch(
+      "https://www.reddit.com/api/v1/access_token",
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          Authorization: `Basic ${Buffer.from(`${this.config.clientId}:${this.config.clientSecret}`).toString("base64")}`,
+          "User-Agent": this.config.userAgent,
+        },
+        body: new URLSearchParams({
+          grant_type: "refresh_token",
+          refresh_token: this.tokenData.refresh_token,
+        }),
+      },
+    );
+
+    if (!response.ok) {
+      throw new Error(
+        `Token refresh failed: ${response.status} ${response.statusText}`,
+      );
+    }
+
+    const data = (await response.json()) as Record<string, unknown>;
+
+    if (data.error) {
+      throw new Error(`Token refresh error: ${data.error}`);
+    }
+
+    this.tokenData = {
+      access_token: data.access_token as string,
+      refresh_token:
+        (data.refresh_token as string) || this.tokenData.refresh_token,
+      token_type: data.token_type as string,
+      expires_in: data.expires_in as number,
+      scope: data.scope as string,
+      obtained_at: Date.now(),
+    };
+
+    await this.storeTokens();
+  }
+
+  private async storeTokens(): Promise<void> {
+    if (!this.tokenData) return;
+
+    const storagePath =
+      this.config.tokenStoragePath || "./.tokens/reddit.json";
+    const dir = dirname(storagePath);
+
+    if (!existsSync(dir)) {
+      await mkdir(dir, { recursive: true });
+    }
+
+    await writeFile(storagePath, JSON.stringify(this.tokenData, null, 2), {
+      mode: 0o600,
+    });
+  }
+
+  private async loadStoredTokens(): Promise<void> {
+    const storagePath =
+      this.config.tokenStoragePath || "./.tokens/reddit.json";
+
+    if (!existsSync(storagePath)) return;
+
+    try {
+      const content = await readFile(storagePath, "utf-8");
+      this.tokenData = JSON.parse(content) as TokenData;
+    } catch {
+      // Corrupted token file, ignore
+      this.tokenData = null;
+    }
+  }
+}
+
+export function createAuthFromEnv(): RedditAuth {
+  const clientId = process.env.REDDIT_CLIENT_ID;
+  const clientSecret = process.env.REDDIT_CLIENT_SECRET;
+  const redirectUri =
+    process.env.REDDIT_REDIRECT_URI || "http://localhost:8080/callback";
+  const userAgent =
+    process.env.REDDIT_USER_AGENT ||
+    "nodejs:reddit-mcp:v0.1.0 (by /u/unknown)";
+  const tokenStoragePath =
+    process.env.TOKEN_STORAGE_PATH || "./.tokens/reddit.json";
+
+  if (!clientId || !clientSecret) {
+    throw new Error(
+      "REDDIT_CLIENT_ID and REDDIT_CLIENT_SECRET environment variables are required",
+    );
+  }
+
+  return new RedditAuth({
+    clientId,
+    clientSecret,
+    redirectUri,
+    userAgent,
+    tokenStoragePath,
+  });
+}

package/src/client/reddit.ts

@@ -0,0 +1,245 @@
+import type { RedditAuth } from "../auth/oauth.js";
+import type { RateLimitInfo } from "../types/index.js";
+
+export class RedditApiError extends Error {
+  constructor(
+    public status: number,
+    public reason: string,
+    message: string,
+  ) {
+    super(message);
+    this.name = "RedditApiError";
+  }
+}
+
+export class RedditClient {
+  private auth: RedditAuth | null;
+  private accessToken: string | null;
+  private userAgent: string;
+  private rateLimitInfo: RateLimitInfo | null = null;
+
+  constructor(auth: RedditAuth | string, userAgent?: string) {
+    if (typeof auth === "string") {
+      this.auth = null;
+      this.accessToken = auth;
+    } else {
+      this.auth = auth;
+      this.accessToken = null;
+    }
+    this.userAgent =
+      userAgent ||
+      process.env.REDDIT_USER_AGENT ||
+      "nodejs:reddit-mcp:v0.1.0 (by /u/unknown)";
+  }
+
+  async get<T>(
+    path: string,
+    params?: Record<string, string | undefined>,
+  ): Promise<T> {
+    return this.request<T>("GET", path, params);
+  }
+
+  async post<T>(
+    path: string,
+    body?: Record<string, string | undefined>,
+  ): Promise<T> {
+    return this.request<T>("POST", path, undefined, body);
+  }
+
+  async patch<T>(
+    path: string,
+    body?: Record<string, unknown>,
+  ): Promise<T> {
+    return this.requestJson<T>("PATCH", path, body);
+  }
+
+  async put<T>(
+    path: string,
+    body?: Record<string, unknown>,
+  ): Promise<T> {
+    return this.requestJson<T>("PUT", path, body);
+  }
+
+  async delete<T>(path: string): Promise<T> {
+    return this.request<T>("DELETE", path);
+  }
+
+  getRateLimitInfo(): RateLimitInfo | null {
+    return this.rateLimitInfo;
+  }
+
+  private async getToken(): Promise<string> {
+    if (this.accessToken) return this.accessToken;
+    if (this.auth) return this.auth.getAccessToken();
+    throw new Error("No authentication configured");
+  }
+
+  private async request<T>(
+    method: string,
+    path: string,
+    params?: Record<string, string | undefined>,
+    body?: Record<string, string | undefined>,
+  ): Promise<T> {
+    return this.executeWithRetry<T>(async () => {
+      const token = await this.getToken();
+      let url = `https://oauth.reddit.com${path}`;
+
+      if (params) {
+        const filtered = Object.entries(params).filter(
+          ([, v]) => v !== undefined,
+        ) as [string, string][];
+        if (filtered.length > 0) {
+          url += `?${new URLSearchParams(filtered).toString()}`;
+        }
+      }
+
+      const headers: Record<string, string> = {
+        Authorization: `Bearer ${token}`,
+        "User-Agent": this.userAgent,
+      };
+
+      const init: RequestInit = { method, headers };
+
+      if (body) {
+        headers["Content-Type"] = "application/x-www-form-urlencoded";
+        const filtered = Object.entries(body).filter(
+          ([, v]) => v !== undefined,
+        ) as [string, string][];
+        init.body = new URLSearchParams(filtered).toString();
+      }
+
+      const response = await fetch(url, init);
+      this.parseRateLimitHeaders(response);
+
+      if (!response.ok) {
+        throw await this.createError(response);
+      }
+
+      return (await response.json()) as T;
+    });
+  }
+
+  private async requestJson<T>(
+    method: string,
+    path: string,
+    body?: Record<string, unknown>,
+  ): Promise<T> {
+    return this.executeWithRetry<T>(async () => {
+      const token = await this.getToken();
+      const url = `https://oauth.reddit.com${path}`;
+
+      const headers: Record<string, string> = {
+        Authorization: `Bearer ${token}`,
+        "User-Agent": this.userAgent,
+        "Content-Type": "application/json",
+      };
+
+      const init: RequestInit = { method, headers };
+      if (body) {
+        init.body = JSON.stringify(body);
+      }
+
+      const response = await fetch(url, init);
+      this.parseRateLimitHeaders(response);
+
+      if (!response.ok) {
+        throw await this.createError(response);
+      }
+
+      return (await response.json()) as T;
+    });
+  }
+
+  private async executeWithRetry<T>(
+    fn: () => Promise<T>,
+    maxRetries = 3,
+  ): Promise<T> {
+    let lastError: Error | undefined;
+
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        return await fn();
+      } catch (error) {
+        lastError = error as Error;
+
+        if (error instanceof RedditApiError) {
+          // Don't retry client errors (except 429)
+          if (error.status < 500 && error.status !== 429) {
+            throw error;
+          }
+
+          // For 429, wait for rate limit reset
+          if (error.status === 429 && this.rateLimitInfo) {
+            const waitMs = this.rateLimitInfo.resetSeconds * 1000;
+            await this.delay(Math.min(waitMs, 30000));
+            continue;
+          }
+        }
+
+        if (attempt < maxRetries) {
+          // Exponential backoff: 1s, 2s, 4s
+          await this.delay(Math.pow(2, attempt) * 1000);
+        }
+      }
+    }
+
+    throw lastError!;
+  }
+
+  private parseRateLimitHeaders(response: Response): void {
+    const remaining = response.headers.get("x-ratelimit-remaining");
+    const used = response.headers.get("x-ratelimit-used");
+    const reset = response.headers.get("x-ratelimit-reset");
+
+    if (remaining !== null || used !== null || reset !== null) {
+      this.rateLimitInfo = {
+        remaining: remaining ? parseFloat(remaining) : 0,
+        used: used ? parseInt(used, 10) : 0,
+        resetSeconds: reset ? parseInt(reset, 10) : 0,
+      };
+    }
+  }
+
+  private async createError(response: Response): Promise<RedditApiError> {
+    let reason = "unknown";
+    let message = `Reddit API error: ${response.status} ${response.statusText}`;
+
+    try {
+      const body = (await response.json()) as Record<string, unknown>;
+      if (body.error) reason = String(body.error);
+      if (body.message) message = String(body.message);
+      if (body.reason) reason = String(body.reason);
+    } catch {
+      // Response body not JSON
+    }
+
+    switch (response.status) {
+      case 400:
+        message = `Bad request: ${reason}`;
+        break;
+      case 401:
+        message =
+          "Unauthorized: Access token expired or invalid. Re-authenticate.";
+        break;
+      case 403:
+        message = `Forbidden: Missing required OAuth scope or banned. ${reason}`;
+        break;
+      case 404:
+        message = "Not found: The requested resource does not exist.";
+        break;
+      case 429:
+        message = `Rate limited: Too many requests. Reset in ${this.rateLimitInfo?.resetSeconds ?? "unknown"}s.`;
+        break;
+      default:
+        if (response.status >= 500) {
+          message = `Reddit server error (${response.status}): Try again later.`;
+        }
+    }
+
+    return new RedditApiError(response.status, reason, message);
+  }
+
+  private delay(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}

package/src/factory.ts

@@ -0,0 +1,5 @@
+import { createServerWithToken } from "./server.js";
+
+export function createServer(accessToken: string) {
+  return createServerWithToken(accessToken);
+}

package/src/index.ts

@@ -0,0 +1,31 @@
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createServer } from "./server.js";
+import { createAuthFromEnv } from "./auth/oauth.js";
+import { startHttpTransport } from "./transport/http.js";
+
+const args = process.argv.slice(2);
+
+function getArg(name: string): string | undefined {
+  const index = args.indexOf(`--${name}`);
+  if (index !== -1 && index + 1 < args.length) {
+    return args[index + 1];
+  }
+  return undefined;
+}
+
+const transport = getArg("transport") || process.env.TRANSPORT || "stdio";
+const port = parseInt(
+  getArg("port") || process.env.HTTP_PORT || "3000",
+  10,
+);
+const host = getArg("host") || process.env.HTTP_HOST || "localhost";
+
+const auth = createAuthFromEnv();
+const server = createServer(auth);
+
+if (transport === "http") {
+  await startHttpTransport(server, { port, host });
+} else {
+  const stdioTransport = new StdioServerTransport();
+  await server.connect(stdioTransport);
+}