import { createServer, type IncomingMessage, type ServerResponse } from 'node:http' import { existsSync, readFileSync, readdirSync } from 'node:fs' import { join } from 'node:path' import { fileURLToPath } from 'node:url' import { randomUUID } from 'node:crypto' import { isIP } from 'node:net' import { z } from 'zod' import { deviceRegistrationRequestSchema, deviceRefreshRequestSchema, parseWireJson } from '@dsh-remote/protocol' import { ApiError, Store, equal, hash, secret } from './store.js' import { Gateway } from './gateway.js' import { buildIceServers, parseIceConfig, type IceConfig } from './ice.js' import { Logger, type LogLevel } from './logger.js' import { FORCE_TERMINATE_GRACE_MS_RANGE, HEARTBEAT_DISCONNECT_MS_MAX, HELLO_TIMEOUT_MS_RANGE, HEARTBEAT_INTERVAL_MS_RANGE, MAX_FRAMES_PER_SEC_RANGE, normalizeForceTerminateGraceMs, normalizeGatewayOptions, normalizeHeartbeatDisconnectMs, normalizeHeartbeatIntervalMs, normalizeHelloTimeoutMs, normalizeMaxFramesPerSec, } from './config.js' export interface Config { account: string password: string dataFile: string publicUrl: string trustedProxyIps?: readonly string[] helloTimeoutMs?: number heartbeatIntervalMs?: number heartbeatDisconnectMs?: number forceTerminateGraceMs?: number maxFramesPerSec?: number logLevel?: LogLevel ice?: IceConfig } /** * Timing configuration is normalized in one place (`config.ts`) so the CLI and * programmatic callers share the same bounds and fallbacks. These wrappers keep * the env-var parsing API used by `main.ts` and the tests, and never echo the * offending input in their warnings. */ export function parseHelloTimeout(val: string | undefined): number { return normalizeHelloTimeoutMs(val) } export function parseHeartbeatInterval(val: string | undefined): number { return normalizeHeartbeatIntervalMs(val) } export function parseHeartbeatDisconnect(val: string | undefined, heartbeatIntervalMs: number = HEARTBEAT_INTERVAL_MS_RANGE.fallback): number { return normalizeHeartbeatDisconnectMs(val, heartbeatIntervalMs) } export function parseForceTerminateGrace(val: string | undefined): number { return normalizeForceTerminateGraceMs(val) } export function parseMaxFramesPerSec(val: string | undefined): number { return normalizeMaxFramesPerSec(val) } export { normalizeGatewayOptions, normalizeHelloTimeoutMs, normalizeHeartbeatIntervalMs, normalizeHeartbeatDisconnectMs, normalizeForceTerminateGraceMs, normalizeMaxFramesPerSec, HELLO_TIMEOUT_MS_RANGE, HEARTBEAT_INTERVAL_MS_RANGE, HEARTBEAT_DISCONNECT_MS_MAX, FORCE_TERMINATE_GRACE_MS_RANGE, MAX_FRAMES_PER_SEC_RANGE, } export type { GatewayTimingOptions, NormalizedGatewayOptions } from './config.js' const loginSchema = z.object({ email: z.string().min(1).max(254), password: z.string().min(1).max(1024) }).strict() const publicDir = fileURLToPath(new URL('../dist/public/', import.meta.url)) function readAssets(): Map { if (!existsSync(publicDir)) return new Map() const assets = new Map() for (const entry of readdirSync(publicDir, { recursive: true, withFileTypes: true })) { if (!entry.isFile()) continue const file = join(entry.parentPath, entry.name) const path = file.slice(publicDir.length).replaceAll('\\', '/') assets.set(path, readFileSync(file)) } return assets } async function body(req: IncomingMessage): Promise { if (!req.headers['content-type']?.toLowerCase().startsWith('application/json')) throw new ApiError('INVALID_MESSAGE', 415) let length = 0 const chunks: Buffer[] = [] for await (const chunk of req) { length += chunk.length if (length > 16384) throw new ApiError('FRAME_TOO_LARGE', 413) chunks.push(chunk) } try { return parseWireJson(Buffer.concat(chunks)) } catch { throw new ApiError('INVALID_MESSAGE') } } /** * Normalize one bare IPv4/IPv6 literal to a single canonical form. IPv4-mapped * IPv6 addresses (e.g. ::ffff:127.0.0.1) collapse to plain IPv4, so a peer * observed through a dual-stack socket and a config entry compare equal. * Returns null for anything that is not a single IP literal: hostnames, ports, * CIDR ranges, comma-separated lists, bracketed hosts and zone identifiers. */ export function normalizeIp(value: string): string | null { const family = isIP(value) if (family === 4) return value.toLowerCase() if (family !== 6) return null let canonical: string try { canonical = new URL(`http://[${value}]/`).hostname.slice(1, -1) } catch { return null } const mapped = /^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/.exec(canonical) if (!mapped) return canonical const high = Number.parseInt(mapped[1]!, 16), low = Number.parseInt(mapped[2]!, 16) return `${high >>> 8}.${high & 0xff}.${low >>> 8}.${low & 0xff}` } /** Validate and normalize the trusted proxy list at startup. Empty means disabled. */ export function normalizeTrustedProxyIps(values: readonly string[] = []): ReadonlySet { const result = new Set() for (const raw of values) { const value = raw.trim() const normalized = value === '' ? null : normalizeIp(value) if (normalized === null) throw new Error(`Invalid DSH_SERVER_TRUSTED_PROXY_IPS entry "${raw}": expected a bare IPv4/IPv6 address (no port, CIDR or hostname).`) result.add(normalized) } return result } function readSingleForwardedFor(req: IncomingMessage): string { let value: string | undefined let count = 0 const raw = req.rawHeaders for (let i = 0; i + 1 < raw.length; i += 2) { if (raw[i]!.toLowerCase() !== 'x-forwarded-for') continue count++ value = raw[i + 1] } if (count !== 1) throw new ApiError('INVALID_MESSAGE') return value! } /** * Resolve the address used for rate limiting. X-Forwarded-For is honored only * when the socket peer is a configured trusted proxy; that peer must send one * header holding exactly one IP literal, otherwise the request is rejected. */ export function clientAddress(req: IncomingMessage, trustedProxyIps: ReadonlySet): string { const peer = normalizeIp(req.socket.remoteAddress ?? '') if (peer === null) throw new ApiError('INVALID_MESSAGE') if (!trustedProxyIps.has(peer)) return peer const forwarded = normalizeIp(readSingleForwardedFor(req)) if (forwarded === null) throw new ApiError('INVALID_MESSAGE') return forwarded } export function createRemoteServer(config: Config) { if (!config.account.trim() || config.password.length < 12) throw new Error('DSH_SERVER_ACCOUNT and DSH_SERVER_PASSWORD (at least 12 characters) are required.') const url = new URL(config.publicUrl) if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || url.pathname !== '/' || url.search || url.hash) throw new Error('DSH_SERVER_PUBLIC_URL must be an HTTP(S) origin.') const trustedProxyIps = normalizeTrustedProxyIps(config.trustedProxyIps) const ice = config.ice ?? parseIceConfig({}) const store = new Store(config.dataFile, config.account.trim(), config.password) const assets = readAssets() const sessions = new Map() const limits = new Map() function rate(key: string, max: number) { for (const [k, v] of limits) if (v.until < Date.now()) limits.delete(k) let entry = limits.get(key) if (!entry) { if (limits.size >= 4096) throw new ApiError('RATE_LIMITED', 429); entry = { count: 0, until: Date.now() + 60_000 }; limits.set(key, entry) } if (++entry.count > max) throw new ApiError('RATE_LIMITED', 429) } function token(req: IncomingMessage): string { const authorization = req.headers.authorization if (authorization) return authorization.startsWith('Bearer ') ? authorization.slice(7) : '' return /(?:^|;\s*)dsh_session=([A-Za-z0-9_-]+)/.exec(req.headers.cookie ?? '')?.[1] ?? '' } function accountAuth(req: IncomingMessage) { const key = hash(token(req)) if ((sessions.get(key) ?? 0) <= Date.now()) { sessions.delete(key); throw new ApiError('ACCOUNT_AUTH_REQUIRED', 401) } } function deviceAuth(req: IncomingMessage) { if (!req.headers.authorization?.startsWith('Bearer ')) throw new ApiError('AUTH_REQUIRED', 401) return store.authenticate(req.headers.authorization.slice(7)) } function cookie(value: string, age: number): string { return `dsh_session=${value}; Path=/; HttpOnly; SameSite=Strict; Max-Age=${age}${url.protocol === 'https:' ? '; Secure' : ''}` } const profile = () => ({ account: store.account, profile: { displayName: store.account }, isAdmin: false }) const server = createServer({ requestTimeout: 15000, headersTimeout: 10000 }, (req, res) => { res.setHeader('Cache-Control', 'no-store') res.setHeader('X-Content-Type-Options', 'nosniff') res.setHeader('Referrer-Policy', 'no-referrer') res.setHeader('Content-Security-Policy', "default-src 'none'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; connect-src 'self'; base-uri 'none'; frame-ancestors 'none'; form-action 'self'") void route(req, res).catch(error => { if (res.headersSent || res.destroyed) return const e = error instanceof ApiError ? error : error instanceof z.ZodError ? new ApiError('INVALID_MESSAGE') : new ApiError('INTERNAL_ERROR', 500) if (e.status === 429) res.setHeader('Retry-After', '60') json(res, e.status, { error: { code: e.code, message: e.code, requestId: randomUUID(), retryable: e.status === 429 || e.status >= 500 } }) }) }) const logger = new Logger('server', config.logLevel ?? 'info') // Normalize at this boundary as well: a programmatic caller may pass NaN, // Infinity or a negative value straight through the Config object. const timing = normalizeGatewayOptions({ helloTimeoutMs: config.helloTimeoutMs, heartbeatIntervalMs: config.heartbeatIntervalMs, heartbeatDisconnectMs: config.heartbeatDisconnectMs, forceTerminateGraceMs: config.forceTerminateGraceMs, }) const gateway = new Gateway(server, store, url.origin, { ...timing, maxFramesPerSec: normalizeMaxFramesPerSec(config.maxFramesPerSec), logLevel: config.logLevel, logger: logger.child('gateway'), turnEnabled: ice.turnUrls.length > 0, }) function descriptor(d: ReturnType) { return { ...d.descriptor, membershipId: `account:${hash(store.account).slice(0, 16)}`, online: gateway.peers.has(d.descriptor.deviceId), lastSeenAt: d.lastSeenAt } } async function route(req: IncomingMessage, res: ServerResponse) { const requestUrl = new URL(req.url ?? '/', url) const path = requestUrl.pathname const method = req.method if (req.headers.origin && req.headers.origin !== url.origin) throw new ApiError('AUTH_INVALID', 403) if (req.headers['sec-fetch-site'] === 'cross-site') throw new ApiError('AUTH_INVALID', 403) const staticAsset = path.startsWith('/assets/') || ['/icon.png', '/brand-whale.webp', '/landing-atmosphere.webp'].includes(path) // SPA fallback: any GET that is not API / WebSocket / health-check returns index.html. // Without this, refreshing a client route such as /app/remote hits the unknown-method branch and yields METHOD_NOT_FOUND. const spaRoute = method === 'GET' && !staticAsset && !path.startsWith('/api/') && !path.startsWith('/ws/') && !['/health', '/healthz', '/ready'].includes(path) if (method === 'GET' && (spaRoute || staticAsset)) { const name = staticAsset ? path.slice(1) : 'index.html' const asset = assets.get(name) if (!asset) throw new ApiError('METHOD_NOT_FOUND', 404) const contentType = name.endsWith('.js') ? 'text/javascript; charset=utf-8' : name.endsWith('.css') ? 'text/css; charset=utf-8' : name.endsWith('.png') ? 'image/png' : name.endsWith('.webp') ? 'image/webp' : 'text/html; charset=utf-8' if (!staticAsset) res.setHeader('Cache-Control', 'no-cache') res.setHeader('Content-Type', contentType) res.end(asset); return } if (method === 'GET' && (path === '/health' || path === '/healthz' || path === '/ready')) { json(res, 200, { status: 'ok' }); return } const client = clientAddress(req, trustedProxyIps) rate(`api:${client}`, 240) if (method === 'POST' && path === '/api/v1/auth/login') { rate(`login:${client}`, 20) const credentials = loginSchema.parse(await body(req)) if (!equal(credentials.email.trim(), store.account) || !equal(credentials.password, config.password)) throw new ApiError('AUTH_INVALID', 401) for (const [key, expires] of sessions) if (expires <= Date.now()) sessions.delete(key) if (sessions.size >= 256) throw new ApiError('RATE_LIMITED', 429) const value = secret(), expiresAt = Date.now() + 8 * 3600_000 sessions.set(hash(value), expiresAt) res.setHeader('Set-Cookie', cookie(value, 8 * 3600)) json(res, 200, { ...profile(), token: value, expiresAt }); return } if (method === 'GET' && path === '/api/v1/auth/me') { accountAuth(req); json(res, 200, profile()); return } if (method === 'POST' && path === '/api/v1/auth/logout') { sessions.delete(hash(token(req))); res.setHeader('Set-Cookie', cookie('', 0)); json(res, 200, { status: 'ok' }); return } if (method === 'GET' && path === '/api/v1/account/devices') { accountAuth(req); json(res, 200, { items: store.list().map(descriptor), serverUrl: url.origin, transport: 'webrtc' }); return } if (method === 'POST' && (path === '/api/v1/devices/register' || path === '/api/v1/devices/register-owned-role')) { const source = path.endsWith('register-owned-role') ? deviceAuth(req) : undefined if (!source) accountAuth(req) const { device } = deviceRegistrationRequestSchema.parse(await body(req)) if (source && (source.descriptor.deviceId === device.deviceId || source.descriptor.role === device.role)) throw new ApiError('INVALID_MESSAGE', 409) json(res, 200, store.register(device)); return } if (method === 'POST' && path === '/api/v1/auth/refresh') { const data = deviceRefreshRequestSchema.parse(await body(req)) json(res, 200, store.refresh(data.deviceId, data.refreshToken)); return } if (method === 'DELETE' && path === '/api/v1/devices/self') { store.revoke(deviceAuth(req).descriptor.deviceId); json(res, 200, { status: 'revoked' }); return } if (method === 'GET' && path === '/api/v1/me') { json(res, 200, descriptor(deviceAuth(req))); return } if (method === 'GET' && path === '/api/v1/turn/credentials') { const source = deviceAuth(req) const connectionId = requestUrl.searchParams.get('connection_id') ?? '' if (!connectionId || connectionId.length > 128) throw new ApiError('INVALID_MESSAGE') if (!gateway.authorizeIce(source.descriptor.deviceId, connectionId)) throw new ApiError('CONNECTION_NOT_FOUND', 404) json(res, 200, { iceServers: buildIceServers(ice, source.descriptor.deviceId) }); return } if (method === 'GET' && path === '/api/v1/devices') { const source = deviceAuth(req) if (source.descriptor.role !== 'client') throw new ApiError('MEMBERSHIP_REQUIRED', 403) const items = store.list().filter(d => d.descriptor.role === 'host').map(d => { const { identityKey: _key, ...item } = descriptor(d) return item }) json(res, 200, { items, nextCursor: null }); return } const renameMatch = /^\/api\/v1\/devices\/([^/]+)\/name$/.exec(path) if (method === 'POST' && renameMatch) { accountAuth(req) const { name } = z.object({ name: z.string().trim().min(1).max(80) }).parse(await body(req)) store.rename(renameMatch[1]!, name) json(res, 200, descriptor(store.get(renameMatch[1]!))); return } const match = /^\/api\/v1\/devices\/([^/]+)(\/presence)?$/.exec(path) if (method === 'GET' && match) { const source = deviceAuth(req), target = store.get(match[1]!) if (source.descriptor.role === target.descriptor.role) throw new ApiError('MEMBERSHIP_REQUIRED', 403) const d = descriptor(target) json(res, 200, match[2] ? { deviceId: d.deviceId, online: d.online, lastSeenAt: d.lastSeenAt } : d); return } throw new ApiError('METHOD_NOT_FOUND', 404) } return { server, store, gateway, logger, close: async () => { gateway.close(); server.closeAllConnections(); await new Promise((resolve, reject) => server.close(error => error ? reject(error) : resolve())) } } } function json(res: ServerResponse, status: number, value: unknown): void { res.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8' }); res.end(JSON.stringify(value)) }