Deploy StreamTime server

Dockerfile

@@ -1,15 +1,33 @@
-FROM stremio/server:latest
-
-  # Patch the hardcoded localhost URL in the bundled web UI JS files
-  RUN find / -name "*.js" \
-          -not -path "*/proc/*" \
-          -not -path "*/sys/*" \
-          2>/dev/null \
-      | while IFS= read -r f; do \
-          if grep -q "127.0.0.1:11470" "$f" 2>/dev/null; then \
-              sed -i 's|http://127.0.0.1:11470|https://xthexbeastx-stremio.hf.space|g' "$f"; \
-              sed -i 's|http://localhost:11470|https://xthexbeastx-stremio.hf.space|g' "$f"; \
-          fi; \
-      done || true
-
-  EXPOSE 11470
+FROM node:20-slim AS base
+RUN npm install -g pnpm
+
+WORKDIR /app
+
+FROM base AS builder
+COPY package.json pnpm-workspace.yaml pnpm-lock.yaml ./
+COPY packages/shared/package.json ./packages/shared/
+COPY apps/server/package.json ./apps/server/
+
+RUN pnpm install --frozen-lockfile
+
+COPY packages/shared ./packages/shared
+COPY apps/server ./apps/server
+
+WORKDIR /app/apps/server
+RUN pnpm db:generate
+RUN pnpm build
+
+FROM node:20-slim AS runner
+RUN npm install -g pnpm
+
+WORKDIR /app
+
+COPY --from=builder /app/apps/server/dist ./dist
+COPY --from=builder /app/apps/server/node_modules ./node_modules
+COPY --from=builder /app/apps/server/prisma ./prisma
+
+ENV NODE_ENV=production
+ENV PORT=7860
+EXPOSE 7860
+
+CMD ["node", "dist/index.js"]

apps/server/esbuild.config.js

@@ -0,0 +1,14 @@
+import { build } from 'esbuild'
+
+await build({
+  entryPoints: ['src/index.ts'],
+  bundle: true,
+  platform: 'node',
+  target: 'node20',
+  format: 'esm',
+  outdir: 'dist',
+  external: ['@prisma/client'],
+  banner: {
+    js: `import { createRequire } from 'module'; const require = createRequire(import.meta.url);`,
+  },
+})

apps/server/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@streamtime/server",
+  "version": "0.0.1",
+  "type": "module",
+  "scripts": {
+    "dev": "tsx watch --env-file=.env src/index.ts",
+    "build": "node esbuild.config.js",
+    "start": "node dist/index.js",
+    "db:push": "prisma db push",
+    "db:generate": "prisma generate"
+  },
+  "dependencies": {
+    "@prisma/client": "^6.1.0",
+    "@streamtime/shared": "workspace:*",
+    "axios": "^1.7.9",
+    "bcryptjs": "^2.4.3",
+    "cookie-parser": "^1.4.7",
+    "cors": "^2.8.5",
+    "express": "^4.21.2",
+    "helmet": "^8.0.0",
+    "jsonwebtoken": "^9.0.2",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@types/bcryptjs": "^2.4.6",
+    "@types/cookie-parser": "^1.4.8",
+    "@types/cors": "^2.8.17",
+    "@types/express": "^5.0.0",
+    "@types/jsonwebtoken": "^9.0.7",
+    "@types/node": "^22.10.7",
+    "esbuild": "^0.24.2",
+    "prisma": "^6.1.0",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.3"
+  }
+}

apps/server/prisma/schema.prisma

