import { Readable } from 'node:stream'; import { hashSeed, escapeXml } from './normalize.js'; import { CCTV_FRAME_FETCH_TIMEOUT_MS } from './constants.js'; /** * Generate a synthetic SVG billboard image for a CCTV camera placeholder. * * Produces a 960x540 SVG with a deterministic gradient (hue derived from * camera ID hash), scanline overlay, HUD-style grid, and text labels * showing camera name, city, ID, status, and current timestamp. Used * when no upstream image or Street View fallback is available. * * @param {object} opts * @param {string} opts.cameraId * @param {string} opts.label * @param {string} [opts.city] * @param {string} [opts.status] * @returns {string} SVG markup string. */ export function buildSyntheticCctvSvg({ cameraId, label, city, status }) { const seed = hashSeed(`${cameraId}:${label}:${city}`); const hue = seed % 360; const hue2 = (hue + 46) % 360; const now = new Date(); const ts = now.toISOString().replace('T', ' ').replace('Z', 'Z').slice(0, 20); const safeLabel = escapeXml(label); const safeCity = escapeXml(city || 'GLOBAL GRID'); const safeId = escapeXml(cameraId); const safeStatus = escapeXml(status || 'SYNTHETIC'); return ` CCTV FEED PLACEHOLDER ${safeLabel} ยท ${safeCity} ${safeId} ${escapeXml(ts)} ${safeStatus} `.trim(); } /** * Coerce a fetch() response body to a Node.js Readable stream. * * Handles both Node-native streams (.pipe) and web ReadableStreams (.getReader). * * @param {ReadableStream|NodeJS.ReadableStream|null} body * @returns {import('stream').Readable|null} */ export function toReadable(body) { if (!body) return null; if (typeof body.pipe === 'function') return body; if (typeof body.getReader === 'function') { return Readable.fromWeb(body); } return null; } /** * Pipe an upstream fetch Response (image or video) to the client HTTP response. * * Forwards Content-Type, Content-Length, Content-Range, Accept-Ranges, and * Cache-Control headers from the upstream. Falls back to buffered arrayBuffer * if the body is not streamable. * * @param {import('http').ServerResponse} res * @param {Response} upstream - fetch() Response object. * @param {object} [opts] * @param {string} [opts.sourceHeader='upstream'] - Value for X-CCTV-Source header. */ export async function proxyMediaResponse( res, upstream, { sourceHeader = 'upstream' } = {}, ) { const contentType = upstream.headers.get('content-type') || 'application/octet-stream'; const cacheControl = upstream.headers.get('cache-control') || 'no-store'; const contentLength = upstream.headers.get('content-length'); const contentRange = upstream.headers.get('content-range'); const acceptRanges = upstream.headers.get('accept-ranges'); const headers = { 'Content-Type': contentType, 'Cache-Control': cacheControl, 'X-CCTV-Source': sourceHeader, }; if (contentLength) headers['Content-Length'] = contentLength; if (contentRange) headers['Content-Range'] = contentRange; if (acceptRanges) headers['Accept-Ranges'] = acceptRanges; // Cheap defense: reject an upstream that DECLARES an oversized fixed body. // Live MJPEG/HLS streams are unbounded by design and send no content-length, // so they pipe normally (piping streams to the client, never buffering). const MEDIA_DECLARED_CAP_BYTES = 64 * 1024 * 1024; if ( Number.isFinite(Number(contentLength)) && Number(contentLength) > MEDIA_DECLARED_CAP_BYTES ) { res.writeHead(502, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store', }); res.end(JSON.stringify({ error: 'Upstream media exceeds size cap' })); try { await upstream.body?.cancel(); } catch { /* no-op */ } return; } res.writeHead(upstream.status, headers); const stream = toReadable(upstream.body); if (!stream) { const buf = Buffer.from(await upstream.arrayBuffer()); res.end(buf); return; } stream.on('error', () => { if (!res.writableEnded) res.end(); }); stream.pipe(res); } /** * Fetch one upstream CCTV image within the frame-refresh budget. * * A timeout is treated like every other upstream miss so the caller can * continue through the Street View and synthetic fallback chain. `fetchImpl` * and `timeoutMs` are injectable only to keep the timeout contract unit-testable. * * @param {string} url - Server-registered upstream image URL. * @param {object} [options] * @param {typeof fetch} [options.fetchImpl=fetch] - Fetch implementation. * @param {number} [options.timeoutMs=CCTV_FRAME_FETCH_TIMEOUT_MS] - Abort timeout. * @returns {Promise<{ok:true,body:Buffer,contentType:string}|null>} */ export async function fetchCctvImageFromUpstream( url, { fetchImpl = fetch, timeoutMs = CCTV_FRAME_FETCH_TIMEOUT_MS } = {}, ) { if (!url || !/^https?:\/\//i.test(url)) return null; const controller = new AbortController(); const timeoutId = setTimeout(() => { controller.abort( new DOMException('CCTV upstream frame fetch timed out', 'TimeoutError'), ); }, timeoutMs); try { const upstream = await fetchImpl(url, { headers: { 'User-Agent': 'gods-eye-view-cctv-proxy/1.0' }, signal: controller.signal, }); const contentType = upstream.headers.get('content-type') || ''; if (!upstream.ok || !contentType.startsWith('image/')) return null; return { ok: true, body: Buffer.from(await upstream.arrayBuffer()), contentType, }; } catch { return null; } finally { clearTimeout(timeoutId); } }