ds-harness-remote-fast/packages/plugin/src/loopback-preview.ts

178 lines
9.8 KiB
TypeScript

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<number, Promise<{ server: Server; ws: WebSocketServer; url: string }>>()
private readonly sockets = new Set<Socket>()
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<void> {
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<void>(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<IncomingMessage, string>()
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<void>((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<void> {
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<LoopbackHttpHead>('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<string, string | string[]> = {}
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<LoopbackRead>('loopback.call', { op: 'http.read', id }, signal)
if (chunk.data !== '' && !res.write(Buffer.from(chunk.data, 'base64'))) {
await new Promise<void>((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<LoopbackWsRead>('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<void>((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<void> {
if (!this.lifetime.signal.aborted) await this.client.rpc('loopback.call', { op: 'close', id }).catch(() => undefined)
}
}