chore: docs and lint

README.md

···
 Your `.env` file should look like this:
 
 ```bash
-SLACK_TOKEN=xoxb-123456789012-123456789012-123456789012-123456789012
+# Either SLACK_BOT_TOKEN or SLACK_TOKEN works (SLACK_BOT_TOKEN takes precedence)
+SLACK_BOT_TOKEN=xoxb-your-bot-token-here
 SLACK_SIGNING_SECRET=12345678901234567890123456789012
 NODE_ENV=production
+BEARER_TOKEN=your-secure-random-token-here # Required for admin endpoints
 SENTRY_DSN="https://[e-mail]/123456" # Optional
 DATABASE_PATH=/path/to/db.sqlite # Optional
 PORT=3000 # Optional
+
+# Optional: Slack rate limiting (adjust if hitting rate limits)
+# SLACK_MAX_CONCURRENT=3    # Max concurrent requests (default: 3)
+# SLACK_MIN_TIME_MS=200     # Min ms between requests (default: 200)
 ```
 
 The slack app can be created from the [`manifest.yaml`](./manifest.yaml) in this repo. It just needs the `emoji:read` and `users:read` scopes.
···
 // Analytics data access
 const stats = await cache.getEssentialStats(7);
 const chartData = await cache.getChartData(7);
-const userAgents = await cache.getUserAgents(7);
+const userAgents = await cache.getUserAgents();
 ```
 
 The final bit was at this point a bit of a ridiculous one. I didn't like how heavyweight the `bolt` or `slack-edge` packages were so I rolled my own slack api wrapper. It's again fully typed and designed to be as lightweight as possible. The background user update queue processes up to 3 users every 30 seconds to respect Slack's rate limits.
 
 ```typescript
-const slack = new Slack(
-  process.env.SLACK_TOKEN,
+const slack = new SlackWrapper(
+  process.env.SLACK_BOT_TOKEN,
   process.env.SLACK_SIGNING_SECRET,
 );
 
-const user = await slack.getUser("U062UG485EE");
-const emojis = await slack.getEmoji();
+const user = await slack.getUserInfo("U062UG485EE");
+const emojis = await slack.getEmojiList();
 
 // Manually purge a specific user's cache using the API endpoint
 const response = await fetch(
···
 ```typescript
 // src/migrations/myNewMigration.ts
 import { Database } from "bun:sqlite";
-import { Migration } from "./types";
+import type { Migration } from "./types";
 
 export const myNewMigration: Migration = {
   version: "0.3.2", // Should match package.json version

src/cache.ts

···
 			averageResponseTime: number;
 		}>;
 		averageResponseTime: number | null;
-		topUserAgents: Array<{ userAgent: string; count: number }>;
+		topUserAgents: Array<{ userAgent: string; hits: number }>;
 		latencyAnalytics: {
 			percentiles: {
 				p50: number | null;
···
 		const topUserAgents = this.db
 			.query(
 				`
-         SELECT user_agent as userAgent, hits as count
+         SELECT user_agent as userAgent, hits
          FROM user_agent_stats
          WHERE user_agent IS NOT NULL
          ORDER BY hits DESC
          LIMIT 50
        `,
 			)
-			.all() as Array<{ userAgent: string; count: number }>;
+			.all() as Array<{ userAgent: string; hits: number }>;
 
 		// Simplified latency analytics from bucket data
 		const percentiles = {
···
 				peakDayRequests: peakDayData?.count || 0,
 			},
 			dashboardMetrics: {
-				statsRequests: statsResult.count,
-				totalWithStats: totalCount + statsResult.count,
+				statsRequests: statsResult.count ?? 0,
+				totalWithStats: totalCount + (statsResult.count ?? 0),
 			},
 			trafficOverview,
 		};

src/migrations/index.ts

···
 import { bucketAnalyticsMigration } from "./bucketAnalyticsMigration";
 import { endpointGroupingMigration } from "./endpointGroupingMigration";
 import { logGroupingMigration } from "./logGroupingMigration";
-import { Migration } from "./types";
+import type { Migration } from "./types";
 
 // Export all migrations
 export const migrations = [
···
 ];
 
 // Export the migration types
-export { Migration };
+export type { Migration };

src/migrations/migrationManager.ts

···
 		if (parts.length !== 3) return null;
 
 		const [major, minor, patch] = parts.map(Number);
+		if (major === undefined || minor === undefined || patch === undefined) {
+			return null;
+		}
 
 		// If patch > 0, decrement patch
 		if (patch > 0) {
 			return `${major}.${minor}.${patch - 1}`;
 		}
 		// If minor > 0, decrement minor and set patch to 0
-		else if (minor > 0) {
+		if (minor > 0) {
 			return `${major}.${minor - 1}.0`;
 		}
 		// If major > 0, decrement major and set minor and patch to 0
-		else if (major > 0) {
+		if (major > 0) {
 			return `${major - 1}.0.0`;
 		}
 
···
 		const partsB = b.split(".").map(Number);
 
 		for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
-			const partA = i < partsA.length ? partsA[i] : 0;
-			const partB = i < partsB.length ? partsB[i] : 0;
+			const partA = partsA[i] ?? 0;
+			const partB = partsB[i] ?? 0;
 
 			if (partA < partB) return -1;
 			if (partA > partB) return 1;