@@ -0,0 +1,56 @@
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider  = "postgresql"
+  url       = env("DATABASE_URL")
+  directUrl = env("DIRECT_URL")
+}
+
+model User {
+  id           String         @id @default(cuid())
+  email        String         @unique
+  username     String         @unique
+  passwordHash String
+  createdAt    DateTime       @default(now())
+  sessions     Session[]
+  watchlist    Watchlist[]
+  watchHistory WatchHistory[]
+}
+
+model Session {
+  id        String   @id @default(cuid())
+  userId    String
+  token     String   @unique
+  expiresAt DateTime
+  user      User     @relation(fields: [userId], references: [id], onDelete: Cascade)
+}
+
+model Watchlist {
+  id        String   @id @default(cuid())
+  userId    String
+  tmdbId    Int
+  mediaType String
+  title     String
+  posterPath String?
+  addedAt   DateTime @default(now())
+  user      User     @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  @@unique([userId, tmdbId, mediaType])
+}
+
+model WatchHistory {
+  id              String   @id @default(cuid())
+  userId          String
+  tmdbId          Int
+  mediaType       String
+  title           String
+  posterPath      String?
+  seasonNumber    Int?
+  episodeNumber   Int?
+  progressSeconds Int      @default(0)
+  durationSeconds Int      @default(0)
+  updatedAt       DateTime @updatedAt
+  user            User     @relation(fields: [userId], references: [id], onDelete: Cascade)
+}

apps/server/src/db.ts

@@ -0,0 +1,3 @@
+import { PrismaClient } from '@prisma/client'
+
+export const prisma = new PrismaClient()

apps/server/src/env.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod'
+
+const envSchema = z.object({
+  DATABASE_URL: z.string(),
+  DIRECT_URL: z.string().optional(),
+  JWT_SECRET: z.string(),
+  TMDB_API_KEY: z.string(),
+  OPENSUBTITLES_API_KEY: z.string(),
+  CLIENT_URL: z.string().default('http://localhost:5173'),
+  PORT: z.coerce.number().default(3001),
+  NODE_ENV: z.enum(['development', 'production', 'test']).default('development'),
+})
+
+export const env = envSchema.parse(process.env)

apps/server/src/index.ts

@@ -0,0 +1,35 @@
+import express from 'express'
+import cors from 'cors'
+import helmet from 'helmet'
+import cookieParser from 'cookie-parser'
+import { env } from './env.js'
+import authRouter from './routes/auth.js'
+import tmdbRouter from './routes/tmdb.js'
+import subtitlesRouter from './routes/subtitles.js'
+import watchlistRouter from './routes/watchlist.js'
+import historyRouter from './routes/history.js'
+
+const app = express()
+
+app.use(helmet({
+  crossOriginResourcePolicy: { policy: 'cross-origin' },
+  contentSecurityPolicy: false,
+}))
+
+app.use(cors({
+  origin: env.CLIENT_URL,
+  credentials: true,
+}))
+
+app.use(express.json())
+app.use(cookieParser())
+
+app.use('/api/auth', authRouter)
+app.use('/api/tmdb', tmdbRouter)
+app.use('/api/subtitles', subtitlesRouter)
+app.use('/api/watchlist', watchlistRouter)
+app.use('/api/history', historyRouter)
+
+app.listen(env.PORT, () => {
+  console.log(`Server listening on port ${env.PORT}`)
+})

apps/server/src/middleware/auth.ts

@@ -0,0 +1,33 @@
+import { Request, Response, NextFunction } from 'express'
+import jwt from 'jsonwebtoken'
+import crypto from 'crypto'
+import { prisma } from '../db.js'
+import { env } from '../env.js'
+
+export interface AuthRequest extends Request {
+  userId?: string
+}
+
+export async function requireAuth(req: AuthRequest, res: Response, next: NextFunction) {
+  const token = req.cookies.st_token
+  if (!token) {
+    res.status(401).json({ error: 'Unauthorized' })
+    return
+  }
+
+  try {
+    const payload = jwt.verify(token, env.JWT_SECRET) as { sub: string; jti: string }
+    const hash = crypto.createHash('sha256').update(payload.jti).digest('hex')
+
+    const session = await prisma.session.findUnique({ where: { token: hash } })
+    if (!session || session.expiresAt < new Date()) {
+      res.status(401).json({ error: 'Session expired' })
+      return
+    }
+
+    req.userId = payload.sub
+    next()
+  } catch {
+    res.status(401).json({ error: 'Invalid token' })
+  }
+}

