deckide 3.5.33 → 3.5.34

package/dist/utils/agent-browser.js

@@ -0,0 +1,815 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs/promises';
+import fsSync from 'node:fs';
+import net from 'node:net';
+import os from 'node:os';
+import path from 'node:path';
+import { WebSocket } from 'ws';
+import { BrowserAudioRelay } from './browser-audio.js';
+const DEFAULT_PROFILE_DIR = path.join(os.homedir(), '.local', 'share', 'agent-browser', 'profile');
+const DEFAULT_OUTPUT_DIR = path.join(os.homedir(), '.local', 'share', 'agent-browser', 'output');
+const START_TIMEOUT_MS = 30_000;
+const MAX_CLIENT_BUFFERED_AMOUNT = 4 * 1024 * 1024;
+const DEFAULT_VIEWPORT = { width: 1280, height: 720 };
+const MIN_VIEWPORT = { width: 320, height: 240 };
+const MAX_VIEWPORT = { width: 3840, height: 2160 };
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isOpen(socket) {
+    return socket.readyState === WebSocket.OPEN;
+}
+function coercePositiveInt(value, fallback, min, max) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        return fallback;
+    }
+    return Math.min(max, Math.max(min, Math.floor(value)));
+}
+function normalizeBrowserUrl(input) {
+    const trimmed = input.trim();
+    if (!trimmed) {
+        throw new Error('URL is required');
+    }
+    const hasExplicitProtocol = /^[a-z][a-z0-9+.-]*:\/\//i.test(trimmed)
+        || /^(about|data|file):/i.test(trimmed);
+    const isLocalHost = /^(localhost|127(?:\.\d{1,3}){0,3}|0\.0\.0\.0|\[::1\])(?::|\/|$)/i.test(trimmed);
+    const withScheme = hasExplicitProtocol
+        ? trimmed
+        : `${isLocalHost ? 'http' : 'https'}://${trimmed}`;
+    const parsed = new URL(withScheme);
+    const allowedProtocols = new Set(['http:', 'https:', 'file:', 'about:', 'data:']);
+    if (!allowedProtocols.has(parsed.protocol)) {
+        throw new Error(`Unsupported URL protocol: ${parsed.protocol}`);
+    }
+    return parsed.href;
+}
+async function pathExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function findInPath(names) {
+    const pathValue = process.env.PATH || '';
+    for (const dir of pathValue.split(path.delimiter)) {
+        if (!dir)
+            continue;
+        for (const name of names) {
+            const candidate = path.join(dir, name);
+            if (await pathExists(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    return null;
+}
+async function findPlaywrightChromium() {
+    const cacheRoot = process.env.PLAYWRIGHT_BROWSERS_PATH || path.join(os.homedir(), '.cache', 'ms-playwright');
+    let entries;
+    try {
+        entries = await fs.readdir(cacheRoot, { withFileTypes: true });
+    }
+    catch {
+        return null;
+    }
+    const chromiumDirs = entries
+        .filter((entry) => entry.isDirectory() && entry.name.startsWith('chromium-'))
+        .map((entry) => entry.name)
+        .sort()
+        .reverse();
+    for (const dir of chromiumDirs) {
+        const candidates = [
+            path.join(cacheRoot, dir, 'chrome-linux64', 'chrome'),
+            path.join(cacheRoot, dir, 'chrome-mac', 'Chromium.app', 'Contents', 'MacOS', 'Chromium'),
+            path.join(cacheRoot, dir, 'chrome-win', 'chrome.exe'),
+        ];
+        for (const candidate of candidates) {
+            if (await pathExists(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    return null;
+}
+async function findChromeExecutable() {
+    if (process.env.AGENT_BROWSER_CHROME) {
+        if (await pathExists(process.env.AGENT_BROWSER_CHROME)) {
+            return process.env.AGENT_BROWSER_CHROME;
+        }
+        throw new Error(`AGENT_BROWSER_CHROME does not exist: ${process.env.AGENT_BROWSER_CHROME}`);
+    }
+    const playwrightChrome = await findPlaywrightChromium();
+    if (playwrightChrome) {
+        return playwrightChrome;
+    }
+    return findInPath([
+        'google-chrome',
+        'google-chrome-stable',
+        'chromium',
+        'chromium-browser',
+        'chrome',
+    ]);
+}
+function getFreePort() {
+    return new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.unref();
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            server.close(() => {
+                if (address && typeof address === 'object') {
+                    resolve(address.port);
+                }
+                else {
+                    reject(new Error('Unable to allocate a local port'));
+                }
+            });
+        });
+    });
+}
+async function fetchJson(url, options = {}, timeoutMs = 5000) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    timer.unref?.();
+    let response;
+    try {
+        response = await fetch(url, { ...options, signal: options.signal ?? controller.signal });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    if (!response.ok) {
+        const body = await response.text().catch(() => '');
+        throw new Error(`Chrome CDP request failed (${response.status}): ${body || response.statusText}`);
+    }
+    return response.json();
+}
+class CdpConnection {
+    socket;
+    nextId = 1;
+    pending = new Map();
+    onEvent;
+    constructor(socket) {
+        this.socket = socket;
+        socket.on('message', (data) => this.handleMessage(data));
+        socket.on('close', () => this.rejectAll(new Error('Chrome DevTools connection closed')));
+        socket.on('error', (error) => this.rejectAll(error));
+    }
+    send(method, params, timeoutMs = 10_000) {
+        if (!isOpen(this.socket)) {
+            return Promise.reject(new Error('Chrome DevTools connection is not open'));
+        }
+        const id = this.nextId++;
+        const payload = params ? { id, method, params } : { id, method };
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`Chrome DevTools command timed out: ${method}`));
+            }, timeoutMs);
+            this.pending.set(id, {
+                resolve: (value) => resolve(value),
+                reject,
+                timer,
+            });
+            try {
+                this.socket.send(JSON.stringify(payload));
+            }
+            catch (error) {
+                clearTimeout(timer);
+                this.pending.delete(id);
+                reject(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+    }
+    close() {
+        try {
+            this.socket.close();
+        }
+        catch {
+            // ignore
+        }
+        this.rejectAll(new Error('Chrome DevTools connection closed'));
+    }
+    handleMessage(data) {
+        let parsed;
+        try {
+            const text = typeof data === 'string'
+                ? data
+                : Buffer.isBuffer(data)
+                    ? data.toString('utf8')
+                    : Array.isArray(data)
+                        ? Buffer.concat(data).toString('utf8')
+                        : Buffer.from(data).toString('utf8');
+            parsed = JSON.parse(text);
+        }
+        catch {
+            return;
+        }
+        if (typeof parsed.id === 'number') {
+            const pending = this.pending.get(parsed.id);
+            if (!pending)
+                return;
+            this.pending.delete(parsed.id);
+            clearTimeout(pending.timer);
+            if (parsed.error) {
+                pending.reject(new Error(parsed.error.message || 'Chrome DevTools command failed'));
+            }
+            else {
+                pending.resolve(parsed.result);
+            }
+            return;
+        }
+        this.onEvent?.(parsed);
+    }
+    rejectAll(error) {
+        for (const [id, pending] of this.pending) {
+            this.pending.delete(id);
+            clearTimeout(pending.timer);
+            pending.reject(error);
+        }
+    }
+}
+export class AgentBrowserService {
+    chromeProcess = null;
+    logStream = null;
+    launching = null;
+    port = null;
+    executablePath = null;
+    cdp = null;
+    cdpSocket = null;
+    cdpConnecting = null;
+    screencastStarted = false;
+    clients = new Set();
+    viewport = { ...DEFAULT_VIEWPORT };
+    pageUrl = null;
+    pageTitle = null;
+    lastError;
+    audioRelay = new BrowserAudioRelay();
+    profileDir = process.env.AGENT_BROWSER_PROFILE_DIR || DEFAULT_PROFILE_DIR;
+    outputDir = process.env.AGENT_BROWSER_OUTPUT_DIR || DEFAULT_OUTPUT_DIR;
+    async getStatus() {
+        return {
+            running: this.isRunning(),
+            launching: Boolean(this.launching),
+            profileDir: this.profileDir,
+            outputDir: this.outputDir,
+            executablePath: this.executablePath ?? await findChromeExecutable().catch(() => null),
+            cdpUrl: this.port ? `http://127.0.0.1:${this.port}` : null,
+            pageUrl: this.pageUrl,
+            pageTitle: this.pageTitle,
+            audio: await this.audioRelay.getStatus(),
+            error: this.lastError,
+        };
+    }
+    async start() {
+        if (this.isRunning()) {
+            await this.ensureCdp();
+            if (this.clients.size > 0) {
+                await this.startScreencast();
+            }
+            return;
+        }
+        if (this.launching) {
+            await this.launching;
+            if (this.clients.size > 0) {
+                await this.startScreencast();
+            }
+            return;
+        }
+        this.launching = this.launch();
+        try {
+            await this.launching;
+        }
+        catch (error) {
+            this.lastError = error instanceof Error ? error.message : String(error);
+            await this.stop().catch(() => undefined);
+            throw error;
+        }
+        finally {
+            this.launching = null;
+        }
+        if (this.clients.size > 0) {
+            await this.startScreencast();
+        }
+    }
+    async stop() {
+        this.closeCdp();
+        const proc = this.chromeProcess;
+        this.chromeProcess = null;
+        this.port = null;
+        this.pageUrl = null;
+        this.pageTitle = null;
+        this.screencastStarted = false;
+        if (proc && proc.exitCode == null && proc.signalCode == null) {
+            await new Promise((resolve) => {
+                const killTimer = setTimeout(() => {
+                    try {
+                        proc.kill('SIGKILL');
+                    }
+                    catch {
+                        // ignore
+                    }
+                }, 3000);
+                killTimer.unref?.();
+                proc.once('exit', () => {
+                    clearTimeout(killTimer);
+                    resolve();
+                });
+                try {
+                    proc.kill('SIGTERM');
+                }
+                catch {
+                    clearTimeout(killTimer);
+                    resolve();
+                }
+            });
+        }
+        this.closeLogStream();
+        await this.audioRelay.stop();
+        await this.broadcastStatus();
+    }
+    attachWebSocket(socket) {
+        this.clients.add(socket);
+        socket.on('message', (data, isBinary) => {
+            if (isBinary)
+                return;
+            void this.handleClientMessage(socket, data);
+        });
+        socket.on('close', () => {
+            this.clients.delete(socket);
+            if (this.clients.size === 0) {
+                void this.stopScreencast();
+            }
+        });
+        void this.openForClient(socket);
+    }
+    attachAudioWebSocket(socket) {
+        this.audioRelay.attachWebSocket(socket);
+    }
+    async navigate(input) {
+        const url = normalizeBrowserUrl(input);
+        await this.start();
+        await this.ensureCdp();
+        await this.cdp?.send('Page.navigate', { url });
+        this.pageUrl = url;
+        await this.refreshPageInfo();
+        await this.broadcastStatus();
+    }
+    async launch() {
+        this.lastError = undefined;
+        await fs.mkdir(this.profileDir, { recursive: true });
+        await fs.mkdir(this.outputDir, { recursive: true });
+        const executable = await findChromeExecutable();
+        if (!executable) {
+            throw new Error('Chromium or Chrome was not found. Set AGENT_BROWSER_CHROME to a browser executable.');
+        }
+        this.executablePath = executable;
+        this.port = await getFreePort();
+        this.openLogStream();
+        const args = [
+            '--headless=new',
+            `--remote-debugging-address=127.0.0.1`,
+            `--remote-debugging-port=${this.port}`,
+            `--user-data-dir=${this.profileDir}`,
+            '--no-first-run',
+            '--no-default-browser-check',
+            '--disable-dev-shm-usage',
+            '--autoplay-policy=no-user-gesture-required',
+            '--window-size=1280,720',
+            'about:blank',
+        ];
+        if (process.getuid?.() === 0) {
+            args.splice(args.length - 1, 0, '--no-sandbox');
+        }
+        const child = spawn(executable, args, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: process.env,
+        });
+        this.chromeProcess = child;
+        child.stdout.pipe(this.logStream ?? process.stdout, { end: false });
+        child.stderr.pipe(this.logStream ?? process.stderr, { end: false });
+        child.once('exit', (code, signal) => {
+            if (this.chromeProcess === child) {
+                this.chromeProcess = null;
+                this.port = null;
+                this.closeCdp();
+                this.closeLogStream();
+                this.lastError = code === 0 ? undefined : `Browser exited (${signal ?? code ?? 'unknown'})`;
+                void this.broadcastStatus();
+            }
+        });
+        child.once('error', (error) => {
+            this.lastError = error.message;
+            void this.broadcastStatus();
+        });
+        await this.waitForChrome();
+        await this.ensureCdp();
+        await this.refreshPageInfo();
+        await this.broadcastStatus();
+    }
+    async waitForChrome() {
+        if (!this.port) {
+            throw new Error('Chrome debugging port is not assigned');
+        }
+        const deadline = Date.now() + START_TIMEOUT_MS;
+        let lastError = null;
+        while (Date.now() < deadline) {
+            if (!this.isRunning()) {
+                throw new Error(this.lastError || 'Browser exited before DevTools became available');
+            }
+            try {
+                await fetchJson(`http://127.0.0.1:${this.port}/json/version`);
+                return;
+            }
+            catch (error) {
+                lastError = error;
+                await sleep(200);
+            }
+        }
+        const detail = lastError instanceof Error ? `: ${lastError.message}` : '';
+        throw new Error(`Timed out waiting for Chrome DevTools${detail}`);
+    }
+    async openForClient(socket) {
+        try {
+            await this.start();
+            await this.ensureCdp();
+            await this.sendStatus(socket);
+            if (this.clients.size > 0) {
+                await this.startScreencast();
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.lastError = message;
+            this.send(socket, { type: 'error', error: message });
+            await this.broadcastStatus();
+        }
+    }
+    isRunning() {
+        const proc = this.chromeProcess;
+        return Boolean(proc && proc.exitCode == null && proc.signalCode == null);
+    }
+    async ensureCdp() {
+        if (this.cdp && this.cdpSocket && isOpen(this.cdpSocket)) {
+            return;
+        }
+        if (this.cdpConnecting) {
+            return this.cdpConnecting;
+        }
+        this.cdpConnecting = this.connectCdp();
+        try {
+            await this.cdpConnecting;
+        }
+        finally {
+            this.cdpConnecting = null;
+        }
+    }
+    async connectCdp() {
+        if (!this.port) {
+            throw new Error('Browser is not running');
+        }
+        const target = await this.getOrCreatePageTarget();
+        if (!target.webSocketDebuggerUrl) {
+            throw new Error('Chrome page target has no DevTools WebSocket URL');
+        }
+        this.closeCdp();
+        const socket = new WebSocket(target.webSocketDebuggerUrl);
+        await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                reject(new Error('Timed out connecting to Chrome DevTools WebSocket'));
+            }, 10_000);
+            socket.once('open', () => {
+                clearTimeout(timer);
+                resolve();
+            });
+            socket.once('error', (error) => {
+                clearTimeout(timer);
+                reject(error);
+            });
+        });
+        const cdp = new CdpConnection(socket);
+        cdp.onEvent = (message) => this.handleCdpEvent(message);
+        this.cdp = cdp;
+        this.cdpSocket = socket;
+        this.screencastStarted = false;
+        this.pageUrl = target.url || this.pageUrl;
+        this.pageTitle = target.title || this.pageTitle;
+        socket.on('close', () => {
+            if (this.cdp === cdp) {
+                this.cdp = null;
+                this.cdpSocket = null;
+                this.screencastStarted = false;
+            }
+        });
+        await cdp.send('Page.enable');
+        await cdp.send('Runtime.enable');
+        await this.applyViewport();
+    }
+    async getOrCreatePageTarget() {
+        if (!this.port) {
+            throw new Error('Browser is not running');
+        }
+        const baseUrl = `http://127.0.0.1:${this.port}`;
+        const targets = await fetchJson(`${baseUrl}/json/list`);
+        const page = targets.find((target) => target.type === 'page' && target.webSocketDebuggerUrl);
+        if (page) {
+            return page;
+        }
+        return fetchJson(`${baseUrl}/json/new?about:blank`, { method: 'PUT' });
+    }
+    async startScreencast() {
+        if (this.screencastStarted || !this.cdp) {
+            return;
+        }
+        await this.applyViewport();
+        await this.cdp.send('Page.startScreencast', {
+            format: 'jpeg',
+            quality: 72,
+            maxWidth: this.viewport.width,
+            maxHeight: this.viewport.height,
+            everyNthFrame: 1,
+        });
+        this.screencastStarted = true;
+    }
+    async stopScreencast() {
+        if (!this.screencastStarted || !this.cdp) {
+            return;
+        }
+        try {
+            await this.cdp.send('Page.stopScreencast');
+        }
+        catch {
+            // ignore
+        }
+        finally {
+            this.screencastStarted = false;
+        }
+    }
+    async applyViewport() {
+        if (!this.cdp) {
+            return;
+        }
+        await this.cdp.send('Emulation.setDeviceMetricsOverride', {
+            width: this.viewport.width,
+            height: this.viewport.height,
+            deviceScaleFactor: 1,
+            mobile: false,
+            screenWidth: this.viewport.width,
+            screenHeight: this.viewport.height,
+        });
+    }
+    async resize(width, height) {
+        const next = {
+            width: coercePositiveInt(width, this.viewport.width, MIN_VIEWPORT.width, MAX_VIEWPORT.width),
+            height: coercePositiveInt(height, this.viewport.height, MIN_VIEWPORT.height, MAX_VIEWPORT.height),
+        };
+        if (next.width === this.viewport.width && next.height === this.viewport.height) {
+            return;
+        }
+        this.viewport = next;
+        if (!this.cdp) {
+            return;
+        }
+        await this.applyViewport();
+        if (this.screencastStarted) {
+            await this.cdp.send('Page.stopScreencast').catch(() => undefined);
+            this.screencastStarted = false;
+            await this.startScreencast();
+        }
+    }
+    async handleClientMessage(socket, data) {
+        let message;
+        try {
+            const text = typeof data === 'string'
+                ? data
+                : Buffer.isBuffer(data)
+                    ? data.toString('utf8')
+                    : Array.isArray(data)
+                        ? Buffer.concat(data).toString('utf8')
+                        : Buffer.from(data).toString('utf8');
+            message = JSON.parse(text);
+        }
+        catch {
+            return;
+        }
+        try {
+            if (message.type === 'resize') {
+                await this.resize(message.width, message.height);
+                return;
+            }
+            await this.start();
+            await this.ensureCdp();
+            if (message.type === 'navigate') {
+                await this.navigate(message.url);
+                return;
+            }
+            if (message.type === 'mouse') {
+                await this.dispatchMouse(message);
+                return;
+            }
+            if (message.type === 'key') {
+                await this.dispatchKey(message);
+            }
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            this.lastError = detail;
+            this.send(socket, { type: 'error', error: detail });
+            await this.broadcastStatus();
+        }
+    }
+    async dispatchMouse(message) {
+        if (!this.cdp)
+            return;
+        await this.cdp.send('Input.dispatchMouseEvent', {
+            type: message.eventType,
+            x: coercePositiveInt(message.x, 0, 0, MAX_VIEWPORT.width),
+            y: coercePositiveInt(message.y, 0, 0, MAX_VIEWPORT.height),
+            button: message.button || 'none',
+            clickCount: message.clickCount ?? 0,
+            deltaX: message.deltaX ?? 0,
+            deltaY: message.deltaY ?? 0,
+            modifiers: message.modifiers ?? 0,
+        });
+    }
+    async dispatchKey(message) {
+        if (!this.cdp)
+            return;
+        const windowsVirtualKeyCode = getWindowsVirtualKeyCode(message.key);
+        await this.cdp.send('Input.dispatchKeyEvent', {
+            type: message.eventType,
+            key: message.key,
+            code: message.code,
+            text: message.eventType === 'keyDown' ? message.text || undefined : undefined,
+            unmodifiedText: message.eventType === 'keyDown' ? message.text || undefined : undefined,
+            windowsVirtualKeyCode,
+            nativeVirtualKeyCode: windowsVirtualKeyCode,
+            modifiers: message.modifiers ?? 0,
+        });
+    }
+    handleCdpEvent(message) {
+        if (message.method === 'Page.screencastFrame') {
+            const params = message.params;
+            const data = typeof params.data === 'string' ? params.data : null;
+            const sessionId = typeof params.sessionId === 'number' ? params.sessionId : null;
+            if (sessionId != null) {
+                void this.cdp?.send('Page.screencastFrameAck', { sessionId }).catch(() => undefined);
+            }
+            if (data) {
+                this.broadcast({
+                    type: 'frame',
+                    data,
+                    metadata: params.metadata ?? null,
+                });
+            }
+            return;
+        }
+        if (message.method === 'Page.frameNavigated') {
+            const frame = (message.params?.frame ?? null);
+            if (frame && !frame.parentId && frame.url) {
+                this.pageUrl = frame.url;
+                void this.refreshPageInfo().finally(() => {
+                    void this.broadcastStatus();
+                });
+            }
+            return;
+        }
+        if (message.method === 'Page.loadEventFired') {
+            void this.refreshPageInfo().finally(() => {
+                void this.broadcastStatus();
+            });
+        }
+    }
+    async refreshPageInfo() {
+        if (!this.cdp) {
+            return;
+        }
+        try {
+            const result = await this.cdp.send('Runtime.evaluate', {
+                expression: '({ title: document.title, url: location.href })',
+                returnByValue: true,
+            });
+            const value = result.result?.value;
+            if (value) {
+                this.pageTitle = typeof value.title === 'string' ? value.title : this.pageTitle;
+                this.pageUrl = typeof value.url === 'string' ? value.url : this.pageUrl;
+            }
+        }
+        catch {
+            // Some internal pages do not allow Runtime.evaluate.
+        }
+    }
+    async sendStatus(socket) {
+        this.send(socket, { type: 'status', status: await this.getStatus() });
+    }
+    async broadcastStatus() {
+        const status = await this.getStatus();
+        this.broadcast({ type: 'status', status });
+    }
+    broadcast(payload) {
+        const text = JSON.stringify(payload);
+        for (const socket of this.clients) {
+            this.sendRaw(socket, text);
+        }
+    }
+    send(socket, payload) {
+        this.sendRaw(socket, JSON.stringify(payload));
+    }
+    sendRaw(socket, payload) {
+        if (!isOpen(socket)) {
+            return;
+        }
+        if (socket.bufferedAmount > MAX_CLIENT_BUFFERED_AMOUNT) {
+            try {
+                socket.close(1009, 'Browser stream overflow');
+            }
+            catch {
+                // ignore
+            }
+            return;
+        }
+        try {
+            socket.send(payload);
+        }
+        catch {
+            try {
+                socket.close(1011, 'Browser stream send failed');
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    closeCdp() {
+        const cdp = this.cdp;
+        const socket = this.cdpSocket;
+        this.cdp = null;
+        this.cdpSocket = null;
+        this.screencastStarted = false;
+        if (cdp) {
+            cdp.close();
+        }
+        else if (socket) {
+            try {
+                socket.close();
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    openLogStream() {
+        this.closeLogStream();
+        const logPath = path.join(this.outputDir, 'deckide-browser.log');
+        this.logStream = fsSync.createWriteStream(logPath, { flags: 'a' });
+    }
+    closeLogStream() {
+        const stream = this.logStream;
+        this.logStream = null;
+        if (stream) {
+            stream.end();
+        }
+    }
+}
+function getWindowsVirtualKeyCode(key) {
+    const table = {
+        Backspace: 8,
+        Tab: 9,
+        Enter: 13,
+        Shift: 16,
+        Control: 17,
+        Alt: 18,
+        Pause: 19,
+        CapsLock: 20,
+        Escape: 27,
+        Space: 32,
+        ' ': 32,
+        PageUp: 33,
+        PageDown: 34,
+        End: 35,
+        Home: 36,
+        ArrowLeft: 37,
+        ArrowUp: 38,
+        ArrowRight: 39,
+        ArrowDown: 40,
+        Insert: 45,
+        Delete: 46,
+        Meta: 91,
+        ContextMenu: 93,
+    };
+    if (key in table) {
+        return table[key];
+    }
+    const functionKey = /^F([1-9]|1[0-2])$/.exec(key);
+    if (functionKey) {
+        return 111 + Number(functionKey[1]);
+    }
+    if (key.length === 1) {
+        return key.toUpperCase().charCodeAt(0);
+    }
+    return 0;
+}