fix: jenin changes

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

.github/workflows/docker.yml

@@ -46,8 +46,7 @@ jobs:
           
           mkdir -p apps/web/src/lib/instrumentation/
           
-          export SLACK_TOKEN=${{ secrets.SLACK_TOKEN }}
-          ./slack-import-emojis-bin
+          ./slack-import-emojis-bin default
 
           cp emojis.json apps/web/
 
@@ -63,41 +62,7 @@ jobs:
           secrets: |
             TURBO_TOKEN=${{ secrets.TURBO_TOKEN }}
             TURBO_TEAM=${{ secrets.TURBO_TEAM }}
-  db:
-    name: Push db to Docker Hub
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check out the repo
-        uses: actions/checkout@v3
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-
-      - name: Log in to Docker Hub
-        uses: docker/login-action@f4ef78c080cd8ba55a85445d5b36e214a81df20a
-        with:
-          username: ${{ secrets.DOCKER_USERNAME }}
-          password: ${{ secrets.DOCKER_PASSWORD }}
-
-      - name: Extract metadata (tags, labels) for Docker
-        id: meta
-        uses: docker/metadata-action@9ec57ed1fcdbf14dcef7dfbe97b2010124a938b7
-        with:
-          images: srizan10/hclive-db
-          tags: latest
-
-      - name: Build and push Docker image
-        uses: docker/build-push-action@v6
-        with:
-          context: .
-          file: ./packages/db/Dockerfile
-          push: true
-          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
-          platforms: linux/amd64
-          secrets: |
-            TURBO_TOKEN=${{ secrets.TURBO_TOKEN }}
-            TURBO_TEAM=${{ secrets.TURBO_TEAM }}
+            SENTRY_AUTH_TOKEN=${{ secrets.SENTRY_AUTH_TOKEN }}
   chat:
     name: Push chat module to Docker Hub
     runs-on: ubuntu-latest
@@ -134,21 +99,10 @@ jobs:
             TURBO_TOKEN=${{ secrets.TURBO_TOKEN }}
             TURBO_TEAM=${{ secrets.TURBO_TEAM }}
   deploy:
-    name: Deploy to server
+    name: Deploy to Coolify
     runs-on: ubuntu-latest
-    needs: [frontend, db, chat]
+    needs: [frontend, chat]
     steps:
-      # source https://github.com/taciturnaxolotl/cachet/blob/main/.github/workflows/deploy.yaml
-      - name: Deploy with Docker
-        uses: appleboy/ssh-action@v1
-        with:
-          host: hackclub.app
-          username: srizan
-          key: ${{ secrets.SSH_KEY }}
-          port: 22
-          script: |
-            cd ~/compose/hctv
-            docker compose pull
-            docker compose up -d --remove-orphans
-            # for some reason, without the restart, the rtmp container stops working
-            docker compose restart
+      - name: Send coolify redeploy webhook
+        run: |
+          curl -X POST -H "Authorization: Bearer ${{ secrets.COOLIFY_API_KEY }}" https://coolify.srizan.dev/api/v1/deploy?uuid=${{ secrets.COOLIFY_APP_UUID }}&force=true

.gitignore

@@ -28,6 +28,7 @@ yarn-error.log*
 # local env files
 .env*.local
 .env* 
+!.env.example
 
 # vercel
 .vercel
@@ -45,4 +46,8 @@ packages/db/generated/client
 *dist
 
 slack-import-emojis/target
-**/*/emojis.json
+**/*/emojis.json
+
+.idea
+
+/apps/docs/src/content/docs/typedoc-sdk

AGENTS.md

@@ -0,0 +1,343 @@
+# Agent Guidelines for HackClub.tv
+
+This document provides essential information for AI coding agents working on the HackClub.tv codebase.
+
+## Project Overview
+
+HackClub.tv is a live streaming platform built with Next.js 16, Prisma, and Turbo monorepo architecture.
+
+- **Monorepo**: Turborepo with pnpm workspaces
+- **Apps**: web (Next.js), chat (Hono), docs
+- **Packages**: db (Prisma), auth (Lucia), hono-ws, sdk
+- **Package Manager**: pnpm 10.6.5
+
+## Build, Lint, and Test Commands
+
+### Root Level Commands
+
+```bash
+pnpm install            # Install all dependencies
+pnpm build              # Build all apps and packages (uses Turbo)
+pnpm dev                # Start all apps in dev mode (uses Turbo)
+pnpm lint               # Lint all apps (uses Turbo)
+```
+
+### Database Commands
+
+```bash
+pnpm db:migrate         # Run Prisma migrations in dev
+pnpm prisma             # Run any Prisma command in db package
+```
+
+### App-Specific Commands
+
+```bash
+# Web app (Next.js)
+pnpm --filter=@hctv/web dev           # Start Next.js dev server
+pnpm --filter=@hctv/web build         # Build Next.js app
+pnpm --filter=@hctv/web lint          # Lint web app
+pnpm --filter=@hctv/web check-types   # Type check (tsc --noEmit)
+pnpm --filter=@hctv/web ui:add        # Add shadcn components
+
+# Chat app (Hono)
+pnpm --filter=@hctv/chat dev          # Start chat server with watch
+pnpm --filter=@hctv/chat build        # Build chat server
+
+# DB package (Prisma)
+pnpm --filter=@hctv/db db:generate    # Generate Prisma client
+pnpm --filter=@hctv/db db:migrate     # Run migrations
+pnpm --filter=@hctv/db build          # Generate client and build
+```
+
+### Running Single Tests
+
+This project does not currently have a test suite configured. When adding tests:
+
+- Use Vitest or Jest for unit tests
+- Use Playwright for E2E tests (recommended for Next.js)
+- Follow the pattern: `pnpm test -- <test-file-path>`
+
+### Docker Commands
+
+```bash
+pnpm docker:web         # Build web app Docker image
+pnpm docker:chat        # Build chat app Docker image
+pnpm r:rtmp             # Restart RTMP server
+```
+
+## Code Style Guidelines
+
+### Formatting
+
+- **Formatter**: Prettier (`.prettierrc.json`)
+- **Indentation**: 2 spaces (no tabs)
+- **Line Width**: 100 characters
+- **Quotes**: Single quotes
+- **Semicolons**: Required
+- **Trailing Commas**: ES5 style
+- **Linter**: ESLint with Next.js rules (`next/core-web-vitals`)
+
+### Import Organization
+
+Imports should be ordered as follows (no blank lines between groups):
+
+1. React/Next.js core imports
+2. Third-party libraries
+3. Internal components (`@/components`)
+4. Internal utilities/libs (`@/lib`)
+5. Package imports (`@hctv/*`)
+6. Type imports (use `import type` keyword)
+7. Relative imports
+
+```typescript
+import { useState, useEffect } from 'react';
+import { Send } from 'lucide-react';
+import { Button } from '@/components/ui/button';
+import { validateRequest } from '@/lib/auth/validate';
+import { prisma } from '@hctv/db';
+import type { User, Channel } from '@hctv/db';
+import { helper } from './utils';
+```
+
+### TypeScript Usage
+
+- **Strict mode**: Enabled
+- **Type over interface**: Use `type` for unions/intersections, `interface` for object shapes
+- **No implicit any**: Always type your variables
+- **Type imports**: Use `import type` for type-only imports
+- **Prisma types**: Import from `@hctv/db` and use type composition
+
+```typescript
+// Interfaces for props and object shapes
+interface ChatMessage {
+  user?: User;
+  message: string;
+  type: 'message' | 'systemMsg';
+}
+
+// Type aliases for complex types
+type FormFieldConfig = {
+  name: string;
+  label?: string;
+};
+
+// Prisma type composition
+type StreamWithChannel = StreamInfo & { channel: Channel };
+```
+
+### Naming Conventions
+
+**Files:**
+
+- React components: `PascalCase.tsx` (e.g., `ChatPanel.tsx`)
+- Utilities/helpers: `camelCase.ts` (e.g., `validate.ts`)
+- Next.js pages: `page.tsx`, `route.ts`, `layout.tsx`
+- Client components: `page.client.tsx`
+
+**Variables & Functions:**
+
+- Components: `PascalCase`
+- Functions: `camelCase`
+- Constants: `SCREAMING_SNAKE_CASE`
+- Booleans: Use `is`, `has`, `should` prefixes
+- Refs: `Ref` suffix (e.g., `socketRef`)
+
+```typescript
+const MESSAGE_HISTORY_SIZE = 15;
+const isFollowing = await checkFollowing();
+const socketRef = useRef<WebSocket | null>(null);
+```
+
+### Error Handling
+
+**API Routes:**
+
+- Return `Response` objects with appropriate status codes
+- Use descriptive error messages
+- Status codes: 400 (bad request), 401 (unauthorized), 403 (forbidden), 404 (not found)
+
+```typescript
+if (!user) {
+  return new Response('Unauthorized', { status: 401 });
+}
+```
+
+**Server Actions:**
+
+- Return objects with `success` boolean and `error` or `data` fields
+- Use `zodVerify` helper for validation
+
+```typescript
+const zod = await zodVerify(schema, formData);
+if (!zod.success) {
+  return { success: false, error: zod.error };
+}
+return { success: true, data: result };
+```
+
+**Client-side:**
+
+- Use try-catch for async operations
+- Use toast notifications (sonner) for user feedback
+- Log errors with `console.error`
+
+### Async Patterns
+
+- **Prefer**: async/await over Promise chains
+- **Parallel operations**: Use `Promise.all()`
+- **No .then() chaining**: Except in utility functions like fetchers
+
+```typescript
+// Standard async/await
+const data = await prisma.model.findMany();
+
+// Parallel operations
+const [channelA, channelB] = await Promise.all([
+  prisma.channel.findUnique({ where: { id: 'a' } }),
+  prisma.channel.findUnique({ where: { id: 'b' } }),
+]);
+```
+
+## React Component Patterns
+
+### Component Structure
+
+1. Directive (`'use client'` or `'use server'`)
+2. Imports
+3. Component function
+4. Helper functions (if needed)
+5. Type/interface definitions (at bottom)
+
+```typescript
+'use client';
+
+import { useState } from 'react';
+import { Button } from '@/components/ui/button';
+
+export default function ChatPanel(props: Props) {
+  const [message, setMessage] = useState('');
+
+  return <div>{/* JSX */}</div>;
+}
+
+interface Props {
+  username: string;
+}
+```
+
+### Server vs Client Components
+
+- **Server components**: Default (no directive), use for data fetching
+- **Client components**: Add `'use client'`, use for interactivity
+- Fetch data in server components, pass to client components as props
+
+## Database Patterns (Prisma)
+
+### Imports
+
+```typescript
+import { prisma } from '@hctv/db';
+import type { User, Channel, StreamInfo } from '@hctv/db';
+```
+
+### Common Queries
+
+```typescript
+// FindUnique with relations
+const channel = await prisma.channel.findUnique({
+  where: { name: channelName },
+  include: { owner: true, streamInfo: true },
+});
+
+// FindMany with dynamic filters
+const where: Prisma.StreamInfoWhereInput = {};
+if (isLive) where.isLive = true;
+const streams = await prisma.streamInfo.findMany({ where });
+
+// Create with relations
+await prisma.channel.create({
+  data: {
+    name: channelName,
+    ownerId: user.id,
+    personalFor: { connect: { id: user.id } },
+  },
+});
+
+// Update
+await prisma.streamInfo.update({
+  where: { username },
+  data: { title: newTitle },
+});
+
+// Upsert
+await prisma.streamKey.upsert({
+  create: { key: newKey, channelId },
+  update: { key: newKey },
+  where: { channelId },
+});
+```
+
+### Redis Usage
+
+```typescript
+import { getRedisConnection } from '@hctv/db';
+
+const redis = getRedisConnection();
+await redis.set('key', 'value');
+await redis.get('key');
+await redis.setex('key', 30, 'value'); // with expiry
+```
+
+## API Route Patterns
+
+### Next.js App Router
+
+```typescript
+import { validateRequest } from '@/lib/auth/validate';
+import { prisma } from '@hctv/db';
+import { NextRequest } from 'next/server';
+
+export async function GET(request: NextRequest) {
+  const { user } = await validateRequest();
+  if (!user) {
+    return new Response('Unauthorized', { status: 401 });
+  }
+
+  const searchParams = request.nextUrl.searchParams;
+  const param = searchParams.get('param');
+
+  const data = await prisma.model.findMany();
+  return Response.json(data);
+}
+```
+
+### Server Actions
+
+```typescript
+'use server';
+
+export async function createChannel(prev: any, formData: FormData) {
+  const { user } = await validateRequest();
+  if (!user) {
+    return { success: false, error: 'Unauthorized' };
+  }
+
+  const zod = await zodVerify(createChannelSchema, formData);
+  if (!zod.success) {
+    return zod;
+  }
+
+  // ... processing
+
+  return { success: true };
+}
+```
+
+## Important Notes
+
+- **Turbo caching**: Build outputs are cached. Use `--force` to bypass cache
+- **Environment variables**: Use `NEXT_PUBLIC_` prefix for client-side vars
+- **Styling**: Tailwind CSS with shadcn/ui components, use `cn()` for conditional classes
+- **Data fetching**: SWR for client-side, direct Prisma for server components
+- **Validation**: Zod schemas for form and API validation
+- **Cache invalidation**: Use `revalidatePath()` after mutations

README.md

@@ -1,7 +1,7 @@
 # hackclub.tv
 