apps/server/src/routes/auth.ts

@@ -0,0 +1,139 @@
+import { Router } from 'express'
+import bcrypt from 'bcryptjs'
+import jwt from 'jsonwebtoken'
+import crypto from 'crypto'
+import { prisma } from '../db.js'
+import { env } from '../env.js'
+import { requireAuth, AuthRequest } from '../middleware/auth.js'
+
+const router: Router = Router()
+
+const COOKIE_OPTS = {
+  httpOnly: true,
+  secure: env.NODE_ENV === 'production',
+  sameSite: 'lax' as const,
+  maxAge: 7 * 24 * 60 * 60 * 1000,
+}
+
+function signToken(userId: string) {
+  const jti = crypto.randomUUID()
+  const token = jwt.sign({ sub: userId, jti }, env.JWT_SECRET, { expiresIn: '7d' })
+  const hash = crypto.createHash('sha256').update(jti).digest('hex')
+  return { token, hash }
+}
+
+router.post('/register', async (req, res) => {
+  const { email, username, password } = req.body
+  if (!email || !username || !password) {
+    res.status(400).json({ error: 'Missing fields' })
+    return
+  }
+
+  const existing = await prisma.user.findFirst({
+    where: { OR: [{ email }, { username }] },
+  })
+  if (existing) {
+    res.status(409).json({ error: 'Email or username already taken' })
+    return
+  }
+
+  const passwordHash = await bcrypt.hash(password, 12)
+  const user = await prisma.user.create({
+    data: { email, username, passwordHash },
+  })
+
+  const { token, hash } = signToken(user.id)
+  await prisma.session.create({
+    data: {
+      userId: user.id,
+      token: hash,
+      expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),
+    },
+  })
+
+  res.cookie('st_token', token, COOKIE_OPTS)
+  res.json({ user: { id: user.id, email: user.email, username: user.username } })
+})
+
+router.post('/login', async (req, res) => {
+  const { email, password } = req.body
+  if (!email || !password) {
+    res.status(400).json({ error: 'Missing fields' })
+    return
+  }
+
+  const user = await prisma.user.findUnique({ where: { email } })
+  if (!user || !(await bcrypt.compare(password, user.passwordHash))) {
+    res.status(401).json({ error: 'Invalid credentials' })
+    return
+  }
+
+  const { token, hash } = signToken(user.id)
+  await prisma.session.create({
+    data: {
+      userId: user.id,
+      token: hash,
+      expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),
+    },
+  })
+
+  res.cookie('st_token', token, COOKIE_OPTS)
+  res.json({ user: { id: user.id, email: user.email, username: user.username } })
+})
+
+router.post('/logout', requireAuth as any, async (req: AuthRequest, res) => {
+  const token = req.cookies.st_token
+  if (token) {
+    try {
+      const payload = jwt.verify(token, env.JWT_SECRET) as { jti: string }
+      const hash = crypto.createHash('sha256').update(payload.jti).digest('hex')
+      await prisma.session.deleteMany({ where: { token: hash } })
+    } catch { /* ignore */ }
+  }
+  res.clearCookie('st_token')
+  res.json({ ok: true })
+})
+
+router.get('/me', requireAuth as any, async (req: AuthRequest, res) => {
+  const user = await prisma.user.findUnique({
+    where: { id: req.userId },
+    select: { id: true, email: true, username: true, createdAt: true },
+  })
+  if (!user) {
+    res.status(404).json({ error: 'User not found' })
+    return
+  }
+  res.json({ user })
+})
+
+router.get('/stats', requireAuth as any, async (req: AuthRequest, res) => {
+  const [watchlistCount, historyCount] = await Promise.all([
+    prisma.watchlist.count({ where: { userId: req.userId! } }),
+    prisma.watchHistory.count({ where: { userId: req.userId! } }),
+  ])
+  res.json({ watchlistCount, historyCount })
+})
+
+router.post('/password', requireAuth as any, async (req: AuthRequest, res) => {
+  const { currentPassword, newPassword } = req.body
+  if (!currentPassword || !newPassword) {
+    res.status(400).json({ error: 'Missing fields' })
+    return
+  }
+  if (newPassword.length < 6) {
+    res.status(400).json({ error: 'New password must be at least 6 characters' })
+    return
+  }
+
+  const user = await prisma.user.findUnique({ where: { id: req.userId! } })
+  if (!user || !(await bcrypt.compare(currentPassword, user.passwordHash))) {
+    res.status(401).json({ error: 'Current password is incorrect' })
+    return
+  }
+
+  const passwordHash = await bcrypt.hash(newPassword, 12)
+  await prisma.user.update({ where: { id: req.userId! }, data: { passwordHash } })
+  res.json({ ok: true })
+})
+
+export default router

