Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

6.9 KB
Raw Blame
import { V86 } from 'v86'

import type { TerminalWorkerRequest, TerminalWorkerResponse } from './terminalWorkerProtocol'

interface FramebufferLayer {
    image_data: ImageData
    screen_x: number
    screen_y: number
    buffer_x: number
    buffer_y: number
    buffer_width: number
    buffer_height: number
}

// v86's DOM-free adapter and PS/2 bus are not declared in its public types.
type WorkerV86 = V86 & {
    bus: { send: (event: string, value: boolean[] | number[]) => void }
    screen_adapter: {
        set_size_graphical: (width: number, height: number) => void
        update_buffer: (layers: FramebufferLayer[]) => void
        clear_screen: () => void
    }
    v86: { cpu: { devices: { vga: { screen_fill_buffer: () => void } } } }
}

function send(message: TerminalWorkerResponse, transfer: Transferable[] = []): void {
    postMessage(message, { transfer })
}

function fail(message: string, error: unknown): void {
    const cause =
        error instanceof Error
            ? { name: error.name, message: error.message, stack: error.stack }
            : { name: 'Error', message: String(error) }
    send({ type: 'error', message, cause })
}

let emulator: WorkerV86 | undefined
let visible = false
let nextRequest = 0
const replies = new Map<number, { tag: number; reply: (bytes: Uint8Array) => void }>()
const serial = [new Uint8Array(8192), new Uint8Array(8192), new Uint8Array(8192)]
const lengths = [0, 0, 0]
let flushScheduled = false

function flushSerial(): void {
    for (const port of [0, 1, 2]) {
        if (lengths[port]) {
            const bytes = serial[port].slice(0, lengths[port])
            lengths[port] = 0
            send({ type: 'serial', port, bytes }, [bytes.buffer])
        }
    }
}

function output(port: number, byte: number): void {
    serial[port][lengths[port]++] = byte
    if (lengths[port] === serial[port].length) {
        flushSerial()
    }
    if (!flushScheduled) {
        flushScheduled = true
        queueMicrotask(() => {
            flushScheduled = false
            flushSerial()
        })
    }
}

function receive(message: TerminalWorkerRequest): void {
    switch (message.type) {
        case 'start': {
            if (emulator) {
                return
            }
            const { canvas } = message
            const context = canvas.getContext('2d', { alpha: false })
            if (!context) {
                throw new Error('Terminal display could not start.')
            }
            emulator = new V86({
                wasm_path: message.wasmUrl,
                bios: { buffer: message.bios },
                vga_bios: { buffer: message.vgaBios },
                bzimage: { buffer: message.kernel },
                memory_size: 512 * 1024 * 1024,
                filesystem: {
                    handle9p: (request, reply) => {
                        const id = nextRequest++
                        const tag = request[5] | (request[6] << 8)
                        if (request[4] === 108) {
                            // Flushed 9P requests do not receive a reply from the filesystem server.
                            const oldTag = request[7] | (request[8] << 8)
                            for (const [pendingId, pending] of replies) {
                                if (pending.tag === oldTag) {
                                    replies.delete(pendingId)
                                }
                            }
                        }
                        replies.set(id, { tag, reply })
                        // Guest memory belongs to WASM and cannot be transferred.
                        const bytes = request.slice()
                        send({ type: '9p', id, bytes }, [bytes.buffer])
                    },
                },
                cmdline: 'tsc=reliable mitigations=off random.trust_cpu=on video=640x480',
                vga_memory_size: 8 * 1024 * 1024,
                disable_keyboard: true,
                disable_mouse: true,
                disable_speaker: true,
                uart1: true,
                // Doom multiplayer frames; see terminalNetplay.ts.
                uart2: true,
                autostart: false,
            }) as WorkerV86
            const vm = emulator
            vm.add_listener('serial0-output-byte', (byte: number) => output(0, byte))
            vm.add_listener('serial1-output-byte', (byte: number) => output(1, byte))
            vm.add_listener('serial2-output-byte', (byte: number) => output(2, byte))
            vm.add_listener('emulator-loaded', () => {
                // Linux uses a graphical framebuffer; retain v86's headless VGA text adapter for boot.
                Object.assign(vm.screen_adapter, {
                    set_size_graphical: (width: number, height: number): void => {
                        canvas.width = width
                        canvas.height = height
                    },
                    clear_screen: (): void => context.clearRect(0, 0, canvas.width, canvas.height),
                    update_buffer: (layers: FramebufferLayer[]): void => {
                        for (const layer of layers) {
                            context.putImageData(
                                layer.image_data,
                                layer.screen_x - layer.buffer_x,
                                layer.screen_y - layer.buffer_y,
                                layer.buffer_x,
                                layer.buffer_y,
                                layer.buffer_width,
                                layer.buffer_height
                            )
                        }
                    },
                })
                const draw = (): void => {
                    if (visible) {
                        vm.v86.cpu.devices.vga.screen_fill_buffer()
                    }
                    requestAnimationFrame(draw)
                }
                requestAnimationFrame(draw)
                send({ type: 'loaded' })
            })
            break
        }
        case 'run':
            emulator?.run()
            break
        case 'serial':
            emulator?.serial_send_bytes(message.port, message.bytes)
            break
        case 'keyboard':
            emulator?.keyboard_send_scancodes(message.codes)
            break
        case 'mouse':
            emulator?.bus.send(message.event, message.value)
            break
        case 'display':
            visible = message.visible
            break
        case '9p': {
            const reply = replies.get(message.id)
            replies.delete(message.id)
            reply?.reply(message.bytes)
            break
        }
    }
}

self.onmessage = (event: MessageEvent<TerminalWorkerRequest>): void => {
    try {
        receive(event.data)
    } catch (error) {
        fail('Terminal worker stopped unexpectedly. Restart the terminal.', error)
    }
}
self.addEventListener('unhandledrejection', (event) => {
    fail('Terminal worker could not start. Restart the terminal.', event.reason)
})