-This is the source code for [hackclub.tv (hctv.srizan.dev)](https://hctv.srizan.dev), a livestreaming website for hackclubbers.
+This is the source code for [hackclub.tv](https://hackclub.tv), a livestreaming website for hackclubbers.
 
-Development has been ongoing for a few months, and the site is now live! There are some half-baked features, but I'm all ears for feedback.
+The development setup guide can be read at <https://docs.hackclub.tv/guides/dev/>
 
-Join [#hctv](https://hackclub.slack.com/archives/C08HGLXGXAB) on the HC Slack for discussion and updates!
+Join [#hctv](https://hackclub.slack.com/archives/C08HGLXGXAB) on the Hack Club Slack for discussion and updates!

apps/chat/Dockerfile

@@ -1,10 +1,13 @@
 FROM node:lts-alpine AS base
+ENV PNPM_HOME="/pnpm"
+ENV PATH="$PNPM_HOME:$PATH"
+RUN corepack enable
 
 FROM base AS builder
 RUN apk update
 RUN apk add --no-cache libc6-compat
 WORKDIR /app
-RUN yarn global add turbo@^2
+RUN pnpm add -g turbo@^2
 COPY . .
 
 RUN turbo prune @hctv/chat --docker
@@ -16,10 +19,10 @@ WORKDIR /app
  
 # First install the dependencies
 COPY --from=builder /app/out/json/ .
-RUN yarn install --frozen-lockfile
+RUN pnpm install --frozen-lockfile
 
 COPY --from=builder /app/out/full/ .
-RUN --mount=type=secret,id=TURBO_TOKEN --mount=type=secret,id=TURBO_TEAM TURBO_TOKEN=$(cat /run/secrets/TURBO_TOKEN) TURBO_TEAM=$(cat /run/secrets/TURBO_TEAM) yarn turbo run build --concurrency=1
+RUN --mount=type=secret,id=TURBO_TOKEN --mount=type=secret,id=TURBO_TEAM TURBO_TOKEN=$(cat /run/secrets/TURBO_TOKEN) TURBO_TEAM=$(cat /run/secrets/TURBO_TEAM) pnpm turbo run build --concurrency=1
  
 FROM base AS runner
 WORKDIR /app

apps/chat/README.md

@@ -1,8 +0,0 @@
-```
-npm install
-npm run dev
-```
-
-```
-open http://localhost:3000
-```

apps/chat/package.json

@@ -7,9 +7,9 @@
     "build": "tsc --build"
   },
   "dependencies": {
-    "@hctv/auth": "*",
-    "@hctv/db": "*",
-    "@hctv/hono-ws": "*",
+    "@hctv/auth": "workspace:*",
+    "@hctv/db": "workspace:*",
+    "@hctv/hono-ws": "workspace:*",
     "@hono/node-server": "^1.14.0",
     "@hono/node-ws": "^1.1.0",
     "@leeoniya/ufuzzy": "^1.0.18",

apps/chat/src/index.ts

@@ -5,7 +5,7 @@ import { readFile } from 'node:fs/promises';
 import { lucia } from '@hctv/auth';
 import { getCookie } from 'hono/cookie';
 import { getPersonalChannel } from './utils/personalChannel.js';
-import { getRedisConnection, prisma, type User } from '@hctv/db';
+import { getRedisConnection, prisma, type BotAccount, type BotApiKey, type User } from '@hctv/db';
 import uFuzzy from '@leeoniya/ufuzzy';
 import { randomString } from './utils/randomString.js';
 
@@ -29,61 +29,105 @@ app.get('/up', async (c) => {
 app.get(
   '/ws/:username',
   upgradeWebSocket((c) => ({
-    // https://hono.dev/helpers/websocket
     async onOpen(evt, ws) {
       const token = getCookie(c, 'auth_session');
       const grant = c.req.query('grant');
-      console.log({
-        token,
-        grant,
-      })
+      const authHeader = c.req.header('Authorization');
+      const botAuth = c.req.query('botAuth');
 
-      // random checks that actually make sense if you read trust me bro
-      if (!token && !grant) {
-        ws.close();
-        return;
-      }
-      if (!token && grant === 'null') {
+      if (!token && (!grant || grant === 'null') && !authHeader && !botAuth) {
         ws.close();
         return;
       }
 
-      let user: User | null = null
-      const dbGrant = await prisma.channel.findFirst({
-        where: {
-          obsChatGrantToken: grant,
+      let chatUser: ChatUser | null = null;
+      let personalChannel: any = null;
+
+      let apiKey: string | null = null;
+      if (authHeader && authHeader.startsWith('Bearer ')) {
+        const extractedKey = authHeader.substring(7);
+        if (extractedKey.startsWith('hctvb_')) {
+          apiKey = extractedKey;
         }
-      });
-      if (token) {
-        user = (await lucia.validateSession(token)).user;
-        const personalChannel = await getPersonalChannel(user!.id);
-        if (!personalChannel) {
-          ws.close();
-          return;
+      } else if (botAuth && typeof botAuth === 'string' && botAuth.trim().length > 0) {
+        if (botAuth.startsWith('hctvb_')) {
+          apiKey = botAuth;
         }
-        ws.personalChannel = personalChannel;
       }
-      if (!user && !dbGrant) {
+
+      if (apiKey) {
+        const botAccount = await prisma.botApiKey.findUnique({
+          where: { key: apiKey },
+          include: { botAccount: true },
+        });
+
+        if (botAccount) {
+          chatUser = {
+            id: botAccount.botAccount.id,
+            username: botAccount.botAccount.slug,
+            pfpUrl: botAccount.botAccount.pfpUrl,
+            displayName: botAccount.botAccount.displayName,
+            isBot: true,
+          };
+
+          personalChannel = {
+            id: botAccount.botAccount.id,
+            name: botAccount.botAccount.slug,
+          };
+        }
+      }
+
+      if (!chatUser && token) {
+        const session = await lucia.validateSession(token);
+        if (session.user) {
+          const userChannel = await getPersonalChannel(session.user.id);
+          if (userChannel) {
+            chatUser = {
+              id: session.user.id,
+              username: userChannel.name,
+              pfpUrl: session.user.pfpUrl,
+              isBot: false,
+            };
+            personalChannel = userChannel;
+          }
+        }
+      }
+
+      const dbGrant =
+        grant && grant !== 'null'
+          ? await prisma.channel.findFirst({
+              where: { obsChatGrantToken: grant },
+            })
+          : null;
+
+      if (!chatUser && !dbGrant) {
         ws.close();
         return;
       }
 
       const { username } = c.req.param();
-      if (dbGrant && dbGrant?.name !== username) {
+      if (dbGrant && dbGrant.name !== username) {
         ws.close();
         return;
       }
-      ws.targetUsername = username;
-      ws.user = user;
-      ws.viewerId = randomString(10);
-      if (ws.raw) {
-        ws.raw.targetUsername = username;
-        // @ts-ignore
-        ws.raw.user = user;
-        ws.raw.personalChannel = ws.personalChannel;
+
+      if (await prisma.channel.count({ where: { name: username } }) === 0) {
+        // channel doesn't exist
+        ws.close();
+        return;
+      }
+
+      ws.targetUsername = username;
+      ws.chatUser = chatUser;
+      ws.personalChannel = personalChannel;
+      ws.viewerId = randomString(10);
+
+      if (ws.raw) {
+        ws.raw.targetUsername = username;
+        ws.raw.chatUser = chatUser;
+        ws.raw.personalChannel = personalChannel;
       }
 
-      const redis = getRedisConnection();
       const channelKey = `chat:history:${username}`;
       const messages = await redis.zrange(channelKey, 0, MESSAGE_HISTORY_SIZE - 1);
 
@@ -115,114 +159,121 @@ app.get(
       await redis.del(`viewer:${ws.targetUsername}:${ws.viewerId}`);
     },
     async onMessage(evt, ws) {
-      const msg = JSON.parse(evt.data.toString());
-      if (msg.type === 'ping') {
-        await redis.setex(`viewer:${ws.targetUsername}:${ws.viewerId}`, 30, '1');
-        ws.send(
-          JSON.stringify({
-            type: 'pong',
-          })
-        );
-        return;
-      }
-      if (msg.type === 'message') {
-        if (!ws.personalChannel) return;
-        const message = (msg.message as string).trim();
-        const msgObj = {
-          user: {
-            id: ws.user.id,
-            username: ws.personalChannel.name,
-            pfpUrl: ws.user.pfpUrl,
-          },
-          message,
-        };
-        
-        // Save to Redis without the type field to maintain compatibility
-        const redisObj = {
-          user: msgObj.user,  
-          message: msgObj.message,
-          type: 'message',
-        };
-        const redisStr = JSON.stringify(redisObj);
-        const msgStr = JSON.stringify(msgObj);
+      try {
+        const msg = JSON.parse(evt.data.toString());
 
-        const channelKey = `chat:history:${ws.targetUsername}`;
-        await redis.zadd(channelKey, Date.now(), redisStr);
-        await redis.zremrangebyrank(channelKey, 0, -MESSAGE_HISTORY_SIZE - 1);
-        await redis.expire(channelKey, MESSAGE_TTL);
+        if (msg.type === 'ping') {
+          await redis.setex(`viewer:${ws.targetUsername}:${ws.viewerId}`, 30, '1');
+          ws.send(JSON.stringify({ type: 'pong' }));
+          return;
+        }
 
-        ws.wss.clients.forEach((c) => {
-          const client = c as ModifiedWebSocket;
-          if (client.readyState === client.OPEN && client.targetUsername === ws.targetUsername) {
-            c.send(msgStr);
-          }
-        });
-      }
-      if (msg.type === 'emojiMsg') {
-        const emojis = msg.emojis as string[];
-        const emojiMap: Record<string, string> = {};
+        if (msg.type === 'message') {
+          if (!ws.chatUser || !ws.personalChannel) return;
 
-        await Promise.all(
-          emojis.map(async (emoji) => {
-            let url = await redis.hget('emojis', emoji);
-            
-            if (!url) {
-              url = await redis.hget(`emojis:${emoji}`, 'url');
+          const message = (msg.message as string).trim();
+          const msgObj = {
+            user: {
+              id: ws.chatUser.id,
+              username: ws.chatUser.username,
+              pfpUrl: ws.chatUser.pfpUrl,
+              displayName: ws.chatUser.displayName,
+              isBot: ws.chatUser.isBot || false,
+            },
+            message,
+            msgId: `${crypto.randomUUID()}`
+          };
+
+          const redisObj = {
+            user: msgObj.user,
+            message: msgObj.message,
+            type: 'message',
+            msgId: `${crypto.randomUUID()}`,
+          };
+
+          const redisStr = JSON.stringify(redisObj);
+          const msgStr = JSON.stringify(msgObj);
+
+          const channelKey = `chat:history:${ws.targetUsername}`;
+          await redis.zadd(channelKey, Date.now(), redisStr);
+          await redis.zremrangebyrank(channelKey, 0, -MESSAGE_HISTORY_SIZE - 1);
+          await redis.expire(channelKey, MESSAGE_TTL);
+
+          ws.wss.clients.forEach((c) => {
+            const client = c as ModifiedWebSocket;
+            if (client.readyState === client.OPEN && client.targetUsername === ws.targetUsername) {
+              c.send(msgStr);
             }
-            if (!url) {
-              url = await redis.hget(`emoji:${emoji}`, 'url');
-            }
-            
-            emojiMap[emoji] = url ?? '';
-          })
-        );
+          });
+        }
+        if (msg.type === 'emojiMsg') {
+          const emojis = msg.emojis as string[];
+          const emojiMap: Record<string, string> = {};
 
-        ws.send(
-          JSON.stringify({
-            type: 'emojiMsgResponse',
-            emojis: emojiMap,
-          })
-        );
-      }
-      if (msg.type === 'emojiSearch') {
-        console.log('emoji search request:', msg);
-        const searchTerm = msg.searchTerm as string;
+          await Promise.all(
+            emojis.map(async (emoji) => {
+              let url = await redis.hget('emojis', emoji);
 
-        const emojis = await redis.hgetall('emojis');
-        const emojiKeys = Object.keys(emojis);
-        const idxs = uf.filter(emojiKeys, searchTerm);
-        console.log(`Emoji search for "${searchTerm}" found ${idxs?.length || 0} results.`);
-        
-        if (idxs && idxs.length > 0) {
-          const results: string[] = [];
-          
-          if (idxs.length <= 150) {
-            const info = uf.info(idxs, emojiKeys, searchTerm);
-            const order = uf.sort(info, emojiKeys, searchTerm);
-            for (let i = 0; i < order.length && i < 10; i++) {
-              results.push(emojiKeys[idxs[order[i]]]);
-            }
-          } else {
-            for (let i = 0; i < idxs.length && i < 10; i++) {
-              results.push(emojiKeys[idxs[i]]);
-            }
-          }
-          
-          ws.send(
-            JSON.stringify({
-              type: 'emojiSearchResponse',
-              results: results,
+              if (!url) {
+                url = await redis.hget(`emojis:${emoji}`, 'url');
+              }
+              if (!url) {
+                url = await redis.hget(`emoji:${emoji}`, 'url');
+              }
+
+              emojiMap[emoji] = url ?? '';
             })
           );
-          console.log(`Sending emoji search results: ${results.join(', ')}`);
-        } else {
+
           ws.send(
             JSON.stringify({
-              type: 'emojiSearchResponse',
-              results: [],
+              type: 'emojiMsgResponse',
+              emojis: emojiMap,
             })
           );
         }
+        if (msg.type === 'emojiSearch') {
+          console.log('emoji search request:', msg);
+          const searchTerm = msg.searchTerm as string;
+
+          const emojis = await redis.hgetall('emojis');
+          const emojiKeys = Object.keys(emojis);
+          const idxs = uf.filter(emojiKeys, searchTerm);
+          console.log(`Emoji search for "${searchTerm}" found ${idxs?.length || 0} results.`);
+
+          if (idxs && idxs.length > 0) {
+            const results: string[] = [];
+
+            if (idxs.length <= 150) {
+              const info = uf.info(idxs, emojiKeys, searchTerm);
+              const order = uf.sort(info, emojiKeys, searchTerm);
+              for (let i = 0; i < order.length && i < 10; i++) {
+                results.push(emojiKeys[idxs[order[i]]]);
+              }
+            } else {
+              for (let i = 0; i < idxs.length && i < 10; i++) {
+                results.push(emojiKeys[idxs[i]]);
+              }
+            }
+
+            ws.send(
+              JSON.stringify({
+                type: 'emojiSearchResponse',
+                results: results,
+              })
+            );
+            console.log(`Sending emoji search results: ${results.join(', ')}`);
+          } else {
+            ws.send(
+              JSON.stringify({
+                type: 'emojiSearchResponse',
+                results: [],
+              })
+            );
+          }
+        }
+      } catch (e) {
+        console.error('Error processing message:', e);
       }
     },
   }))
@@ -238,3 +289,11 @@ const server = serve(
   }
 );
 injectWebSocket(server);
+
+interface ChatUser {
+  id: string;
+  username: string;
+  pfpUrl: string;
+  displayName?: string;
+  isBot: boolean;
+}

apps/docs/README.md

@@ -1,49 +0,0 @@
-# Starlight Starter Kit: Basics
-
-[![Built with Starlight](https://astro.badg.es/v2/built-with-starlight/tiny.svg)](https://starlight.astro.build)
-
-```
-yarn create astro@latest -- --template starlight
-```
-
-> 🧑‍🚀 **Seasoned astronaut?** Delete this file. Have fun!
-
-## 🚀 Project Structure
-
-Inside of your Astro + Starlight project, you'll see the following folders and files:
-
-```
-.
-├── public/
-├── src/
-│   ├── assets/
-│   ├── content/
-│   │   └── docs/
-│   └── content.config.ts
-├── astro.config.mjs
-├── package.json
-└── tsconfig.json
-```
-
-Starlight looks for `.md` or `.mdx` files in the `src/content/docs/` directory. Each file is exposed as a route based on its file name.
-
-Images can be added to `src/assets/` and embedded in Markdown with a relative link.
-
-Static assets, like favicons, can be placed in the `public/` directory.
-
-## 🧞 Commands
-
-All commands are run from the root of the project, from a terminal:
-
-| Command                   | Action                                           |
-| :------------------------ | :----------------------------------------------- |
-| `yarn install`             | Installs dependencies                            |
-| `yarn dev`             | Starts local dev server at `localhost:4321`      |
-| `yarn build`           | Build your production site to `./dist/`          |
-| `yarn preview`         | Preview your build locally, before deploying     |
-| `yarn astro ...`       | Run CLI commands like `astro add`, `astro check` |
-| `yarn astro -- --help` | Get help using the Astro CLI                     |
-
-## 👀 Want to learn more?
-
-Check out [Starlight’s docs](https://starlight.astro.build/), read [the Astro documentation](https://docs.astro.build), or jump into the [Astro Discord server](https://astro.build/chat).

apps/docs/astro.config.mjs

@@ -2,24 +2,44 @@
 import { defineConfig } from 'astro/config';
 import starlight from '@astrojs/starlight';
 import mermaid from 'astro-mermaid';
-import catppuccin from "@catppuccin/starlight";
+import catppuccin from '@catppuccin/starlight';
+import starlightTypeDoc, { typeDocSidebarGroup } from 'starlight-typedoc';
 
 // https://astro.build/config
 export default defineConfig({
-	integrations: [
+  integrations: [
     mermaid({
       theme: 'base',
-      autoTheme: true
+      autoTheme: true,
     }),
-		starlight({
-			title: 'hctv docs',
-			social: [{ icon: 'github', label: 'GitHub', href: 'https://github.com/SrIzan10/hctv' }],
+    starlight({
+      title: 'hctv docs',
+      social: [{ icon: 'github', label: 'GitHub', href: 'https://github.com/SrIzan10/hctv' }],
       plugins: [
         catppuccin({
-          dark: { flavor: "mocha", accent: "blue" },
-          light: { flavor: "latte", accent: "blue" }
+          dark: { flavor: 'mocha', accent: 'blue' },
+          light: { flavor: 'latte', accent: 'blue' },
         }),
-      ]
-		}),
-	],
+        starlightTypeDoc({
+          entryPoints: ['../../packages/sdk/src/index.ts'],
+          tsconfig: '../../packages/sdk/tsconfig.json',
+          output: 'typedoc-sdk',
+          sidebar: {
+            label: 'SDK Reference',
+          },
+        }),
+      ],
+      sidebar: [
+        {
+          label: 'API',
+          autogenerate: { directory: 'api' },
+        },
+        {
+          label: 'Guides',
+          autogenerate: { directory: 'guides' },
+        },
+        typeDocSidebarGroup,
+      ],
+    }),
+  ],
 });

apps/docs/package.json

@@ -15,6 +15,9 @@
     "astro": "^5.6.1",
     "astro-mermaid": "^1.0.4",
     "mermaid": "^11.10.1",
-    "sharp": "^0.34.2"
+    "sharp": "^0.34.2",
+    "starlight-typedoc": "^0.21.5",
+    "typedoc": "^0.28.16",
+    "typedoc-plugin-markdown": "^4.9.0"
   }
 }

apps/docs/src/content/docs/api/chat.mdx

@@ -3,25 +3,39 @@ title: Chat
 description: Chat websocket
 ---
 
+import { Aside } from '@astrojs/starlight/components';
+
 The chat system is powered by a websocket server. Please read the entire page before implementing anything, as there are some important notes.
 
 ## Connection and messages
 
-The websocket server is located at `wss://hctv.srizan.dev/api/chat/ws/:username`, where `:username` is the channel you want to connect to.  
+The websocket server is located at `wss://hackclub.tv/api/chat/ws/:username`, where `:username` is the channel you want to connect to.
+
 You'll need to provide authentication, which can be done by providing an `auth_session` cookie, just like the REST API.
 
-Once connected, you must implement a subroutine in your code to send ping messages every 5 seconds. This is because of Cloudflare limitations.
+<Aside type="tip">
+Bot accounts are now supported. You can choose to connect as a bot by providing a bot account's API key in one of two ways:
+- Using the `Authorization` header: `Bearer hctvb_xxxxxxx`
+- Using the `?botAuth=hctvb_xxxxxxx` query parameter
+
+**Security Note:** When using the `?botAuth=` query parameter, be aware that query parameters may be logged in server logs, and/or proxy logs. Use the `Authorization` header method whenever possible. The query parameter method should only be used when connecting from an environment where headers cannot be set.
+
+It is highly advised to use a bot account for any automated task, and to implement anything pointed out in this page.
+</Aside>
+
+Once connected, you must implement a subroutine in your code to send ping messages every about 5 seconds. This is because of Cloudflare limitations.
 
 Messages are sent and received in JSON format. The following message types are supported:
-- `message`: a chat message.  
-  - sent by client:  
+
+- `message`: a chat message.
+  - sent by client:
     ```json
     {
       "type": "message",
-      "content": "Hello, world!"
+      "message": "Hello, world!"
     }
     ```
-  - received by client:  
+  - received by client:
     ```json
     {
       "user": {
@@ -29,24 +43,24 @@ Messages are sent and received in JSON format. The following message types are s
         "username": "user_who_sent_message",
         "avatar": "https://emoji.slack-edge.com/avatar.png"
       },
-      "message": "Hello, world!",
+      "message": "Hello, world!"
     }
     ```
-- `ping`: a ping message to keep the connection alive.  
-  - sent by client:  
+- `ping`: a ping message to keep the connection alive.
+  - sent by client:
     ```json
     {
       "type": "ping"
     }
     ```
-  - received by client:  
+  - received by client:
     ```json
     {
-      "type": "ping"
+      "type": "pong"
     }
     ```
-- `history`: a message containing the chat history. This is sent upon connection.  
-  - received by client:  
+- `history`: a message containing the chat history. This is sent upon connection.
+  - received by client:
     ```json
     {
       "type": "history",
@@ -64,9 +78,11 @@ Messages are sent and received in JSON format. The following message types are s
       ]
     }
     ```
+
 ## Emoji handling
 
-*diagram source: devin deepwiki*
+_diagram source: devin deepwiki_
+
 ```mermaid
 graph TB
     subgraph "Emoji Processing Pipeline"
@@ -104,6 +120,7 @@ The server then checks Redis for the emoji URL and returns it.
 When a user wants to look up an emoji (by typing `:(partial name)`), the server uses uFuzzy to find matching emojis in the Redis `emojis` hash key and returns the results.
 
 Here's what gets sent on the websocket:
+
 - `emojiMsg`: Looks up emojis
   - sent by client:
     ```json

apps/docs/src/content/docs/api/index.mdx

@@ -9,7 +9,7 @@ since this is beta software, the API is subject to change. additionally, many en
 
 ## Base url
 
-base url for all endpoints is `https://hctv.srizan.dev/api`.
+base url for all endpoints is `https://hackclub.tv/api`.
 
 ## Authentication
 

apps/docs/src/content/docs/api/rtmp.mdx

@@ -3,10 +3,6 @@ title: RTMP
 description: RTMP related endpoint group
 ---
 
-## GET `/rtmp/hls/:path`
-gets HLS segments, the backbone of hctv livestreaming. **authentication required**.  
-not really sure why you would need this? but check the browser console when playing a stream for an insight on how it's used.
-
 ## POST `/rtmp/streamKey`
 regenerates your stream key. **authentication required**.  
 body parameters (json):

apps/docs/src/content/docs/guides/dev.mdx

@@ -0,0 +1,32 @@
+---
+title: Development Setup
+description: Instructions to set up a local development environment for hackclub.tv
+---
+
+1. clone repo
+2. `pnpm install`
+3. `cp apps/web/.env.example apps/web/.env && cp packages/db/.env.example packages/db/.env` 
+4. `pnpm dev`
+5. `pnpm db:migrate` (RUN THIS AFTER POPULATING ENV)
+
+- slack notifier app manifest is as follows:  
+```
+display_information:
+  # please change the name to something that can be linked to you if possible
+  name: hctv notifier dev
+features:
+  bot_user:
+    # same with this :pray:
+    display_name: hctv notifier dev
+    always_online: false
+oauth_config:
+  scopes:
+    bot:
+      - chat:write
+      - users:read
+      - channels:join
+settings:
+  org_deploy_enabled: false
+  socket_mode_enabled: false
+  token_rotation_enabled: false
+```

apps/docs/src/content/docs/guides/start-stream.mdx

@@ -7,7 +7,7 @@ description: Get started with OBS and streaming on hackclub.tv
 - open settings
 - open "Stream"
 - set service to custom
-- set url to `rtmp://hackclub.app:45913/live`
+- set url to `srt://localhost:8890?streamid=publish:CHANNEL_NAME:thisusernameislongonpurposesoyoudontaccidentallyleakyourstreamkey:STREAM_KEY&pkt_size=1316`
 - on the website, click "Regenerate key"
 - paste the key into your obs "Stream Key"
 - start streaming!

apps/web/.env.example

@@ -0,0 +1,31 @@
+DATABASE_URL=postgresql://postgres:skbiditoilet@localhost:5555/postgres
+
+# make a slack app here: https://api.slack.com/apps
+SLACK_NOTIFIER_TOKEN=<make a bot for this, check app manifest below>
+
+# invite your bot to the channel you created. below is #hctv-dev, so use that if you want!
+NOTIFICATION_CHANNEL_ID=C08M3MGE6PJ
+
+REDIS_URL=redis://localhost:6379
+
+# get from https://uploadthing.com/
+UPLOADTHING_TOKEN=<get from uploadthing>
+
+# enable oauth mode on your hca account and make an app: https://auth.hackclub.com/identity/edit
+HCID_CLIENT=<auth.hackclub.com client>
+HCID_SECRET=<auth.hackclub.com secret>
+# make sure to put this as one of the redirect uri
+HCID_REDIRECT_URI=http://localhost:3000/auth/hackclub/callback
+
+# mediamtx settings
+NEXT_PUBLIC_MEDIAMTX_URL_HQ=http://localhost:8891
+MEDIAMTX_API_HQ=http://localhost:9997
+NEXT_PUBLIC_MEDIAMTX_INGEST_ROUTE_HQ=localhost:8890
+
+# commented because we don't have another ingest server as of right now
+# NEXT_PUBLIC_MEDIAMTX_URL_ASIA=http://localhost:8991
+# MEDIAMTX_API_ASIA=http://localhost:9999
+# NEXT_PUBLIC_MEDIAMTX_INGEST_ROUTE_ASIA=localhost:8990
+
+# idt you should change this
+MEDIAMTX_PUBLISH_KEY=rjq1xdpCPA4qyt3jge

apps/web/Dockerfile

@@ -1,13 +1,16 @@
-FROM node:lts-alpine AS base
+FROM node:lts-slim AS base
+ENV PNPM_HOME="/pnpm"
+ENV PATH="$PNPM_HOME:$PATH"
+RUN corepack enable
 
 FROM base AS builder
-RUN apk update
-RUN apk add --no-cache libc6-compat git
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    git \
+    ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
 # Set working directory
 WORKDIR /app
-# Replace <your-major-version> with the major version installed in your repository. For example:
-# RUN yarn global add turbo@^2
-RUN yarn global add turbo@^2
+RUN pnpm add -g turbo@^2
 COPY . .
 
 # Get the git commit hash before pruning (since .git might be removed)
@@ -19,40 +22,55 @@ RUN turbo prune @hctv/web --docker
  
 # Add lockfile and package.json's of isolated subworkspace
 FROM base AS installer
-RUN apk update
-RUN apk add --no-cache libc6-compat git
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    git \
+    libvips-dev \
+    python3 \
+    make \
+    g++ \
+    ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
 # Get the commit hash from the builder stage
 COPY --from=builder /tmp/commit_hash /tmp/commit_hash
-# Read commit hash and set as build arg
-ARG COMMIT_HASH_FILE=/tmp/commit_hash
-RUN COMMIT_HASH=$(cat /tmp/commit_hash 2>/dev/null || echo "unknown") && \
-    echo "COMMIT_HASH=$COMMIT_HASH" > /tmp/build_env
 WORKDIR /app
 
 # First install the dependencies (as they change less often)
 COPY --from=builder /app/out/json/ .
-RUN yarn install --frozen-lockfile
+RUN pnpm install --frozen-lockfile
 
 COPY --from=builder /app/out/full/ .
-RUN --mount=type=secret,id=TURBO_TOKEN --mount=type=secret,id=TURBO_TEAM \
-    . /tmp/build_env && \
-    export commit=$COMMIT_HASH && \
-    TURBO_TOKEN=$(cat /run/secrets/TURBO_TOKEN) TURBO_TEAM=$(cat /run/secrets/TURBO_TEAM) yarn turbo run build --env-mode=loose
+RUN --mount=type=secret,id=TURBO_TOKEN --mount=type=secret,id=TURBO_TEAM --mount=type=secret,id=SENTRY_AUTH_TOKEN \
+    COMMIT=$(cat /tmp/commit_hash 2>/dev/null || echo "unknown") && \
+    TURBO_TOKEN=$(cat /run/secrets/TURBO_TOKEN) TURBO_TEAM=$(cat /run/secrets/TURBO_TEAM) \
+    SENTRY_AUTH_TOKEN=$(cat /run/secrets/SENTRY_AUTH_TOKEN) \
+    commit=$COMMIT yarn turbo run build --env-mode=loose
  
 FROM base AS runner
 WORKDIR /app
 
-RUN apk add --no-cache ffmpeg
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    ffmpeg \
+    libvips42 \
+    && rm -rf /var/lib/apt/lists/*
 
-# Don't run production as root
-RUN addgroup --system --gid 1001 nodejs
-RUN adduser --system --uid 1001 nextjs
+RUN groupadd --system --gid 1001 nodejs
+RUN useradd --system --uid 1001 nextjs
+
+# Copy Prisma files for migrations
+COPY --from=installer --chown=nextjs:nodejs /app/packages/db/prisma ./packages/db/prisma
+COPY --from=installer --chown=nextjs:nodejs /app/packages/db/generated ./packages/db/generated
+COPY --from=installer --chown=nextjs:nodejs /app/packages/db/package.json ./packages/db/package.json
+COPY --from=installer --chown=nextjs:nodejs /app/node_modules ./node_modules
 
-# Get the commit hash from the installer stage and create a startup script
 COPY --from=installer /tmp/commit_hash /tmp/commit_hash
 RUN COMMIT_VALUE=$(cat /tmp/commit_hash 2>/dev/null || echo "unknown") && \
     echo "#!/bin/sh" > /usr/local/bin/start.sh && \
+    echo "set -e" >> /usr/local/bin/start.sh && \
+    echo "echo 'Running database migrations...'" >> /usr/local/bin/start.sh && \
+    echo "pnpm prisma migrate deploy --schema=/app/packages/db/prisma/schema.prisma" >> /usr/local/bin/start.sh && \
+    echo "cd /app" >> /usr/local/bin/start.sh && \
     echo "export commit=$COMMIT_VALUE" >> /usr/local/bin/start.sh && \
+    echo "echo 'Starting Next.js application...'" >> /usr/local/bin/start.sh && \
     echo "exec node apps/web/server.js" >> /usr/local/bin/start.sh && \
     chmod +x /usr/local/bin/start.sh
 

apps/web/next.config.mjs

@@ -33,6 +33,9 @@ const nextConfig = {
         hostname: 'cdn.jsdelivr.net',
         pathname: '/npm/emoji-datasource-twitter@15.1.2/img/twitter/64/*',
       },
+      {
+        hostname: 'eoceqrx2r7.ufs.sh'
+      },
     ],
     minimumCacheTTL: 120,
   },
@@ -44,6 +47,7 @@ const nextConfig = {
   reactStrictMode: false,
   output: 'standalone',
   outputFileTracingRoot: path.join(__dirname, '../../'),
+  serverExternalPackages: ['bullmq'],
   async rewrites() {
     return [
       {
@@ -52,6 +56,9 @@ const nextConfig = {
       },
     ];
   },
+  logging: {
+    incomingRequests: false,
+  },
 };
 
 export default withSentryConfig(nextConfig, {
@@ -62,6 +69,9 @@ export default withSentryConfig(nextConfig, {
 
   project: "hctv",
 
+  // Auth token for uploading source maps
+  authToken: process.env.SENTRY_AUTH_TOKEN,
+
   // Only print logs for uploading source maps in CI
   silent: !process.env.CI,
 
@@ -71,6 +81,9 @@ export default withSentryConfig(nextConfig, {
   // Upload a larger set of source maps for prettier stack traces (increases build time)
   widenClientFileUpload: true,
 
+  // Hides source maps from generated client bundles
+  hideSourceMaps: true,
+
   // Route browser requests to Sentry through a Next.js rewrite to circumvent ad-blockers.
   // This can increase your server load as well as your hosting bill.
   // Note: Check that the configured route will not match with your Next.js middleware, otherwise reporting of client-

apps/web/package.json

@@ -1,25 +1,27 @@
 {
   "name": "@hctv/web",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "private": true,
   "type": "module",
   "scripts": {
     "dd": "docker compose --file ../../dev/docker-compose.yml up -d",
-    "dev": "next dev --turbo",
+    "dev": "next dev --turbo -H 0.0.0.0",
     "donly": "docker compose --file ../../dev/docker-compose.yml up",
     "build": "next build",
     "start": "next start",
     "lint": "next lint",
     "ui:add": "shadcn add",
     "check-types": "tsc --noEmit",
-    "openapi": "next-openapi-gen"
+    "genMtxTypes": "bunx openapi-typescript https://github.com/bluenviron/mediamtx/raw/refs/tags/v1.15.5/api/openapi.yaml -o ./src/lib/types/mediamtx.d.ts"
   },
   "dependencies": {
-    "@hctv/auth": "*",
-    "@hctv/db": "*",
+    "@hctv/auth": "workspace:*",
+    "@hctv/db": "workspace:*",
     "@hookform/resolvers": "^3.9.1",
     "@lucia-auth/adapter-prisma": "^4.0.1",
     "@node-rs/argon2": "^2.0.2",
+    "@omit/react-confirm-dialog": "^1.2.0",
+    "@radix-ui/react-alert-dialog": "^1.1.15",
     "@radix-ui/react-avatar": "^1.0.4",
     "@radix-ui/react-checkbox": "^1.1.4",
     "@radix-ui/react-dialog": "^1.1.5",
@@ -29,7 +31,7 @@
     "@radix-ui/react-popover": "^1.1.5",
     "@radix-ui/react-select": "^2.1.5",
     "@radix-ui/react-separator": "^1.1.1",
-    "@radix-ui/react-slot": "^1.1.1",
+    "@radix-ui/react-slot": "^1.2.4",
     "@radix-ui/react-switch": "^1.1.3",
     "@radix-ui/react-tabs": "^1.1.12",
     "@radix-ui/react-tooltip": "^1.2.7",
@@ -45,19 +47,21 @@
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.0",
     "cmdk": "1.0.0",
+    "date-fns": "^4.1.0",
     "hls-video-element": "^1.5.0",
-    "ioredis": "5.7.0",
+    "hls.js": "^1.6.15",
     "lucia": "^3.2.2",
     "lucide-react": "^0.473.0",
     "media-chrome": "^4.8.0",
-    "next": "^15.3.4",
+    "next": "^16.1.0",
     "next-themes": "^0.4.4",
     "node-cron": "^3.0.3",
     "nuqs": "^2.4.3",
     "pg": "^8.14.1",
     "pg-boss": "^10.1.6",
-    "react": "19",
-    "react-dom": "19",
+    "react": "^19.2.3",
+    "react-day-picker": "^9.13.0",
+    "react-dom": "^19.2.3",
     "react-hook-form": "^7.54.2",
     "rehype-raw": "^7.0.0",
     "rehype-react": "^8.0.0",

apps/web/sentry.edge.config.ts

@@ -16,4 +16,5 @@ Sentry.init({
 
   // Setting this option to true will print useful information to the console while you're setting up Sentry.
   debug: false,
+  enabled: process.env.NODE_ENV === 'production',
 });

apps/web/sentry.server.config.ts

@@ -1,18 +0,0 @@
-// This file configures the initialization of Sentry on the server.
-// The config you add here will be used whenever the server handles a request.
-// https://docs.sentry.io/platforms/javascript/guides/nextjs/
-
-import * as Sentry from "@sentry/nextjs";
-
-Sentry.init({
-  dsn: "https://f3c26671c39af48406c6e23702a4f3dd@o4506961023860736.ingest.us.sentry.io/4509895816773632",
-
-  // Define how likely traces are sampled. Adjust this value in production, or use tracesSampler for greater control.
-  tracesSampleRate: 1,
-
-  // Enable logs to be sent to Sentry
-  enableLogs: true,
-
-  // Setting this option to true will print useful information to the console while you're setting up Sentry.
-  debug: false,
-});

apps/web/src/app/(ui)/(protected)/[username]/page.tsx

@@ -5,11 +5,34 @@ export default async function Page({ params }: { params: Promise<{ username: str
   const { username } = await params;
   const streamInfo = await prisma.streamInfo.findUnique({
     where: { username },
-    include: { channel: true },
+    include: {
+      channel: {
+        include: {
+          restriction: true,
+        },
+      },
+    },
   });
   if (!streamInfo) {
     return <div>Stream not found</div>;
   }
+
+  if (streamInfo.channel.restriction) {
+    const isExpired = streamInfo.channel.restriction.expiresAt &&
+      new Date(streamInfo.channel.restriction.expiresAt) < new Date();
+    
+    if (!isExpired) {
+      return (
+        <div className="flex flex-col items-center justify-center h-[calc(100vh-64px)] p-4">
+          <h1 className="text-2xl font-bold text-destructive mb-2">Channel Restricted</h1>
+          <p className="text-muted-foreground text-center max-w-md">
+            This channel has been restricted by a moderator and is not currently available for viewing.
+          </p>
+        </div>
+      );
+    }
+  }
+
   return (
     <LiveStream username={username} streamInfo={streamInfo} />
   );

apps/web/src/app/(ui)/(protected)/admin/page.client.tsx

@@ -0,0 +1,792 @@
+'use client';
+
+import { useState, useEffect, useCallback } from 'react';
+import { format } from 'date-fns';
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card';
+import { Tabs, TabsContent, TabsList, TabsTrigger } from '@/components/ui/tabs';
+import { Badge } from '@/components/ui/badge';
+import { Avatar, AvatarFallback, AvatarImage } from '@/components/ui/avatar';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import { Textarea } from '@/components/ui/textarea';
+import { Calendar } from '@/components/ui/calendar';
+import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover';
+import {
+  Users,
+  Tv,
+  Ban,
+  ShieldOff,
+  Search,
+  CalendarIcon,
+  ShieldCheck,
+  ShieldMinus,
+  X,
+} from 'lucide-react';
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from '@/components/ui/dialog';
+import { toast } from 'sonner';
+import type { User } from '@hctv/db';
+import {
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,
+} from '@/components/ui/table';
+import { cn } from '@/lib/utils';
+
+export default function AdminPanelClient({ currentUser }: AdminPanelClientProps) {
+  const [userSearch, setUserSearch] = useState('');
+  const [channelSearch, setChannelSearch] = useState('');
+  const [users, setUsers] = useState<UserWithBan[]>([]);
+  const [channels, setChannels] = useState<ChannelWithRestriction[]>([]);
+  const [usersLoading, setUsersLoading] = useState(false);
+  const [channelsLoading, setChannelsLoading] = useState(false);
+
+  const [banDialogOpen, setBanDialogOpen] = useState(false);
+  const [restrictDialogOpen, setRestrictDialogOpen] = useState(false);
+  const [selectedUser, setSelectedUser] = useState<UserWithBan | null>(null);
+  const [selectedChannel, setSelectedChannel] = useState<ChannelWithRestriction | null>(null);
+  const [reason, setReason] = useState('');
+  const [expiresAt, setExpiresAt] = useState<Date | undefined>(undefined);
+
+  const fetchUsers = useCallback(async (search: string) => {
+    setUsersLoading(true);
+    try {
+      const res = await fetch(`/api/admin/users?search=${encodeURIComponent(search)}`);
+      if (res.ok) {
+        setUsers(await res.json());
+      }
+    } catch (e) {
+      toast.error('Failed to fetch users');
+    } finally {
+      setUsersLoading(false);
+    }
+  }, []);
+
+  const fetchChannels = useCallback(async (search: string) => {
+    setChannelsLoading(true);
+    try {
+      const res = await fetch(`/api/admin/channels?search=${encodeURIComponent(search)}`);
+      if (res.ok) {
+        setChannels(await res.json());
+      }
+    } catch (e) {
+      toast.error('Failed to fetch channels');
+    } finally {
+      setChannelsLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    fetchUsers('');
+    fetchChannels('');
+  }, [fetchUsers, fetchChannels]);
+
+  useEffect(() => {
+    const timer = setTimeout(() => {
+      fetchUsers(userSearch);
+    }, 300);
+    return () => clearTimeout(timer);
+  }, [userSearch, fetchUsers]);
+
+  useEffect(() => {
+    const timer = setTimeout(() => {
+      fetchChannels(channelSearch);
+    }, 300);
+    return () => clearTimeout(timer);
+  }, [channelSearch, fetchChannels]);
+
+  const resetDialogState = () => {
+    setReason('');
+    setExpiresAt(undefined);
+    setSelectedUser(null);
+    setSelectedChannel(null);
+  };
+
+  const handleBanUser = async () => {
+    if (!selectedUser || !reason.trim()) {
+      toast.error('Please provide a reason');
+      return;
+    }
+
+    try {
+      const res = await fetch('/api/admin/users', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          userId: selectedUser.id,
+          action: 'ban',
+          reason,
+          expiresAt: expiresAt?.toISOString(),
+        }),
+      });
+
+      if (res.ok) {
+        toast.success('User banned successfully');
+        fetchUsers(userSearch);
+        setBanDialogOpen(false);
+        resetDialogState();
+      } else {
+        const err = await res.text();
+        toast.error(err || 'Failed to ban user');
+      }
+    } catch (e) {
+      toast.error('Failed to ban user');
+    }
+  };
+
+  const handleUnbanUser = async (userId: string) => {
+    try {
+      const res = await fetch('/api/admin/users', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          userId,
+          action: 'unban',
+        }),
+      });
+
+      if (res.ok) {
+        toast.success('User unbanned successfully');
+        fetchUsers(userSearch);
+      } else {
+        toast.error('Failed to unban user');
+      }
+    } catch (e) {
+      toast.error('Failed to unban user');
+    }
+  };
+
+  const handleRestrictChannel = async () => {
+    if (!selectedChannel || !reason.trim()) {
+      toast.error('Please provide a reason');
+      return;
+    }
+
+    try {
+      const res = await fetch('/api/admin/channels', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          channelId: selectedChannel.id,
+          action: 'restrict',
+          reason,
+          expiresAt: expiresAt?.toISOString(),
+        }),
+      });
+
+      if (res.ok) {
+        toast.success('Channel restricted successfully');
+        fetchChannels(channelSearch);
+        setRestrictDialogOpen(false);
+        resetDialogState();
+      } else {
+        const err = await res.text();
+        toast.error(err || 'Failed to restrict channel');
+      }
+    } catch (e) {
+      toast.error('Failed to restrict channel');
+    }
+  };
+
+  const handleUnrestrictChannel = async (channelId: string) => {
+    try {
+      const res = await fetch('/api/admin/channels', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          channelId,
+          action: 'unrestrict',
+        }),
+      });
+
+      if (res.ok) {
+        toast.success('Channel unrestricted successfully');
+        fetchChannels(channelSearch);
+      } else {
+        toast.error('Failed to unrestrict channel');
+      }
+    } catch (e) {
+      toast.error('Failed to unrestrict channel');
+    }
+  };
+
+  const handlePromoteUser = async (userId: string) => {
+    try {
+      const res = await fetch('/api/admin/users', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          userId,
+          action: 'promote',
+        }),
+      });
+
+      if (res.ok) {
+        toast.success('User promoted to admin');
+        fetchUsers(userSearch);
+      } else {
+        const err = await res.text();
+        toast.error(err || 'Failed to promote user');
+      }
+    } catch (e) {
+      toast.error('Failed to promote user');
+    }
+  };
+
+  const handleDemoteUser = async (userId: string) => {
+    try {
+      const res = await fetch('/api/admin/users', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          userId,
+          action: 'demote',
+        }),
+      });
+
+      if (res.ok) {
+        toast.success('User demoted from admin');
+        fetchUsers(userSearch);
+      } else {
+        const err = await res.text();
+        toast.error(err || 'Failed to demote user');
+      }
+    } catch (e) {
+      toast.error('Failed to demote user');
+    }
+  };
+
+  return (
+    <div className="container max-w-6xl mx-auto py-6 px-4">
+      <div className="mb-6">
+        <h1 className="text-3xl font-bold flex items-center gap-2">
+          Admin Panel
+        </h1>
+        <p className="text-muted-foreground">Manage users and channels on the platform</p>
+      </div>
+
+      <Tabs defaultValue="users" className="w-full">
+        <TabsList className="grid w-full grid-cols-2">
+          <TabsTrigger value="users" className="flex items-center gap-2">
+            <Users className="h-4 w-4" />
+            Users
+          </TabsTrigger>
+          <TabsTrigger value="channels" className="flex items-center gap-2">
+            <Tv className="h-4 w-4" />
+            Channels
+          </TabsTrigger>
+        </TabsList>
+
+        <TabsContent value="users">
+          <Card>
+            <CardHeader>
+              <CardTitle>User Management</CardTitle>
+              <CardDescription>
+                Search and manage user accounts. Ban users to prevent them from using the platform.
+              </CardDescription>
+            </CardHeader>
+            <CardContent>
+              <div className="mb-4">
+                <div className="relative">
+                  <Search className="absolute left-3 top-1/2 -translate-y-1/2 h-4 w-4 text-muted-foreground" />
+                  <Input
+                    placeholder="Search by username or email..."
+                    value={userSearch}
+                    onChange={(e) => setUserSearch(e.target.value)}
+                    className="pl-10"
+                  />
+                </div>
+              </div>
+
+              <Table>
+                <TableHeader>
+                  <TableRow>
+                    <TableHead>User</TableHead>
+                    <TableHead>Status</TableHead>
+                    <TableHead>Actions</TableHead>
+                  </TableRow>
+                </TableHeader>
+                <TableBody>
+                  {usersLoading ? (
+                    <TableRow>
+                      <TableCell colSpan={3} className="text-center py-8">
+                        Loading...
+                      </TableCell>
+                    </TableRow>
+                  ) : users.length === 0 ? (
+                    <TableRow>
+                      <TableCell colSpan={3} className="text-center py-8">
+                        No users found
+                      </TableCell>
+                    </TableRow>
+                  ) : (
+                    users.map((user) => (
+                      <TableRow key={user.id}>
+                        <TableCell>
+                          <div className="flex items-center gap-3">
+                            <Avatar className="h-10 w-10">
+                              <AvatarImage src={user.pfpUrl} />
+                              <AvatarFallback>
+                                {user.personalChannel?.name?.[0]?.toUpperCase() || 'U'}
+                              </AvatarFallback>
+                            </Avatar>
+                            <div>
+                              <p className="font-medium">
+                                {user.personalChannel?.name}
+                              </p>
+                              <p className="text-sm text-muted-foreground">{user.email}</p>
+                            </div>
+                          </div>
+                        </TableCell>
+                        <TableCell>
+                          <div className="flex items-center gap-2">
+                            {user.isAdmin && (
+                              <Badge variant="default">Admin</Badge>
+                            )}
+                            {user.ban ? (
+                              <Badge variant="destructive" className="flex items-center gap-1">
+                                <Ban className="h-3 w-3" />
+                                Banned
+                              </Badge>
+                            ) : (
+                              <Badge variant="secondary">Active</Badge>
+                            )}
+                          </div>
+                          {user.ban && (
+                            <div className="text-xs text-muted-foreground mt-1">
+                              <p>Reason: {user.ban.reason}</p>
+                              {user.ban.expiresAt && (
+                                <p>Expires: {format(new Date(user.ban.expiresAt), 'PPP')}</p>
+                              )}
+                            </div>
+                          )}
+                        </TableCell>
+                        <TableCell>
+                          <div className="flex items-center gap-2">
+                            {user.isAdmin ? (
+                              user.id !== currentUser.id && (
+                                <Button
+                                  variant="outline"
+                                  size="sm"
+                                  onClick={() => handleDemoteUser(user.id)}
+                                >
+                                  <ShieldMinus className="h-4 w-4 mr-1" />
+                                  Demote
+                                </Button>
+                              )
+                            ) : (
+                              <>
+                                {user.ban ? (
+                                  <Button
+                                    variant="outline"
+                                    size="sm"
+                                    onClick={() => handleUnbanUser(user.id)}
+                                  >
+                                    <ShieldOff className="h-4 w-4 mr-1" />
+                                    Unban
+                                  </Button>
+                                ) : (
+                                  <Button
+                                    variant="destructive"
+                                    size="sm"
+                                    onClick={() => {
+                                      setSelectedUser(user);
+                                      setBanDialogOpen(true);
+                                    }}
+                                  >
+                                    <Ban className="h-4 w-4 mr-1" />
+                                    Ban
+                                  </Button>
+                                )}
+                                <Button
+                                  variant="outline"
+                                  size="sm"
+                                  onClick={() => handlePromoteUser(user.id)}
+                                >
+                                  <ShieldCheck className="h-4 w-4 mr-1" />
+                                  Promote
+                                </Button>
+                              </>
+                            )}
+                          </div>
+                        </TableCell>
+                      </TableRow>
+                    ))
+                  )}
+                </TableBody>
+              </Table>
+            </CardContent>
+          </Card>
+        </TabsContent>
+
+        <TabsContent value="channels">
+          <Card>
+            <CardHeader>
+              <CardTitle>Channel Management</CardTitle>
+              <CardDescription>
+                Search and manage channels. Restrict channels to prevent streams from being viewed.
+              </CardDescription>
+            </CardHeader>
+            <CardContent>
+              <div className="mb-4">
+                <div className="relative">
+                  <Search className="absolute left-3 top-1/2 -translate-y-1/2 h-4 w-4 text-muted-foreground" />
+                  <Input
+                    placeholder="Search by channel name..."
+                    value={channelSearch}
+                    onChange={(e) => setChannelSearch(e.target.value)}
+                    className="pl-10"
+                  />
+                </div>
+              </div>
+
+              <Table>
+                <TableHeader>
+                  <TableRow>
+                    <TableHead>Channel</TableHead>
+                    <TableHead>Owner</TableHead>
+                    <TableHead>Status</TableHead>
+                    <TableHead>Actions</TableHead>
+                  </TableRow>
+                </TableHeader>
+                <TableBody>
+                  {channelsLoading ? (
+                    <TableRow>
+                      <TableCell colSpan={4} className="text-center py-8">
+                        Loading...
+                      </TableCell>
+                    </TableRow>
+                  ) : channels.length === 0 ? (
+                    <TableRow>
+                      <TableCell colSpan={4} className="text-center py-8">
+                        No channels found
+                      </TableCell>
+                    </TableRow>
+                  ) : (
+                    channels.map((channel) => (
+                      <TableRow key={channel.id}>
+                        <TableCell>
+                          <div className="flex items-center gap-3">
+                            <Avatar className="h-10 w-10">
+                              <AvatarImage src={channel.pfpUrl} />
+                              <AvatarFallback>
+                                {channel.name[0]?.toUpperCase()}
+                              </AvatarFallback>
+                            </Avatar>
+                            <div>
+                              <p className="font-medium">{channel.name}</p>
+                              {channel.personalFor && (
+                                <Badge variant="outline" className="text-xs">Personal</Badge>
+                              )}
+                            </div>
+                          </div>
+                        </TableCell>
+                        <TableCell>
+                          <div className="flex items-center gap-2">
+                            <Avatar className="h-6 w-6">
+                              <AvatarImage src={channel.owner.pfpUrl} />
+                              <AvatarFallback>O</AvatarFallback>
+                            </Avatar>
+                            <span className="text-sm">{channel.owner.personalChannel.name}</span>
+                          </div>
+                        </TableCell>
+                        <TableCell>
+                          {channel.restriction ? (
+                            <Badge variant="destructive" className="flex items-center gap-1 w-fit">
+                              <Ban className="h-3 w-3" />
+                              Restricted
+                            </Badge>
+                          ) : (
+                            <Badge variant="secondary">Active</Badge>
+                          )}
+                          {channel.restriction && (
+                            <div className="text-xs text-muted-foreground mt-1">
+                              <p>Reason: {channel.restriction.reason}</p>
+                              {channel.restriction.expiresAt && (
+                                <p>Expires: {format(new Date(channel.restriction.expiresAt), 'PPP')}</p>
+                              )}
+                            </div>
+                          )}
+                        </TableCell>
+                        <TableCell>
+                          {channel.restriction ? (
+                            <Button
+                              variant="outline"
+                              size="sm"
+                              onClick={() => handleUnrestrictChannel(channel.id)}
+                            >
+                              <ShieldOff className="h-4 w-4 mr-1" />
+                              Unrestrict
+                            </Button>
+                          ) : (
+                            <Button
+                              variant="destructive"
+                              size="sm"
+                              onClick={() => {
+                                setSelectedChannel(channel);
+                                setRestrictDialogOpen(true);
+                              }}
+                            >
+                              <Ban className="h-4 w-4 mr-1" />
+                              Restrict
+                            </Button>
+                          )}
+                        </TableCell>
+                      </TableRow>
+                    ))
+                  )}
+                </TableBody>
+              </Table>
+            </CardContent>
+          </Card>
+        </TabsContent>
+      </Tabs>
+
+      <Dialog open={banDialogOpen} onOpenChange={(open) => {
+        setBanDialogOpen(open);
+        if (!open) resetDialogState();
+      }}>
+        <DialogContent>
+          <DialogHeader>
+            <DialogTitle>Ban User</DialogTitle>
+            <DialogDescription>
+              Ban {selectedUser?.personalChannel?.name || selectedUser?.slack_id} from the platform.
+              They will not be able to stream or use the platform while banned.
+            </DialogDescription>
+          </DialogHeader>
+          <div className="space-y-4">
+            <div>
+              <label className="text-sm font-medium">Reason</label>
+              <Textarea
+                placeholder="Enter the reason for banning this user..."
+                value={reason}
+                onChange={(e) => setReason(e.target.value)}
+                className="mt-1"
+              />
+            </div>
+            <div>
+              <label className="text-sm font-medium">Expires (optional)</label>
+              <p className="text-xs text-muted-foreground mb-2">
+                Leave empty for a permanent ban
+              </p>
+              <div className="flex gap-2">
+                <Popover>
+                  <PopoverTrigger asChild>
+                    <Button
+                      variant="outline"
+                      className={cn(
+                        'flex-1 justify-start text-left font-normal',
+                        !expiresAt && 'text-muted-foreground'
+                      )}
+                    >
+                      <CalendarIcon className="mr-2 h-4 w-4" />
+                      {expiresAt ? format(expiresAt, 'PPP p') : 'Pick a date & time'}
+                    </Button>
+                  </PopoverTrigger>
+                  <PopoverContent className="w-auto p-0" align="start">
+                    <Calendar
+                      mode="single"
+                      selected={expiresAt}
+                      onSelect={(date) => {
+                        if (date) {
+                          const newDate = expiresAt ? new Date(expiresAt) : new Date();
+                          date.setHours(newDate.getHours(), newDate.getMinutes());
+                          setExpiresAt(date);
+                        } else {
+                          setExpiresAt(undefined);
+                        }
+                      }}
+                      disabled={(date) => date < new Date(new Date().setHours(0, 0, 0, 0))}
+                    />
+                    <div className="border-t p-3">
+                      <label className="text-sm font-medium">Time</label>
+                      <Input
+                        type="time"
+                        className="mt-1"
+                        value={expiresAt ? format(expiresAt, 'HH:mm') : ''}
+                        onChange={(e) => {
+                          if (e.target.value) {
+                            const [hours, minutes] = e.target.value.split(':').map(Number);
+                            const newDate = expiresAt ? new Date(expiresAt) : new Date();
+                            newDate.setHours(hours, minutes);
+                            setExpiresAt(newDate);
+                          }
+                        }}
+                      />
+                    </div>
+                  </PopoverContent>
+                </Popover>
+                {expiresAt && (
+                  <Button
+                    variant="ghost"
+                    size="icon"
+                    onClick={() => setExpiresAt(undefined)}
+                  >
+                    <X className='w-4 h-4' />
+                  </Button>
+                )}
+              </div>
+            </div>
+          </div>
+          <DialogFooter>
+            <Button variant="outline" onClick={() => {
+              setBanDialogOpen(false);
+              resetDialogState();
+            }}>
+              Cancel
+            </Button>
+            <Button variant="destructive" onClick={handleBanUser}>
+              Ban User
+            </Button>
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
+
+      <Dialog open={restrictDialogOpen} onOpenChange={(open) => {
+        setRestrictDialogOpen(open);
+        if (!open) resetDialogState();
+      }}>
+        <DialogContent>
+          <DialogHeader>
+            <DialogTitle>Restrict Channel</DialogTitle>
+            <DialogDescription>
+              Restrict {selectedChannel?.name} from streaming. Viewers will not be able to watch
+              streams from this channel.
+            </DialogDescription>
+          </DialogHeader>
+          <div className="space-y-4">
+            <div>
+              <label className="text-sm font-medium">Reason</label>
+              <Textarea
+                placeholder="Enter the reason for restricting this channel..."
+                value={reason}
+                onChange={(e) => setReason(e.target.value)}
+                className="mt-1"
+              />
+            </div>
+            <div>
+              <label className="text-sm font-medium">Expires (optional)</label>
+              <p className="text-xs text-muted-foreground mb-2">
+                Leave empty for a permanent restriction
+              </p>
+              <div className="flex gap-2">
+                <Popover>
+                  <PopoverTrigger asChild>
+                    <Button
+                      variant="outline"
+                      className={cn(
+                        'flex-1 justify-start text-left font-normal',
+                        !expiresAt && 'text-muted-foreground'
+                      )}
+                    >
+                      <CalendarIcon className="mr-2 h-4 w-4" />
+                      {expiresAt ? format(expiresAt, 'PPP p') : 'Pick a date & time'}
+                    </Button>
+                  </PopoverTrigger>
+                  <PopoverContent className="w-auto p-0" align="start">
+                    <Calendar
+                      mode="single"
+                      selected={expiresAt}
+                      onSelect={(date) => {
+                        if (date) {
+                          const newDate = expiresAt ? new Date(expiresAt) : new Date();
+                          date.setHours(newDate.getHours(), newDate.getMinutes());
+                          setExpiresAt(date);
+                        } else {
+                          setExpiresAt(undefined);
+                        }
+                      }}
+                      disabled={(date) => date < new Date(new Date().setHours(0, 0, 0, 0))}
+                    />
+                    <div className="border-t p-3">
+                      <label className="text-sm font-medium">Time</label>
+                      <Input
+                        type="time"
+                        className="mt-1"
+                        value={expiresAt ? format(expiresAt, 'HH:mm') : ''}
+                        onChange={(e) => {
+                          if (e.target.value) {
+                            const [hours, minutes] = e.target.value.split(':').map(Number);
+                            const newDate = expiresAt ? new Date(expiresAt) : new Date();
+                            newDate.setHours(hours, minutes);
+                            setExpiresAt(newDate);
+                          }
+                        }}
+                      />
+                    </div>
+                  </PopoverContent>
+                </Popover>
+                {expiresAt && (
+                  <Button
+                    variant="ghost"
+                    size="icon"
+                    onClick={() => setExpiresAt(undefined)}
+                  >
+                    <X className='w-4 h-4' />
+                  </Button>
+                )}
+              </div>
+            </div>
+          </div>
+          <DialogFooter>
+            <Button variant="outline" onClick={() => {
+              setRestrictDialogOpen(false);
+              resetDialogState();
+            }}>
+              Cancel
+            </Button>
+            <Button variant="destructive" onClick={handleRestrictChannel}>
+              Restrict Channel
+            </Button>
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
+    </div>
+  );
+}
+
+interface UserWithBan {
+  id: string;
+  slack_id: string;
+  email: string | null;
+  pfpUrl: string;
+  isAdmin: boolean;
+  ban: {
+    id: string;
+    reason: string;
+    bannedBy: string;
+    createdAt: string;
+    expiresAt: string | null;
+  } | null;
+  personalChannel: { name: string } | null;
+}
+
+interface ChannelWithRestriction {
+  id: string;
+  name: string;
+  description: string;
+  pfpUrl: string;
+  owner: { id: string; slack_id: string; pfpUrl: string; personalChannel: { name: string } };
+  personalFor: { id: string } | null;
+  restriction: {
+    id: string;
+    reason: string;
+    restrictedBy: string;
+    createdAt: string;
+    expiresAt: string | null;
+  } | null;
+}
+
+interface AdminPanelClientProps {
+  currentUser: User;
+}
+

apps/web/src/app/(ui)/(protected)/admin/page.tsx

@@ -0,0 +1,17 @@
+import { validateRequest } from '@/lib/auth/validate';
+import { redirect } from 'next/navigation';
+import AdminPanelClient from './page.client';
+
+export default async function AdminPage() {
+  const { user } = await validateRequest();
+
+  if (!user) {
+    redirect('/auth/hackclub');
+  }
+
+  if (!user.isAdmin) {
+    redirect('/');
+  }
+
+  return <AdminPanelClient currentUser={user} />;
+}

apps/web/src/app/(ui)/(protected)/api/admin/channels/route.ts

@@ -0,0 +1,91 @@
+import { validateRequest } from '@/lib/auth/validate';
+import { prisma } from '@hctv/db';
+import { NextRequest } from 'next/server';
+
+export async function GET(request: NextRequest) {
+  const { user } = await validateRequest();
+  if (!user?.isAdmin) {
+    return new Response('Forbidden', { status: 403 });
+  }
+
+  const searchParams = request.nextUrl.searchParams;
+  const search = searchParams.get('search') || '';
+
+  const channels = await prisma.channel.findMany({
+    where: search
+      ? {
+        OR: [
+          { name: { contains: search, mode: 'insensitive' } },
+          { description: { contains: search, mode: 'insensitive' } },
+        ],
+      }
+      : undefined,
+    include: {
+      restriction: true,
+      owner: {
+        select: { id: true, slack_id: true, pfpUrl: true, personalChannel: { select: { name: true } } },
+      },
+      personalFor: {
+        select: {
+          id: true,
+        },
+      },
+    },
+    take: 50,
+  });
+  return Response.json(channels);
+}
+
+export async function POST(request: NextRequest) {
+  const { user } = await validateRequest();
+  if (!user?.isAdmin) {
+    return new Response('Forbidden', { status: 403 });
+  }
+
+  const body = await request.json();
+  const { channelId, action, reason, expiresAt } = body as {
+    channelId: string;
+    action: 'restrict' | 'unrestrict';
+    reason?: string;
+    expiresAt?: string;
+  };
+
+  if (!channelId || !action) {
+    return new Response('Missing required fields', { status: 400 });
+  }
+
+  const channel = await prisma.channel.findUnique({ where: { id: channelId } });
+  if (!channel) {
+    return new Response('Channel not found', { status: 404 });
+  }
+
+  if (action === 'restrict') {
+    if (!reason) {
+      return new Response('Reason is required for restricting', { status: 400 });
+    }
+
+    await prisma.channelRestriction.upsert({
+      where: { channelId },
+      update: {
+        reason,
+        restrictedBy: user.id,
+        expiresAt: expiresAt ? new Date(expiresAt) : null,
+      },
+      create: {
+        channelId,
+        reason,
+        restrictedBy: user.id,
+        expiresAt: expiresAt ? new Date(expiresAt) : null,
+      },
+    });
+
+    return Response.json({ success: true, message: 'Channel restricted' });
+  }
+
+  if (action === 'unrestrict') {
+    await prisma.channelRestriction.delete({ where: { channelId } }).catch(() => { });
+    return Response.json({ success: true, message: 'Channel unrestricted' });
+  }
+
+  return new Response('Invalid action', { status: 400 });
+}

apps/web/src/app/(ui)/(protected)/api/admin/users/route.ts

@@ -0,0 +1,119 @@
+import { validateRequest } from '@/lib/auth/validate';
+import { prisma } from '@hctv/db';
+import { NextRequest } from 'next/server';
+
+export async function GET(request: NextRequest) {
+  const { user } = await validateRequest();
+  if (!user?.isAdmin) {
+    return new Response('Forbidden', { status: 403 });
+  }
+
+  const searchParams = request.nextUrl.searchParams;
+  const search = searchParams.get('search') || '';
+
+  const users = await prisma.user.findMany({
+    where: search
+      ? {
+        OR: [
+          { slack_id: { contains: search, mode: 'insensitive' } },
+          { email: { contains: search, mode: 'insensitive' } },
+          { personalChannel: { name: { contains: search, mode: 'insensitive' } } },
+        ],
+      }
+      : undefined,
+    include: {
+      ban: true,
+      personalChannel: { select: { name: true } },
+    },
+    take: 50,
+  });
+  return Response.json(users);
+}
+
+export async function POST(request: NextRequest) {
+  const { user } = await validateRequest();
+  if (!user?.isAdmin) {
+    return new Response('Forbidden', { status: 403 });
+  }
+
+  const body = await request.json();
+  const { userId, action, reason, expiresAt } = body as {
+    userId: string;
+    action: 'ban' | 'unban' | 'promote' | 'demote';
+    reason?: string;
+    expiresAt?: string;
+  };
+
+  if (!userId || !action) {
+    return new Response('Missing required fields', { status: 400 });
+  }
+
+  const targetUser = await prisma.user.findUnique({ where: { id: userId } });
+  if (!targetUser) {
+    return new Response('User not found', { status: 404 });
+  }
+
+  if (action === 'ban') {
+    if (targetUser.isAdmin) {
+      return new Response('Cannot ban an admin', { status: 400 });
+    }
+
+    if (!reason) {
+      return new Response('Reason is required for banning', { status: 400 });
+    }
+
+    await prisma.userBan.upsert({
+      where: { userId },
+      update: {
+        reason,
+        bannedBy: user.id,
+        expiresAt: expiresAt ? new Date(expiresAt) : null,
+      },
+      create: {
+        userId,
+        reason,
+        bannedBy: user.id,
+        expiresAt: expiresAt ? new Date(expiresAt) : null,
+      },
+    });
+
+    return Response.json({ success: true, message: 'User banned' });
+  }
+
+  if (action === 'unban') {
+    await prisma.userBan.delete({ where: { userId } }).catch(() => { });
+    return Response.json({ success: true, message: 'User unbanned' });
+  }
+
+  if (action === 'promote') {
+    if (targetUser.isAdmin) {
+      return new Response('User is already an admin', { status: 400 });
+    }
+
+    await prisma.user.update({
+      where: { id: userId },
+      data: { isAdmin: true },
+    });
+
+    return Response.json({ success: true, message: 'User promoted to admin' });
+  }
+
+  if (action === 'demote') {
+    if (!targetUser.isAdmin) {
+      return new Response('User is not an admin', { status: 400 });
+    }
+
+    if (targetUser.id === user.id) {
+      return new Response('Cannot demote yourself', { status: 400 });
+    }
+
+    await prisma.user.update({
+      where: { id: userId },
+      data: { isAdmin: false },
+    });
+
+    return Response.json({ success: true, message: 'User demoted from admin' });
+  }
+
+  return new Response('Invalid action', { status: 400 });
+}

apps/web/src/app/(ui)/(protected)/api/mediamtx/publish/route.ts

@@ -0,0 +1,86 @@
+import { prisma, getRedisConnection } from '@hctv/db';
+import { NextRequest } from 'next/server';
+import { z } from 'zod';
+
+export async function POST(request: NextRequest) {
+  const redis = getRedisConnection();
+  const body = await request.json();
+
+  if (process.env.NODE_ENV !== 'production') {
+    console.log(
+      'Mediamtx publish auth request:',
+      JSON.stringify(body, null, 2)
+    );
+  };
+  const parsed = schema.safeParse(body);
+
+  if (!parsed.success) {
+    return new Response('invalid request', { status: 400 });
+  }
+  const { action, protocol, path, password } = parsed.data;
+  if (action === 'publish' && protocol === 'srt') {
+    const channelKey = await redis.get(`streamKey:${path}`);
+
+    if (channelKey) {
+      if (channelKey !== password) {
+        return new Response('invalid stream key', { status: 403 });
+      }
+
+      const channel = await prisma.channel.findUnique({
+        where: { name: path },
+        include: {
+          restriction: true,
+          owner: {
+            include: { ban: true },
+          },
+          streamInfo: true,
+        },
+      });
+
+      if (channel?.restriction) {
+        const isExpired = channel.restriction.expiresAt &&
+          new Date(channel.restriction.expiresAt) < new Date();
+        if (!isExpired) {
+          return new Response('channel restricted', { status: 403 });
+        }
+      }
+
+      if (channel?.owner?.ban) {
+        const isExpired = channel.owner.ban.expiresAt &&
+          new Date(channel.owner.ban.expiresAt) < new Date();
+        if (!isExpired) {
+          return new Response('user banned', { status: 403 });
+        }
+      }
+
+      if (channel?.streamInfo[0].isLive) {
+        return new Response('stream already live', { status: 403 });
+      }
+
+      return new Response('youre in yay', { status: 200 });
+    }
+  } else if (action === 'read' && protocol === 'hls') {
+    if (password === process.env.MEDIAMTX_PUBLISH_KEY) {
+      return new Response('authorized (hls read key for thumbs)', { status: 200 });
+    }
+    const sessionExists = await redis.exists(`sessions:${password}`);
+    if (!sessionExists) {
+      return new Response('unauthorized', { status: 401 });
+    }
+    return new Response('authorized', { status: 200 });
+  }
+
+  return new Response('uhh', { status: 401 });
+}
+
+const schema = z.object({
+  user: z.string(),
+  password: z.string(),
+  token: z.string(),
+  ip: z.string(),
+  action: z.enum(['publish', 'read', 'playback', 'api', 'metrics', 'pprof']),
+  path: z.string(),
+  protocol: z.enum(['rtsp', 'rtmp', 'hls', 'webrtc', 'srt']),
+  id: z.string().nullable(),
+  query: z.string(),
+});

apps/web/src/app/(ui)/(protected)/api/rtmp/hls/[path]/route.ts

@@ -1,39 +0,0 @@
-import fsP from 'fs/promises';
-import fs from 'fs'; 
-import { getRedisConnection } from '@hctv/db';
-import { cookies } from 'next/headers';
-
-export async function GET(request: Request, { params }: { params: Promise<{ path: string }> }) {
-  const { path } = await params;
-  const c = await cookies();
-  
-  const sessionCookie = c.get('auth_session')?.value;
-  if (!sessionCookie) {
-    return new Response("Unauthorized", { status: 401 });
-  }
-  const sessionExists = await getRedisConnection().exists(`sessions:${sessionCookie}`);
-  if (sessionExists === 0) {
-    return new Response("Unauthorized", { status: 401 });
-  }
-
-  if (path.includes('..')) {
-    return new Response("nuh uh", { status: 403 });
-  }
-
-  const basePath = '/dev/shm/hls';
-  const filePath = `${basePath}/${path}`;
-  const exists = fs.existsSync(filePath);
-
-  if (!exists) {
-    return new Response("Not Found", { status: 404 });
-  }
-
-  const file = await fsP.readFile(filePath);
-  return new Response(file, {
-    headers: {
-      'Content-Type': 'application/octet-stream',
-      'Access-Control-Allow-Origin': '*',
-      'Access-Control-Allow-Methods': 'GET',
-    },
-  });
-}

apps/web/src/app/(ui)/(protected)/api/rtmp/publish/route.ts

@@ -15,7 +15,14 @@ export async function POST(request: NextRequest) {
       key: streamKey,
     },
     include: {
-      channel: true,
+      channel: {
+        include: {
+          restriction: true,
+          owner: {
+            include: { ban: true },
+          },
+        },
+      },
     },
   });
 
@@ -24,6 +31,23 @@ export async function POST(request: NextRequest) {
       status: 403,
     });
   }
+
+  if (key.channel.restriction) {
+    const isExpired = key.channel.restriction.expiresAt &&
+      new Date(key.channel.restriction.expiresAt) < new Date();
+    if (!isExpired) {
+      return new Response('channel restricted', { status: 403 });
+    }
+  }
+
+  if (key.channel.owner?.ban) {
+    const isExpired = key.channel.owner.ban.expiresAt &&
+      new Date(key.channel.owner.ban.expiresAt) < new Date();
+    if (!isExpired) {
+      return new Response('user banned', { status: 403 });
+    }
+  }
+
   return new Response('', {
     status: 302,
     headers: {

apps/web/src/app/(ui)/(protected)/api/rtmp/streamKey/route.ts

@@ -1,6 +1,7 @@
 import { validateRequest } from '@/lib/auth/validate';
 import { prisma } from '@hctv/db';
 import { NextRequest } from "next/server";
+import { regenerateStreamKey } from '@/lib/db/streamKey';
 
 export async function POST(request: NextRequest) {
   const { user } = await validateRequest();
@@ -34,20 +35,9 @@ export async function POST(request: NextRequest) {
     return new Response('Unauthorized', { status: 401 });
   }
 
-  const dbUpdate = await prisma.streamKey.upsert({
-    create: {
-      key: crypto.randomUUID(),
-      channelId: channelInfo.id
-    },
-    update: {
-      key: crypto.randomUUID()
-    },
-    where: {
-      channelId: channelInfo.id
-    }
-  })
+  const streamKey = await regenerateStreamKey(channelInfo.id, channel);
 
-  return new Response(JSON.stringify({ key: dbUpdate.key }), {
+  return new Response(JSON.stringify({ key: streamKey.key }), {
     status: 200,
     headers: {
       'Content-Type': 'application/json'

apps/web/src/app/(ui)/(protected)/api/settings/bot/[slug]/apiKey/route.ts

@@ -0,0 +1,124 @@
+import { validateRequest } from "@/lib/auth/validate";
+import { prisma } from "@hctv/db";
+import { NextRequest } from "next/server";
+import { z } from "zod";
+
+type Params = Promise<{ slug: string }>;
+
+export async function POST(request: NextRequest, segmentData: { params: Params }) {
+  const { slug } = await segmentData.params;
+  const { user } = await validateRequest();
+  if (!user) {
+    return new Response(JSON.stringify({ success: false, error: 'Unauthorized' }), { status: 401 });
+  }
+
+  const bodySchema = z.object({
+    action: z.enum(['revoke', 'regenerate', 'create']),
+    name: z.string().min(3, 'Name must be at least 3 characters long').max(50, 'Name must be at most 50 characters long'),
+  });
+  const body = await request.json();
+  const parsedBody = bodySchema.safeParse(body);
+  if (!parsedBody.success) {
+    return new Response(JSON.stringify({ success: false, error: parsedBody.error.errors.map(e => e.message).join(', ') }), { status: 400 });
+  }
+
+  const { action, name } = parsedBody.data;
+
+  if (action === 'create') {
+    const exists = await prisma.botApiKey.findFirst({
+      where: {
+        name,
+        botAccount: {
+          ownerId: user.id,
+          slug,
+        }
+      }
+    });
+    if (exists) {
+      return new Response(JSON.stringify({ success: false, error: 'API Key with this name already exists' }), { status: 400 });
+    }
+    const newKey = await prisma.botApiKey.create({
+      data: {
+        name,
+        botAccount: {
+          connect: {
+            ownerId: user.id,
+            slug,
+          }
+        },
+        key: generateApiKey(),
+      }
+    });
+    return new Response(JSON.stringify({ success: true, apiKey: newKey.key, id: newKey.id }));
+  }
+  if (action === 'regenerate') {
+    const existingKey = await prisma.botApiKey.findFirst({
+      where: {
+        name,
+        botAccount: {
+          ownerId: user.id,
+          slug,
+        }
+      }
+    });
+    if (!existingKey) {
+      return new Response(JSON.stringify({ success: false, error: 'API Key not found' }), { status: 404 });
+    }
+    const newKey = generateApiKey();
+    await prisma.botApiKey.update({
+      where: { id: existingKey.id },
+      data: { key: newKey },
+    });
+    return new Response(JSON.stringify({ success: true, apiKey: newKey, id: existingKey.id }));
+  }
+  if (action === 'revoke') {
+    const existingKey = await prisma.botApiKey.findFirst({
+      where: {
+        name,
+        botAccount: {
+          ownerId: user.id,
+          slug,
+        }
+      }
+    });
+    if (!existingKey) {
+      return new Response(JSON.stringify({ success: false, error: 'API Key not found' }), { status: 404 });
+    }
+    await prisma.botApiKey.delete({
+      where: { id: existingKey.id },
+    });
+    return new Response(JSON.stringify({ success: true }));
+  }
+  return new Response(JSON.stringify({ success: false, error: 'Invalid action' }), { status: 400 });
+}
+
+export async function GET(request: NextRequest, segmentData: { params: Params }) {
+  const { slug } = await segmentData.params;
+  const { user } = await validateRequest();
+  if (!user) {
+    return new Response(JSON.stringify({ success: false, error: 'Unauthorized' }), { status: 401 });
+  }
+
+  const apiKeys = await prisma.botApiKey.findMany({
+    where: {
+      botAccount: {
+        ownerId: user.id,
+        slug,
+      }
+    },
+    select: {
+      id: true,
+      name: true,
+      createdAt: true,
+    },
+    orderBy: {
+      createdAt: 'desc',
+    }
+  });
+  return new Response(JSON.stringify({ success: true, apiKeys }));
+}
+
+function generateApiKey() {
+  const uuid = crypto.randomUUID().replace(/-/g, '');
+  return `hctvb_${uuid}`;
+}

apps/web/src/app/(ui)/(protected)/api/stream/info/route.ts

@@ -9,6 +9,7 @@ export async function GET(request: NextRequest) {
   const shouldGetOwned = searchParams.get('owned') === 'true';
   const allPersonalChannels = searchParams.get('personal') === 'true';
   const isLive = searchParams.get('live') === 'true';
+  const username = searchParams.get('username');
   const { user } = await validateRequest();
 
   if ((shouldGetOwned || allPersonalChannels) && !user) {
@@ -18,6 +19,10 @@ export async function GET(request: NextRequest) {
   const where: Prisma.StreamInfoWhereInput = {};
   const channelConditions: Prisma.ChannelWhereInput[] = [];
 
+  if (username) {
+    where.username = username;
+  }
+
   if (shouldGetOwned && user) {
     channelConditions.push({ ownerId: user.id });
   }
@@ -46,10 +51,41 @@ export async function GET(request: NextRequest) {
       channel: {
         include: {
           personalFor: true,
+          restriction: {
+            select: {
+              id: true,
+              expiresAt: true,
+            },
+          },
         }
       },
     },
   });
 
+  db.forEach((obj) => {
+    if (obj.channel.personalFor) {
+      // @ts-ignore
+      delete obj.channel.personalFor.email;
+    }
+    // @ts-ignore
+    delete obj.channel.obsChatGrantToken;
+
+    if (obj.channel.restriction) {
+      const isExpired = obj.channel.restriction.expiresAt &&
+        new Date(obj.channel.restriction.expiresAt) < new Date();
+      if (isExpired) {
+        // @ts-ignore
+        obj.channel.restriction = null;
+      } else {
+        // @ts-ignore
+        obj.channel.isRestricted = true;
+        // @ts-ignore
+        obj.channel.restrictionExpiresAt = obj.channel.restriction.expiresAt;
+        // @ts-ignore
+        delete obj.channel.restriction;
+      }
+    }
+  });
+
   return Response.json(db);
 }

apps/web/src/app/(ui)/(protected)/layout.tsx

@@ -1,13 +1,42 @@
 import { validateRequest } from '@/lib/auth/validate';
 import { redirect, RedirectType } from 'next/navigation';
+import { prisma } from '@hctv/db';
 
 export default async function Layout({ children }: { children: React.ReactNode }) {
   const { user } = await validateRequest();
   if (!user) {
-    return redirect('/auth/slack');
+    return redirect('/auth/hackclub');
   }
   if (!user.hasOnboarded) {
     return redirect(`/onboarding`, RedirectType.push);
   }
+
+  const ban = await prisma.userBan.findUnique({
+    where: { userId: user.id },
+  });
+
+  if (ban) {
+    const isExpired = ban.expiresAt && new Date(ban.expiresAt) < new Date();
+    if (!isExpired) {
+      return (
+        <div className="flex flex-col items-center justify-center min-h-screen">
+          <h1 className="text-3xl font-bold text-destructive mb-4">Account Suspended</h1>
+          <p className="text-muted-foreground text-center max-w-md mb-4">
+            Your account has been suspended from hackclub.tv.
+          </p>
+          <div className="bg-muted p-4 rounded-lg max-w-md">
+            <p className="text-sm font-medium">Reason:</p>
+            <p className="text-sm text-muted-foreground">{ban.reason}</p>
+          </div>
+          {ban.expiresAt && (
+            <p className="text-sm text-muted-foreground mt-4">
+              Expires: {new Date(ban.expiresAt).toLocaleDateString()}
+            </p>
+          )}
+        </div>
+      );
+    }
+  }
+
   return children;
 }

apps/web/src/app/(ui)/(protected)/settings/bot/[slug]/apikeys.tsx

@@ -0,0 +1,221 @@
+'use client';
+
+import { Button } from '@/components/ui/button';
+import {
+  Card,
+  CardContent,
+  CardDescription,
+  CardFooter,
+  CardHeader,
+  CardTitle,
+} from '@/components/ui/card';
+import { Input } from '@/components/ui/input';
+import { Skeleton } from '@/components/ui/skeleton';
+import { fetcher } from '@/lib/services/swr';
+import { useConfirm } from '@omit/react-confirm-dialog';
+import { Plus, RefreshCcw, Trash } from 'lucide-react';
+import { useState } from 'react';
+import { toast } from 'sonner';
+import useSWR from 'swr';
+import useSWRMutation from 'swr/mutation';
+
+export function ApiKeys({ slug }: { slug: string }) {
+  const confirm = useConfirm();
+  const [newApiKeyName, setNewApiKeyName] = useState('');
+  const { data, error, isLoading, mutate } = useSWR<GetResponse>(
+    `/api/settings/bot/${slug}/apiKey`,
+    fetcher
+  );
+  const { trigger } = useSWRMutation(`/api/settings/bot/${slug}/apiKey`, createApiKey);
+
+  const apiKeyCreate = () => {
+    if (newApiKeyName.trim().length < 3) {
+      toast.error('API Key name must be at least 3 characters long');
+      return;
+    }
+    if (newApiKeyName.trim().length > 50) {
+      toast.error('API Key name must be at most 50 characters long');
+      return;
+    }
+    trigger({ action: 'create', name: newApiKeyName }).then(
+      async (res: PostResponse) => {
+        if (res.success) {
+          setNewApiKeyName('');
+          await navigator.clipboard
+            .writeText(res.apiKey || '')
+            .then(() => toast.success('API key copied to clipboard'))
+            .catch(() => {
+              alert('Failed to copy API key to clipboard, here it is: ' + res.apiKey);
+            });
+          await mutate();
+        } else {
+          toast.error(res.error || 'Error creating API key');
+        }
+      }
+    );
+  };
+
+  return (
+    <Card>
+      <CardHeader>
+        <CardTitle>API Keys</CardTitle>
+        <CardDescription>Manage your API keys</CardDescription>
+      </CardHeader>
+      <CardContent>
+        {isLoading && <ApiKeysSkeleton />}
+        {error && <p>Error loading API keys</p>}
+        {data && !data.success && <p>Error: Could not fetch API keys</p>}
+        {data && (
+          <div className="flex">
+            <Input
+              placeholder="New API Key Name"
+              className="flex-1 mr-2"
+              value={newApiKeyName}
+              onChange={(e) => setNewApiKeyName(e.target.value)}
+              onKeyDown={(e) => {
+                if (e.key === 'Enter') {
+                  apiKeyCreate();
+                }
+              }}
+            />
+            <Button
+              size="icon"
+              onClick={apiKeyCreate}
+            >
+              <Plus />
+            </Button>
+          </div>
+        )}
+        {data && data.success && data.apiKeys.length === 0 && <p>No API keys found</p>}
+        {data && data.success && data.apiKeys.length > 0 && (
+          <ul className="space-y-2 pt-4">
+            {data.apiKeys.map((key) => (
+              <li
+                key={key.id}
+                className="flex items-center justify-between p-3 bg-mantle/50 rounded-md"
+              >
+                <div className="flex-1">
+                  <strong className="text-sm font-medium">{key.name}</strong>
+                </div>
+                <div className="flex items-center space-x-2">
+                  <Button
+                    variant="outline"
+                    size="sm"
+                    onClick={async () => {
+                      const confirmation = await confirm({
+                        title: 'Regenerate API Key',
+                        description:
+                          'Are you sure you want to regenerate this API key? The old key will stop working.',
+                        confirmText: 'Regenerate',
+                        cancelText: 'Cancel',
+                      });
+                      if (!confirmation) return;
+
+                      trigger({ action: 'regenerate', name: key.name }).then(
+                        async (res: PostResponse) => {
+                          if (res.success) {
+                            await navigator.clipboard
+                              .writeText(res.apiKey || '')
+                              .then(() => {
+                                toast.success('API key copied to clipboard');
+                              })
+                              .catch(() => {
+                                alert(
+                                  'Failed to copy API key to clipboard, here it is: ' + res.apiKey
+                                );
+                              });
+                            mutate();
+                          } else {
+                            toast.error(res.error || 'Error regenerating API key');
+                          }
+                        }
+                      );
+                    }}
+                  >
+                    <RefreshCcw className="h-4 w-4" />
+                  </Button>
+                  <Button
+                    variant="destructive"
+                    size="sm"
+                    onClick={async () => {
+                      const confirmation = await confirm({
+                        title: 'Revoke API Key',
+                        description:
+                          'Are you sure you want to revoke this API key? This action cannot be undone.',
+                        confirmText: 'Revoke',
+                        cancelText: 'Cancel',
+                      });
+                      if (!confirmation) return;
+                      trigger({ action: 'revoke', name: key.name }).then(
+                        async (res: PostResponse) => {
+                          if (res.success) {
+                            await mutate();
+                          } else {
+                            toast.error(res.error || 'Error revoking API key');
+                          }
+                        }
+                      );
+                    }}
+                  >
+                    <Trash className="h-4 w-4" />
+                  </Button>
+                </div>
+              </li>
+            ))}
+          </ul>
+        )}
+      </CardContent>
+    </Card>
+  );
+}
+
+function ApiKeysSkeleton() {
+  return (
+    <>
+      <div className='flex'>
+        <Skeleton className='h-10 flex-1 mr-2' />
+        <Skeleton className='h-10 w-10' />
+      </div>
+      <div className='space-y-2 pt-4'>
+        {[1, 2, 3].map((i) => (
+          <div key={i} className='flex items-center justify-between p-3 bg-mantle/50 rounded-md'>
+            <div className='flex-1'>
+              <Skeleton className='h-4 w-1/2' />
+            </div>
+            <div className='flex items-center space-x-2'>
+              <Skeleton className='h-8 w-8' />
+              <Skeleton className='h-8 w-8' />
+            </div>
+          </div>
+        ))}
+      </div>
+    </>
+  )
+}
+
+async function createApiKey(url: string, { arg }: { arg: PostRequest }) {
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(arg),
+  });
+  return res.json();
+}
+
+interface GetResponse {
+  success: boolean;
+  apiKeys: Array<{ id: string; name: string; createdAt: string }>;
+}
+
+interface PostRequest {
+  action: 'revoke' | 'regenerate' | 'create';
+  name: string;
+}
+interface PostResponse {
+  success: boolean;
+  apiKey?: string;
+  id?: string;
+  error?: string;
+}

apps/web/src/app/(ui)/(protected)/settings/bot/[slug]/gensettings.tsx

@@ -0,0 +1,62 @@
+'use client';
+import { UniversalForm } from '@/components/app/UniversalForm/UniversalForm';
+import {
+  Card,
+  CardContent,
+  CardDescription,
+  CardHeader,
+  CardTitle,
+} from '@/components/ui/card';
+import { editBot } from '@/lib/form/actions';
+import { BotAccount } from '@hctv/db';
+import { useRouter } from 'next/navigation';
+
+export function GeneralSettings(props: BotAccount) {
+  const router = useRouter();
+  return (
+    <Card>
+      <CardHeader>
+        <CardTitle>General Settings</CardTitle>
+        <CardDescription>Edit your bot settings!</CardDescription>
+      </CardHeader>
+      <CardContent>
+        <UniversalForm
+          fields={[
+            {
+              name: 'from',
+              type: 'hidden',
+              value: props.id,
+              required: true,
+            },
+            {
+              name: 'name',
+              type: 'text',
+              label: 'Bot Name',
+              placeholder: 'Enter bot name',
+              required: true,
+              value: props.displayName,
+            },
+            {
+              name: 'slug',
+              type: 'text',
+              label: 'Bot Slug',
+              placeholder: 'Enter bot slug',
+              required: true,
+              value: props.slug
+            },
+            {
+              name: 'description',
+              type: 'textarea',
+              label: 'Description',
+              placeholder: 'Enter bot description',
+              value: props.description,
+              textArea: true,
+            },
+          ]}
+          schemaName={'editBot'}
+          action={editBot}
+        />
+      </CardContent>
+    </Card>
+  )
+}

apps/web/src/app/(ui)/(protected)/settings/bot/[slug]/page.tsx

@@ -0,0 +1,46 @@
+import { getBotBySlug } from '@/lib/db/resolve';
+import { validateRequest } from '@/lib/auth/validate';
+import { can } from '@/lib/auth/abac';
+import { redirect } from 'next/navigation';
+import Image from 'next/image';
+import { GeneralSettings } from '@/app/(ui)/(protected)/settings/bot/[slug]/gensettings';
+import { ApiKeys } from '@/app/(ui)/(protected)/settings/bot/[slug]/apikeys';
+import Link from 'next/link';
+import { ArrowLeft } from 'lucide-react';
+
+export default async function Page({ params }: { params: Promise<{ slug: string }> }) {
+  const { user } = await validateRequest();
+  const { slug } = await params;
+  const bot = await getBotBySlug(slug);
+
+  if (!user || !bot || !can(user, 'update', 'bot', { bot })) {
+    redirect('/settings/bot');
+  }
+
+  return (
+    <div className={'container mx-auto py-6 space-y-6'}>
+      <Link href={'/settings/bot'} className="text-sm text-muted-foreground hover:underline flex items-center gap-2">
+        <ArrowLeft className='size-4' /> Back to Bot Accounts
+      </Link>
+      <div className="flex items-center justify-between">
+        <div className={'flex items-center space-x-4'}>
+          <Image
+            src={bot.pfpUrl}
+            alt={'Bot Avatar'}
+            width={48}
+            height={48}
+            className="rounded-full"
+          />
+          <div className={'flex flex-col'}>
+            <h1 className="text-3xl font-bold tracking-tight">{bot.displayName}</h1>
+            <p className="text-muted-foreground">Manage your bot account settings</p>
+          </div>
+        </div>
+      </div>
+      <div className="flex w-full gap-4 flex-col md:flex-row *:w-1/2">
+        <GeneralSettings {...bot} />
+        <ApiKeys slug={slug} />
+      </div>
+    </div>
+  );
+}

apps/web/src/app/(ui)/(protected)/settings/bot/create/page.tsx

@@ -0,0 +1,65 @@
+'use client';
+
+import { UniversalForm } from '@/components/app/UniversalForm/UniversalForm';
+import { createBot } from '@/lib/form/actions';
+import { Bot } from 'lucide-react';
+import { useRouter } from 'next/navigation';
+
+export default function Page() {
+  const router = useRouter();
+
+  return (
+    <div className="min-h-screen bg-background">
+      <div className="flex h-full w-full flex-col items-center justify-center px-4 py-12">
+        <div className="mb-8 text-center">
+          <div className="mx-auto mb-4 flex h-16 w-16 items-center justify-center rounded-full bg-primary shadow-lg">
+            <Bot className="h-8 w-8 text-primary-foreground" />
+          </div>
+          <h1 className="mb-2 text-3xl font-bold text-foreground">Create Bot Account</h1>
+          <p className="text-muted-foreground max-w-xl">
+            Create an automated bot account to provide custom functionality for your community.
+          </p>
+        </div>
+
+        <div className="w-full max-w-md bg-card rounded-xl p-8 border border-border">
+          <UniversalForm
+            fields={[
+              {
+                name: 'name',
+                type: 'text',
+                label: 'Bot Name',
+                placeholder: 'Enter bot name',
+                required: true,
+              },
+              {
+                name: 'slug',
+                type: 'text',
+                label: 'Bot Slug',
+                placeholder: 'Enter bot slug',
+                required: true,
+              },
+              {
+                name: 'description',
+                type: 'textarea',
+                label: 'Description',
+                placeholder: 'Enter bot description',
+              },
+            ]}
+            schemaName={'createBot'}
+            action={createBot}
+            onActionComplete={(res) => {
+              router.push(`/settings/bot/${res.slug}`);
+            }}
+          />
+        </div>
+
+        {/*
+          <p className="mt-6 text-sm text-muted-foreground text-center max-w-md">
+            Your bot will be created with chat permissions. You can configure advanced settings and
+            permissions after creation.
+          </p>
+        */}
+      </div>
+    </div>
+  );
+}

apps/web/src/app/(ui)/(protected)/settings/bot/page.tsx

@@ -0,0 +1,88 @@
+import { validateRequest } from '@/lib/auth/validate';
+import { prisma } from '@hctv/db';
+import { Button } from '@/components/ui/button';
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card';
+import { Badge } from '@/components/ui/badge';
+import { Separator } from '@/components/ui/separator';
+import Link from 'next/link';
+import { Plus, Bot, Calendar, Hash } from 'lucide-react';
+import { redirect } from 'next/navigation';
+import Image from 'next/image';
+
+export default async function Page() {
+  const { user } = await validateRequest();
+  if (!user) {
+    redirect('/');
+  }
+
+  const bots = await prisma.user.findFirst({
+    where: { id: user.id },
+    select: {
+      botAccounts: true,
+    },
+  });
+
+  return (
+    <div className="container mx-auto py-6 space-y-6">
+      <div className="flex items-center justify-between">
+        <div>
+          <h1 className="text-3xl font-bold tracking-tight">Bot Accounts</h1>
+          <p className="text-muted-foreground">Manage your automated bot accounts</p>
+        </div>
+        <Link href="/settings/bot/create">
+          <Button>
+            <Plus className="mr-2 h-4 w-4" />
+            Create Bot
+          </Button>
+        </Link>
+      </div>
+
+      <Separator />
+
+      {bots?.botAccounts.length ? (
+        <div className="grid gap-4 md:grid-cols-2 lg:grid-cols-3">
+          {bots.botAccounts.map((bot) => (
+            <Link href={`/settings/bot/${bot.slug}`} key={bot.id}>
+              <Card key={bot.id} className="hover:shadow-md transition-shadow">
+                <CardHeader className="pb-3">
+                  <div className="flex items-center space-x-2">
+                    <Image src={bot.pfpUrl} alt={'Bot Avatar'} width={32} height={32} className="rounded-full" />
+                    <CardTitle className="text-lg">{bot.displayName}</CardTitle>
+                  </div>
+                </CardHeader>
+                <CardContent className="space-y-3">
+                  <div className="flex items-center space-x-2 text-sm text-muted-foreground">
+                    <Hash className="h-4 w-4" />
+                    <span>{bot.slug}</span>
+                  </div>
+                  <div className="flex items-center space-x-2 text-sm text-muted-foreground">
+                    <Calendar className="h-4 w-4" />
+                    <span>{new Date(bot.createdAt).toLocaleDateString()}</span>
+                  </div>
+                </CardContent>
+              </Card>
+            </Link>
+          ))}
+        </div>
+      ) : (
+        <Card className="text-center py-8">
+          <CardContent className="space-y-4">
+            <Bot className="mx-auto h-12 w-12 text-muted-foreground" />
+            <div>
+              <CardTitle>No bot accounts yet</CardTitle>
+              <CardDescription className="mt-2">
+                Get started by creating your first bot account
+              </CardDescription>
+            </div>
+            <Link href="/settings/bot/create">
+              <Button>
+                <Plus className="mr-2 h-4 w-4" />
+                Create Your First Bot
+              </Button>
+            </Link>
+          </CardContent>
+        </Card>
+      )}
+    </div>
+  );
+}

apps/web/src/app/(ui)/(protected)/settings/channel/[channelName]/page.client.tsx

@@ -19,6 +19,8 @@ import {
   Copy,
   Check,
   Wrench,
+  Eye,
+  EyeOff,
 } from 'lucide-react';
 import { UniversalForm } from '@/components/app/UniversalForm/UniversalForm';
 import {
@@ -28,6 +30,7 @@ import {
   deleteChannel,
   toggleGlobalChannelNotifs,
   editStreamInfo,
+  changeUsername,
 } from '@/lib/form/actions';
 import { Switch } from '@/components/ui/switch';
 import { toast } from 'sonner';
@@ -50,6 +53,16 @@ import { useOwnedChannels } from '@/lib/hooks/useUserList';
 import { ChannelSelect } from '@/components/app/ChannelSelect/ChannelSelect';
 import { useRouter } from 'next/navigation';
 import Link from 'next/link';
+import { useConfirm } from '@omit/react-confirm-dialog';
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from '@/components/ui/select';
+import { getMediamtxClientEnvs } from '@/lib/utils/mediamtx/client';
+import type { MediaMTXRegion } from '@/lib/utils/mediamtx/regions';
 
 interface ChannelSettingsClientProps {
   channel: Channel & {
@@ -62,6 +75,7 @@ interface ChannelSettingsClientProps {
     followers: (Follow & { user: { id: string; slack_id: string } })[];
     followerPersonalChannels: (Channel | null)[];
     is247: boolean;
+    nameLastChanged: Date | null;
   };
   isOwner: boolean;
   currentUser: User;
@@ -74,12 +88,17 @@ export default function ChannelSettingsClient({
   currentUser,
   isPersonal,
 }: ChannelSettingsClientProps) {
+  const confirm = useConfirm();
   const [streamKey, setStreamKey] = useState(channel.streamKey?.key || '');
   const [keyVisible, setKeyVisible] = useState(false);
-  const [copied, setCopied] = useState(false);
+  const [copied, setCopied] = useState({
+    streamKey: false,
+    streamUrl: false,
+  });
   const [selTab, setSelTab] = useQueryState('tab', parseAsString.withDefault('general'));
   const [isUploading, setIsUploading] = useState(false);
   const [uploadError, setUploadError] = useState<string | null>(null);
+  const [region, setRegion] = useState<MediaMTXRegion>('hq');
   const channelList = useOwnedChannels();
   const router = useRouter();
 
@@ -95,12 +114,38 @@ export default function ChannelSettingsClient({
     }
   }, []);
 
+  const handleUsernameChangeComplete = useCallback(
+    (result: any) => {
+      if (result?.success && result?.newUsername) {
+        toast.success('Username changed successfully! Redirecting...');
+        router.push(`/settings/channel/${result.newUsername}?tab=${selTab}`);
+      }
+    },
+    [router, selTab]
+  );
+
+  const getUsernameChangeCooldownInfo = () => {
+    if (!channel.nameLastChanged) {
+      return { canChange: true, daysRemaining: 0 };
+    }
+    const daysSinceLastChange = Math.floor(
+      (Date.now() - new Date(channel.nameLastChanged).getTime()) / (1000 * 60 * 60 * 24)
+    );
+    const cooldownDays = 30;
+    if (daysSinceLastChange >= cooldownDays) {
+      return { canChange: true, daysRemaining: 0 };
+    }
+    return { canChange: false, daysRemaining: cooldownDays - daysSinceLastChange };
+  };
+
+  const cooldownInfo = getUsernameChangeCooldownInfo();
+
   const copyStreamKey = async () => {
     if (streamKey) {
       await navigator.clipboard.writeText(streamKey);
-      setCopied(true);
+      setCopied({ ...copied, streamKey: true });
       toast.success('Stream key copied to clipboard');
-      setTimeout(() => setCopied(false), 2000);
+      setTimeout(() => setCopied({ ...copied, streamKey: false }), 2000);
     }
   };
 
@@ -124,6 +169,25 @@ export default function ChannelSettingsClient({
     }
   };
 
+  const generateStreamUrl = () => {
+    if (!streamKey) {
+      toast.error('Stream key not available');
+      return '';
+    }
+    const { ingestRoute } = getMediamtxClientEnvs(region);
+    return `srt://${ingestRoute}?streamid=publish:${channel.name}:thisusernameislongonpurposesoyoudontaccidentallyleakyourstreamkey:${streamKey}&pkt_size=1316`;
+  };
+
+  const copyStreamUrl = async () => {
+    const url = generateStreamUrl();
+    if (url) {
+      await navigator.clipboard.writeText(url);
+      setCopied({ ...copied, streamUrl: true });
+      toast.success('Stream URL copied to clipboard');
+      setTimeout(() => setCopied({ ...copied, streamUrl: false }), 2000);
+    }
+  };
+
   return (
     <div className="container max-w-4xl mx-auto py-6 px-4">
       <div className="mb-6 flex">
@@ -143,14 +207,14 @@ export default function ChannelSettingsClient({
             </div>
           </div>
         </div>
-        <div className='flex-1' />
+        <div className="flex-1" />
         <div>
           <ChannelSelect
-            channelList={channelList.channels.map(c => c.channel)}
+            channelList={channelList.channels.map((c) => c.channel)}
             value={channel.name}
             onSelect={(value) => {
               if (value === 'create') {
-                router.push(`/create`);
+                router.push(`/settings/channel/create`);
               } else {
                 router.push(`/settings/channel/${value}?tab=${selTab}`);
               }
@@ -180,7 +244,7 @@ export default function ChannelSettingsClient({
             Notifications
           </TabsTrigger>
           <TabsTrigger value="utilities" className="flex items-center gap-2">
-            <Wrench className='size-4' />
+            <Wrench className="size-4" />
             Utilities
           </TabsTrigger>
         </TabsList>
@@ -206,7 +270,7 @@ export default function ChannelSettingsClient({
                       return (
                         <div className="space-y-4">
                           <input type="hidden" {...field} />
-                          
+
                           {field.value && (
                             <div className="flex items-center space-x-4">
                               <Avatar className="h-16 w-16">
@@ -215,7 +279,9 @@ export default function ChannelSettingsClient({
                               </Avatar>
                               <div className="flex-1">
                                 <p className="text-sm font-medium">Current profile picture</p>
-                                <p className="text-xs text-muted-foreground">Click &quot;Upload new image&quot; to replace</p>
+                                <p className="text-xs text-muted-foreground">
+                                  Click &quot;Upload new image&quot; to replace
+                                </p>
                               </div>
                               <Button
                                 type="button"
@@ -230,14 +296,14 @@ export default function ChannelSettingsClient({
                               </Button>
                             </div>
                           )}
-                          
+
                           <div>
                             <UploadButton
                               endpoint="pfpUpload"
                               className="mt-2 ut-button:bg-mantle ut-button:text-mantle-foreground ut-allowed-content:text-muted-foreground/70"
                               content={{
-                                button: field.value ? "Upload new image" : "Upload profile picture",
-                                allowedContent: "Image (1MB max)"
+                                button: field.value ? 'Upload new image' : 'Upload profile picture',
+                                allowedContent: 'Image (1MB max)',
                               }}
                               onUploadBegin={() => {
                                 setIsUploading(true);
@@ -257,19 +323,15 @@ export default function ChannelSettingsClient({
                               }}
                               disabled={isUploading}
                             />
-                            
+
                             {isUploading && (
-                              <p className="mt-2 text-sm text-primary">
-                                Uploading...
-                              </p>
+                              <p className="mt-2 text-sm text-primary">Uploading...</p>
                             )}
-                            
+
                             {uploadError && (
-                              <p className="mt-2 text-sm text-red-600">
-                                {uploadError}
-                              </p>
+                              <p className="mt-2 text-sm text-red-600">{uploadError}</p>
                             )}
-                            
+
                             {!field.value && !isUploading && !uploadError && (
                               <p className="mt-2 text-sm text-muted-foreground">
                                 Upload a profile picture for your channel.
@@ -315,7 +377,8 @@ export default function ChannelSettingsClient({
                         <div>
                           <label className="text-sm font-medium">24/7 Channel</label>
                           <p className="text-xs text-muted-foreground">
-                            Mark this channel as always live. It will disable notifications on #hctv-streams.
+                            Mark this channel as always live. It will disable notifications on
+                            #hctv-streams.
                           </p>
                         </div>
                         <Switch
@@ -327,7 +390,7 @@ export default function ChannelSettingsClient({
                         <input type="hidden" {...field} value={field.value ? 'true' : 'false'} />
                       </div>
                     ),
-                  }
+                  },
                 ]}
                 schemaName="updateChannelSettings"
                 action={updateChannelSettings}
@@ -335,36 +398,87 @@ export default function ChannelSettingsClient({
                 onActionComplete={handleChannelSettingsActionComplete}
               />
 
-              {false && isOwner && (
+              <Separator />
+
+              {isPersonal && isOwner && (
+                <div className="space-y-4">
+                  <div className="flex items-center gap-2">
+                    <h3 className="text-lg font-semibold">Username</h3>
+                  </div>
+                  <p className="text-sm text-muted-foreground">
+                    Your username is how others find and mention you on hctv. You can change it once
+                    every 30 days.
+                  </p>
+                  {!cooldownInfo.canChange && (
+                    <div className="p-3 border border-accent/20 rounded-lg bg-accent/5">
+                      <p className="text-sm text-accent">
+                        You can change your username again in {cooldownInfo.daysRemaining} day
+                        {cooldownInfo.daysRemaining === 1 ? '' : 's'}.
+                      </p>
+                    </div>
+                  )}
+                  <UniversalForm
+                    fields={[
+                      { name: 'channelId', type: 'hidden', value: channel.id, label: 'Channel ID' },
+                      {
+                        name: 'newUsername',
+                        label: 'New Username',
+                        type: 'text',
+                        value: '',
+                        placeholder: channel.name,
+                        description:
+                          'Only lowercase letters, numbers, underscores, and dashes. Max 20 characters.',
+                        inputFilter: /[^a-z0-9_-]/g,
+                        maxChars: 20,
+                      },
+                    ]}
+                    schemaName="changeUsername"
+                    action={changeUsername}
+                    submitText="Change Username"
+                    onActionComplete={handleUsernameChangeComplete}
+                  />
+                </div>
+              )}
+
+              {isOwner && !isPersonal && (
                 <>
                   <Separator />
                   <div className="space-y-4">
                     <h3 className="text-lg font-semibold text-destructive">Danger Zone</h3>
-                    <Card className="border-destructive">
-                      <CardHeader>
-                        <CardTitle className="text-destructive">Delete Channel</CardTitle>
-                        <CardDescription>
+                    <div className="flex items-center justify-between p-4 border border-destructive/20 rounded-lg bg-destructive/5">
+                      <div>
+                        <p className="font-medium text-destructive">Delete Channel</p>
+                        <p className="text-sm text-muted-foreground">
                           Permanently delete this channel. This action cannot be undone.
-                        </CardDescription>
-                      </CardHeader>
-                      <CardContent>
-                        <Button
-                          variant="destructive"
-                          onClick={() => {
-                            if (
-                              confirm(
-                                'Are you sure you want to delete this channel? This action cannot be undone.'
-                              )
-                            ) {
-                              deleteChannel(channel.id);
+                        </p>
+                      </div>
+                      <Button
+                        variant="destructive"
+                        size="sm"
+                        onClick={async () => {
+                          if (
+                            await confirm({
+                              title: 'Delete Channel',
+                              description:
+                                'Are you sure you want to delete this channel? This action cannot be undone.',
+                              confirmText: 'Delete',
+                              cancelText: 'Cancel',
+                            })
+                          ) {
+                            const result = await deleteChannel(channel.id);
+                            if (result.success) {
+                              toast.success('Channel deleted successfully');
+                              router.push('/settings/channel');
+                            } else {
+                              toast.error(result.error || 'Failed to delete channel');
                             }
-                          }}
-                        >
-                          <Trash2 className="h-4 w-4 mr-2" />
-                          Delete Channel
-                        </Button>
-                      </CardContent>
-                    </Card>
+                          }
+                        }}
+                      >
+                        <Trash2 className="h-4 w-4 mr-2" />
+                        Delete
+                      </Button>
+                    </div>
                   </div>
                 </>
               )}
@@ -379,51 +493,96 @@ export default function ChannelSettingsClient({
               <CardDescription>Manage your stream key and streaming configuration.</CardDescription>
             </CardHeader>
             <CardContent className="space-y-6">
-              <div className="space-y-4">
-                <div>
-                  <h3 className="text-lg font-semibold mb-2">Stream Key</h3>
-                  <p className="text-sm text-mantle-foreground mb-4">
-                    Use this key to start streaming to your channel. Keep it secure!
-                  </p>
-                  <p className="text-xs text-muted-foreground mb-4">
-                    Need help getting started? Check out our{' '}
-                    <Link
-                      href="https://gist.github.com/SrIzan10/ebd89ced6b21b016d4d389e6711a94e9" 
-                      className="text-primary hover:underline"
-                      target="_blank"
-                      rel="noopener noreferrer"
-                    >
-                      streaming guide
-                    </Link>
-                    .
-                  </p>
-                  <div className="flex items-center gap-2">
-                    <div className="relative flex-1">
-                      <input
-                        type={keyVisible ? 'text' : 'password'}
-                        value={streamKey}
-                        readOnly
-                        className="w-full px-3 py-2 border rounded-md bg-mantle font-mono text-sm"
-                      />
+              <div>
+                <div className="space-y-3">
+                  <div className="space-y-2">
+                    <label className="text-sm font-medium">Stream Key</label>
+                    <div className="flex items-center gap-2">
+                      <div className="relative flex-1">
+                        <input
+                          type={keyVisible ? 'text' : 'password'}
+                          value={streamKey}
+                          readOnly
+                          className="w-full px-3 py-2 pr-10 border rounded-md bg-mantle font-mono text-sm"
+                        />
+                        <button
+                          type="button"
+                          onClick={() => setKeyVisible(!keyVisible)}
+                          className="absolute right-3 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground transition-colors"
+                        >
+                          {keyVisible ? (
+                            <EyeOff className="h-4 w-4" />
+                          ) : (
+                            <Eye className="h-4 w-4" />
+                          )}
+                        </button>
+                      </div>
+                      <Button onClick={regenerateStreamKey} variant="outline" size="smicon">
+                        <Key className="h-4 w-4" />
+                      </Button>
+                      <Button
+                        variant="outline"
+                        size="smicon"
+                        onClick={copyStreamKey}
+                        disabled={!streamKey}
+                      >
+                        {copied.streamKey ? (
+                          <Check className="h-4 w-4" />
+                        ) : (
+                          <Copy className="h-4 w-4" />
+                        )}
+                      </Button>
+                    </div>
+                  </div>
+
+                  <div className="space-y-2">
+                    <div className="flex items-center justify-between">
+                      <label className="text-sm font-medium">Stream URL (for OBS)</label>
+                      <Select value={region} onValueChange={(v) => setRegion(v as MediaMTXRegion)}>
+                        <SelectTrigger className="w-[180px] h-8">
+                          <SelectValue placeholder="Select region" />
+                        </SelectTrigger>
+                        <SelectContent>
+                          <SelectItem value="hq">HQ Server A 🇺🇸</SelectItem>
+                        </SelectContent>
+                      </Select>
+                    </div>
+                    <div className="flex items-center gap-2">
+                      <div className="relative flex-1">
+                        <input
+                          type="text"
+                          value={generateStreamUrl()}
+                          readOnly
+                          className="w-full px-3 py-2 border rounded-md bg-mantle font-mono text-xs"
+                        />
+                      </div>
+                      <Button
+                        variant="outline"
+                        size="smicon"
+                        onClick={copyStreamUrl}
+                        disabled={!streamKey}
+                      >
+                        {copied.streamUrl ? (
+                          <Check className="h-4 w-4" />
+                        ) : (
+                          <Copy className="h-4 w-4" />
+                        )}
+                      </Button>
                     </div>
-                    <Button variant="outline" size="sm" onClick={() => setKeyVisible(!keyVisible)}>
-                      {keyVisible ? 'Hide' : 'Show'}
-                    </Button>
-                    <Button
-                      variant="outline"
-                      size="sm"
-                      onClick={copyStreamKey}
-                      disabled={!streamKey}
-                    >
-                      {copied ? <Check className="h-4 w-4" /> : <Copy className="h-4 w-4" />}
-                    </Button>
                   </div>
                 </div>
-
-                <Button onClick={regenerateStreamKey} variant="outline">
-                  <Key className="h-4 w-4 mr-2" />
-                  Regenerate Stream Key
-                </Button>
+                <p className="text-xs text-muted-foreground mt-2">
+                  Need help getting started? Check out our{' '}
+                  <Link
+                    href="https://docs.hackclub.tv/guides/start-stream/"
+                    className="text-primary hover:underline"
+                    target="_blank"
+                    rel="noopener noreferrer"
+                  >
+                    streaming guide
+                  </Link>
+                  .
+                </p>
               </div>
 
               <Separator />
@@ -536,8 +695,15 @@ export default function ChannelSettingsClient({
                             <Button
                               variant="outline"
                               size="sm"
-                              onClick={() => {
-                                if (confirm('Remove this manager?')) {
+                              onClick={async () => {
+                                if (
+                                  await confirm({
+                                    title: 'Remove Manager',
+                                    description: `Are you sure you want to remove ${personalChannel?.name} as a manager? They will no longer be able to stream or moderate this channel.`,
+                                    confirmText: 'Remove',
+                                    cancelText: 'Cancel',
+                                  })
+                                ) {
                                   removeChannelManager(channel.id, manager.id);
                                 }
                               }}
@@ -643,13 +809,13 @@ export default function ChannelSettingsClient({
                 <div>
                   <h3 className="text-lg font-semibold mb-2">Chat overlay</h3>
                   <p className="text-sm text-mantle-foreground mb-4">
-                    Add a 300x600 browser source with this and enjoy! 
+                    Add a 300x600 browser source with this and enjoy!
                   </p>
                   <div className="flex items-center gap-2">
                     <div className="relative flex-1">
                       <input
                         type={keyVisible ? 'text' : 'password'}
-                        value={`https://hctv.srizan.dev/chat/${channel.name}?grant=${channel.obsChatGrantToken}`}
+                        value={`https://hackclub.tv/chat/${channel.name}?grant=${channel.obsChatGrantToken}`}
                         readOnly
                         className="w-full px-3 py-2 border rounded-md bg-mantle font-mono text-sm"
                       />

apps/web/src/app/(ui)/(protected)/settings/channel/[channelName]/page.tsx

@@ -3,6 +3,7 @@ import { prisma } from '@hctv/db';
 import { redirect } from 'next/navigation';
 import ChannelSettingsClient from './page.client';
 import { resolvePersonalChannel } from '@/lib/auth/resolve';
+import { can } from '@/lib/auth/abac';
 
 export default async function ChannelSettingsPage({
   params,
@@ -13,7 +14,7 @@ export default async function ChannelSettingsPage({
   const { user } = await validateRequest();
 
   if (!user) {
-    redirect('/auth/slack');
+    redirect('/auth/hackclub');
   }
 
   const channel = await prisma.channel.findUnique({
@@ -42,9 +43,8 @@ export default async function ChannelSettingsPage({
   }
 
   const isOwner = channel.ownerId === user.id;
-  const isManager = channel.managers.some((manager) => manager.id === user.id);
 
-  if (!isOwner && !isManager) {
+  if (!can(user, 'update', 'channel', { channel })) {
     redirect('/');
   }
 

apps/web/src/app/(ui)/(protected)/settings/channel/create/page.tsx

@@ -32,8 +32,7 @@ function CreateChannelPage() {
             schemaName="createChannel"
             action={createChannel}
             onActionComplete={(r) => {
-              // @ts-expect-error
-              const channelName = r?.channel;
+              const channelName = r.channel;
               if (channelName) {
                 router.push(`/${channelName}`);
               }

apps/web/src/app/(ui)/(public)/auth/hackclub/callback/route.ts

@@ -1,6 +1,6 @@
-import { slack, lucia } from '@hctv/auth';
+import { hackClub, lucia, HCID_TOKEN_URL, HCID_USER_INFO_URL } from '@hctv/auth';
 import { cookies as nextCookies } from 'next/headers';
-import { decodeIdToken, OAuth2RequestError } from 'arctic';
+import { OAuth2RequestError } from 'arctic';
 import { generateIdFromEntropySize } from 'lucia';
 import { prisma } from '@hctv/db';
 import { getRedisConnection } from '@hctv/db';
@@ -10,7 +10,7 @@ export async function GET(request: Request): Promise<Response> {
   const url = new URL(request.url);
 	const code = url.searchParams.get("code");
 	const state = url.searchParams.get("state");
-	const storedState = cookies.get("slack_oauth_state")?.value ?? null;
+	const storedState = cookies.get("hackclub_oauth_state")?.value ?? null;
 	if (!code || !state || !storedState || state !== storedState) {
     console.log('invalid state stuff');
 		return new Response(null, {
@@ -19,22 +19,38 @@ export async function GET(request: Request): Promise<Response> {
 	}
 
   try {
-    const tokens = await slack.validateAuthorizationCode(code);
-    const accessToken = tokens.accessToken()
-    const slackUserResponse = await fetch('https://slack.com/api/openid.connect.userInfo', {
+    const tokens = await hackClub.validateAuthorizationCode(HCID_TOKEN_URL, code, null);
+    const accessToken = tokens.accessToken();
+    const userResponse = await fetch(HCID_USER_INFO_URL, {
       headers: {
         'Authorization': `Bearer ${accessToken}`,
       },
     });
-    const slackUser: SlackUserInfo = await slackUserResponse.json();
+    const userResult: HackClubUserResponse = await userResponse.json();
+    const identity = userResult.identity;
+
+    const slackId = identity.slack_id;
+    if (!slackId) {
+      return new Response("Please make sure to have a Slack account before continuing.", {
+        status: 400,
+      });
+    }
 
     const existingUser = await prisma.user.findFirst({
       where: {
-        slack_id: slackUser.sub,
+        slack_id: slackId,
       },
     });
 
     if (existingUser) {
+      // Update email if it's missing or changed
+      if (existingUser.email !== identity.primary_email) {
+        await prisma.user.update({
+          where: { id: existingUser.id },
+          data: { email: identity.primary_email },
+        });
+      }
+
       const session = await lucia.createSession(existingUser.id, {});
       const sessionCookie = lucia.createSessionCookie(session.id);
       await getRedisConnection().set(`sessions:${session.id}`, '');
@@ -52,8 +68,9 @@ export async function GET(request: Request): Promise<Response> {
     await prisma.user.create({
       data: {
         id: userId,
-        slack_id: slackUser.sub,
-        pfpUrl: `https://cachet.dunkirk.sh/users/${slackUser.sub}/r`,
+        slack_id: slackId,
+        email: identity.primary_email,
+        pfpUrl: identity.slack_id ? `https://cachet.dunkirk.sh/users/${identity.slack_id}/r` : 'https://github.com/hackclub.png',
         hasOnboarded: false,
       },
     });
@@ -83,40 +100,15 @@ export async function GET(request: Request): Promise<Response> {
   }
 }
 
-interface SlackUserInfo {
-  // OpenID Connect standard fields
-  ok: boolean;
-  sub: string;
-  email: string;
-  email_verified: boolean;
-  date_email_verified: number;
-  name: string;
-  picture: string;
-  given_name: string;
-  family_name: string;
-  locale: string;
-
-  // Slack-specific fields
-  ['https://slack.com/user_id']: string;
-  ['https://slack.com/team_id']: string;
-  ['https://slack.com/team_name']: string;
-  ['https://slack.com/team_domain']: string;
-
-  // User image URLs
-  ['https://slack.com/user_image_24']: string;
-  ['https://slack.com/user_image_32']: string;
-  ['https://slack.com/user_image_48']: string;
-  ['https://slack.com/user_image_72']: string;
-  ['https://slack.com/user_image_192']: string;
-  ['https://slack.com/user_image_512']: string;
-
-  // Team image URLs
-  ['https://slack.com/team_image_34']?: string;
-  ['https://slack.com/team_image_44']?: string;
-  ['https://slack.com/team_image_68']?: string;
-  ['https://slack.com/team_image_88']?: string;
-  ['https://slack.com/team_image_102']?: string;
-  ['https://slack.com/team_image_132']?: string;
-  ['https://slack.com/team_image_230']?: string;
-  ['https://slack.com/team_image_default']?: boolean;
+interface HackClubIdentity {
+  id: string;
+  slack_id?: string;
+  first_name: string;
+  last_name: string;
+  primary_email: string;
 }
+
+interface HackClubUserResponse {
+  identity: HackClubIdentity;
+}
+

apps/web/src/app/(ui)/(public)/auth/hackclub/route.ts

@@ -1,12 +1,12 @@
 import { generateState } from "arctic";
-import { slack } from '@hctv/auth';
+import { hackClub, HCID_AUTH_URL } from '@hctv/auth';
 import { cookies } from "next/headers";
 
 export async function GET(): Promise<Response> {
 	const state = generateState();
-	const url = slack.createAuthorizationURL(state, ['openid', 'profile']);
+	const url = hackClub.createAuthorizationURL(HCID_AUTH_URL, state, ['slack_id', 'verification_status', 'email']);
 
-	(await cookies()).set("slack_oauth_state", state, {
+	(await cookies()).set("hackclub_oauth_state", state, {
 		path: "/",
 		secure: process.env.NODE_ENV === "production",
 		httpOnly: true,

apps/web/src/app/(ui)/(public)/onboarding/page.client.tsx

@@ -107,7 +107,9 @@ export default function OnboardingClient() {
                   name: 'username', 
                   label: 'Channel Username', 
                   type: 'text',
-                  placeholder: 'e.g., yourname or yourname-codes'
+                  placeholder: 'e.g., yourname or yourname-codes',
+                  maxChars: 20,
+                  inputFilter: /[^a-z0-9_-]/g,
                 },
               ]}
               schemaName="onboard"
@@ -119,7 +121,7 @@ export default function OnboardingClient() {
             <div className="mt-4 p-3 bg-muted/30 rounded-md">
               <p className="text-xs text-muted-foreground">
                 <strong>Username rules:</strong> Only lowercase letters (a-z), numbers (0-9), 
-                underscores (_), and dashes (-) are allowed. Must be unique across the platform.
+                underscores (_), and dashes (-) are allowed. Up to 20 characters. Must be unique across the platform.
               </p>
             </div>
           </CardContent>

apps/web/src/app/(ui)/(public)/onboarding/page.tsx

@@ -4,7 +4,10 @@ import OnboardingClient from "./page.client";
 
 export default async function Page() {
   const { user } = await validateRequest();
-  if (user!.hasOnboarded) {
+  if (!user) {
+    return redirect('/');
+  }
+  if (user.hasOnboarded) {
     return redirect('/');
   }
   return <OnboardingClient />;

apps/web/src/app/(ui)/(public)/page.tsx

@@ -42,7 +42,8 @@ export default async function Home() {
             <Card className="overflow-hidden hover:shadow-lg transition-shadow">
               <CardContent className="p-0">
                 <div className="relative">
-                  <Image
+                  {/* eslint-disable-next-line @next/next/no-img-element */}
+                  <img
                     src={`/api/stream/thumb/${stream.channel.name}`}
                     width={512}
                     height={512}

apps/web/src/app/(ui)/layout.tsx

@@ -1,5 +1,6 @@
 import type { Metadata } from 'next';
 import { Inter } from 'next/font/google';
+import { cookies } from 'next/headers';
 import '../globals.css';
 import Navbar from '@/components/app/NavBar/NavBar';
 import { SessionProvider } from '@/lib/providers/SessionProvider';
@@ -16,6 +17,7 @@ import { extractRouterConfig } from 'uploadthing/server';
 import { ourFileRouter } from '@/lib/services/uploadthing/fileRouter';
 import { NuqsAdapter } from 'nuqs/adapters/next/app'
 import SonnerNewVersion from '@/components/app/SonnerNewVersion/SonnerNewVersion';
+import ConfirmDialogProvider from '@/lib/providers/ConfirmProvider';
 
 const inter = Inter({ subsets: ['latin'] });
 
@@ -30,6 +32,9 @@ export default async function RootLayout({
   children: React.ReactNode;
 }>) {
   const sessionData = await validateRequest();
+  const cookieStore = await cookies();
+  const defaultOpen = cookieStore.get('sidebar:state')?.value === 'true';
+
   return (
     <html lang="en">
       <body className={cn('flex flex-col h-screen', inter.className)}>
@@ -44,20 +49,26 @@ export default async function RootLayout({
             <NextSSRPlugin
               routerConfig={extractRouterConfig(ourFileRouter)}
             />
-            <NuqsAdapter>
-              <SidebarProvider>
-                <StreamInfoProvider>
-                  {/* this promise is ugly but i'm lazy to fix the type errors */}
-                  <Navbar editLivestream={Promise.resolve(<EditLivestream />)} />
-                  <div className="flex flex-1 pt-16">
-                    {/* pt-16 for navbar height */}
-                    <Sidebar className="pt-16" />
-                    <main className="flex-1 overflow-auto">{children}</main>
-                  </div>
-                  <Toaster />
-                </StreamInfoProvider>
-              </SidebarProvider>
-            </NuqsAdapter>
+            <ConfirmDialogProvider defaultOptions={{
+              cancelButton: {
+                variant: 'outline',
+              },
+            }}>
+              <NuqsAdapter>
+                <SidebarProvider defaultOpen={defaultOpen}>
+                  <StreamInfoProvider>
+                    {/* this promise is ugly but i'm lazy to fix the type errors */}
+                    <Navbar editLivestream={Promise.resolve(<EditLivestream />)} />
+                    <div className="flex flex-1 pt-16">
+                      {/* pt-16 for navbar height */}
+                      <Sidebar className="pt-16" />
+                      <main className="flex-1 overflow-auto">{children}</main>
+                    </div>
+                    <Toaster />
+                  </StreamInfoProvider>
+                </SidebarProvider>
+              </NuqsAdapter>
+            </ConfirmDialogProvider>
           </ThemeProvider>
         </SessionProvider>
       </body>

apps/web/src/app/globals.css

@@ -4,111 +4,125 @@
 
 @layer base {
   :root {
-    --background: 220 23.077% 94.902%;
-    --foreground: 233.793 16.022% 35.49%;
+    /* Light theme - based on your color scheme */
 
-    --muted: 222.857 15.909% 82.745%;
-    --muted-foreground: 233.333 12.796% 41.373%;
+    /* Main background and foreground */
+    --background: 350 59% 98%; /* FDF7F8 - main background */
+    --foreground: 351 34% 30%; /* 5D3A3F - main text */
 
-    --popover: 220 23.077% 94.902%;
-    --popover-foreground: 233.793 16.022% 35.49%;
+    /* Muted elements */
+    --muted: 350 40% 93%; /* F8E8EA - muted background */
+    --muted-foreground: 350 30% 45%; /* Lighter version of main text */
 
-    --card: 220 23.077% 94.902%;
-    --card-foreground: 233.793 16.022% 35.49%;
+    /* Popover and card */
+    --popover: 0 0% 100%; /* FFFFFF - popover background */
+    --popover-foreground: 351 34% 30%; /* 5D3A3F - popover text */
+    --card: 0 0% 100%; /* FFFFFF - card background */
+    --card-foreground: 351 34% 30%; /* 5D3A3F - card text */
 
-    --border: 225 13.559% 76.863%;
-    --input: 225 13.559% 76.863%;
+    /* Border and input */
+    --border: 350 30% 85%; /* Derived border color */
+    --input: 350 30% 85%; /* Input background */
 
-    --primary: 219.907 91.489% 53.922%;
-    --primary-foreground: 220 23.077% 94.902%;
+    /* Primary actions */
+    --primary: 350 70% 50%; /* C8394F - primary button */
+    --primary-foreground: 0 0% 100%; /* FFFFFF - text on primary */
 
-    --secondary: 222.857 15.909% 82.745%;
-    --secondary-foreground: 233.793 16.022% 35.49%;
+    /* Secondary elements */
+    --secondary: 350 40% 93%; /* F8E8EA - secondary background */
+    --secondary-foreground: 351 34% 30%; /* 5D3A3F - text on secondary */
 
-    --accent: 222.857 15.909% 82.745%;
-    --accent-foreground: 233.793 16.022% 35.49%;
+    /* Accent elements */
+    --accent: 350 70% 40%; /* A12D3E - accent color */
+    --accent-foreground: 0 0% 100%; /* FFFFFF - text on accent */
 
-    --destructive: 347.077 86.667% 44.118%;
-    --destructive-foreground: 220 21.951% 91.961%;
+    /* Destructive actions */
+    --destructive: 350 70% 55%; /* D63C56 - error/destroy */
+    --destructive-foreground: 0 0% 100%; /* FFFFFF - text on destructive */
 
-    --ring: 233.793 16.022% 35.49%;
+    /* Focus ring */
+    --ring: 350 70% 50%; /* C8394F - focus ring */
 
-    --surface-1: 225 14% 77%;
-    --surface-2: 227 12% 71%;
+    /* Surface colors */
+    --surface-1: 350 40% 93%; /* F8E8EA - surface 1 */
+    --surface-2: 350 35% 88%; /* Derived surface 2 */
 
-    --mantle: 220 22% 92%;
+    /* Mantle */
+    --mantle: 350 59% 98%; /* FDF7F8 - mantle */
 
+    /* Radius */
     --radius: 0.5rem;
 
-    --sidebar-background: 0 0% 98%;
-
-    --sidebar-foreground: 240 5.3% 26.1%;
-
-    --sidebar-primary: 240 5.9% 10%;
-
-    --sidebar-primary-foreground: 0 0% 98%;
-
-    --sidebar-accent: 240 4.8% 95.9%;
-
-    --sidebar-accent-foreground: 240 5.9% 10%;
-
-    --sidebar-border: 220 13% 91%;
-
-    --sidebar-ring: 217.2 91.2% 59.8%;
+    /* Sidebar specific */
+    --sidebar-background: 350 59% 98%; /* FDF7F8 - sidebar bg */
+    --sidebar-foreground: 351 34% 30%; /* 5D3A3F - sidebar text */
+    --sidebar-primary: 350 70% 50%; /* C8394F - sidebar primary */
+    --sidebar-primary-foreground: 0 0% 100%; /* FFFFFF - text on sidebar primary */
+    --sidebar-accent: 350 40% 93%; /* F8E8EA - sidebar accent */
+    --sidebar-accent-foreground: 351 34% 30%; /* 5D3A3F - text on sidebar accent */
+    --sidebar-border: 350 30% 85%; /* Derived border */
+    --sidebar-ring: 350 70% 50%; /* C8394F - sidebar focus ring */
   }
 
   .dark {
-    --background: 240 21.053% 14.902%;
-    --foreground: 226.154 63.934% 88.039%;
+    /* Dark theme - based on your color scheme */
 
-    --muted: 240 12% 19%;
-    --muted-foreground: 240 12% 69%;
+    /* Main background and foreground */
+    --background: 350 20% 15%; /* 2A1F21 - main background */
+    --foreground: 350 30% 92%; /* F5E6E8 - main text */
 
-    --popover: 240 21.053% 14.902%;
-    --popover-foreground: 226.154 63.934% 88.039%;
+    /* Muted elements */
+    --muted: 350 20% 25%; /* 4A2D31 - muted background */
+    --muted-foreground: 350 30% 75%; /* Lighter version of main text */
 
-    --card: 240 21.053% 14.902%;
-    --card-foreground: 226.154 63.934% 88.039%;
+    /* Popover and card */
+    --popover: 350 20% 15%; /* 2A1F21 - popover background */
+    --popover-foreground: 350 30% 92%; /* F5E6E8 - popover text */
+    --card: 350 20% 15%; /* 2A1F21 - card background */
+    --card-foreground: 350 30% 92%; /* F5E6E8 - card text */
 
-    --border: 234.286 13.208% 31.176%;
-    --input: 234.286 13.208% 31.176%;
+    /* Border and input */
+    --border: 350 20% 35%; /* Derived border color */
+    --input: 350 20% 35%; /* Input background */
 
-    --primary: 267 84% 81%;
-    --primary-foreground: 267 84% 21%;
+    /* Primary actions */
+    --primary: 350 100% 75%; /* FF7A8A - primary button */
+    --primary-foreground: 350 20% 15%; /* 2A1F21 - text on primary */
 
-    --secondary: 236.842 16.239% 22.941%;
-    --secondary-foreground: 226.154 63.934% 88.039%;
+    /* Secondary elements */
+    --secondary: 350 20% 25%; /* 4A2D31 - secondary background */
+    --secondary-foreground: 350 30% 92%; /* F5E6E8 - text on secondary */
 
-    --accent: 236.842 16.239% 22.941%;
-    --accent-foreground: 226.154 63.934% 88.039%;
+    /* Accent elements */
+    --accent: 350 100% 80%; /* FF9AAA - accent color */
+    --accent-foreground: 350 20% 15%; /* 2A1F21 - text on accent */
 
-    --destructive: 343.269 81.25% 74.902%;
-    --destructive-foreground: 240 21.311% 11.961%;
+    /* Destructive actions */
+    --destructive: 350 100% 70%; /* FF6B7D - error/destroy */
+    --destructive-foreground: 350 20% 15%; /* 2A1F21 - text on destructive */
 
-    --ring: 226.154 63.934% 88.039%;
+    /* Focus ring */
+    --ring: 350 100% 75%; /* FF7A8A - focus ring */
 
-    --surface-1: 234 13% 31%;
-    --surface-2: 233 12% 39%;
+    /* Surface colors */
+    --surface-1: 350 20% 25%; /* 4A2D31 - surface 1 */
+    --surface-2: 350 20% 35%; /* Derived surface 2 */
 
-    --mantle: 240 21.311% 11.961%;
+    /* Mantle */
+    --mantle: 350 20% 12%; /* 1F1617 - mantle */
 
+    /* Radius */
     --radius: 0.5rem;
 
-    --sidebar-background: 240 21.311% 11.961%;     /* crust - matches mantle var */
-    
-    --sidebar-foreground: 226.154 63.934% 88.039%; /* matches main foreground */
-    
-    --sidebar-primary: 217.168 91.87% 75.882%;     /* matches primary */
-    
-    --sidebar-primary-foreground: 240 21.053% 14.902%; /* matches primary-foreground */
-    
-    --sidebar-accent: 236.842 16.239% 22.941%;     /* matches accent */
-    
-    --sidebar-accent-foreground: 226.154 63.934% 88.039%; /* matches accent-foreground */
-    
-    --sidebar-border: 234.286 13.208% 31.176%;     /* matches border */
-    
-    --sidebar-ring: 217.168 91.87% 75.882%;        /* matches primary */
+    /* Sidebar specific */
+    --sidebar-background: 350 20% 12%; /* 1F1617 - sidebar bg */
+    --sidebar-foreground: 350 30% 92%; /* F5E6E8 - sidebar text */
+    --sidebar-primary: 350 100% 75%; /* FF7A8A - sidebar primary */
+    --sidebar-primary-foreground: 350 20% 15%; /* 2A1F21 - text on sidebar primary */
+    --sidebar-accent: 350 20% 25%; /* 4A2D31 - sidebar accent */
+    --sidebar-accent-foreground: 350 30% 92%; /* F5E6E8 - text on sidebar accent */
+    --sidebar-border: 350 20% 35%; /* Derived border */
+    --sidebar-ring: 350 100% 75%; /* FF7A8A - sidebar focus ring */
   }
 }
 
@@ -119,16 +133,20 @@
   body {
     @apply bg-background text-foreground;
   }
+  
   .scrollbar-hide::-webkit-scrollbar { display: none; }
   .scrollbar-hide { -ms-overflow-style: none; scrollbar-width: none; }
 }
+
 h1 {
   @apply scroll-m-20 text-4xl font-extrabold tracking-tight lg:text-5xl;
 }
+
 h2 {
   @apply scroll-m-20 pb-2 text-3xl font-semibold tracking-tight first:mt-0;
 }
 
+/* Media controller styles remain unchanged */
 media-controller {
   --media-primary-color: #ffffff;
   --media-secondary-color: hsla(var(--background), 0.85);
@@ -160,7 +178,7 @@ media-time-range {
 }
 
 media-time-display {
-  --media-text-color: #ffffff; 
+  --media-text-color: #ffffff;
 }
 
 media-controller::part(centered-layer) {

apps/web/src/app/layout.tsx

@@ -2,8 +2,22 @@ import { NuqsAdapter } from 'nuqs/adapters/next/app';
 import './globals.css';
 
 export default function Layout({ children }: { children: React.ReactNode }) {
+  const publicEnv = Object.keys(process.env).reduce((acc, key) => {
+    if (key.startsWith('NEXT_PUBLIC_')) {
+      acc[key] = process.env[key];
+    }
+    return acc;
+  }, {} as Record<string, string | undefined>);
+
   return (
     <html lang="en">
+      <head>
+        <script
+          dangerouslySetInnerHTML={{
+            __html: `window.__ENV = ${JSON.stringify(publicEnv)}`,
+          }}
+        />
+      </head>
       <NuqsAdapter>
         <body>
           <main>{children}</main>

apps/web/src/components/app/ChatPanel/ChatPanel.tsx

@@ -245,9 +245,14 @@ export default function ChatPanel(props: Props) {
   };
 
   return (
-    <div className={`${props.isObsPanel ? 'w-full text-white' : 'md:border bg-mantle w-[350px] max-w-[350px]'} flex flex-col h-full`}>
-      <div ref={scrollRef} className={`flex-1 p-4 ${props.isObsPanel ? 'scrollbar-hide' : ''} overflow-y-auto flex flex-col`}>
-        <div className="space-y-4 flex-1">
+    <div
+      className={`${props.isObsPanel ? 'w-full text-white' : 'md:border-l border-border bg-mantle w-[350px] max-w-[350px]'} flex flex-col h-full`}
+    >
+      <div
+        ref={scrollRef}
+        className={`flex-1 px-4 py-2 ${props.isObsPanel ? 'scrollbar-hide' : 'scrollbar-thin scrollbar-thumb-border scrollbar-track-transparent'} overflow-y-auto overflow-x-hidden`}
+      >
+        <div className="space-y-1 min-h-full flex flex-col justify-end">
           {chatMessages.map((msg, i) => (
             <Message
               key={i}
@@ -260,8 +265,8 @@ export default function ChatPanel(props: Props) {
         </div>
       </div>
       {!props.isObsPanel && (
-        <div className="p-4 border-t relative">
-          <div className="flex space-x-2">
+        <div className="p-3 border-t border-border relative">
+          <div className="flex gap-2">
             <Textarea
               ref={textareaRef}
               value={message}
@@ -281,11 +286,16 @@ export default function ChatPanel(props: Props) {
               onClick={(e) => {
                 setCursorPosition(e.currentTarget.selectionStart || 0);
               }}
-              placeholder="Type a message"
-              className="flex-1 bg-transparent focus-visible:ring-offset-0 min-h-[40px] max-h-[120px] resize-none py-2"
+              placeholder="Send a message..."
+              className="flex-1 bg-background/50 border-border focus-visible:ring-1 focus-visible:ring-primary focus-visible:ring-offset-0 min-h-[40px] max-h-[100px] resize-none py-2 text-sm"
               rows={1}
             />
-            <Button size="icon" className="text-black transition-colors" onClick={sendMessage}>
+            <Button
+              size="icon"
+              className="shrink-0 transition-colors"
+              onClick={sendMessage}
+              disabled={!message.trim()}
+            >
               <Send className="h-4 w-4" />
             </Button>
           </div>
@@ -313,6 +323,8 @@ export interface User {
   id: string;
   username: string;
   pfpUrl: string;
+  isBot: boolean;
+  displayName?: string;
 }
 
 interface Props {

apps/web/src/components/app/ChatPanel/EmojiSearch.tsx

@@ -28,25 +28,27 @@ export function EmojiSearch({
   useEffect(() => {
     const beforeCursor = message.substring(0, cursorPosition);
     const match = beforeCursor.match(/:[\w\-+]*$/);
-    
+
     if (match) {
       const term = match[0].substring(1);
       setSearchTerm(term);
-      
+
       if (term.length > 0) {
         const localResults = Array.from(emojiMap.keys())
-          .filter(name => name.toLowerCase().includes(term.toLowerCase()))
+          .filter((name) => name.toLowerCase().includes(term.toLowerCase()))
           .slice(0, 5);
-        
+
         if (localResults.length > 0) {
           setSearchResults(localResults);
         }
-        
+
         if (socket && socket.readyState === WebSocket.OPEN) {
-          socket.send(JSON.stringify({
-            type: 'emojiSearch',
-            searchTerm: term
-          }));
+          socket.send(
+            JSON.stringify({
+              type: 'emojiSearch',
+              searchTerm: term,
+            })
+          );
         }
       } else {
         setSearchResults([]);
@@ -63,22 +65,22 @@ export function EmojiSearch({
     const handleEmojiSearchResponse = (event: MessageEvent) => {
       try {
         const data = JSON.parse(event.data);
-        
+
         if (data.type === 'emojiSearchResponse') {
           const serverResults = data.results || [];
-          
+
           const localResults = Array.from(emojiMap.keys())
-            .filter(name => searchTerm && name.toLowerCase().includes(searchTerm.toLowerCase()))
+            .filter((name) => searchTerm && name.toLowerCase().includes(searchTerm.toLowerCase()))
             .slice(0, 5);
-            
+
           const combinedResults = [...serverResults];
-          
-          localResults.forEach(name => {
+
+          localResults.forEach((name) => {
             if (!combinedResults.includes(name)) {
               combinedResults.push(name);
             }
           });
-          
+
           setSearchResults(combinedResults.slice(0, 10));
           setSelectedIndex(0);
         }
@@ -95,18 +97,18 @@ export function EmojiSearch({
 
   useEffect(() => {
     if (!textareaRef.current) return;
-    
+
     const handleKeyDown = (e: KeyboardEvent) => {
       if (!searchTerm || searchResults.length === 0) return;
-      
+
       switch (e.key) {
         case 'ArrowDown':
           e.preventDefault();
-          setSelectedIndex(prev => (prev + 1) % searchResults.length);
+          setSelectedIndex((prev) => (prev + 1) % searchResults.length);
           break;
         case 'ArrowUp':
           e.preventDefault();
-          setSelectedIndex(prev => (prev - 1 + searchResults.length) % searchResults.length);
+          setSelectedIndex((prev) => (prev - 1 + searchResults.length) % searchResults.length);
           break;
         case 'Enter':
           if (searchResults[selectedIndex]) {
@@ -127,10 +129,10 @@ export function EmojiSearch({
           break;
       }
     };
-    
+
     const textarea = textareaRef.current;
     textarea.addEventListener('keydown', handleKeyDown);
-    
+
     return () => {
       textarea.removeEventListener('keydown', handleKeyDown);
     };
@@ -150,25 +152,25 @@ export function EmojiSearch({
   }
 
   return (
-    <div className="absolute bottom-16 left-4 bg-mantle border rounded-md shadow-lg max-h-60 overflow-y-auto z-10 min-w-[200px] max-w-[300px]">
+    <div className="absolute bottom-full left-0 right-0 mb-2 mx-0 bg-mantle border border-border rounded-lg shadow-lg max-h-60 overflow-y-auto z-10">
       <div ref={resultsRef} className="py-1">
         {searchResults.map((emojiName, index) => {
           const isSelected = index === selectedIndex;
           const emojiUrl = emojiMap.get(emojiName);
-          
+
           return (
             <div
               key={emojiName}
-              className={`px-3 py-1.5 flex items-center gap-2 cursor-pointer ${
+              className={`px-3 py-2 flex items-center gap-3 cursor-pointer transition-colors ${
                 isSelected ? 'bg-primary/10' : 'hover:bg-primary/5'
               }`}
               onClick={() => onSelect(emojiName)}
             >
               {emojiUrl && (
-                <Image src={emojiUrl} alt={emojiName} width={20} height={20} className="w-5 h-5" />
+                <Image src={emojiUrl} alt={emojiName} width={24} height={24} className="w-6 h-6" />
               )}
-              <span className="flex-grow text-sm">{emojiName}</span>
-              {isSelected && <Check className="h-4 w-4 text-blue-500" />}
+              <span className="flex-grow text-sm font-medium">{emojiName}</span>
+              {isSelected && <Check className="h-4 w-4 text-primary" />}
             </div>
           );
         })}

apps/web/src/components/app/ChatPanel/message.tsx

@@ -1,31 +1,32 @@
 import { User } from './ChatPanel';
 import React from 'react';
 import Image from 'next/image';
-import {
-  Tooltip,
-  TooltipContent,
-  TooltipTrigger,
-} from "@/components/ui/tooltip"
+import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@/components/ui/tooltip';
+import { Bot } from 'lucide-react';
 
 export function Message({ user, message, type, emojiMap }: MessageProps) {
   if (type === 'systemMsg') {
     return (
-      <div className="flex items-center justify-center">
-        <span className="text-xs text-muted-foreground">{message}</span>
+      <div className="flex items-center justify-center py-1">
+        <span className="text-xs text-muted-foreground italic">{message}</span>
       </div>
     );
   }
 
   return (
-    <div className="flex">
-      <div
-        lang="en"
-        className="max-w-full break-all whitespace-pre-wrap hyphens-auto"
-      >
-        <p>
-          <span className="font-bold mr-2">{user?.username}</span>
+    <div className="group hover:bg-primary/5 rounded px-2 py-1 -mx-2 transition-colors">
+      <div className="flex items-start gap-2">
+        <span className="font-semibold text-primary shrink-0 flex items-center gap-1">
+          {user?.isBot && <Bot className="size-4 text-muted-foreground" />}
+          <span>{user?.displayName || user?.username}</span>
+        </span>
+        <span
+          lang="en"
+          className="text-foreground break-words overflow-wrap-anywhere min-w-0 flex-1"
+          style={{ overflowWrap: 'anywhere', wordBreak: 'break-word' }}
+        >
           <EmojiRenderer text={message} emojiMap={emojiMap} />
-        </p>
+        </span>
       </div>
     </div>
   );
@@ -45,21 +46,31 @@ export function EmojiRenderer({ text, emojiMap }: EmojiRendererProps) {
 
           if (emojiUrl) {
             return (
-              <Tooltip key={index} delayDuration={250}>
-                <TooltipTrigger>
-                  <span key={index} className="inline-block align-middle" style={{ height: '1.2em' }}>
-                    <Image src={emojiUrl} alt={part} width={20} height={20} className="inline-block" />
-                  </span>
-                </TooltipTrigger>
-                <TooltipContent>
-                  {part}
-                </TooltipContent>
-              </Tooltip>
+              <TooltipProvider key={index}>
+                <Tooltip delayDuration={250}>
+                  <TooltipTrigger asChild>
+                    <span className="inline-flex items-center align-middle mx-0.5">
+                      <Image
+                        src={emojiUrl}
+                        alt={part}
+                        width={20}
+                        height={20}
+                        className="inline-block"
+                      />
+                    </span>
+                  </TooltipTrigger>
+                  <TooltipContent>{part}</TooltipContent>
+                </Tooltip>
+              </TooltipProvider>
             );
           }
         }
 
-        return <span key={index}>{part}</span>;
+        // Preserve text as-is, handling whitespace properly
+        if (part) {
+          return <span key={index}>{part}</span>;
+        }
+        return null;
       })}
     </>
   );

apps/web/src/components/app/LandingPage/LandingPage.tsx

@@ -8,22 +8,16 @@ export default function LandingPage() {
   return (
     <>
       <main className="flex-1">
-        {/* Hero Section */}
         <section className="relative w-full py-20 md:py-32 lg:py-40 xl:py-48 overflow-hidden">
-          <div className="absolute inset-0 bg-gradient-to-br from-primary/10 via-transparent to-secondary/10"></div>
+          <div className="absolute inset-0"></div>
           <div className="container px-4 md:px-6 relative">
-            <div className="flex flex-col items-center space-y-8 text-center">
-              <Badge variant="outline" className="px-4 py-2 text-sm font-medium bg-primary/10 text-primary border-primary/20">
-                <Heart className="w-4 h-4 mr-2" />
-                Made with ❤️ by Hack Clubbers
-              </Badge>
-              
+            <div className="flex flex-col items-center space-y-8 text-center">              
               <div className="space-y-6">
-                <h1 className="text-4xl font-bold tracking-tight sm:text-5xl md:text-6xl lg:text-7xl bg-gradient-to-r from-primary via-primary/80 to-primary/60 bg-clip-text text-transparent">
+                <h1 className="text-4xl font-bold tracking-tight sm:text-5xl md:text-6xl lg:text-7xl text-primary">
                   hackclub.tv
                 </h1>
                 <p className="mx-auto max-w-[600px] text-lg text-muted-foreground md:text-xl">
-                  The streaming platform where Hack Clubbers share their coding journeys, workshops, and hackathon adventures with the world.
+                  The streaming website for Hack Clubbers, by Hack Clubbers.
                 </p>
               </div>
               
@@ -42,133 +36,6 @@ export default function LandingPage() {
             </div>
           </div>
         </section>
-
-        {/* Features Section */}
-        <section className="w-full py-16 md:py-24 lg:py-32 bg-muted/30" id="features">
-          <div className="container px-4 md:px-6">
-            <div className="flex flex-col items-center text-center space-y-8 mb-16">
-              <Badge variant="secondary" className="px-4 py-2">
-                Platform Features
-              </Badge>
-              <div className="space-y-4">
-                <h2 className="text-3xl font-bold tracking-tight sm:text-4xl md:text-5xl">
-                  Built for creators, by creators
-                </h2>
-                <p className="max-w-[700px] text-lg text-muted-foreground">
-                  Everything you need to connect, create, and grow within the Hack Club community.
-                </p>
-              </div>
-            </div>
-
-            <div className="grid gap-6 md:grid-cols-2 lg:grid-cols-3 max-w-5xl mx-auto">
-              <Card className="border-0 shadow-sm hover:shadow-md transition-shadow">
-                <CardHeader className="pb-4">
-                  <div className="w-12 h-12 bg-primary/10 rounded-lg flex items-center justify-center mb-4">
-                    <Zap className="w-6 h-6 text-primary" />
-                  </div>
-                  <CardTitle className="text-xl">Low-Latency Streaming</CardTitle>
-                </CardHeader>
-                <CardContent>
-                  <CardDescription className="text-base">
-                    Share your coding sessions with ultra-low latency. Your audience stays engaged with real-time interaction.
-                  </CardDescription>
-                </CardContent>
-              </Card>
-
-              <Card className="border-0 shadow-sm hover:shadow-md transition-shadow">
-                <CardHeader className="pb-4">
-                  <div className="w-12 h-12 bg-primary/10 rounded-lg flex items-center justify-center mb-4">
-                    <MessageCircle className="w-6 h-6 text-primary" />
-                  </div>
-                  <CardTitle className="text-xl">Real-Time Chat</CardTitle>
-                </CardHeader>
-                <CardContent>
-                  <CardDescription className="text-base">
-                    Engage with your community through integrated chat. Get instant feedback and build connections.
-                  </CardDescription>
-                </CardContent>
-              </Card>
-
-              <Card className="border-0 shadow-sm hover:shadow-md transition-shadow">
-                <CardHeader className="pb-4">
-                  <div className="w-12 h-12 bg-primary/10 rounded-lg flex items-center justify-center mb-4">
-                    <Users className="w-6 h-6 text-primary" />
-                  </div>
-                  <CardTitle className="text-xl">Community First</CardTitle>
-                </CardHeader>
-                <CardContent>
-                  <CardDescription className="text-base">
-                    Follow your favorite streamers, discover new creators, and be part of the vibrant Hack Club ecosystem.
-                  </CardDescription>
-                </CardContent>
-              </Card>
-
-              <Card className="border-0 shadow-sm hover:shadow-md transition-shadow">
-                <CardHeader className="pb-4">
-                  <div className="w-12 h-12 bg-accent/50 rounded-lg flex items-center justify-center mb-4">
-                    <Code className="w-6 h-6 text-accent-foreground" />
-                  </div>
-                  <CardTitle className="text-xl">Code-Focused</CardTitle>
-                </CardHeader>
-                <CardContent>
-                  <CardDescription className="text-base">
-                    Built specifically for developers. Perfect for coding sessions, tutorials, and technical workshops.
-                  </CardDescription>
-                </CardContent>
-              </Card>
-
-              <Card className="border-0 shadow-sm hover:shadow-md transition-shadow">
-                <CardHeader className="pb-4">
-                  <div className="w-12 h-12 bg-secondary/50 rounded-lg flex items-center justify-center mb-4">
-                    <Play className="w-6 h-6 text-secondary-foreground" />
-                  </div>
-                  <CardTitle className="text-xl">Easy to Use</CardTitle>
-                </CardHeader>
-                <CardContent>
-                  <CardDescription className="text-base">
-                    Simple, intuitive interface. Start streaming in minutes, not hours. Focus on what you love: coding.
-                  </CardDescription>
-                </CardContent>
-              </Card>
-
-              <Card className="border-0 shadow-sm hover:shadow-md transition-shadow">
-                <CardHeader className="pb-4">
-                  <div className="w-12 h-12 bg-primary/10 rounded-lg flex items-center justify-center mb-4">
-                    <Heart className="w-6 h-6 text-primary" />
-                  </div>
-                  <CardTitle className="text-xl">Open Source</CardTitle>
-                </CardHeader>
-                <CardContent>
-                  <CardDescription className="text-base">
-                    Transparent, community-driven, and built in the open. Contribute, customize, and make it yours.
-                  </CardDescription>
-                </CardContent>
-              </Card>
-            </div>
-          </div>
-        </section>
-
-        {/* CTA Section */}
-        <section className="w-full py-16 md:py-24">
-          <div className="container px-4 md:px-6">
-            <div className="flex flex-col items-center text-center space-y-8">
-              <div className="space-y-4">
-                <h2 className="text-3xl font-bold tracking-tight sm:text-4xl">
-                  Ready to share your journey?
-                </h2>
-                <p className="max-w-[600px] text-lg text-muted-foreground">
-                  Join the community of makers, builders, and dreamers. Start streaming your coding adventures today.
-                </p>
-              </div>
-              <Link href="/login">
-                <Button size="lg" className="px-8 py-3 text-lg font-semibold">
-                  <Play className="w-5 h-5 mr-2" />
-                  Get Started Now
-                </Button>
-              </Link>
-            </div>
-          </div>
-        </section>
       </main>
     </>
   );

apps/web/src/components/app/Livestream/Livestream.tsx

@@ -1,28 +1,77 @@
 'use client';
 
+import { useEffect, useState } from 'react';
+import { format } from 'date-fns';
 import StreamPlayer from '../StreamPlayer/StreamPlayer';
 import UserInfoCard from '../UserInfoCard/UserInfoCard';
 import ChatPanel from '../ChatPanel/ChatPanel';
-import type { StreamInfo, User, Channel } from '@hctv/db';
+import { Button } from '@/components/ui/button';
+import type { StreamInfo, Channel } from '@hctv/db';
 import { useIsMobile } from '@/lib/hooks/useMobile';
+import { useAllChannels } from '@/lib/hooks/useUserList';
+import { RefreshCw } from 'lucide-react';
 
 export default function LiveStream(props: Props) {
   const isMobile = useIsMobile();
-  
+  const { channels, refresh } = useAllChannels(5000);
+  const [isRestricted, setIsRestricted] = useState(false);
+  const [restrictionExpiresAt, setRestrictionExpiresAt] = useState<string | null>(null);
+  const [isRefreshing, setIsRefreshing] = useState(false);
+
+  useEffect(() => {
+    const currentStream = channels.find((s) => s.username === props.username);
+    if (currentStream?.channel?.isRestricted) {
+      setIsRestricted(true);
+      setRestrictionExpiresAt(currentStream.channel.restrictionExpiresAt || null);
+    } else if (isRestricted && currentStream && !currentStream.channel?.isRestricted) {
+      setIsRestricted(false);
+      setRestrictionExpiresAt(null);
+    }
+  }, [channels, props.username, isRestricted]);
+
+  const handleRefresh = async () => {
+    setIsRefreshing(true);
+    try {
+      await refresh();
+    } finally {
+      setIsRefreshing(false);
+    }
+  };
+
+  if (isRestricted) {
+    return (
+      <div className="flex flex-col items-center justify-center h-[calc(100vh-64px)] p-4">
+        <h1 className="text-2xl font-bold text-destructive mb-2">Channel Restricted</h1>
+        <p className="text-muted-foreground text-center max-w-md mb-4">
+          This channel has been restricted by a moderator and is no longer available for viewing.
+        </p>
+        {restrictionExpiresAt && (
+          <p className="text-sm text-muted-foreground mb-4">
+            Restriction lifts: {format(new Date(restrictionExpiresAt), 'PPP p')}
+          </p>
+        )}
+        <Button variant="outline" onClick={handleRefresh} disabled={isRefreshing}>
+          <RefreshCw className={`h-4 w-4 mr-2 ${isRefreshing ? 'animate-spin' : ''}`} />
+          {isRefreshing ? 'Checking...' : 'Check again'}
+        </Button>
+      </div>
+    );
+  }
+
   return (
     <div className={`${isMobile ? 'flex flex-col' : 'flex'} h-[calc(100vh-64px)] w-full`}>
-      <div className="flex-1 flex flex-col">
+      <div className="flex-1 flex flex-col min-w-0 overflow-hidden">
         <StreamPlayer />
         {isMobile && (
-          <div className="h-[300px]">
+          <div className="flex-1 min-h-[250px] max-h-[400px] border-t border-border">
             <ChatPanel />
           </div>
         )}
         <UserInfoCard streamInfo={props.streamInfo} />
       </div>
-      
+
       {!isMobile && (
-        <div>
+        <div className="h-full shrink-0">
           <ChatPanel />
         </div>
       )}
@@ -33,4 +82,4 @@ export default function LiveStream(props: Props) {
 interface Props {
   username: string;
   streamInfo: StreamInfo & { channel: Channel };
-}
+}

apps/web/src/components/app/NavBar/NavBar.tsx

@@ -15,7 +15,7 @@ import { logout } from '@/lib/auth/actions';
 import { useSession } from '@/lib/providers/SessionProvider';
 import Link from 'next/link';
 import { ThemeSwitcher } from '../ThemeSwitcher/ThemeSwitcher';
-import { Slack } from 'lucide-react';
+import { IdCard, Shield } from 'lucide-react';
 import { SidebarTrigger } from '@/components/ui/sidebar';
 
 export default function Navbar(props: Props) {
@@ -51,9 +51,33 @@ export default function Navbar(props: Props) {
                   <Link href={`/settings/follows`}>
                     <DropdownMenuItem className="cursor-pointer">Follows</DropdownMenuItem>
                   </Link>
-                  <Link href={`/create`}>
+                  <Link href={`/settings/channel/create`}>
                     <DropdownMenuItem className="cursor-pointer">Create channel</DropdownMenuItem>
                   </Link>
+                  <Link href={`/settings/bot`}>
+                    <DropdownMenuItem className="cursor-pointer">Bot accounts</DropdownMenuItem>
+                  </Link>
+                  {user.isAdmin && (
+                    <>
+                      <DropdownMenuSeparator />
+                      <Link href={`/admin`}>
+                        <DropdownMenuItem className="cursor-pointer text-primary">
+                          <Shield className="w-4 h-4 mr-2" />
+                          Admin Panel
+                        </DropdownMenuItem>
+                      </Link>
+                    </>
+                  )}
+                  <DropdownMenuSeparator />
+                  <Link href={'https://docs.hackclub.tv'} target="_blank" rel="noreferrer">
+                    <DropdownMenuItem className="cursor-pointer">API Docs</DropdownMenuItem>
+                  </Link>
+                  <Link href={'https://github.com/SrIzan10/hctv'} target="_blank" rel="noreferrer">
+                    <DropdownMenuItem className="cursor-pointer">Github</DropdownMenuItem>
+                  </Link>
+                  <Link href={'https://github.com/sponsors/SrIzan10'} target="_blank" rel="noreferrer">
+                    <DropdownMenuItem className="cursor-pointer">Sponsor</DropdownMenuItem>
+                  </Link>
                 </DropdownMenuGroup>
                 <DropdownMenuSeparator />
                 <DropdownMenuGroup>
@@ -84,9 +108,9 @@ export default function Navbar(props: Props) {
               </DropdownMenuContent>
             </DropdownMenu>
           ) : (
-            <Link href="/auth/slack">
+            <Link href="/auth/hackclub">
               <Button variant="outline" size="sm" className="gap-1 md:gap-2 text-xs md:text-sm">
-                <Slack className="w-3 h-3 md:w-4 md:h-4" />
+                <IdCard className="w-3 h-3 md:w-4 md:h-4" />
                 <span className="hidden sm:inline">Sign in</span>
                 <span className="sm:hidden">Login</span>
               </Button>

apps/web/src/components/app/Sidebar/Sidebar.tsx

@@ -1,136 +1,162 @@
 'use client';
 
 import * as React from 'react';
-import { ChevronDown, ChevronUp } from 'lucide-react';
-import { Avatar, AvatarFallback, AvatarImage } from '@/components/ui/avatar';
 import {
   Sidebar as UISidebar,
   SidebarContent,
   SidebarGroup,
   SidebarGroupContent,
   SidebarGroupLabel,
-  SidebarHeader,
   SidebarMenu,
   SidebarMenuButton,
   SidebarMenuItem,
+  useSidebar,
 } from '@/components/ui/sidebar';
-import { StreamInfoResponse, useStreams } from '@/lib/providers/StreamInfoProvider';
+import { StreamInfoResponse } from '@/lib/providers/StreamInfoProvider';
 import { useRouter } from 'next/navigation';
 import { Skeleton } from '@/components/ui/skeleton';
 import { useAllChannels } from '@/lib/hooks/useUserList';
+import { Separator } from '@/components/ui/separator';
 
 export default function Sidebar({ ...props }: React.ComponentProps<typeof UISidebar>) {
   const { channels: stream, isLoading } = useAllChannels(5000);
-  const [followedExpanded, setFollowedExpanded] = React.useState(true);
+  const { state } = useSidebar();
+  const isCollapsed = state === 'collapsed';
 
-  if (isLoading) return <SidebarSkeleton />;
+  if (isLoading) return <SidebarSkeleton {...props} />;
 
   const liveStreamers = stream?.filter((s) => s.isLive) || [];
   const offlineStreamers = stream?.filter((s) => !s.isLive) || [];
 
   return (
-    <UISidebar {...props}>
+    <UISidebar collapsible="icon" {...props}>
       <SidebarContent>
         <SidebarGroup>
-          <SidebarGroupLabel asChild>
-            <button
-              onClick={() => setFollowedExpanded(!followedExpanded)}
-              className="w-full flex items-center justify-between"
-            >
-              <span>Live Channels</span>
-              {followedExpanded ? (
-                <ChevronUp className="h-4 w-4" />
-              ) : (
-                <ChevronDown className="h-4 w-4" />
-              )}
-            </button>
+          <SidebarGroupLabel className="flex items-center justify-between px-2 py-1.5">
+            <span className="text-xs font-semibold uppercase text-muted-foreground group-data-[collapsible=icon]:opacity-0 transition-opacity duration-200">
+              Live Channels
+            </span>
+            <span className="text-xs text-muted-foreground group-data-[collapsible=icon]:opacity-0 transition-opacity duration-200">
+              {liveStreamers.length}
+            </span>
           </SidebarGroupLabel>
 
-          {followedExpanded && (
-            <SidebarGroupContent>
-              <SidebarMenu>
-                {liveStreamers.map((streamer) => (
-                  <StreamerItem key={streamer.id} streamer={streamer} />
-                ))}
-              </SidebarMenu>
-            </SidebarGroupContent>
-          )}
+          <SidebarGroupContent>
+            <SidebarMenu>
+              {liveStreamers.length === 0 && !isCollapsed && (
+                <div className="px-4 py-2 text-sm text-muted-foreground">
+                  No channels live
+                </div>
+              )}
+              {liveStreamers.map((streamer) => (
+                <StreamerItem key={streamer.id} streamer={streamer} isCollapsed={isCollapsed} />
+              ))}
+            </SidebarMenu>
+          </SidebarGroupContent>
         </SidebarGroup>
 
-        {offlineStreamers.length > 0 && (
-          <SidebarGroup>
-            <SidebarGroupLabel>Offline Channels</SidebarGroupLabel>
-            <SidebarGroupContent>
-              <SidebarMenu>
-                {offlineStreamers.map((streamer) => (
-                  <StreamerItem key={streamer.id} streamer={streamer} />
-                ))}
-              </SidebarMenu>
-            </SidebarGroupContent>
-          </SidebarGroup>
-        )}
+        <Separator className="group-data-[collapsible=icon]:block hidden" />
+        
+        <SidebarGroup>
+          <SidebarGroupLabel className="flex items-center justify-between px-2 py-1.5">
+            <span className="text-xs font-semibold uppercase text-muted-foreground group-data-[collapsible=icon]:opacity-0 transition-opacity duration-200">
+              Offline Channels
+            </span>
+          </SidebarGroupLabel>
+          <SidebarGroupContent>
+            <SidebarMenu>
+              {offlineStreamers.map((streamer) => (
+                <StreamerItem key={streamer.id} streamer={streamer} isCollapsed={isCollapsed} />
+              ))}
+            </SidebarMenu>
+          </SidebarGroupContent>
+        </SidebarGroup>
       </SidebarContent>
     </UISidebar>
   );
 }
 
-function StreamerItem({ streamer }: { streamer: StreamInfoResponse[0] }) {
+function StreamerItem({ streamer, isCollapsed }: { streamer: StreamInfoResponse[0], isCollapsed: boolean }) {
   const router = useRouter();
+  
   return (
-    <SidebarMenuItem key={streamer.id} className={streamer.isLive ? '' : '*:text-muted-foreground'}>
-      <SidebarMenuButton className="flex items-center gap-3 h-full" onClick={() => {
-        router.push(`/${streamer.username}`);
-      }}>
-        <div className="relative">
-          <Avatar className="h-9 w-9">
-            <AvatarImage src={streamer.channel.pfpUrl} alt={streamer.username} />
-            <AvatarFallback>{streamer.username}</AvatarFallback>
-          </Avatar>
-          {streamer.isLive && (
-            <span className="absolute -top-1 -right-1 w-3 h-3 bg-primary rounded-full border-2 border-black" />
+    <SidebarMenuItem>
+      <SidebarMenuButton
+        asChild
+        tooltip={streamer.username}
+        className="h-12"
+        onClick={() => router.push(`/${streamer.username}`)}
+      >
+        <button className="flex w-full items-center gap-3">
+          <div className="relative flex-shrink-0">
+            {/* eslint-disable-next-line @next/next/no-img-element */}
+            <img
+              src={streamer.channel.pfpUrl}
+              alt={streamer.username}
+              className="h-8 w-8 rounded-full object-cover"
+              loading="lazy"
+            />
+            {streamer.isLive && (
+              <span className="absolute -bottom-0.5 -right-0.5 flex h-3 w-3 items-center justify-center rounded-full bg-background ring-2 ring-background">
+                <span className="h-2 w-2 rounded-full bg-red-500 animate-pulse" />
+              </span>
+            )}
+          </div>
+          
+          {!isCollapsed && (
+            <div className="flex flex-1 flex-col items-start overflow-hidden">
+              <div className="flex w-full items-center justify-between">
+                <span className="truncate font-medium text-sm leading-none">
+                  {streamer.username}
+                </span>
+                {streamer.isLive && (
+                  <div className="flex items-center gap-1 text-xs text-red-500">
+                    <span className="h-1.5 w-1.5 rounded-full bg-red-500" />
+                    <span>{streamer.viewers}</span>
+                  </div>
+                )}
+              </div>
+              <span className="truncate text-xs text-muted-foreground w-full text-left">
+                {streamer.isLive ? streamer.title || streamer.category || 'Live' : 'Offline'}
+              </span>
+            </div>
           )}
-        </div>
-        <div className="flex-1">
-          <p className="font-medium truncate">{streamer.username}</p>
-          <p className="text-sm truncate">{streamer.category}</p>
-          {streamer.isLive && (
-            <p className="text-sm">
-              {streamer.viewers} viewer{streamer.viewers === 1 ? '' : 's'}
-            </p>
-          )}
-        </div>
+        </button>
       </SidebarMenuButton>
     </SidebarMenuItem>
   );
 }
 
 function SidebarSkeleton({ ...props }: React.ComponentProps<typeof UISidebar>) {
+  const { state } = useSidebar();
+  const isCollapsed = state === 'collapsed';
+
   return (
-    <UISidebar {...props}>
+    <UISidebar collapsible="icon" {...props}>
       <SidebarContent>
         <SidebarGroup>
-          <SidebarGroupLabel asChild>
-            <button className="w-full flex items-center justify-between">
-              <span>Live Channels</span>
-              <ChevronUp className="h-4 w-4" />
-            </button>
+          <SidebarGroupLabel className="px-2 py-1.5">
+            <Skeleton className="h-4 w-24 group-data-[collapsible=icon]:opacity-0 transition-opacity duration-200" />
           </SidebarGroupLabel>
-
           <SidebarGroupContent>
             <SidebarMenu>
               {Array(3).fill(0).map((_, i) => (
-                <StreamerItemSkeleton key={i} />
+                <StreamerItemSkeleton key={i} isCollapsed={isCollapsed} />
               ))}
             </SidebarMenu>
           </SidebarGroupContent>
         </SidebarGroup>
 
+        <Separator className="group-data-[collapsible=icon]:block hidden" />
+
         <SidebarGroup>
-          <SidebarGroupLabel>Offline Channels</SidebarGroupLabel>
+          <SidebarGroupLabel className="px-2 py-1.5">
+            <Skeleton className="h-4 w-24 group-data-[collapsible=icon]:opacity-0 transition-opacity duration-200" />
+          </SidebarGroupLabel>
           <SidebarGroupContent>
             <SidebarMenu>
               {Array(5).fill(0).map((_, i) => (
-                <StreamerItemSkeleton key={i} />
+                <StreamerItemSkeleton key={i} isCollapsed={isCollapsed} />
               ))}
             </SidebarMenu>
           </SidebarGroupContent>
@@ -140,16 +166,18 @@ function SidebarSkeleton({ ...props }: React.ComponentProps<typeof UISidebar>) {
   );
 }
 
-function StreamerItemSkeleton() {
+function StreamerItemSkeleton({ isCollapsed }: { isCollapsed: boolean }) {
   return (
     <SidebarMenuItem>
-      <SidebarMenuButton className="flex items-center gap-3 h-full">
-        <div className="relative">
-          <Skeleton className="h-9 w-9 rounded-full" />
-        </div>
-        <div className="flex-1 space-y-2">
-          <Skeleton className="h-4 w-24" />
-          <Skeleton className="h-3 w-16" />
+      <SidebarMenuButton className="h-12">
+        <div className="flex w-full items-center gap-3">
+          <Skeleton className="h-8 w-8 rounded-full flex-shrink-0" />
+          {!isCollapsed && (
+            <div className="flex-1 space-y-1.5">
+              <Skeleton className="h-3.5 w-24" />
+              <Skeleton className="h-3 w-16" />
+            </div>
+          )}
         </div>
       </SidebarMenuButton>
     </SidebarMenuItem>

apps/web/src/components/app/StreamPlayer/StreamPlayer.tsx

@@ -1,57 +1,67 @@
 'use client';
 
 import { useParams } from 'next/navigation';
+import { useRef, useEffect } from 'react';
 import {
   MediaController,
   MediaLoadingIndicator,
   MediaControlBar,
   MediaPlayButton,
-  MediaSeekBackwardButton,
-  MediaSeekForwardButton,
   MediaMuteButton,
   MediaVolumeRange,
   MediaFullscreenButton,
 } from 'media-chrome/react';
 import HlsVideo from 'hls-video-element/react';
+import { useSession } from '@/lib/providers/SessionProvider';
+import { useUserStreamInfo } from '@/lib/hooks/useUserList';
+import { getMediamtxClientEnvs } from '@/lib/utils/mediamtx/client';
 
 export default function StreamPlayer() {
   const { username } = useParams();
+  const { session } = useSession();
+  const { streamInfo: userInfo } = useUserStreamInfo(username!.toString());
+  
+  const videoRef = useRef(null);
+
+  useEffect(() => {
+    const video = videoRef.current;
+    if (video && username && session) {
+      const user = 'skibiditoilet';
+      const credentials = btoa(`${user}:${session.id}`);
+
+      // @ts-ignore
+      video.config = {
+        xhrSetup: (xhr: XMLHttpRequest) => {
+          xhr.setRequestHeader('Authorization', `Basic ${credentials}`);
+        },
+        lowLatencyMode: true,
+        debug: process.env.NODE_ENV === 'development',
+        backBufferLength: 90,
+        enableWorker: true,
+        maxLiveSyncPlaybackRate: 1.5,
+        liveSyncDurationCount: 2,
+        liveMaxLatencyDurationCount: 4,
+      };
+
+      // @ts-ignore
+      video.src = `${getMediamtxClientEnvs(userInfo?.streamRegion!).publicUrl}/${username}/index.m3u8`;
+    }
+
+    return () => {
+      if (video) {
+        // @ts-ignore
+        video.src = '';
+      }
+    };
+  }, [username, session]);
 
   return (
     <MediaController className="w-full aspect-video">
       <HlsVideo
-        src={`/api/rtmp/hls/${username}.m3u8`}
+        ref={videoRef}
         slot="media"
         crossOrigin="anonymous"
         autoplay
-        config={{
-          lowLatencyMode: true,
-          liveSyncDurationCount: 1,
-          liveMaxLatencyDurationCount: 2,
-          liveDurationInfinity: true,
-          enableWorker: true,
-          backBufferLength: 1,
-          startLevel: -1,
-          maxBufferLength: 2,
-          maxMaxBufferLength: 4,
-          startFragPrefetch: true,
-          testBandwidth: false,
-          progressive: false,
-          maxBufferSize: 10 * 1000 * 1000,
-          maxBufferHole: 0.1,
-          highBufferWatchdogPeriod: 0.5,
-          nudgeOffset: 0.01,
-          nudgeMaxRetry: 3,
-          manifestLoadingTimeOut: 3000,
-          manifestLoadingMaxRetry: 3,
-          levelLoadingTimeOut: 3000,
-          fragLoadingTimeOut: 5000,
-          debug: process.env.NODE_ENV === 'development',
-          liveSyncDuration: 1,
-          liveMaxLatencyDuration: 3,
-          maxLiveSyncPlaybackRate: 1.5,
-          liveBackBufferLength: 0,
-        }}
       />
       <MediaLoadingIndicator slot="centered-chrome" noAutohide />
       <MediaControlBar className="w-full px-2">

apps/web/src/components/app/UniversalForm/UniversalForm.tsx

@@ -19,13 +19,24 @@ import React from 'react';
 import { toast } from 'sonner';
 import { Textarea } from '@/components/ui/textarea';
 import { cn } from '@/lib/utils';
-import { createChannelSchema, onboardSchema, streamInfoEditSchema, updateChannelSettingsSchema } from '@/lib/form/zod';
+import {
+  createBotSchema,
+  createChannelSchema,
+  changeUsernameSchema,
+  editBotSchema,
+  onboardSchema,
+  streamInfoEditSchema,
+  updateChannelSettingsSchema,
+} from '@/lib/form/zod';
 
 export const schemaDb = [
   { name: 'streamInfoEdit', zod: streamInfoEditSchema },
   { name: 'onboard', zod: onboardSchema },
   { name: 'createChannel', zod: createChannelSchema },
   { name: 'updateChannelSettings', zod: updateChannelSettingsSchema },
+  { name: 'createBot', zod: createBotSchema },
+  { name: 'editBot', zod: editBotSchema },
+  { name: 'changeUsername', zod: changeUsernameSchema },
 ] as const;
 
 export function UniversalForm<T extends z.ZodType>({
@@ -57,7 +68,7 @@ export function UniversalForm<T extends z.ZodType>({
   }, [fields, defaultValues]);
 
   type FormData = z.infer<T>;
-  
+
   const form = useForm<FormData>({
     resolver: zodResolver(schema as any),
     defaultValues: initialValues as FormData,
@@ -81,8 +92,8 @@ export function UniversalForm<T extends z.ZodType>({
             control={form.control}
             name={field.name as Path<FormData>}
             render={({ field: formField }) => (
-              <FormItem>
-                {(field.type !== 'hidden' || field.label) && <FormLabel>{field.label}</FormLabel>}
+              <FormItem className={field.type === 'hidden' ? 'hidden' : undefined}>
+                {field.type !== 'hidden' && field.label && <FormLabel>{field.label}</FormLabel>}
                 <FormControl>
                   {field.component ? (
                     field.component({ field: formField, ...field.componentProps })
@@ -92,27 +103,37 @@ export function UniversalForm<T extends z.ZodType>({
                       {...formField}
                       value={formField.value ?? ''}
                       rows={field.textAreaRows ?? 5}
+                      maxLength={field.maxChars}
                     />
                   ) : (
                     <Input
                       type={field.type || 'text'}
                       placeholder={field.placeholder}
                       {...formField}
+                      onChange={(e) => {
+                        if (field.inputFilter) {
+                          e.target.value = e.target.value.replace(field.inputFilter, '');
+                        }
+                        formField.onChange(e);
+                      }}
                       value={formField.value ?? ''}
+                      maxLength={field.maxChars}
                     />
                   )}
                 </FormControl>
-                {field.description && <FormDescription>{field.description}</FormDescription>}
-                <FormMessage />
+                {field.type !== 'hidden' && field.description && (
+                  <FormDescription>{field.description}</FormDescription>
+                )}
+                {field.type !== 'hidden' && <FormMessage />}
               </FormItem>
             )}
           />
         ))}
-        <div className={cn("flex gap-2 py-2", submitButtonDivClassname)}>
+        <div className={cn('flex gap-2 py-2', submitButtonDivClassname)}>
           {otherSubmitButton}
           <SubmitButton buttonText={submitText} className={submitClassname} />
         </div>
       </form>
     </Form>
   );
-}
+}

apps/web/src/components/app/UniversalForm/types.ts

@@ -12,15 +12,18 @@ export type FormFieldConfig = {
   value?: any;
   textArea?: boolean;
   textAreaRows?: number;
+  maxChars?: number;
+  inputFilter?: RegExp;
   component?: (props: { field: ControllerRenderProps<any, any> } & any) => React.ReactNode;
   componentProps?: Record<string, any>;
+  required?: boolean;
 };
 
 export type UniversalFormProps<T extends z.ZodType> = {
   fields: FormFieldConfig[];
   schemaName: (typeof schemaDb)[number]['name'];
   action: (prev: any, formData: FormData) => void;
-  onActionComplete?: (result: unknown) => void;
+  onActionComplete?: (result: any) => void;
   defaultValues?: Partial<z.infer<T>>;
   submitText?: string;
   submitClassname?: string;

apps/web/src/components/ui/button.tsx

@@ -26,7 +26,8 @@ const buttonVariants = cva(
         default: "h-10 px-4 py-2",
         sm: "h-9 rounded-md px-3",
         lg: "h-11 rounded-md px-8",
-        icon: "h-10 w-10"
+        icon: "h-10 w-10",
+        smicon: "h-9 w-9",
       },
     },
     defaultVariants: {

apps/web/src/components/ui/calendar.tsx

@@ -0,0 +1,213 @@
+"use client"
+
+import * as React from "react"
+import {
+  ChevronDownIcon,
+  ChevronLeftIcon,
+  ChevronRightIcon,
+} from "lucide-react"
+import { DayButton, DayPicker, getDefaultClassNames } from "react-day-picker"
+
+import { cn } from "@/lib/utils"
+import { Button, buttonVariants } from "@/components/ui/button"
+
+function Calendar({
+  className,
+  classNames,
+  showOutsideDays = true,
+  captionLayout = "label",
+  buttonVariant = "ghost",
+  formatters,
+  components,
+  ...props
+}: React.ComponentProps<typeof DayPicker> & {
+  buttonVariant?: React.ComponentProps<typeof Button>["variant"]
+}) {
+  const defaultClassNames = getDefaultClassNames()
+
+  return (
+    <DayPicker
+      showOutsideDays={showOutsideDays}
+      className={cn(
+        "bg-background group/calendar p-3 [--cell-size:2rem] [[data-slot=card-content]_&]:bg-transparent [[data-slot=popover-content]_&]:bg-transparent",
+        String.raw`rtl:**:[.rdp-button\_next>svg]:rotate-180`,
+        String.raw`rtl:**:[.rdp-button\_previous>svg]:rotate-180`,
+        className
+      )}
+      captionLayout={captionLayout}
+      formatters={{
+        formatMonthDropdown: (date) =>
+          date.toLocaleString("default", { month: "short" }),
+        ...formatters,
+      }}
+      classNames={{
+        root: cn("w-fit", defaultClassNames.root),
+        months: cn(
+          "relative flex flex-col gap-4 md:flex-row",
+          defaultClassNames.months
+        ),
+        month: cn("flex w-full flex-col gap-4", defaultClassNames.month),
+        nav: cn(
+          "absolute inset-x-0 top-0 flex w-full items-center justify-between gap-1",
+          defaultClassNames.nav
+        ),
+        button_previous: cn(
+          buttonVariants({ variant: buttonVariant }),
+          "h-[--cell-size] w-[--cell-size] select-none p-0 aria-disabled:opacity-50",
+          defaultClassNames.button_previous
+        ),
+        button_next: cn(
+          buttonVariants({ variant: buttonVariant }),
+          "h-[--cell-size] w-[--cell-size] select-none p-0 aria-disabled:opacity-50",
+          defaultClassNames.button_next
+        ),
+        month_caption: cn(
+          "flex h-[--cell-size] w-full items-center justify-center px-[--cell-size]",
+          defaultClassNames.month_caption
+        ),
+        dropdowns: cn(
+          "flex h-[--cell-size] w-full items-center justify-center gap-1.5 text-sm font-medium",
+          defaultClassNames.dropdowns
+        ),
+        dropdown_root: cn(
+          "has-focus:border-ring border-input shadow-xs has-focus:ring-ring/50 has-focus:ring-[3px] relative rounded-md border",
+          defaultClassNames.dropdown_root
+        ),
+        dropdown: cn(
+          "bg-popover absolute inset-0 opacity-0",
+          defaultClassNames.dropdown
+        ),
+        caption_label: cn(
+          "select-none font-medium",
+          captionLayout === "label"
+            ? "text-sm"
+            : "[&>svg]:text-muted-foreground flex h-8 items-center gap-1 rounded-md pl-2 pr-1 text-sm [&>svg]:size-3.5",
+          defaultClassNames.caption_label
+        ),
+        table: "w-full border-collapse",
+        weekdays: cn("flex", defaultClassNames.weekdays),
+        weekday: cn(
+          "text-muted-foreground flex-1 select-none rounded-md text-[0.8rem] font-normal",
+          defaultClassNames.weekday
+        ),
+        week: cn("mt-2 flex w-full", defaultClassNames.week),
+        week_number_header: cn(
+          "w-[--cell-size] select-none",
+          defaultClassNames.week_number_header
+        ),
+        week_number: cn(
+          "text-muted-foreground select-none text-[0.8rem]",
+          defaultClassNames.week_number
+        ),
+        day: cn(
+          "group/day relative aspect-square h-full w-full select-none p-0 text-center [&:first-child[data-selected=true]_button]:rounded-l-md [&:last-child[data-selected=true]_button]:rounded-r-md",
+          defaultClassNames.day
+        ),
+        range_start: cn(
+          "bg-accent rounded-l-md",
+          defaultClassNames.range_start
+        ),
+        range_middle: cn("rounded-none", defaultClassNames.range_middle),
+        range_end: cn("bg-accent rounded-r-md", defaultClassNames.range_end),
+        today: cn(
+          "bg-accent text-accent-foreground rounded-md data-[selected=true]:rounded-none",
+          defaultClassNames.today
+        ),
+        outside: cn(
+          "text-muted-foreground aria-selected:text-muted-foreground",
+          defaultClassNames.outside
+        ),
+        disabled: cn(
+          "text-muted-foreground opacity-50",
+          defaultClassNames.disabled
+        ),
+        hidden: cn("invisible", defaultClassNames.hidden),
+        ...classNames,
+      }}
+      components={{
+        Root: ({ className, rootRef, ...props }) => {
+          return (
+            <div
+              data-slot="calendar"
+              ref={rootRef}
+              className={cn(className)}
+              {...props}
+            />
+          )
+        },
+        Chevron: ({ className, orientation, ...props }) => {
+          if (orientation === "left") {
+            return (
+              <ChevronLeftIcon className={cn("size-4", className)} {...props} />
+            )
+          }
+
+          if (orientation === "right") {
+            return (
+              <ChevronRightIcon
+                className={cn("size-4", className)}
+                {...props}
+              />
+            )
+          }
+
+          return (
+            <ChevronDownIcon className={cn("size-4", className)} {...props} />
+          )
+        },
+        DayButton: CalendarDayButton,
+        WeekNumber: ({ children, ...props }) => {
+          return (
+            <td {...props}>
+              <div className="flex size-[--cell-size] items-center justify-center text-center">
+                {children}
+              </div>
+            </td>
+          )
+        },
+        ...components,
+      }}
+      {...props}
+    />
+  )
+}
+
+function CalendarDayButton({
+  className,
+  day,
+  modifiers,
+  ...props
+}: React.ComponentProps<typeof DayButton>) {
+  const defaultClassNames = getDefaultClassNames()
+
+  const ref = React.useRef<HTMLButtonElement>(null)
+  React.useEffect(() => {
+    if (modifiers.focused) ref.current?.focus()
+  }, [modifiers.focused])
+
+  return (
+    <Button
+      ref={ref}
+      variant="ghost"
+      size="icon"
+      data-day={day.date.toLocaleDateString()}
+      data-selected-single={
+        modifiers.selected &&
+        !modifiers.range_start &&
+        !modifiers.range_end &&
+        !modifiers.range_middle
+      }
+      data-range-start={modifiers.range_start}
+      data-range-end={modifiers.range_end}
+      data-range-middle={modifiers.range_middle}
+      className={cn(
+        "data-[selected-single=true]:bg-primary data-[selected-single=true]:text-primary-foreground data-[range-middle=true]:bg-accent data-[range-middle=true]:text-accent-foreground data-[range-start=true]:bg-primary data-[range-start=true]:text-primary-foreground data-[range-end=true]:bg-primary data-[range-end=true]:text-primary-foreground group-data-[focused=true]/day:border-ring group-data-[focused=true]/day:ring-ring/50 flex aspect-square h-auto w-full min-w-[--cell-size] flex-col gap-1 font-normal leading-none data-[range-end=true]:rounded-md data-[range-middle=true]:rounded-none data-[range-start=true]:rounded-md group-data-[focused=true]/day:relative group-data-[focused=true]/day:z-10 group-data-[focused=true]/day:ring-[3px] [&>span]:text-xs [&>span]:opacity-70",
+        defaultClassNames.day,
+        className
+      )}
+      {...props}
+    />
+  )
+}
+
+export { Calendar, CalendarDayButton }

apps/web/src/components/ui/channel-desc-fancy-area/mention.tsx

@@ -37,7 +37,7 @@ export function Mention({ children, handle }: Props) {
   }
 
   const fallback = handle.substring(0, 2).toUpperCase();
-  const url = `https://hctv.srizan.dev/${handle}`;
+  const url = `https://hackclub.tv/${handle}`;
 
   return (
     <HoverCard>

apps/web/src/components/ui/sidebar.tsx

@@ -23,7 +23,7 @@ const SIDEBAR_COOKIE_NAME = "sidebar:state"
 const SIDEBAR_COOKIE_MAX_AGE = 60 * 60 * 24 * 7
 const SIDEBAR_WIDTH = "16rem"
 const SIDEBAR_WIDTH_MOBILE = "18rem"
-const SIDEBAR_WIDTH_ICON = "3rem"
+const SIDEBAR_WIDTH_ICON = "4rem"
 const SIDEBAR_KEYBOARD_SHORTCUT = "b"
 
 type SidebarContext = {
@@ -512,7 +512,7 @@ const SidebarMenuItem = React.forwardRef<
 SidebarMenuItem.displayName = "SidebarMenuItem"
 
 const sidebarMenuButtonVariants = cva(
-  "peer/menu-button flex w-full items-center gap-2 overflow-hidden rounded-md p-2 text-left text-sm outline-none ring-sidebar-ring transition-[width,height,padding] hover:bg-sidebar-accent hover:text-sidebar-accent-foreground focus-visible:ring-2 active:bg-sidebar-accent active:text-sidebar-accent-foreground disabled:pointer-events-none disabled:opacity-50 group-has-[[data-sidebar=menu-action]]/menu-item:pr-8 aria-disabled:pointer-events-none aria-disabled:opacity-50 data-[active=true]:bg-sidebar-accent data-[active=true]:font-medium data-[active=true]:text-sidebar-accent-foreground data-[state=open]:hover:bg-sidebar-accent data-[state=open]:hover:text-sidebar-accent-foreground group-data-[collapsible=icon]:!size-8 group-data-[collapsible=icon]:!p-2 [&>span:last-child]:truncate [&>svg]:size-4 [&>svg]:shrink-0",
+  "peer/menu-button flex w-full items-center gap-2 overflow-hidden rounded-md p-2 text-left text-sm outline-none ring-sidebar-ring transition-[width,height,padding] hover:bg-sidebar-accent hover:text-sidebar-accent-foreground focus-visible:ring-2 active:bg-sidebar-accent active:text-sidebar-accent-foreground disabled:pointer-events-none disabled:opacity-50 group-has-[[data-sidebar=menu-action]]/menu-item:pr-8 aria-disabled:pointer-events-none aria-disabled:opacity-50 data-[active=true]:bg-sidebar-accent data-[active=true]:font-medium data-[active=true]:text-sidebar-accent-foreground data-[state=open]:hover:bg-sidebar-accent data-[state=open]:hover:text-sidebar-accent-foreground group-data-[collapsible=icon]:!size-12 group-data-[collapsible=icon]:!p-2 [&>span:last-child]:truncate [&>svg]:size-4 [&>svg]:shrink-0",
   {
     variants: {
       variant: {

apps/web/src/instrumentation-client.ts

@@ -14,6 +14,7 @@ Sentry.init({
 
   // Setting this option to true will print useful information to the console while you're setting up Sentry.
   debug: false,
+  enabled: process.env.NODE_ENV === 'production'
 });
 
 export const onRouterTransitionStart = Sentry.captureRouterTransitionStart;

apps/web/src/instrumentation.ts

@@ -1,7 +1,12 @@
+import * as Sentry from "@sentry/nextjs";
+
+export const onRequestError = Sentry.captureRequestError;
+
 export async function register() {
   if (process.env.NEXT_RUNTIME === 'nodejs') {
     await (await import('@/lib/instrumentation/streamInfo')).default();
     await (await import('@/lib/instrumentation/writeSessions')).default();
+    await (await import('@/lib/instrumentation/syncStreamKeys')).default();
   }
   
   if (process.env.NEXT_RUNTIME === 'nodejs') {
@@ -40,4 +45,21 @@ export async function register() {
       await viewerCountSync();
     }, 2000);
   }
+
+  process.env.NODE_ENV === 'production' && Sentry.init({
+    dsn: "https://f3c26671c39af48406c6e23702a4f3dd@o4506961023860736.ingest.us.sentry.io/4509895816773632",
+  
+    // Define how likely traces are sampled. Adjust this value in production, or use tracesSampler for greater control.
+    tracesSampleRate: 1,
+  
+    // Enable logs to be sent to Sentry
+    enableLogs: true,
+  
+    // Setting this option to true will print useful information to the console while you're setting up Sentry.
+    debug: false,
+    
+    integrations: [
+      Sentry.extraErrorDataIntegration(),
+    ],
+  });
 }

apps/web/src/lib/auth/abac.ts

@@ -0,0 +1,121 @@
+import { prisma } from '@hctv/db';
+
+export type Resource = 'channel' | 'bot' | 'streamInfo';
+export type Action = 'read' | 'update' | 'delete' | 'manage';
+
+type User = { id: string };
+
+type ChannelWithRelations = {
+  ownerId: string;
+  managers?: { id: string }[];
+  personalFor?: { id: string } | null;
+};
+
+type BotWithRelations = {
+  ownerId: string;
+};
+
+type PolicyContext = {
+  channel?: ChannelWithRelations;
+  bot?: BotWithRelations;
+};
+
+const policies: Record<Resource, Record<Action, (user: User, ctx: PolicyContext) => boolean>> = {
+  channel: {
+    read: () => true,
+    update: (user, { channel }) => {
+      if (!channel) return false;
+      return channel.ownerId === user.id || (channel.managers?.some((m) => m.id === user.id) ?? false);
+    },
+    delete: (user, { channel }) => {
+      if (!channel) return false;
+      if (channel.personalFor) return false;
+      return channel.ownerId === user.id;
+    },
+    manage: (user, { channel }) => {
+      if (!channel) return false;
+      return channel.ownerId === user.id;
+    },
+  },
+  bot: {
+    read: () => true,
+    update: (user, { bot }) => {
+      if (!bot) return false;
+      return bot.ownerId === user.id;
+    },
+    delete: (user, { bot }) => {
+      if (!bot) return false;
+      return bot.ownerId === user.id;
+    },
+    manage: (user, { bot }) => {
+      if (!bot) return false;
+      return bot.ownerId === user.id;
+    },
+  },
+  streamInfo: {
+    read: () => true,
+    update: (user, { channel }) => {
+      if (!channel) return false;
+      return channel.ownerId === user.id || (channel.managers?.some((m) => m.id === user.id) ?? false);
+    },
+    delete: () => false,
+    manage: (user, { channel }) => {
+      if (!channel) return false;
+      return channel.ownerId === user.id;
+    },
+  },
+};
+
+export function can(user: User, action: Action, resource: Resource, context: PolicyContext): boolean {
+  const policy = policies[resource]?.[action];
+  if (!policy) return false;
+  return policy(user, context);
+}
+
+export async function canAccessChannel(
+  user: User,
+  action: Action,
+  channelId: string
+): Promise<boolean> {
+  const channel = await prisma.channel.findUnique({
+    where: { id: channelId },
+    include: { managers: { select: { id: true } }, personalFor: { select: { id: true } } },
+  });
+  if (!channel) return false;
+  return can(user, action, 'channel', { channel });
+}
+
+export async function canAccessChannelByName(
+  user: User,
+  action: Action,
+  channelName: string
+): Promise<boolean> {
+  const channel = await prisma.channel.findUnique({
+    where: { name: channelName },
+    include: { managers: { select: { id: true } }, personalFor: { select: { id: true } } },
+  });
+  if (!channel) return false;
+  return can(user, action, 'channel', { channel });
+}
+
+export async function canAccessBot(user: User, action: Action, botId: string): Promise<boolean> {
+  const bot = await prisma.botAccount.findUnique({
+    where: { id: botId },
+    select: { ownerId: true },
+  });
+  if (!bot) return false;
+  return can(user, action, 'bot', { bot });
+}
+
+export async function canAccessBotBySlug(
+  user: User,
+  action: Action,
+  slug: string
+): Promise<boolean> {
+  const bot = await prisma.botAccount.findUnique({
+    where: { slug },
+    select: { ownerId: true },
+  });
+  if (!bot) return false;
+  return can(user, action, 'bot', { bot });
+}

apps/web/src/lib/auth/actions.ts

@@ -12,5 +12,5 @@ export async function logout() {
   await lucia.invalidateSession(session!.id);
   const sessionCookie = lucia.createBlankSessionCookie();
   (await cookies()).set(sessionCookie.name, sessionCookie.value, sessionCookie.attributes);
-  return redirect('/login');
+  return redirect('/');
 }

apps/web/src/lib/db/resolve.ts

@@ -1,4 +1,5 @@
-import { prisma } from '@hctv/db';
+import {Prisma, prisma} from '@hctv/db';
+import {validateRequest} from "@/lib/auth/validate";
 
 export async function resolveChannelNameId(channelName: string) {
   const channel = await prisma.channel.findUnique({
@@ -28,4 +29,14 @@ export async function resolveUserPersonalChannel(userId: string) {
   }
 
   return channel;
+}
+
+export async function getBotBySlug(slug: string) {
+  const bot = await prisma.botAccount.findFirst({
+    where: {
+      slug,
+    },
+  });
+
+  return bot;
 }

apps/web/src/lib/db/streamKey.ts

@@ -0,0 +1,35 @@
+import { prisma, getRedisConnection } from '@hctv/db';
+
+export async function generateStreamKey(channelId: string, channelName: string) {
+  const streamKey = await prisma.streamKey.create({
+    data: {
+      key: crypto.randomUUID(),
+      channelId,
+    },
+  });
+
+  const redis = getRedisConnection();
+  await redis.set(`streamKey:${channelName}`, streamKey.key);
+
+  return streamKey;
+}
+
+export async function regenerateStreamKey(channelId: string, channelName: string) {
+  const streamKey = await prisma.streamKey.upsert({
+    create: {
+      key: crypto.randomUUID(),
+      channelId,
+    },
+    update: {
+      key: crypto.randomUUID(),
+    },
+    where: {
+      channelId,
+    },
+  });
+
+  const redis = getRedisConnection();
+  await redis.set(`streamKey:${channelName}`, streamKey.key);
+
+  return streamKey;
+}

apps/web/src/lib/env.ts

@@ -0,0 +1,10 @@
+export const getEnv = (key: string): string | undefined => {
+  if (typeof window !== 'undefined') {
+    // @ts-ignore
+    return window.__ENV?.[key];
+  }
+  return process.env[key];
+};
+
+export const MEDIAMTX_URL = getEnv('NEXT_PUBLIC_MEDIAMTX_URL');
+export const MEDIAMTX_INGEST_ROUTE = getEnv('NEXT_PUBLIC_MEDIAMTX_INGEST_ROUTE');

apps/web/src/lib/form/actions.ts

@@ -2,12 +2,26 @@
 
 import { revalidatePath } from 'next/cache';
 import { validateRequest } from '@/lib/auth/validate';
-import { prisma } from '@hctv/db';
+import { prisma, getRedisConnection } from '@hctv/db';
 import zodVerify from '../zodVerify';
-import { createChannelSchema, onboardSchema, streamInfoEditSchema, updateChannelSettingsSchema } from './zod';
+import {
+  createBotSchema,
+  createChannelSchema,
+  changeUsernameSchema,
+  editBotSchema,
+  onboardSchema,
+  streamInfoEditSchema,
+  updateChannelSettingsSchema,
+} from './zod';
 import { initializeStreamInfo } from '../instrumentation/streamInfo';
-import { resolveFollowedChannels, resolveStreamInfo, resolveUserFromPersonalChannelName } from '../auth/resolve';
+import {
+  resolveFollowedChannels,
+  resolveStreamInfo,
+  resolveUserFromPersonalChannelName,
+} from '../auth/resolve';
+import { can } from '../auth/abac';
 import { genIdenticonUpload } from '../utils/genIdenticonUpload';
+import { generateStreamKey } from '../db/streamKey';
 
 export async function editStreamInfo(prev: any, formData: FormData) {
   const { user } = await validateRequest();
@@ -30,9 +44,7 @@ export async function editStreamInfo(prev: any, formData: FormData) {
     return { success: false, error: 'Channel not found' };
   }
 
-  const isBroadcaster =
-    channelInfo.ownerId === user.id || channelInfo.managers.some((m) => m.id === user.id);
-  if (!isBroadcaster) {
+  if (!can(user, 'update', 'streamInfo', { channel: channelInfo })) {
     return { success: false, error: 'Unauthorized' };
   }
 
@@ -78,8 +90,8 @@ export async function onboard(prev: any, formData: FormData) {
       ownerId: user.id,
       personalFor: { connect: { id: user.id } },
       pfpUrl: user.pfpUrl,
-    }
-  })
+    },
+  });
   await prisma.user.update({
     where: { id: user.id },
     data: {
@@ -91,13 +103,15 @@ export async function onboard(prev: any, formData: FormData) {
   });
   await initializeStreamInfo(createdChannel.id);
 
-  if (process.env.NODE_ENV === 'production') {
-    await fetch(process.env.WELCOME_WORKFLOW_URL!, {
+  await generateStreamKey(createdChannel.id, createdChannel.name);
+
+  if (process.env.NODE_ENV === 'production' && process.env.WELCOME_WORKFLOW_URL) {
+    await fetch(process.env.WELCOME_WORKFLOW_URL, {
       method: 'POST',
       body: JSON.stringify({
         username: zod.data.username,
       }),
-    })
+    });
   }
 
   return { success: true };
@@ -150,11 +164,13 @@ export async function createChannel(prev: any, formData: FormData) {
       name: zod.data.name,
       ownerId: user.id,
       pfpUrl: identicon,
-    }
+    },
   });
 
   await initializeStreamInfo(createdChannel.id);
 
+  await generateStreamKey(createdChannel.id, createdChannel.name);
+
   return { success: true, channel: createdChannel.name };
 }
 
@@ -163,9 +179,10 @@ export async function updateChannelSettings(prev: any, formData: FormData) {
   if (!user) {
     return { success: false, error: 'Unauthorized' };
   }
-  
+
   const zod = await zodVerify(updateChannelSettingsSchema, formData);
-  const urlRegex = /(?:http[s]?:\/\/.)?(?:www\.)?[-a-zA-Z0-9@%._\+~#=]{2,256}\.[a-z]{2,6}\b(?:[-a-zA-Z0-9@:%_\+.~#?&\/\/=]*)/gm;
+  const urlRegex =
+    /(?:http[s]?:\/\/.)?(?:www\.)?[-a-zA-Z0-9@%._\+~#=]{2,256}\.[a-z]{2,6}\b(?:[-a-zA-Z0-9@:%_\+.~#?&\/\/=]*)/gm;
   if (!zod.success) {
     return zod;
   }
@@ -185,10 +202,7 @@ export async function updateChannelSettings(prev: any, formData: FormData) {
     return { success: false, error: 'Channel not found' };
   }
 
-  const isOwner = channel.ownerId === user.id;
-  const isManager = channel.managers.some(manager => manager.id === user.id);
-
-  if (!isOwner && !isManager) {
+  if (!can(user, 'update', 'channel', { channel })) {
     return { success: false, error: 'Unauthorized' };
   }
 
@@ -225,12 +239,12 @@ export async function addChannelManager(channelId: string, userChannel: string)
     return { success: false, error: 'Channel not found OR is personal.' };
   }
 
-  if (channel.ownerId !== user.id) {
+  if (!can(user, 'manage', 'channel', { channel })) {
     return { success: false, error: 'Only channel owners can add managers' };
   }
 
   if (channel.ownerId === userChannel) {
-    return { success: false, error: 'Owner can\'t add themselves as managers' };
+    return { success: false, error: "Owner can't add themselves as managers" };
   }
 
   const userDb = await resolveUserFromPersonalChannelName(userChannel);
@@ -269,7 +283,7 @@ export async function removeChannelManager(channelId: string, userId: string) {
     return { success: false, error: 'Channel not found' };
   }
 
-  if (channel.ownerId !== user.id) {
+  if (!can(user, 'manage', 'channel', { channel })) {
     return { success: false, error: 'Only channel owners can remove managers' };
   }
 
@@ -312,8 +326,8 @@ export async function toggleGlobalChannelNotifs(channelId: string) {
     },
     data: {
       enableNotifications: !streamInfo.enableNotifications,
-    }
-  })
+    },
+  });
 
   revalidatePath(`/settings/channel/${channel.name}`);
 
@@ -321,15 +335,14 @@ export async function toggleGlobalChannelNotifs(channelId: string) {
 }
 
 export async function deleteChannel(channelId: string) {
-  return { success: false, error: 'disabled atm. dm @eth0 if you want to request a deletion.' }
-  /* const { user } = await validateRequest();
+  const { user } = await validateRequest();
   if (!user) {
     return { success: false, error: 'Unauthorized' };
   }
 
   const channel = await prisma.channel.findUnique({
     where: { id: channelId },
-    include: { 
+    include: {
       owner: true,
       personalFor: true,
     },
@@ -339,18 +352,210 @@ export async function deleteChannel(channelId: string) {
     return { success: false, error: 'Channel not found' };
   }
 
-  if (channel.ownerId !== user.id) {
-    return { success: false, error: 'Only channel owners can delete channels' };
-  }
-
-  // Prevent deletion of personal channels
-  if (channel.personalFor) {
-    return { success: false, error: 'Cannot delete personal channels' };
+  if (!can(user, 'delete', 'channel', { channel })) {
+    return {
+      success: false,
+      error: 'Only channel owners can delete channels (personal channels cannot be deleted)',
+    };
   }
 
   await prisma.channel.delete({
     where: { id: channelId },
   });
 
-  return { success: true }; */
-}
+  return { success: true };
+}
+
+export async function createBot(prev: any, formData: FormData) {
+  const { user } = await validateRequest();
+  if (!user) {
+    return { success: false, error: 'Unauthorized' };
+  }
+  const zod = await zodVerify(createBotSchema, formData);
+  if (!zod.success) {
+    return zod;
+  }
+
+  const botExists = await prisma.botAccount.findFirst({
+    where: { slug: zod.data.slug },
+  });
+  if (botExists) {
+    return { success: false, error: 'Bot slug already exists' };
+  }
+
+  const createdBot = await prisma.botAccount.create({
+    data: {
+      displayName: zod.data.name,
+      slug: zod.data.slug,
+      ownerId: user.id,
+      description: zod.data.description,
+      pfpUrl: await genIdenticonUpload(zod.data.slug, 'botpfp'),
+    },
+  });
+
+  return { success: true, slug: createdBot.slug };
+}
+
+export async function editBot(prev: any, formData: FormData) {
+  const { user } = await validateRequest();
+  if (!user) {
+    return { success: false, error: 'Unauthorized' };
+  }
+  const zod = await zodVerify(editBotSchema, formData);
+  if (!zod.success) {
+    return zod;
+  }
+
+  const bot = await prisma.botAccount.findUnique({
+    where: { id: zod.data.from },
+  });
+  if (!bot) {
+    return { success: false, error: 'Bot not found' };
+  }
+  if (!can(user, 'update', 'bot', { bot })) {
+    return { success: false, error: 'Unauthorized' };
+  }
+  if (bot.slug !== zod.data.slug) {
+    const botExists = await prisma.botAccount.findFirst({
+      where: { slug: zod.data.slug },
+    });
+    if (botExists) {
+      return { success: false, error: 'Bot slug already exists' };
+    }
+  }
+
+  const updatedBot = await prisma.botAccount.update({
+    where: { id: zod.data.from },
+    data: {
+      displayName: zod.data.name,
+      slug: zod.data.slug,
+      description: zod.data.description,
+    },
+  });
+
+  revalidatePath(`/settings/bot/${updatedBot.slug}`);
+
+  return { success: true, slug: updatedBot.slug };
+}
+
+const USERNAME_CHANGE_COOLDOWN_DAYS = 30;
+
+export async function changeUsername(prev: any, formData: FormData) {
+  const { user } = await validateRequest();
+  if (!user) {
+    return { success: false, error: 'Unauthorized' };
+  }
+
+  const zod = await zodVerify(changeUsernameSchema, formData);
+  if (!zod.success) {
+    return zod;
+  }
+
+  const channel = await prisma.channel.findUnique({
+    where: { id: zod.data.channelId },
+    include: {
+      owner: true,
+      managers: true,
+      personalFor: true,
+      streamInfo: true,
+      streamKey: true,
+    },
+  });
+
+  if (!channel) {
+    return { success: false, error: 'Channel not found' };
+  }
+
+  if (!channel.personalFor || channel.personalFor.id !== user.id) {
+    return { success: false, error: 'You can only change the username of your personal channel' };
+  }
+
+  if (channel.ownerId !== user.id) {
+    return { success: false, error: 'Unauthorized' };
+  }
+
+  if (channel.nameLastChanged) {
+    const daysSinceLastChange = Math.floor(
+      (Date.now() - new Date(channel.nameLastChanged).getTime()) / (1000 * 60 * 60 * 24)
+    );
+    if (daysSinceLastChange < USERNAME_CHANGE_COOLDOWN_DAYS) {
+      const daysRemaining = USERNAME_CHANGE_COOLDOWN_DAYS - daysSinceLastChange;
+      return {
+        success: false,
+        error: `Please wait ${daysRemaining} more day${daysRemaining === 1 ? '' : 's'}.`,
+      };
+    }
+  }
+
+  const oldName = channel.name;
+  const newName = zod.data.newUsername;
+
+  if (oldName === newName) {
+    return { success: false, error: 'New username must be different from the current one' };
+  }
+
+  const existingChannel = await prisma.channel.findUnique({
+    where: { name: newName },
+  });
+  if (existingChannel) {
+    return { success: false, error: 'This username is already taken' };
+  }
+
+  const redis = getRedisConnection();
+
+  try {
+    await prisma.channel.update({
+      where: { id: channel.id },
+      data: {
+        name: newName,
+        nameLastChanged: process.env.NODE_ENV === 'production' ? new Date() : null,
+      },
+    });
+
+    if (channel.streamInfo.length > 0) {
+      await prisma.streamInfo.updateMany({
+        where: { channelId: channel.id },
+        data: { username: newName },
+      });
+    }
+
+    if (channel.streamKey) {
+      const oldStreamKey = `streamKey:${oldName}`;
+      const newStreamKey = `streamKey:${newName}`;
+      if (await redis.exists(oldStreamKey)) {
+        await redis.rename(oldStreamKey, newStreamKey);
+      }
+    }
+
+    const oldHistoryKey = `chat:history:${oldName}`;
+    const newHistoryKey = `chat:history:${newName}`;
+    if (await redis.exists(oldHistoryKey)) {
+      const messagesWithScores = await redis.zrange(oldHistoryKey, 0, -1, 'WITHSCORES');
+      if (messagesWithScores.length > 0) {
+        const args: (string | number)[] = [];
+        for (let i = 0; i < messagesWithScores.length; i += 2) {
+          const msgStr = messagesWithScores[i];
+          const score = messagesWithScores[i + 1];
+          try {
+            const msg = JSON.parse(msgStr);
+            msg.user.username = newName;
+            args.push(score, JSON.stringify(msg));
+          } catch {
+            args.push(score, msgStr);
+          }
+        }
+        await redis.zadd(newHistoryKey, ...args);
+      }
+      await redis.del(oldHistoryKey);
+    }
+
+    revalidatePath(`/settings/channel/${newName}`);
+    revalidatePath(`/${oldName}`);
+    revalidatePath(`/${newName}`);
+
+    return { success: true, newUsername: newName };
+  } catch (error) {
+    console.error('Failed to change username:', error);
+    return { success: false, error: 'Failed to change username. Please try again.' };
+  }
+}

apps/web/src/lib/form/zod.ts

@@ -1,9 +1,21 @@
 import { z } from 'zod';
 
+const disallowedUsernames = [
+  'admin',
+  'administrator',
+  'settings',
+  'create',
+  // i hope this doesn't age well tbh
+  'zrl',
+];
 const username = z
   .string()
   .min(1)
-  .regex(/^[a-z0-9_-]+$/, { message: 'Only characters from a-z, 0-9, underscores and dashes' });
+  .max(20)
+  .regex(/^[a-z0-9_-]+$/, { message: 'Only characters from a-z, 0-9, underscores and dashes' })
+  .refine((val) => !disallowedUsernames.includes(val.toLowerCase()), {
+    message: 'This username is reserved',
+  });
 
 export const streamInfoEditSchema = z.object({
   username: z.string().min(1),
@@ -25,4 +37,21 @@ export const updateChannelSettingsSchema = z.object({
   pfpUrl: z.string(),
   description: z.string().min(1).max(500),
   is247: z.boolean(),
-});
+});
+
+export const createBotSchema = z.object({
+  name: z.string().min(1, { message: 'Name is required' }),
+  slug: username.refine((val) => val !== 'settings', { message: 'This slug is reserved' }),
+  description: z.string().max(300).optional(),
+});
+
+export const editBotSchema = createBotSchema.and(
+  z.object({
+    from: z.string().min(1),
+  })
+);
+
+export const changeUsernameSchema = z.object({
+  channelId: z.string().min(1),
+  newUsername: username,
+});

apps/web/src/lib/hooks/useUserList.tsx

@@ -27,6 +27,7 @@ function createCacheKey(options: UseUserListOptions): string {
   if (options.owned) params.push('owned')
   if (options.personal) params.push('personal')
   if (options.live) params.push('live')
+  if (options.username) params.push(`user-${options.username}`)
   
   return params.length > 0 
     ? `stream-info:${params.join('-')}` 
@@ -76,6 +77,8 @@ export interface UseUserListOptions {
   personal?: boolean
   /** Only fetch live channels */
   live?: boolean
+  /** Search for a specific user's streaminfo */
+  username?: string
   /** Refresh interval in milliseconds */
   refreshInterval?: number
   /** Cache time to live in milliseconds (default: 5 minutes) */
@@ -132,6 +135,7 @@ export function useUserList(options: UseUserListOptions = {}): UseUserListReturn
     owned = false, 
     personal = false, 
     live = false, 
+    username,
     refreshInterval = 30000,
     cacheTTL = 5 * 60 * 1000, // 5 minutes
     revalidateOnFocus = false,
@@ -151,8 +155,9 @@ export function useUserList(options: UseUserListOptions = {}): UseUserListReturn
     if (owned) searchParams.set('owned', 'true')
     if (personal) searchParams.set('personal', 'true')
     if (live) searchParams.set('live', 'true')
+    if (username) searchParams.set('username', username)
     return searchParams
-  }, [owned, personal, live])
+  }, [owned, personal, live, username])
 
   const queryString = params.toString()
   const url = `/api/stream/info${queryString ? `?${queryString}` : ''}`
@@ -325,6 +330,67 @@ export function usePersonalChannels(refreshInterval?: number): UseUserListReturn
   })
 }
 
+export interface UseUserStreamInfoReturn extends Omit<UseUserListReturn, 'channels'> {
+  /** The found stream info for the specific user */
+  streamInfo: StreamInfoResponse[0] | null
+  /** All matching channels (usually just one) */
+  channels: StreamInfoResponse
+}
+
+/** 
+ * Hook to fetch stream info for a specific user 
+ * Returns the first match if multiple channels exist for that user
+ */
+export function useUserStreamInfo(
+  username: string | undefined, 
+  refresh = true,
+  refreshInterval?: number,
+): UseUserStreamInfoReturn {
+  const result = useUserList({ 
+    username,
+    refreshInterval: refresh ? (refreshInterval ?? 15000) : undefined,
+    cacheTTL: 2 * 60 * 1000, // 2 minutes cache
+    revalidateOnFocus: true,
+    isPaused: !username, // Don't fetch if no username provided
+    errorRetryCount: 3,
+  })
+
+  return {
+    ...result,
+    streamInfo: result.channels[0] || null,
+  }
+}
+
+/** 
+ * Lazy version that doesn't automatically fetch - useful for on-demand lookups 
+ */
+export function useUserStreamInfoLazy(refreshInterval?: number) {
+  const result = useUserList({ 
+    refreshInterval: refreshInterval ?? 15000,
+    cacheTTL: 2 * 60 * 1000,
+    revalidateOnFocus: true,
+    isPaused: true, // Start paused
+    errorRetryCount: 3,
+  })
+
+  const lookupUser = useCallback(async (username: string) => {
+    if (!username) return null
+    
+    try {
+      const response = await enhancedFetcher(`/api/stream/info?username=${encodeURIComponent(username)}`)
+      return response[0] || null
+    } catch (error) {
+      console.error('[useUserStreamInfoLazy] Error looking up user:', error)
+      throw error
+    }
+  }, [])
+
+  return {
+    ...result,
+    lookupUser,
+  }
+}
+
 // Cache management utilities with proper error handling
 export const channelCacheUtils = {
   /** Clear all channel caches */
@@ -379,6 +445,7 @@ export const channelCacheUtils = {
       if (options.owned) params.set('owned', 'true')
       if (options.personal) params.set('personal', 'true')
       if (options.live) params.set('live', 'true')
+      if (options.username) params.set('username', options.username)
       
       const queryString = params.toString()
       const url = `/api/stream/info${queryString ? `?${queryString}` : ''}`

apps/web/src/lib/instrumentation/getLiveThumb.ts

@@ -14,8 +14,10 @@ export default async function getLiveThumb() {
 
   const thumbQueue = getThumbnailQueue();
   for (const channel of liveChannelNames) {
+    const lc = liveChannels.find(c => c.channel.name === channel)!;
     await thumbQueue.add("getLiveThumb", {
       name: channel,
+      server: lc.streamRegion,
     });
   }
 }

apps/web/src/lib/instrumentation/streamInfo.ts

@@ -2,6 +2,8 @@ import { prisma } from '@hctv/db';
 import { HttpFlv } from '../types/liveBackendJson';
 import { getNotificationQueue } from '../workers';
 import client from '../services/slackNotifier';
+import type { paths } from '../types/mediamtx.d.ts';
+import { MEDIAMTX_SERVER_REGIONS } from '../utils/mediamtx/server';
 
 export default async function runner() {
   // if there are no users it explodes so yeah
@@ -48,45 +50,43 @@ export async function initializeStreamInfo(channelId?: string) {
 
 export async function syncStream() {
   try {
-    const response = await fetch(`${process.env.LIVE_SERVER_URL}/stat`, {
-      headers: {
-        Authorization: process.env.STAT_AUTH!,
-      },
-    });
+    const regions = Object.keys(MEDIAMTX_SERVER_REGIONS) as Array<
+      keyof typeof MEDIAMTX_SERVER_REGIONS
+    >;
 
-    if (!response.ok) {
-      console.error(`Failed to fetch stream stats: ${response.status} ${response.statusText}`);
-      return;
+    const allActiveStreams = new Map<string, keyof typeof MEDIAMTX_SERVER_REGIONS>();
+
+    for (const r of regions) {
+      const region = MEDIAMTX_SERVER_REGIONS[r];
+      const response = await fetch(`${region.apiUrl}/v3/paths/list?itemsPerPage=1000`);
+
+      if (!response.ok) {
+        console.error(
+          `Failed to fetch ${r} stream stats: ${response.status} ${response.statusText}`
+        );
+        continue;
+      }
+
+      type ResponseType =
+        paths['/v3/paths/list']['get']['responses']['200']['content']['application/json'];
+      const data = (await response.json()) as ResponseType;
+
+      if (data?.items) {
+        for (const stream of data.items) {
+          if (stream.ready && stream.name) {
+            allActiveStreams.set(stream.name, r);
+          }
+        }
+      }
     }
 
-    const data = await response.json();
-    const httpFlv = data['http-flv'] as HttpFlv;
-
-    if (!httpFlv?.servers?.[0]?.applications) {
-      return;
-    }
-
-    const channelLiveApp = httpFlv.servers[0].applications.find(
-      (app) => app.name === 'channel-live'
-    );
-    const activeStreams = channelLiveApp?.live?.streams || [];
-
+    // handle streams going offline
     const currentLiveStreams = await prisma.streamInfo.findMany({
       where: { isLive: true },
     });
 
-    const activeStreamMap = new Map();
-    for (const stream of activeStreams) {
-      activeStreamMap.set(stream.name, {
-        isLive: stream.active,
-        viewers: stream.clients.filter((c) => !c.publishing).length,
-      });
-    }
-
     for (const dbStream of currentLiveStreams) {
-      const streamStats = activeStreamMap.get(dbStream.username);
-
-      if (!streamStats || !streamStats.isLive) {
+      if (!allActiveStreams.has(dbStream.username)) {
         await prisma.streamInfo.update({
           where: { username: dbStream.username },
           data: {
@@ -98,50 +98,52 @@ export async function syncStream() {
       }
     }
 
-    for (const stream of activeStreams) {
-      if (stream.active) {
-        const existingStream = await prisma.streamInfo.findUnique({
-          where: { username: stream.name },
-          include: { channel: true },
+    // handle streams going online
+    for (const [username, regionKey] of allActiveStreams) {
+      const existingStream = await prisma.streamInfo.findUnique({
+        where: { username },
+        include: { channel: true },
+      });
+
+      if (existingStream && !existingStream.isLive) {
+        console.log(`Stream ${username} is now live in region ${regionKey}`);
+        await prisma.streamInfo.update({
+          where: { username },
+          data: {
+            isLive: true,
+            startedAt: new Date(),
+            streamRegion: regionKey,
+          },
         });
 
-        if (existingStream && !existingStream.isLive) {
-          await prisma.streamInfo.update({
-            where: { username: stream.name },
-            data: {
-              isLive: true,
-              startedAt: new Date(),
-            },
-          });
+        const subscribedFollowers = await prisma.follow.findMany({
+          where: {
+            channelId: existingStream.channelId,
+            notifyStream: true,
+          },
+          include: {
+            user: true,
+          },
+        });
 
-          const subscribedFollowers = await prisma.follow.findMany({
-            where: {
-              channelId: existingStream.channelId,
-              notifyStream: true,
-            },
-            include: {
-              user: true,
-            },
-          });
-          
-          const queue = getNotificationQueue();
+        const queue = getNotificationQueue();
 
-          if (!existingStream.channel.is247) {
-            queue.add(`streamStartChannel:${existingStream.username}`, {
-              text: `${existingStream.username} is now *live*, streaming *${existingStream.title}* (${existingStream.category})!\n<https://hctv.srizan.dev/${existingStream.username}|Go check them out>`,
-              channel: process.env.NOTIFICATION_CHANNEL_ID!,
+        if (!existingStream.channel.is247) {
+          queue.add(`streamStartChannel:${existingStream.username}`, {
+            text: `${existingStream.username} is now *live*, streaming *${existingStream.title}* (${existingStream.category})!\n<https://hackclub.tv/${existingStream.username}|Go check them out>`,
+            channel: process.env.NOTIFICATION_CHANNEL_ID!,
+            unfurl_links: true,
+          });
+        }
+
+        if (existingStream.enableNotifications && !existingStream.channel.is247) {
+          for (const follower of subscribedFollowers) {
+            queue.add(`streamStartDm:${follower.user.id}`, {
+              text: `${existingStream.username} is now *live*, streaming *${existingStream.title}* (${existingStream.category})!\n<https://hackclub.tv/${existingStream.username}|Go check them out>\n_Stream notifications are enabled for this user. If you want to disable them, you can do so in \`Profile > Follows\`._`,
+              channel: follower.user.slack_id,
               unfurl_links: true,
             });
           }
-          if (existingStream.enableNotifications && !existingStream.channel.is247) {
-            for (const follower of subscribedFollowers) {
-              queue.add(`streamStartDm:${follower.user.id}`, {
-                text: `${existingStream.username} is now *live*, streaming *${existingStream.title}* (${existingStream.category})!\n<https://hctv.srizan.dev/${existingStream.username}|Go check them out>\n_Stream notifications are enabled for this user. If you want to disable them, you can do so in \`Profile > Follows\`._`,
-                channel: follower.user.slack_id,
-                unfurl_links: true,
-              });
-            }
-          }
         }
       }
     }

apps/web/src/lib/instrumentation/syncStreamKeys.ts

@@ -0,0 +1,31 @@
+import { prisma, getRedisConnection } from '@hctv/db';
+
+export default async function syncStreamKeys() {
+  console.log('Syncing stream keys to Redis...');
+  try {
+    const keys = await prisma.streamKey.findMany({
+      include: {
+        channel: true,
+      },
+    });
+
+    if (keys.length === 0) {
+      console.log('No stream keys found to sync.');
+      return;
+    }
+
+    const redis = getRedisConnection();
+    const pipeline = redis.pipeline();
+
+    for (const key of keys) {
+      if (key.channel && key.channel.name) {
+        pipeline.set(`streamKey:${key.channel.name}`, key.key);
+      }
+    }
+
+    await pipeline.exec();
+    console.log(`Synced ${keys.length} stream keys to Redis`);
+  } catch (error) {
+    console.error('Failed to sync stream keys to Redis:', error);
+  }
+}

apps/web/src/lib/providers/ConfirmProvider.tsx

@@ -0,0 +1,21 @@
+'use client';
+
+import {
+  ConfirmDialogProvider as BaseConfirmDialogProvider,
+  ConfirmOptions,
+} from '@omit/react-confirm-dialog';
+
+interface Props {
+  children: React.ReactNode;
+  defaultOptions?: ConfirmOptions;
+}
+
+export const ConfirmDialogProvider = ({ children, defaultOptions }: Props) => {
+  return (
+    <BaseConfirmDialogProvider defaultOptions={defaultOptions}>
+      {children}
+    </BaseConfirmDialogProvider>
+  );
+};
+
+export default ConfirmDialogProvider;

apps/web/src/lib/providers/StreamInfoProvider.tsx

@@ -37,4 +37,9 @@ export function useStreams() {
   return context
 }
 
-export type StreamInfoResponse = (StreamInfo & { channel: Channel })[]
+export type StreamInfoResponse = (StreamInfo & {
+  channel: Channel & {
+    isRestricted?: boolean;
+    restrictionExpiresAt?: string | null;
+  };
+})[]

apps/web/src/lib/utils/mediamtx/client.ts

@@ -0,0 +1,29 @@
+import { MediaMTXRegion } from './regions';
+import { getEnv } from '@/lib/env';
+
+export interface MediaMTXClientEnvs {
+  publicUrl: string;
+  ingestRoute: string;
+  emoji: string;
+  string: string;
+}
+
+export function getMediamtxClientEnvs(region: MediaMTXRegion = 'hq'): MediaMTXClientEnvs {
+  const envs: Record<MediaMTXRegion, MediaMTXClientEnvs> = {
+    hq: {
+      publicUrl: getEnv('NEXT_PUBLIC_MEDIAMTX_URL_HQ')!,
+      ingestRoute: getEnv('NEXT_PUBLIC_MEDIAMTX_INGEST_ROUTE_HQ')!,
+      emoji: '🇺🇸',
+      string: 'HQ Server A',
+    },
+  };
+
+  const regionEnvs = envs[region];
+
+  if (!regionEnvs) {
+    throw new Error(`Invalid MediaMTX region: ${region}`);
+  }
+
+  return regionEnvs;
+}
+

apps/web/src/lib/utils/mediamtx/regions.ts

@@ -0,0 +1 @@
+export type MediaMTXRegion = 'hq';

apps/web/src/lib/utils/mediamtx/server.ts

@@ -0,0 +1,21 @@
+import { MediaMTXRegion } from './regions';
+
+export interface MediaMTXEnvs {
+  apiUrl: string;
+}
+
+export const MEDIAMTX_SERVER_REGIONS: Record<MediaMTXRegion, MediaMTXEnvs> = {
+  hq: {
+    apiUrl: process.env.MEDIAMTX_API_HQ!,
+  },
+};
+
+export function getMediamtxEnvs(region: MediaMTXRegion = 'hq'): MediaMTXEnvs {
+  const envs = MEDIAMTX_SERVER_REGIONS[region];
+
+  if (!envs) {
+    throw new Error(`Invalid MediaMTX region: ${region}`);
+  }
+
+  return envs;
+}

apps/web/src/lib/workers/worker/thumbnails.ts

@@ -1,9 +1,10 @@
 import { Worker } from 'bullmq';
 import { getRedisConnection } from '@hctv/db';
-import { exec } from 'node:child_process';
 import { promisify } from 'node:util';
 import { existsSync } from 'node:fs';
-const pExec = promisify(exec);
+import { exec as execCallback } from 'node:child_process';
+import { getMediamtxClientEnvs } from '@/lib/utils/mediamtx/client';
+const pExec = promisify(execCallback);
 
 const globalForWorker = global as unknown as {
   thumbnailWorker: Worker | null;
@@ -26,30 +27,29 @@ export async function registerThumbnailWorker(): Promise<void> {
       try {
         // this is totally unnecessary, but i'll keep it for security purposes.
         const name = job.data.name.replace(/[^a-zA-Z0-9]/g, '_');
-        const m3u8location = `/dev/shm/hls/${name}.m3u8`;
+        const server = job.data.server || 'hq';
+        const srvValues = getMediamtxClientEnvs(server);
+        
+        const m3u8location = `${srvValues.publicUrl}/${name}/index.m3u8`;
         const thumbDir = '/dev/shm/hctv-thumb';
         
-        if (!existsSync(m3u8location)) return;
         if (!existsSync(thumbDir)) {
           await pExec(`mkdir -p ${thumbDir}`);
         }
-        // unnecessary for development, but maybe docker volumes mess with permissions in prod
-        // also ik it's not the best practice to use 777, but it'll be fiiiiiine
-        // await pExec('chown -R 777 /dev/shm/hctv-thumb');
 
-        exec(
-          `ffmpeg -i ${m3u8location} -vframes 1 -an -y -f image2 ${thumbDir}/${name}.webp`,
-          (error) => {
-            if (error) {
-              console.error(`Error: ${error.message}`);
-              return { success: false, error: error.message };
-            }
-          }
-        );
-
-        return { success: true };
+        const header = `-headers "Authorization: Basic ${Buffer.from(`skibiditoilet:${process.env.MEDIAMTX_PUBLISH_KEY}`).toString('base64')}\r\n" `;
+        
+        try {
+          await pExec(
+            `ffmpeg ${header} -i ${m3u8location} -vframes 1 -an -y -f image2 ${thumbDir}/${name}.webp`
+          );
+          return { success: true };
+        } catch (ffmpegError) {
+          console.error(`FFmpeg error for ${name} on server ${server}:`, ffmpegError);
+          return { success: false, error: ffmpegError instanceof Error ? ffmpegError.message : String(ffmpegError) };
+        }
       } catch (e) {
-        console.error('Slack notification failed:', e);
+        console.error('Thumbnail generation failed:', e);
         // @ts-ignore e is unknown
         return { success: false, error: e.message };
       }

apps/web/tailwind.config.mts

@@ -1,5 +1,6 @@
 import type { Config } from "tailwindcss"
-import { withUt } from "uploadthing/tw";
+import { uploadthingPlugin } from 'uploadthing/tw'
+import * as tan from 'tailwindcss-animate'
 
 const config = {
   darkMode: ["class"],
@@ -102,7 +103,7 @@ const config = {
   		}
   	}
   },
-  plugins: [require("tailwindcss-animate")],
+  plugins: [tan, uploadthingPlugin],
 } satisfies Config
 
-export default withUt(config)
+export default config

apps/web/tsconfig.json

@@ -14,7 +14,7 @@
     "moduleResolution": "bundler",
     "resolveJsonModule": true,
     "isolatedModules": true,
-    "jsx": "preserve",
+    "jsx": "react-jsx",
     "incremental": true,
     "plugins": [
       {
@@ -32,7 +32,9 @@
     "next-env.d.ts",
     "**/*.ts",
     "**/*.tsx",
-    ".next/types/**/*.ts"
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts",
+    "tailwind.config.mts"
   ],
   "exclude": [
     "node_modules"

compose.yml

@@ -0,0 +1,60 @@
+services:
+  hctv:
+    container_name: hctv
+    depends_on:
+      postgres:
+        condition: service_healthy
+      pgbouncer:
+        condition: service_started
+    env_file:
+      - .env
+    restart: unless-stopped
+    image: srizan10/hclive
+  chat:
+    depends_on:
+      postgres:
+        condition: service_healthy
+      hctv:
+        condition: service_started
+    env_file:
+      - .env
+    restart: unless-stopped
+    image: srizan10/hclive-chat
+  postgres:
+    image: 'postgres:17-alpine'
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: '${PG_PASS}'
+    restart: unless-stopped
+    volumes:
+      - 'hctv_pgdata:/var/lib/postgresql/data'
+    healthcheck:
+      test:
+        - CMD-SHELL
+        - 'pg_isready -U postgres'
+      interval: 5s
+      timeout: 5s
+      retries: 5
+  pgbouncer:
+    image: 'bitnamilegacy/pgbouncer:1'
+    environment:
+      - POSTGRESQL_HOST=postgres
+      - POSTGRESQL_PORT=5432
+      - POSTGRESQL_USERNAME=postgres
+      - 'POSTGRESQL_PASSWORD=${PG_PASS}'
+      - PGBOUNCER_POOL_MODE=transaction
+      - PGBOUNCER_MAX_CLIENT_CONN=100
+      - PGBOUNCER_DEFAULT_POOL_SIZE=20
+    depends_on:
+      - postgres
+    restart: unless-stopped
+  redis:
+    image: 'redis:7.4-alpine'
+    volumes:
+      - 'hctv_redis:/data'
+  mediamtx:
+    image: 'bluenviron/mediamtx:latest'
+    ports:
+      - '8890:8890/udp'
+    volumes:
+      - './mediamtx.yml:/mediamtx.yml'

dev/docker-compose.yml

@@ -1,12 +1,12 @@
 services:
   psql:
-    image: postgres
+    image: postgres:18-alpine
     environment:
       POSTGRES_USER: postgres
       # my condolences
       POSTGRES_PASSWORD: skbiditoilet
     volumes:
-      - ./psql:/var/lib/postgresql/data
+      - ./psql:/var/lib/postgresql
     ports:
       - 5555:5432
   redis:
@@ -15,38 +15,23 @@ services:
       - ./redis:/data
     ports:
       - 6379:6379
-  nginx-rtmp:
-    # ports:
-    #   - 1935:1935
-    #   - 8888:8888
-    network_mode: host
-    environment:
-      UID: 1000
-      GID: 1000
-      API_AUTH: skibiditoilet
+  mediamtx:
+    image: bluenviron/mediamtx:latest
+    ports:
+      - 8890:8890/udp
+      - 8891:8888
+      - 9997:9997
     volumes:
-      - ./nginx.conf:/etc/nginx/templates/nginx.conf.template
-      - ./html:/var/www/html
-      - /dev/shm/hls:/dev/shm/hls
-    image: srizan10/flv-module
-    entrypoint:
-      - /bin/sh
-      - -c
-      - |
-        # Process the template file
-        mkdir -p /usr/local/nginx/conf
-        envsubst '$${API_AUTH}' < /etc/nginx/templates/nginx.conf.template > /usr/local/nginx/conf/nginx.conf
-
-        echo "Setting UID to $${UID} and GID to $${GID}"
-        usermod -u $${UID} nginx || echo "failed to change uid"
-        groupmod -g $${GID} nginx || echo "failed to change gid"
-
-        mkdir -p /usr/local/nginx/proxy_temp /usr/local/nginx/client_body_temp
-        chown -R nginx:nginx /usr/local/nginx
-        mkdir -p /var/www/html
-        chown -R nginx:nginx /var/www/html
-
-        echo "testing nginx config..."
-        /usr/local/nginx/sbin/nginx -t
-
-        /usr/local/nginx/sbin/nginx -g 'daemon off;'
+      - ./mediamtx.yml:/mediamtx.yml
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+  # mediamtx2:
+  #   image: bluenviron/mediamtx:latest
+  #   ports:
+  #     - 8990:8890/udp
+  #     - 8991:8891
+  #     - 9999:9997
+  #   volumes:
+  #     - ./mediamtx.yml:/mediamtx.yml
+  #   extra_hosts:
+  #     - "host.docker.internal:host-gateway"

dev/mediamtx.yml

@@ -0,0 +1,18 @@
+paths:
+  all:
+    source: publisher
+
+srt: yes
+srtAddress: :8890
+
+hls: yes
+hlsAddress: :8891
+hlsSegmentCount: 7
+hlsSegmentDuration: 500ms
+hlsPartDuration: 200ms
+hlsMuxerCloseAfter: 5s
+
+authMethod: http
+authHTTPAddress: http://host.docker.internal:3000/api/mediamtx/publish
+
+api: yes

dev/nginx.conf

@@ -28,8 +28,8 @@ rtmp {
       hls on;
       hls_type live;
       hls_path /dev/shm/hls;
-      hls_fragment 1s;
-      hls_playlist_length 3s;
+      hls_fragment 2s;
+      hls_playlist_length 10s;
       hls_cleanup on;
 
       hls_fragment_naming timestamp;
@@ -54,7 +54,7 @@ http {
 
   map $http_authorization $is_authorized {
     default 0;
-    $API_AUTH 1;
+    ${API_AUTH} 1;
   }
 
   server {

flv-module/Dockerfile

@@ -1,4 +1,4 @@
-FROM alpine:3.19 as builder
+FROM alpine:3.19 AS builder
 
 RUN apk add --no-cache \
     build-base \
@@ -37,20 +37,8 @@ RUN mkdir -p /etc/nginx/templates
 
 EXPOSE 80 1935 8888
 
-# Create an entrypoint script to handle environment variable substitution
-RUN echo '#!/bin/sh \n\
-# Replace environment variables in configuration templates \n\
-for template in /etc/nginx/templates/*.conf.template; do \n\
-  if [ -f "$template" ]; then \n\
-    output_file="/usr/local/nginx/conf/$(basename $template .template)" \n\
-    echo "Processing template: $template -> $output_file" \n\
-    envsubst "$(env | awk -F= "{printf \\\"\\\$%s \\\",\\\$1}")" < $template > $output_file \n\
-  fi \n\
-done \n\
-\n\
-# Start Nginx \n\
-exec "$@"' > /docker-entrypoint.sh && \
-chmod +x /docker-entrypoint.sh
+COPY docker-entrypoint.sh /docker-entrypoint.sh
+RUN chmod +x /docker-entrypoint.sh
 
 ENTRYPOINT ["/docker-entrypoint.sh"]
 CMD ["/usr/local/nginx/sbin/nginx", "-g", "daemon off;"]

flv-module/docker-entrypoint.sh

@@ -0,0 +1,27 @@
+#!/bin/sh
+set -e
+
+UID=${UID:-1000}
+GID=${GID:-1000}
+
+echo "Setting UID to $UID and GID to $GID"
+usermod -u $UID nginx 2>/dev/null || echo "Failed to change UID"
+groupmod -g $GID nginx 2>/dev/null || echo "Failed to change GID"
+
+mkdir -p /usr/local/nginx/conf
+for template in /etc/nginx/templates/*.conf.template; do
+  if [ -f "$template" ]; then
+    output_file="/usr/local/nginx/conf/$(basename $template .template)"
+    echo "Processing template: $template -> $output_file"
+    envsubst '${API_AUTH}' < $template > $output_file
+  fi
+done
+
+mkdir -p /usr/local/nginx/proxy_temp /usr/local/nginx/client_body_temp
+mkdir -p /var/www/html
+chown -R nginx:nginx /usr/local/nginx /var/www/html
+
+echo "Testing nginx configuration..."
+/usr/local/nginx/sbin/nginx -t
+
+exec "$@"

package.json

@@ -14,13 +14,16 @@
     "docker:web": "dotenvx run -f .env.docker -- docker buildx build --platform linux/amd64 -f apps/web/Dockerfile . --secret id=TURBO_TOKEN,env=TURBO_TOKEN --secret id=TURBO_TEAM,env=TURBO_TEAM --no-cache",
     "docker:chat": "dotenvx run -f .env.docker -- docker buildx build --platform linux/amd64 -f apps/chat/Dockerfile . --secret id=TURBO_TOKEN,env=TURBO_TOKEN --secret id=TURBO_TEAM,env=TURBO_TEAM --no-cache",
     "act": "act --secret-file .env.ci",
-    "db:migrate": "yarn workspace @hctv/db db:migrate",
-    "ui:add": "yarn workspace @hctv/web ui:add",
-    "prisma": "yarn workspace @hctv/db prisma",
-    "r:rtmp": "docker compose -f dev/docker-compose.yml restart nginx-rtmp -t 0"
+    "db:migrate": "pnpm --filter=@hctv/db db:migrate",
+    "ui:add": "pnpm --filter=@hctv/web ui:add",
+    "prisma": "pnpm --filter=@hctv/db prisma",
+    "r:rtmp": "docker compose -f dev/docker-compose.yml restart nginx-rtmp -t 0",
+    "sdk:test": "dotenvx run -f .env.sdk -- pnpm --filter=@hctv/sdk test",
+    "sdk:example": "dotenvx run -f .env.sdk -- pnpm --filter=@hctv/sdk example"
   },
   "devDependencies": {
+    "prettier": "^3.6.2",
     "turbo": "^2.4.4"
   },
-  "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
+  "packageManager": "pnpm@10.6.5"
 }

packages/auth/package.json

@@ -14,7 +14,7 @@
     "dev": "tsc --watch --preserveWatchOutput"
   },
   "dependencies": {
-    "@hctv/db": "*",
+    "@hctv/db": "workspace:*",
     "@lucia-auth/adapter-prisma": "^4.0.1",
     "arctic": "^3.1.1",
     "lucia": "^3.2.2"

packages/auth/src/index.ts

@@ -1,10 +1,18 @@
 import { PrismaAdapter } from '@lucia-auth/adapter-prisma';
 import { Lucia } from 'lucia';
 import { prisma } from '@hctv/db';
-import { Slack } from 'arctic';
+import { OAuth2Client } from 'arctic';
 
 const adapter = new PrismaAdapter(prisma.session, prisma.user);
-export const slack = new Slack(process.env.SLACK_ID!, process.env.SLACK_SECRET!, process.env.SLACK_REDIRECT_URI!);
+export const hackClub = new OAuth2Client(
+  process.env.HCID_CLIENT!,
+  process.env.HCID_SECRET!,
+  process.env.HCID_REDIRECT_URI!
+);
+
+export const HCID_AUTH_URL = "https://auth.hackclub.com/oauth/authorize";
+export const HCID_TOKEN_URL = "https://auth.hackclub.com/oauth/token";
+export const HCID_USER_INFO_URL = "https://auth.hackclub.com/api/v1/me";
 
 export const lucia = new Lucia(adapter, {
   sessionCookie: {
@@ -19,9 +27,11 @@ export const lucia = new Lucia(adapter, {
   getUserAttributes: (attributes) => {
     return {
       slack_id: attributes.slack_id,
+      email: attributes.email,
       pfpUrl: attributes.pfpUrl,
       hasOnboarded: attributes.hasOnboarded,
       personalChannelId: attributes.personalChannelId,
+      isAdmin: attributes.isAdmin,
     };
   },
 });
@@ -35,7 +45,9 @@ declare module 'lucia' {
 
 interface DatabaseUserAttributes {
   slack_id: string;
+  email: string | null;
   pfpUrl: string;
   hasOnboarded: boolean;
   personalChannelId: string | null;
+  isAdmin: boolean;
 }

packages/db/.env.example

@@ -0,0 +1,2 @@
+DATABASE_URL=postgresql://postgres:skbiditoilet@localhost:5555/postgres
+DATABASE_DIRECT_URL=postgresql://postgres:skbiditoilet@localhost:5555/postgres

packages/db/Dockerfile

@@ -1,44 +0,0 @@
-FROM node:lts-alpine AS base
-
-FROM base AS builder
-RUN apk update
-RUN apk add --no-cache libc6-compat
-# Set working directory
-WORKDIR /app
-RUN yarn global add turbo@^2
-COPY . .
- 
-# Generate a partial monorepo with a pruned lockfile for the db package
-RUN turbo prune @hctv/db --docker
- 
-FROM base AS installer
-RUN apk update
-RUN apk add --no-cache libc6-compat
-WORKDIR /app
- 
-# First install the dependencies
-COPY --from=builder /app/out/json/ .
-RUN yarn install --frozen-lockfile
-
-COPY --from=builder /app/out/full/ .
-RUN --mount=type=secret,id=TURBO_TOKEN --mount=type=secret,id=TURBO_TEAM TURBO_TOKEN=$(cat /run/secrets/TURBO_TOKEN) TURBO_TEAM=$(cat /run/secrets/TURBO_TEAM) yarn turbo run build --filter=@hctv/db
- 
-FROM base AS runner
-WORKDIR /app
- 
-RUN addgroup --system --gid 1001 nodejs
-RUN adduser --system --uid 1001 prisma
-USER prisma
- 
-COPY --from=installer --chown=prisma:nodejs /app/packages ./packages
-COPY --from=installer --chown=prisma:nodejs /app/node_modules ./node_modules
-COPY --from=installer --chown=prisma:nodejs /app/package.json ./package.json
-
-# Set environment variables for database connection
-ENV NODE_ENV=production
-
-# Set the working directory to the db package
-WORKDIR /app/packages/db
-
-# Run Prisma migrations as the entrypoint
-ENTRYPOINT ["npx", "prisma", "migrate", "deploy"]

packages/db/prisma/migrations/20250909181358_bot_accounts_draft/migration.sql

@@ -0,0 +1,42 @@
+-- CreateTable
+CREATE TABLE "BotAccounts" (
+    "id" TEXT NOT NULL,
+    "displayName" TEXT NOT NULL,
+    "slug" TEXT NOT NULL,
+    "description" TEXT NOT NULL,
+    "pfpUrl" TEXT NOT NULL,
+    "channelId" TEXT NOT NULL,
+
+    CONSTRAINT "BotAccounts_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "ApiKey" (
+    "id" TEXT NOT NULL,
+    "key" TEXT NOT NULL,
+    "botAccountId" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "ApiKey_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "BotAccounts_slug_key" ON "BotAccounts"("slug");
+
+-- CreateIndex
+CREATE INDEX "BotAccounts_channelId_idx" ON "BotAccounts"("channelId");
+
+-- CreateIndex
+CREATE INDEX "BotAccounts_slug_idx" ON "BotAccounts"("slug");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "ApiKey_key_key" ON "ApiKey"("key");
+
+-- CreateIndex
+CREATE INDEX "ApiKey_botAccountId_idx" ON "ApiKey"("botAccountId");
+
+-- AddForeignKey
+ALTER TABLE "BotAccounts" ADD CONSTRAINT "BotAccounts_channelId_fkey" FOREIGN KEY ("channelId") REFERENCES "Channel"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "ApiKey" ADD CONSTRAINT "ApiKey_botAccountId_fkey" FOREIGN KEY ("botAccountId") REFERENCES "BotAccounts"("id") ON DELETE CASCADE ON UPDATE CASCADE;

packages/db/prisma/migrations/20250909210506_bot_accounts_on_user/migration.sql

@@ -0,0 +1,22 @@
+/*
+  Warnings:
+
+  - You are about to drop the column `channelId` on the `BotAccounts` table. All the data in the column will be lost.
+  - Added the required column `ownerId` to the `BotAccounts` table without a default value. This is not possible if the table is not empty.
+
+*/
+-- DropForeignKey
+ALTER TABLE "BotAccounts" DROP CONSTRAINT "BotAccounts_channelId_fkey";
+
+-- DropIndex
+DROP INDEX "BotAccounts_channelId_idx";
+
+-- AlterTable
+ALTER TABLE "BotAccounts" DROP COLUMN "channelId",
+ADD COLUMN     "ownerId" TEXT NOT NULL;
+
+-- CreateIndex
+CREATE INDEX "BotAccounts_ownerId_idx" ON "BotAccounts"("ownerId");
+
+-- AddForeignKey
+ALTER TABLE "BotAccounts" ADD CONSTRAINT "BotAccounts_ownerId_fkey" FOREIGN KEY ("ownerId") REFERENCES "User"("id") ON DELETE RESTRICT ON UPDATE CASCADE;