diff --git a/packages/plugin/src/loopback-preview.ts b/packages/plugin/src/loopback-preview.ts new file mode 100644 index 0000000..9ef3e75 --- /dev/null +++ b/packages/plugin/src/loopback-preview.ts @@ -0,0 +1,177 @@ +import { randomBytes, randomUUID } from 'node:crypto' +import { createServer, type IncomingMessage, type Server, type ServerResponse } from 'node:http' +import type { Socket } from 'node:net' +import { WebSocketServer, WebSocket } from 'ws' +import type { RemoteClientCore } from '@dsh-remote/client-core' +import { LOOPBACK_MAX_BODY_BYTES, LOOPBACK_MAX_WS_BYTES, type LoopbackHttpHead, type LoopbackRead, type LoopbackWsRead } from '@dsh-remote/protocol' +import { cleanHeaders, headerPairs } from './loopback-host.js' +import { RpcError } from './safe-error.js' + +/** One unpredictable origin per upstream port. Only the local machine can reach this listener. */ +export class LoopbackPreview { + private readonly servers = new Map>() + private readonly sockets = new Set() + private readonly lifetime = new AbortController() + constructor(private readonly client: RemoteClientCore) {} + + async open(port: number): Promise<{ url: string }> { + if (!Number.isInteger(port) || port < 1024 || port > 65535) throw new RpcError('INVALID_MESSAGE', 'Enter a port between 1024 and 65535.') + this.lifetime.signal.throwIfAborted() + const description = await this.client.rpc<{ ports: number[] }>('loopback.call', { op: 'describe' }, this.lifetime.signal) + if (!description.ports.includes(port)) throw new RpcError('LOOPBACK_PORT_DENIED', 'Allow this port in the Host Remote settings (loopback.ports), then save the access settings. / 请在 Host Remote 设置中允许此端口,然后保存访问设置。') + let pending = this.servers.get(port) + if (pending === undefined) { + if (this.servers.size >= 16) throw new RpcError('RATE_LIMITED', 'Too many preview origins.') + pending = this.start(port) + this.servers.set(port, pending) + void pending.catch(() => { this.servers.delete(port) }) + } + return { url: (await pending).url } + } + + async close(): Promise { + this.lifetime.abort() + for (const socket of this.sockets) socket.destroy() + for (const pending of this.servers.values()) { + const running = await pending.catch(() => undefined) + if (running === undefined) continue + for (const client of running.ws.clients) client.terminate() + running.ws.close(); running.server.closeAllConnections() + await new Promise(resolve => running.server.close(() => resolve())) + } + this.servers.clear() + } + + private async start(port: number): Promise<{ server: Server; ws: WebSocketServer; url: string }> { + const hostname = `dsh-${randomBytes(24).toString('hex')}.localhost` + let authority = '' + const accepted = (req: IncomingMessage): boolean => req.headers.host === authority + && (req.headers.origin === undefined || req.headers.origin === `http://${authority}`) + && req.headers['service-worker'] === undefined + const server = createServer((req, res) => { + if (!accepted(req)) { res.writeHead(403); res.end('Preview origin denied.'); return } + void this.http(port, authority, req, res) + }) + server.requestTimeout = 30_000; server.headersTimeout = 15_000; server.maxHeadersCount = 64 + server.on('connection', socket => { + if (this.sockets.size >= 64 || this.lifetime.signal.aborted) { socket.destroy(); return } + this.sockets.add(socket); socket.on('close', () => this.sockets.delete(socket)) + }) + const selectedProtocols = new WeakMap() + const ws = new WebSocketServer({ noServer: true, maxPayload: LOOPBACK_MAX_WS_BYTES, perMessageDeflate: false, + handleProtocols: (_protocols, req) => selectedProtocols.get(req) || false }) + server.on('upgrade', (req, socket, head) => { + if (!accepted(req)) { socket.destroy(); return } + const id = randomUUID() + const headers = this.headers(req, port) + const protocols = (req.headers['sec-websocket-protocol'] ?? '').split(',').map(item => item.trim()).filter(Boolean) + void this.client.rpc<{ protocol: string }>('loopback.call', { op: 'ws.open', id, port, path: req.url ?? '/', headers, protocols }, this.lifetime.signal) + .then(result => { + if (socket.destroyed || this.lifetime.signal.aborted) { socket.destroy(); void this.release(id); return } + selectedProtocols.set(req, result.protocol) + ws.handleUpgrade(req, socket, head, local => this.websocket(id, local)) + }).catch(() => { socket.destroy(); void this.release(id) }) + }) + await new Promise((resolve, reject) => { + server.once('error', reject) + server.listen(0, '127.0.0.1', () => { server.off('error', reject); resolve() }) + }) + const address = server.address() + if (address === null || typeof address === 'string') { server.close(); throw new Error('Preview listener unavailable') } + authority = `${hostname}:${address.port}` + if (this.lifetime.signal.aborted) { server.close(); ws.close(); throw new Error('Preview closed') } + return { server, ws, url: `http://${authority}/` } + } + + private headers(req: IncomingMessage, port: number): Array<[string, string]> { + return cleanHeaders(headerPairs(req.headers)).filter(([name]) => !['origin', 'referer'].includes(name.toLowerCase())) + .concat(req.headers.origin === undefined ? [] : [['origin', `http://127.0.0.1:${port}`]]) + } + + private async http(port: number, authority: string, req: IncomingMessage, res: ServerResponse): Promise { + const id = randomUUID() + const controller = new AbortController() + const abort = (): void => { controller.abort(); void this.release(id) } + res.once('close', abort) + const signal = AbortSignal.any([controller.signal, this.lifetime.signal]) + try { + const chunks: Buffer[] = []; let length = 0 + for await (const chunk of req) { + length += (chunk as Buffer).length + if (length > LOOPBACK_MAX_BODY_BYTES) throw new RpcError('PAYLOAD_TOO_LARGE', 'Preview request body is limited to 1 MiB.') + chunks.push(chunk as Buffer) + } + const head = await this.client.rpc('loopback.call', { op: 'http.open', id, port, + path: req.url ?? '/', method: req.method ?? 'GET', headers: this.headers(req, port), + ...(length === 0 ? {} : { body: Buffer.concat(chunks).toString('base64') }) }, signal) + const headers: Record = {} + for (let [name, value] of cleanHeaders(head.headers)) { + name = name.toLowerCase() + if (name === 'location') { + const url = new URL(value, `http://127.0.0.1:${port}/`) + if (!['127.0.0.1', 'localhost', '[::1]'].includes(url.hostname) || Number(url.port || 80) !== port || url.protocol !== 'http:') { + throw new Error('Redirect is outside the authorized preview service') + } + value = `http://${authority}${url.pathname}${url.search}${url.hash}` + } + if (name === 'set-cookie') { + // Each preview has a separate cookie host; never widen cookies to .localhost. + value = value.replace(/;\s*domain=[^;]*/ig, '') + const existing = headers[name]; headers[name] = [...(Array.isArray(existing) ? existing : []), value] + } else if (!['service-worker-allowed', 'clear-site-data', 'alt-svc'].includes(name)) headers[name] = value + } + headers['referrer-policy'] = 'no-referrer' + res.writeHead(head.status, headers) + while (!signal.aborted) { + const chunk = await this.client.rpc('loopback.call', { op: 'http.read', id }, signal) + if (chunk.data !== '' && !res.write(Buffer.from(chunk.data, 'base64'))) { + await new Promise((resolve, reject) => { + const ready = (): void => { cleanup(); resolve() } + const closed = (): void => { cleanup(); reject(new Error('closed')) } + const cleanup = (): void => { res.off('drain', ready); res.off('close', closed) } + res.once('drain', ready); res.once('close', closed) + }) + } + if (chunk.done) break + } + res.end() + } catch { + if (!res.headersSent) { res.writeHead(502, { 'Content-Type': 'text/plain; charset=utf-8' }); res.end('Remote preview unavailable. Check the Host service and connection, then reload.') } + else res.destroy() + } finally { res.off('close', abort); await this.release(id) } + } + + private websocket(id: string, socket: WebSocket): void { + let input = Promise.resolve(); let queued = 0; let count = 0 + const controller = new AbortController() + const signal = AbortSignal.any([controller.signal, this.lifetime.signal]) + const close = (): void => { controller.abort(); socket.terminate(); void this.release(id) } + socket.on('error', close); socket.on('close', close) + socket.on('message', (data, binary) => { + const bytes = Buffer.from(data as Buffer) + queued += bytes.length; count += 1 + if (queued > 1024 * 1024 || count > 256) { close(); return } + input = input.then(async () => { + await this.client.rpc('loopback.call', { op: 'ws.send', id, data: bytes.toString('base64'), binary }, signal) + queued -= bytes.length; count -= 1 + }).catch(close) + }) + void (async () => { + try { + while (!signal.aborted) { + const result = await this.client.rpc('loopback.call', { op: 'ws.read', id }, signal) + for (const message of result.messages) { + if (socket.bufferedAmount > 1024 * 1024) throw new Error('slow preview') + await new Promise((resolve, reject) => socket.send(Buffer.from(message.data, 'base64'), { binary: message.binary }, error => error ? reject(error) : resolve())) + } + if (result.closed) break + } + } catch { /* Closed channels must not reconnect or replay application messages. */ } + finally { close() } + })() + } + + private async release(id: string): Promise { + if (!this.lifetime.signal.aborted) await this.client.rpc('loopback.call', { op: 'close', id }).catch(() => undefined) + } +}