apps/server/src/routes/history.ts

@@ -0,0 +1,89 @@
+import { Router } from 'express'
+import { prisma } from '../db.js'
+import { requireAuth, AuthRequest } from '../middleware/auth.js'
+
+const router: Router = Router()
+
+router.use(requireAuth as any)
+
+router.get('/', async (req: AuthRequest, res) => {
+  const items = await prisma.watchHistory.findMany({
+    where: { userId: req.userId },
+    orderBy: { updatedAt: 'desc' },
+  })
+  res.json(items)
+})
+
+router.post('/', async (req: AuthRequest, res) => {
+  const { tmdbId, mediaType, title, posterPath, seasonNumber, episodeNumber, progressSeconds, durationSeconds } = req.body
+  if (!tmdbId || !mediaType || !title) {
+    res.status(400).json({ error: 'Missing fields' })
+    return
+  }
+
+  const existing = await prisma.watchHistory.findFirst({
+    where: {
+      userId: req.userId!,
+      tmdbId: Number(tmdbId),
+      mediaType,
+      seasonNumber: seasonNumber ?? null,
+      episodeNumber: episodeNumber ?? null,
+    },
+  })
+
+  if (existing) {
+    const updated = await prisma.watchHistory.update({
+      where: { id: existing.id },
+      data: {
+        progressSeconds: Number(progressSeconds) || 0,
+        durationSeconds: Number(durationSeconds) || 0,
+        posterPath: posterPath ?? existing.posterPath,
+      },
+    })
+    res.json(updated)
+  } else {
+    const item = await prisma.watchHistory.create({
+      data: {
+        userId: req.userId!,
+        tmdbId: Number(tmdbId),
+        mediaType,
+        title,
+        posterPath: posterPath ?? null,
+        seasonNumber: seasonNumber ?? null,
+        episodeNumber: episodeNumber ?? null,
+        progressSeconds: Number(progressSeconds) || 0,
+        durationSeconds: Number(durationSeconds) || 0,
+      },
+    })
+    res.status(201).json(item)
+  }
+})
+
+router.delete('/:id', async (req: AuthRequest, res) => {
+  const { id } = req.params
+  await prisma.watchHistory.deleteMany({
+    where: { id, userId: req.userId! },
+  })
+  res.json({ ok: true })
+})
+
+router.get('/progress', async (req: AuthRequest, res) => {
+  const { tmdbId, mediaType, season, episode } = req.query as Record<string, string>
+  if (!tmdbId || !mediaType) {
+    res.status(400).json({ error: 'Missing fields' })
+    return
+  }
+
+  const item = await prisma.watchHistory.findFirst({
+    where: {
+      userId: req.userId!,
+      tmdbId: Number(tmdbId),
+      mediaType,
+      seasonNumber: season ? Number(season) : null,
+      episodeNumber: episode ? Number(episode) : null,
+    },
+  })
+  res.json(item ?? null)
+})
+
+export default router

apps/server/src/routes/subtitles.ts

