Class MagicContextRpcServer

packages/plugin/src/shared/rpc-server.ts:67–334

 *    of idle TUI CPU (#200). Pi never imports this module, so `Bun.serve` is safe.
 */
export class MagicContextRpcServer {
    private server: Server<WsData> | null = null;
    private port = 0;
    private handlers = new Map<string, RpcHandler>();
    private portFilePath: string;
    private portDir: string;
    private startedAt = Date.now();
    /** Every authenticated WS socket, so dispose can close them all. */
    private sockets = new Set<ServerWebSocket<WsData>>();
    // Unguessable per-process bearer token, published in the (user-private) port
    // file and required on every non-health RPC call AND in the WS hello. Defends
    // side-effecting endpoints (recomp/upgrade/dismiss) and the push channel
    // against any local process or browser-origin script that merely
    // discovers/guesses the port.
    private readonly token = randomBytes(32).toString("hex");

    constructor(storageDir: string, directory: string) {
        this.portFilePath = rpcPortFilePath(storageDir, directory);
        this.portDir = rpcPortDir(storageDir, directory);
    }

    /** Register an RPC method handler. */
    handle(method: string, handler: RpcHandler): void {
        this.handlers.set(method, handler);
    }

    /** Start the server on a random port, write port to disk. */
    async start(): Promise<number> {
        const self = this;
        const server = Bun.serve<WsData>({
            port: 0,
            hostname: "127.0.0.1",
            fetch(req, srv) {
                return self.handleFetch(req, srv);
            },
            websocket: {
                open(ws) {
                    // Close the socket if it doesn't authenticate promptly. A
                    // never-authenticated socket holds no sink and is harmless,
                    // but we don't want to keep raw connections open forever.
                    ws.data.authTimer = setTimeout(() => {
                        if (!ws.data.authed) ws.close(WS_CLOSE_UNAUTHORIZED, "auth timeout");
                    }, WS_AUTH_TIMEOUT_MS);
                },
                message(ws, raw) {
                    self.handleWsMessage(ws, raw);
                },
                close(ws) {
                    if (ws.data.authTimer) clearTimeout(ws.data.authTimer);
                    ws.data.unregister?.();
                    self.sockets.delete(ws);
                },
            },
        });

        this.server = server;
        this.port = server.port ?? 0;