@@ -0,0 +1,79 @@
+import { Router } from 'express'
+import axios from 'axios'
+import { env } from '../env.js'
+import type { SubtitleTrack } from '@streamtime/shared'
+
+const router: Router = Router()
+
+const OS_API = 'https://api.opensubtitles.com/api/v1'
+const osHeaders = {
+  'Api-Key': env.OPENSUBTITLES_API_KEY,
+  'Content-Type': 'application/json',
+  'User-Agent': 'StreamTime v1.0',
+}
+
+const subtitleCache = new Map<string, string>()
+
+router.get('/search', async (req, res) => {
+  const { imdb_id, type, languages } = req.query as Record<string, string>
+  if (!imdb_id) {
+    res.status(400).json({ error: 'Missing imdb_id' })
+    return
+  }
+
+  const params = new URLSearchParams()
+  params.set('imdb_id', imdb_id.replace(/^tt/, ''))
+  if (type === 'tv') params.set('type', 'episode')
+  else params.set('type', 'movie')
+  if (languages) params.set('languages', languages)
+
+  const response = await axios.get(`${OS_API}/subtitles?${params}`, { headers: osHeaders })
+  const results: SubtitleTrack[] = (response.data.data || [])
+    .filter((item: any) => item.attributes?.files?.length > 0)
+    .map((item: any) => ({
+      fileId: String(item.attributes.files[0].file_id),
+      language: item.attributes.language,
+      languageName: item.attributes.language,
+      releaseName: item.attributes.release || '',
+    }))
+
+  res.json(results)
+})
+
+router.get('/download/:fileId', async (req, res) => {
+  const { fileId } = req.params
+
+  if (subtitleCache.has(fileId)) {
+    res.setHeader('Content-Type', 'text/vtt')
+    res.send(subtitleCache.get(fileId))
+    return
+  }
+
+  const downloadRes = await axios.post(
+    `${OS_API}/download`,
+    { file_id: parseInt(fileId) },
+    { headers: osHeaders }
+  )
+
+  const fileUrl: string = downloadRes.data.link
+  const fileRes = await axios.get(fileUrl, { responseType: 'text' })
+  let content: string = fileRes.data
+
+  if (!content.startsWith('WEBVTT')) {
+    content = srtToVtt(content)
+  }
+
+  subtitleCache.set(fileId, content)
+  res.setHeader('Content-Type', 'text/vtt')
+  res.send(content)
+})
+
+function srtToVtt(srt: string): string {
+  const vtt = srt
+    .replace(/\r\n/g, '\n')
+    .replace(/\r/g, '\n')
+    .replace(/(\d{2}:\d{2}:\d{2}),(\d{3})/g, '$1.$2')
+  return 'WEBVTT\n\n' + vtt
+}
+
+export default router

apps/server/src/routes/tmdb.ts

@@ -0,0 +1,90 @@
+import { Router } from 'express'
+import axios from 'axios'
+import { env } from '../env.js'
+
+const router: Router = Router()
+
+const tmdb = axios.create({
+  baseURL: 'https://api.themoviedb.org/3',
+  headers: {
+    Authorization: `Bearer ${env.TMDB_API_KEY}`,
+    'Content-Type': 'application/json',
+  },
+})
+
+async function proxyGet(path: string, params?: Record<string, string>) {
+  const res = await tmdb.get(path, { params })
+  return res.data
+}
+
+router.get('/trending', async (_req, res) => {
+  const data = await proxyGet('/trending/all/week')
+  res.json(data)
+})
+
+router.get('/movies/popular', async (_req, res) => {
+  const data = await proxyGet('/movie/popular')
+  res.json(data)
+})
+
+router.get('/movies/top-rated', async (_req, res) => {
+  const data = await proxyGet('/movie/top_rated')
+  res.json(data)
+})
+
+router.get('/tv/popular', async (_req, res) => {
+  const data = await proxyGet('/tv/popular')
+  res.json(data)
+})
+
+router.get('/movies/:id', async (req, res) => {
+  const data = await proxyGet(`/movie/${req.params.id}`, {
+    append_to_response: 'videos,credits,external_ids',
+  })
+  res.json(data)
+})
+
+router.get('/tv/:id', async (req, res) => {
+  const data = await proxyGet(`/tv/${req.params.id}`, {
+    append_to_response: 'external_ids,seasons',
+  })
+  res.json(data)
+})
+
+router.get('/tv/:id/season/:season', async (req, res) => {
+  const data = await proxyGet(`/tv/${req.params.id}/season/${req.params.season}`)
+  res.json(data)
+})
+
+router.get('/movies/:id/similar', async (req, res) => {
+  const data = await proxyGet(`/movie/${req.params.id}/recommendations`)
+  res.json(data)
+})
+
+router.get('/tv/:id/similar', async (req, res) => {
+  const data = await proxyGet(`/tv/${req.params.id}/recommendations`)
+  res.json(data)
+})
+
+router.get('/discover', async (req, res) => {
+  const { type, genreId, page = '1' } = req.query as Record<string, string>
+  const endpoint = type === 'tv' ? '/discover/tv' : '/discover/movie'
+  const data = await proxyGet(endpoint, {
+    with_genres: genreId,
+    page,
+    sort_by: 'popularity.desc',
+  })
+  res.json(data)
+})
+
+router.get('/search', async (req, res) => {
+  const q = req.query.q as string
+  if (!q) {
+    res.status(400).json({ error: 'Missing q parameter' })
+    return
+  }
+  const data = await proxyGet('/search/multi', { query: q })
+  res.json(data)
+})
+
+export default router

apps/server/src/routes/watchlist.ts

@@ -0,0 +1,70 @@
+import { Router } from 'express'
+import { prisma } from '../db.js'
+import { requireAuth, AuthRequest } from '../middleware/auth.js'
+
+const router: Router = Router()
+
+router.use(requireAuth as any)
+
+router.get('/', async (req: AuthRequest, res) => {
+  const items = await prisma.watchlist.findMany({
+    where: { userId: req.userId },
+    orderBy: { addedAt: 'desc' },
+  })
+  res.json(items)
+})
+
+router.post('/', async (req: AuthRequest, res) => {
+  const { tmdbId, mediaType, title, posterPath } = req.body
+  if (!tmdbId || !mediaType || !title) {
+    res.status(400).json({ error: 'Missing fields' })
+    return
+  }
+
+  const existing = await prisma.watchlist.findFirst({
+    where: { userId: req.userId!, tmdbId: Number(tmdbId), mediaType },
+  })
+  if (existing) {
+    res.json(existing)
+    return
+  }
+
+  const item = await prisma.watchlist.create({
+    data: {
+      userId: req.userId!,
+      tmdbId: Number(tmdbId),
+      mediaType,
+      title,
+      posterPath: posterPath ?? null,
+    },
+  })
+  res.status(201).json(item)
+})
+
+router.delete('/', async (req: AuthRequest, res) => {
+  const { tmdbId, mediaType } = req.body
+  if (!tmdbId || !mediaType) {
+    res.status(400).json({ error: 'Missing fields' })
+    return
+  }
+
+  await prisma.watchlist.deleteMany({
+    where: { userId: req.userId!, tmdbId: Number(tmdbId), mediaType },
+  })
+  res.json({ ok: true })
+})
+
+router.get('/check', async (req: AuthRequest, res) => {
+  const { tmdbId, mediaType } = req.query as Record<string, string>
+  if (!tmdbId || !mediaType) {
+    res.status(400).json({ error: 'Missing fields' })
+    return
+  }
+
+  const item = await prisma.watchlist.findFirst({
+    where: { userId: req.userId!, tmdbId: Number(tmdbId), mediaType },
+  })
+  res.json({ inWatchlist: !!item })
+})
+
+export default router

apps/server/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src"]
+}

package.json

@@ -0,0 +1,18 @@
+{
+  "name": "streamtime",
+  "private": true,
+  "scripts": {
+    "dev": "turbo run dev",
+    "build": "turbo run build",
+    "lint": "turbo run lint",
+    "type-check": "turbo run type-check"
+  },
+  "devDependencies": {
+    "turbo": "^2.3.3",
+    "typescript": "^5.7.3"
+  },
+  "packageManager": "pnpm@9.15.4",
+  "engines": {
+    "node": ">=20"
+  }
+}

packages/shared/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "@streamtime/shared",
+  "version": "0.0.1",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  }
+}

packages/shared/src/index.ts

@@ -0,0 +1,4 @@
+export * from './types/tmdb'
+export * from './types/user'
+export * from './types/watchlist'
+export * from './types/subtitle'

packages/shared/src/types/subtitle.ts

@@ -0,0 +1,12 @@
+export interface SubtitleTrack {
+  fileId: string
+  language: string
+  languageName: string
+  releaseName: string
+}
+
+export interface SubtitleCue {
+  start: number
+  end: number
+  text: string
+}

packages/shared/src/types/tmdb.ts

@@ -0,0 +1,103 @@
+export interface TMDBMovie {
+  id: number
+  title: string
+  overview: string
+  poster_path: string | null
+  backdrop_path: string | null
+  release_date: string
+  vote_average: number
+  vote_count: number
+  genre_ids?: number[]
+  genres?: { id: number; name: string }[]
+  runtime?: number
+  tagline?: string
+  status?: string
+  external_ids?: { imdb_id?: string }
+  videos?: { results: TMDBVideo[] }
+  credits?: { cast: TMDBCast[]; crew: TMDBCrew[] }
+}
+
+export interface TMDBTVShow {
+  id: number
+  name: string
+  overview: string
+  poster_path: string | null
+  backdrop_path: string | null
+  first_air_date: string
+  vote_average: number
+  vote_count: number
+  genre_ids?: number[]
+  genres?: { id: number; name: string }[]
+  number_of_seasons?: number
+  seasons?: TMDBSeason[]
+  tagline?: string
+  status?: string
+  external_ids?: { imdb_id?: string }
+}
+
+export interface TMDBSeason {
+  id: number
+  season_number: number
+  name: string
+  episode_count: number
+  poster_path: string | null
+  air_date: string
+  episodes?: TMDBEpisode[]
+}
+
+export interface TMDBEpisode {
+  id: number
+  name: string
+  overview: string
+  episode_number: number
+  season_number: number
+  air_date: string
+  still_path: string | null
+  vote_average: number
+  runtime?: number
+}
+
+export interface TMDBVideo {
+  id: string
+  key: string
+  name: string
+  site: string
+  type: string
+  official: boolean
+}
+
+export interface TMDBCast {
+  id: number
+  name: string
+  character: string
+  profile_path: string | null
+  order: number
+}
+
+export interface TMDBCrew {
+  id: number
+  name: string
+  job: string
+  department: string
+  profile_path: string | null
+}
+
+export interface TMDBSearchResult {
+  id: number
+  media_type: 'movie' | 'tv' | 'person'
+  title?: string
+  name?: string
+  poster_path: string | null
+  backdrop_path: string | null
+  release_date?: string
+  first_air_date?: string
+  vote_average: number
+  overview: string
+}
+
+export interface TMDBPaginatedResponse<T> {
+  page: number
+  results: T[]
+  total_pages: number
+  total_results: number
+}

packages/shared/src/types/user.ts

@@ -0,0 +1,6 @@
+export interface User {
+  id: string
+  email: string
+  username: string
+  createdAt?: string
+}

packages/shared/src/types/watchlist.ts

@@ -0,0 +1,21 @@
+export interface WatchlistItem {
+  id: string
+  tmdbId: number
+  mediaType: 'movie' | 'tv'
+  title: string
+  posterPath: string | null
+  addedAt: string
+}
+
+export interface WatchHistoryItem {
+  id: string
+  tmdbId: number
+  mediaType: 'movie' | 'tv'
+  title: string
+  posterPath: string | null
+  seasonNumber: number | null
+  episodeNumber: number | null
+  progressSeconds: number
+  durationSeconds: number
+  updatedAt: string
+}

packages/shared/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true
+  },
+  "include": ["src"]
+}

pnpm-workspace.yaml

@@ -0,0 +1,3 @@
+packages:
+  - "apps/*"
+  - "packages/*"