green-screen-proxy 0.3.0

package/dist/tn5250/screen.js

@@ -0,0 +1,155 @@
+import { createHash } from 'crypto';
+import { SCREEN } from './constants.js';
+export class ScreenBuffer {
+    rows;
+    cols;
+    /** Character buffer stored as UTF-8 characters */
+    buffer;
+    /** Attribute buffer (display attribute per cell) */
+    attrBuffer;
+    fields = [];
+    cursorRow = 0;
+    cursorCol = 0;
+    constructor(rows = SCREEN.ROWS_24, cols = SCREEN.COLS_80) {
+        this.rows = rows;
+        this.cols = cols;
+        const size = rows * cols;
+        this.buffer = new Array(size).fill(' ');
+        this.attrBuffer = new Array(size).fill(0x20); // normal
+    }
+    get size() {
+        return this.rows * this.cols;
+    }
+    /** Convert row,col to linear offset */
+    offset(row, col) {
+        return row * this.cols + col;
+    }
+    /** Convert linear offset to row,col */
+    toRowCol(offset) {
+        return {
+            row: Math.floor(offset / this.cols),
+            col: offset % this.cols,
+        };
+    }
+    /** Set a character at row,col */
+    setChar(row, col, char) {
+        const off = this.offset(row, col);
+        if (off >= 0 && off < this.size) {
+            this.buffer[off] = char;
+        }
+    }
+    /** Get a character at row,col */
+    getChar(row, col) {
+        const off = this.offset(row, col);
+        return off >= 0 && off < this.size ? this.buffer[off] : ' ';
+    }
+    /** Set attribute at row,col */
+    setAttr(row, col, attr) {
+        const off = this.offset(row, col);
+        if (off >= 0 && off < this.size) {
+            this.attrBuffer[off] = attr;
+        }
+    }
+    /** Set character at a linear address */
+    setCharAt(addr, char) {
+        if (addr >= 0 && addr < this.size) {
+            this.buffer[addr] = char;
+        }
+    }
+    /** Set attribute at a linear address */
+    setAttrAt(addr, attr) {
+        if (addr >= 0 && addr < this.size) {
+            this.attrBuffer[addr] = attr;
+        }
+    }
+    /** Clear the entire screen */
+    clear() {
+        this.buffer.fill(' ');
+        this.attrBuffer.fill(0x20);
+        this.fields = [];
+        this.cursorRow = 0;
+        this.cursorCol = 0;
+    }
+    /** Fill range [start, end) with a character */
+    fillRange(start, end, char) {
+        for (let i = start; i < end && i < this.size; i++) {
+            this.buffer[i] = char;
+        }
+    }
+    /** Get the content of a field as a string */
+    getFieldValue(field) {
+        const start = this.offset(field.row, field.col);
+        return this.buffer.slice(start, start + field.length).join('');
+    }
+    /** Set the content of a field */
+    setFieldValue(field, value) {
+        const start = this.offset(field.row, field.col);
+        for (let i = 0; i < field.length; i++) {
+            this.buffer[start + i] = i < value.length ? value[i] : ' ';
+        }
+        field.modified = true;
+    }
+    /** Find the field at cursor position */
+    getFieldAtCursor() {
+        return this.getFieldAt(this.cursorRow, this.cursorCol);
+    }
+    /** Find the field containing a given position */
+    getFieldAt(row, col) {
+        const pos = this.offset(row, col);
+        for (const field of this.fields) {
+            const start = this.offset(field.row, field.col);
+            if (pos >= start && pos < start + field.length) {
+                return field;
+            }
+        }
+        return null;
+    }
+    /** Whether a field is an input field (not bypass/protected) */
+    isInputField(field) {
+        return (field.ffw1 & 0x20) === 0; // BYPASS bit not set
+    }
+    /** Whether a field is highlighted (high intensity) */
+    isHighlighted(field) {
+        return field.attribute === 0x22;
+    }
+    /** Whether a field is reverse video */
+    isReverse(field) {
+        return field.attribute === 0x21;
+    }
+    /** Whether a field is non-display (password) */
+    isNonDisplay(field) {
+        return field.attribute === 0x27;
+    }
+    /** Convert screen buffer to the ScreenData format expected by the frontend */
+    toScreenData() {
+        // Build content as newline-separated rows
+        const lines = [];
+        for (let r = 0; r < this.rows; r++) {
+            const start = r * this.cols;
+            lines.push(this.buffer.slice(start, start + this.cols).join(''));
+        }
+        const content = lines.join('\n');
+        // Map fields to frontend format
+        const fields = this.fields.map(f => ({
+            row: f.row,
+            col: f.col,
+            length: f.length,
+            is_input: this.isInputField(f),
+            is_protected: !this.isInputField(f),
+            is_highlighted: this.isHighlighted(f) || undefined,
+            is_reverse: this.isReverse(f) || undefined,
+        }));
+        // Generate screen signature
+        const hash = createHash('md5').update(content).digest('hex').substring(0, 12);
+        return {
+            content,
+            cursor_row: this.cursorRow,
+            cursor_col: this.cursorCol,
+            rows: this.rows,
+            cols: this.cols,
+            fields,
+            screen_signature: hash,
+            timestamp: new Date().toISOString(),
+        };
+    }
+}

package/dist/vt/connection.d.ts

@@ -0,0 +1,45 @@
+import { EventEmitter } from 'events';
+export interface VTConnectionOptions {
+    terminalType?: string;
+    rows?: number;
+    cols?: number;
+}
+/**
+ * Manages a TCP/Telnet connection for VT terminal sessions.
+ *
+ * Unlike TN5250/TN3270, VT data is a continuous byte stream — there is no
+ * IAC EOR record framing. Telnet IAC commands are handled inline and stripped
+ * from the data stream; all remaining bytes are emitted as 'data' events.
+ */
+export declare class VTConnection extends EventEmitter {
+    private socket;
+    private host;
+    private port;
+    private connected;
+    private recvBuffer;
+    private terminalType;
+    private rows;
+    private cols;
+    get isConnected(): boolean;
+    get remoteHost(): string;
+    get remotePort(): number;
+    connect(host: string, port: number, options?: VTConnectionOptions): Promise<void>;
+    disconnect(): void;
+    /** Send raw bytes over the socket */
+    sendRaw(data: Buffer): void;
+    private cleanup;
+    private onData;
+    /**
+     * Process the receive buffer. Strip out Telnet IAC commands and emit
+     * the remaining application data as 'data' events.
+     */
+    private processBuffer;
+    /** Find IAC SE after position `start` (which points to IAC SB) */
+    private findSubnegEnd;
+    private handleNegotiation;
+    private handleSubnegotiation;
+    private sendTerminalType;
+    /** Send NAWS (Negotiate About Window Size) subnegotiation */
+    private sendNAWS;
+    private sendTelnet;
+}

package/dist/vt/connection.js

@@ -0,0 +1,229 @@
+import * as net from 'net';
+import { EventEmitter } from 'events';
+import { TELNET, DEFAULT_TERMINAL_TYPE, DEFAULT_ROWS, DEFAULT_COLS } from './constants.js';
+/**
+ * Manages a TCP/Telnet connection for VT terminal sessions.
+ *
+ * Unlike TN5250/TN3270, VT data is a continuous byte stream — there is no
+ * IAC EOR record framing. Telnet IAC commands are handled inline and stripped
+ * from the data stream; all remaining bytes are emitted as 'data' events.
+ */
+export class VTConnection extends EventEmitter {
+    socket = null;
+    host = '';
+    port = 23;
+    connected = false;
+    recvBuffer = Buffer.alloc(0);
+    terminalType = DEFAULT_TERMINAL_TYPE;
+    rows = DEFAULT_ROWS;
+    cols = DEFAULT_COLS;
+    get isConnected() {
+        return this.connected;
+    }
+    get remoteHost() {
+        return this.host;
+    }
+    get remotePort() {
+        return this.port;
+    }
+    connect(host, port, options) {
+        return new Promise((resolve, reject) => {
+            if (this.socket) {
+                this.disconnect();
+            }
+            this.host = host;
+            this.port = port;
+            this.recvBuffer = Buffer.alloc(0);
+            if (options?.terminalType)
+                this.terminalType = options.terminalType;
+            if (options?.rows)
+                this.rows = options.rows;
+            if (options?.cols)
+                this.cols = options.cols;
+            this.socket = new net.Socket();
+            this.socket.setTimeout(30000);
+            const onError = (err) => {
+                this.cleanup();
+                reject(err);
+            };
+            this.socket.once('error', onError);
+            this.socket.connect(port, host, () => {
+                this.connected = true;
+                this.socket.removeListener('error', onError);
+                this.socket.on('error', (err) => {
+                    this.emit('error', err);
+                    this.cleanup();
+                });
+                this.socket.on('close', () => {
+                    this.cleanup();
+                    this.emit('disconnected');
+                });
+                this.socket.on('timeout', () => {
+                    this.emit('error', new Error('Connection timeout'));
+                });
+                this.socket.on('data', (data) => this.onData(data));
+                this.emit('connected');
+                resolve();
+            });
+        });
+    }
+    disconnect() {
+        if (this.socket) {
+            this.socket.destroy();
+            this.cleanup();
+        }
+    }
+    /** Send raw bytes over the socket */
+    sendRaw(data) {
+        if (this.socket && this.connected) {
+            this.socket.write(data);
+        }
+    }
+    cleanup() {
+        this.connected = false;
+        if (this.socket) {
+            this.socket.removeAllListeners();
+            this.socket.destroy();
+            this.socket = null;
+        }
+    }
+    onData(data) {
+        this.recvBuffer = Buffer.concat([this.recvBuffer, data]);
+        this.processBuffer();
+    }
+    /**
+     * Process the receive buffer. Strip out Telnet IAC commands and emit
+     * the remaining application data as 'data' events.
+     */
+    processBuffer() {
+        const appData = [];
+        let i = 0;
+        while (i < this.recvBuffer.length) {
+            const byte = this.recvBuffer[i];
+            if (byte === TELNET.IAC) {
+                if (i + 1 >= this.recvBuffer.length) {
+                    // Incomplete IAC sequence — keep remainder for next chunk
+                    break;
+                }
+                const cmd = this.recvBuffer[i + 1];
+                // IAC IAC = escaped 0xFF literal byte
+                if (cmd === TELNET.IAC) {
+                    appData.push(0xff);
+                    i += 2;
+                    continue;
+                }
+                // Subnegotiation: IAC SB ... IAC SE
+                if (cmd === TELNET.SB) {
+                    const seIdx = this.findSubnegEnd(i);
+                    if (seIdx === -1)
+                        break; // Wait for more data
+                    const subData = this.recvBuffer.subarray(i + 2, seIdx);
+                    this.handleSubnegotiation(subData);
+                    i = seIdx + 2; // skip past IAC SE
+                    continue;
+                }
+                // DO/DONT/WILL/WONT: 3-byte commands
+                if (cmd === TELNET.DO || cmd === TELNET.DONT || cmd === TELNET.WILL || cmd === TELNET.WONT) {
+                    if (i + 2 >= this.recvBuffer.length)
+                        break; // Wait for option byte
+                    const option = this.recvBuffer[i + 2];
+                    this.handleNegotiation(cmd, option);
+                    i += 3;
+                    continue;
+                }
+                // Other 2-byte IAC commands (GA, NOP, etc.) — skip
+                i += 2;
+                continue;
+            }
+            // Regular data byte
+            appData.push(byte);
+            i++;
+        }
+        // Keep unprocessed bytes
+        this.recvBuffer = this.recvBuffer.subarray(i);
+        // Emit application data
+        if (appData.length > 0) {
+            this.emit('data', Buffer.from(appData));
+        }
+    }
+    /** Find IAC SE after position `start` (which points to IAC SB) */
+    findSubnegEnd(start) {
+        for (let j = start + 2; j < this.recvBuffer.length - 1; j++) {
+            if (this.recvBuffer[j] === TELNET.IAC && this.recvBuffer[j + 1] === TELNET.SE) {
+                return j;
+            }
+        }
+        return -1;
+    }
+    handleNegotiation(cmd, option) {
+        switch (cmd) {
+            case TELNET.DO:
+                if (option === TELNET.OPT_TTYPE ||
+                    option === TELNET.OPT_NAWS ||
+                    option === TELNET.OPT_BINARY ||
+                    option === TELNET.OPT_SGA) {
+                    this.sendTelnet(TELNET.WILL, option);
+                    // After agreeing to NAWS, immediately send window size
+                    if (option === TELNET.OPT_NAWS) {
+                        this.sendNAWS();
+                    }
+                }
+                else {
+                    this.sendTelnet(TELNET.WONT, option);
+                }
+                break;
+            case TELNET.WILL:
+                if (option === TELNET.OPT_ECHO ||
+                    option === TELNET.OPT_SGA ||
+                    option === TELNET.OPT_BINARY) {
+                    this.sendTelnet(TELNET.DO, option);
+                }
+                else {
+                    this.sendTelnet(TELNET.DONT, option);
+                }
+                break;
+            case TELNET.DONT:
+                this.sendTelnet(TELNET.WONT, option);
+                break;
+            case TELNET.WONT:
+                this.sendTelnet(TELNET.DONT, option);
+                break;
+        }
+    }
+    handleSubnegotiation(data) {
+        if (data.length === 0)
+            return;
+        const option = data[0];
+        if (option === TELNET.OPT_TTYPE && data.length >= 2 && data[1] === TELNET.TTYPE_SEND) {
+            this.sendTerminalType();
+        }
+    }
+    sendTerminalType() {
+        const typeStr = this.terminalType;
+        const buf = Buffer.alloc(4 + typeStr.length + 2);
+        let i = 0;
+        buf[i++] = TELNET.IAC;
+        buf[i++] = TELNET.SB;
+        buf[i++] = TELNET.OPT_TTYPE;
+        buf[i++] = TELNET.TTYPE_IS;
+        for (let j = 0; j < typeStr.length; j++) {
+            buf[i++] = typeStr.charCodeAt(j);
+        }
+        buf[i++] = TELNET.IAC;
+        buf[i++] = TELNET.SE;
+        this.sendRaw(buf);
+    }
+    /** Send NAWS (Negotiate About Window Size) subnegotiation */
+    sendNAWS() {
+        const buf = Buffer.from([
+            TELNET.IAC, TELNET.SB, TELNET.OPT_NAWS,
+            (this.cols >> 8) & 0xff, this.cols & 0xff,
+            (this.rows >> 8) & 0xff, this.rows & 0xff,
+            TELNET.IAC, TELNET.SE,
+        ]);
+        this.sendRaw(buf);
+    }
+    sendTelnet(cmd, option) {
+        this.sendRaw(Buffer.from([TELNET.IAC, cmd, option]));
+    }
+}

package/dist/vt/constants.d.ts

@@ -0,0 +1,97 @@
+/**
+ * VT100/VT220/VT320 terminal constants and escape sequences.
+ */
+export declare const ESC = 27;
+export declare const CSI_CHAR = 91;
+export declare const CSI = "\u001B[";
+export declare const NUL = 0;
+export declare const BEL = 7;
+export declare const BS = 8;
+export declare const HT = 9;
+export declare const LF = 10;
+export declare const VT = 11;
+export declare const FF = 12;
+export declare const CR = 13;
+export declare const SO = 14;
+export declare const SI = 15;
+export declare const DEL = 127;
+export declare const TELNET: {
+    readonly IAC: 255;
+    readonly DONT: 254;
+    readonly DO: 253;
+    readonly WONT: 252;
+    readonly WILL: 251;
+    readonly SB: 250;
+    readonly SE: 240;
+    readonly GA: 249;
+    readonly NOP: 241;
+    readonly OPT_BINARY: 0;
+    readonly OPT_ECHO: 1;
+    readonly OPT_SGA: 3;
+    readonly OPT_TTYPE: 24;
+    readonly OPT_NAWS: 31;
+    readonly TTYPE_IS: 0;
+    readonly TTYPE_SEND: 1;
+};
+export declare const DEFAULT_ROWS = 24;
+export declare const DEFAULT_COLS = 80;
+export declare const TERMINAL_TYPES: {
+    readonly VT220: "VT220";
+    readonly VT320: "VT320";
+    readonly XTERM: "xterm";
+};
+export declare const DEFAULT_TERMINAL_TYPE: "VT220";
+export declare const VT_KEYS: Record<string, string>;
+export declare const SGR: {
+    readonly RESET: 0;
+    readonly BOLD: 1;
+    readonly DIM: 2;
+    readonly ITALIC: 3;
+    readonly UNDERLINE: 4;
+    readonly BLINK: 5;
+    readonly RAPID_BLINK: 6;
+    readonly REVERSE: 7;
+    readonly HIDDEN: 8;
+    readonly STRIKETHROUGH: 9;
+    readonly NORMAL_INTENSITY: 22;
+    readonly NO_ITALIC: 23;
+    readonly NO_UNDERLINE: 24;
+    readonly NO_BLINK: 25;
+    readonly NO_REVERSE: 27;
+    readonly NO_HIDDEN: 28;
+    readonly NO_STRIKETHROUGH: 29;
+    readonly FG_BLACK: 30;
+    readonly FG_RED: 31;
+    readonly FG_GREEN: 32;
+    readonly FG_YELLOW: 33;
+    readonly FG_BLUE: 34;
+    readonly FG_MAGENTA: 35;
+    readonly FG_CYAN: 36;
+    readonly FG_WHITE: 37;
+    readonly FG_DEFAULT: 39;
+    readonly BG_BLACK: 40;
+    readonly BG_RED: 41;
+    readonly BG_GREEN: 42;
+    readonly BG_YELLOW: 43;
+    readonly BG_BLUE: 44;
+    readonly BG_MAGENTA: 45;
+    readonly BG_CYAN: 46;
+    readonly BG_WHITE: 47;
+    readonly BG_DEFAULT: 49;
+    readonly FG_BRIGHT_BLACK: 90;
+    readonly FG_BRIGHT_RED: 91;
+    readonly FG_BRIGHT_GREEN: 92;
+    readonly FG_BRIGHT_YELLOW: 93;
+    readonly FG_BRIGHT_BLUE: 94;
+    readonly FG_BRIGHT_MAGENTA: 95;
+    readonly FG_BRIGHT_CYAN: 96;
+    readonly FG_BRIGHT_WHITE: 97;
+    readonly BG_BRIGHT_BLACK: 100;
+    readonly BG_BRIGHT_RED: 101;
+    readonly BG_BRIGHT_GREEN: 102;
+    readonly BG_BRIGHT_YELLOW: 103;
+    readonly BG_BRIGHT_BLUE: 104;
+    readonly BG_BRIGHT_MAGENTA: 105;
+    readonly BG_BRIGHT_CYAN: 106;
+    readonly BG_BRIGHT_WHITE: 107;
+};

package/dist/vt/constants.js

@@ -0,0 +1,163 @@
+/**
+ * VT100/VT220/VT320 terminal constants and escape sequences.
+ */
+// ---------------------------------------------------------------------------
+// Control characters
+// ---------------------------------------------------------------------------
+export const ESC = 0x1b;
+export const CSI_CHAR = 0x5b; // '['
+export const CSI = '\x1b['; // Control Sequence Introducer
+export const NUL = 0x00;
+export const BEL = 0x07;
+export const BS = 0x08;
+export const HT = 0x09;
+export const LF = 0x0a;
+export const VT = 0x0b;
+export const FF = 0x0c;
+export const CR = 0x0d;
+export const SO = 0x0e; // Shift Out (G1 charset)
+export const SI = 0x0f; // Shift In (G0 charset)
+export const DEL = 0x7f;
+// ---------------------------------------------------------------------------
+// Telnet constants (standard RFC 854 / RFC 855)
+// ---------------------------------------------------------------------------
+export const TELNET = {
+    IAC: 0xff,
+    DONT: 0xfe,
+    DO: 0xfd,
+    WONT: 0xfc,
+    WILL: 0xfb,
+    SB: 0xfa,
+    SE: 0xf0,
+    GA: 0xf9,
+    NOP: 0xf1,
+    // Options
+    OPT_BINARY: 0x00,
+    OPT_ECHO: 0x01,
+    OPT_SGA: 0x03, // Suppress Go Ahead
+    OPT_TTYPE: 0x18, // Terminal Type
+    OPT_NAWS: 0x1f, // Negotiate About Window Size
+    // Subnegotiation
+    TTYPE_IS: 0x00,
+    TTYPE_SEND: 0x01,
+};
+// ---------------------------------------------------------------------------
+// Screen defaults
+// ---------------------------------------------------------------------------
+export const DEFAULT_ROWS = 24;
+export const DEFAULT_COLS = 80;
+// ---------------------------------------------------------------------------
+// Terminal type strings
+// ---------------------------------------------------------------------------
+export const TERMINAL_TYPES = {
+    VT220: 'VT220',
+    VT320: 'VT320',
+    XTERM: 'xterm',
+};
+export const DEFAULT_TERMINAL_TYPE = TERMINAL_TYPES.VT220;
+// ---------------------------------------------------------------------------
+// VT220 function key escape sequences (sent by client)
+// ---------------------------------------------------------------------------
+export const VT_KEYS = {
+    // F1-F5 (VT220 sends SS3 sequences for F1-F4)
+    F1: '\x1bOP',
+    F2: '\x1bOQ',
+    F3: '\x1bOR',
+    F4: '\x1bOS',
+    F5: '\x1b[15~',
+    // F6-F12
+    F6: '\x1b[17~',
+    F7: '\x1b[18~',
+    F8: '\x1b[19~',
+    F9: '\x1b[20~',
+    F10: '\x1b[21~',
+    F11: '\x1b[23~',
+    F12: '\x1b[24~',
+    // F13-F24 (shifted function keys on VT220)
+    F13: '\x1b[25~',
+    F14: '\x1b[26~',
+    F15: '\x1b[28~',
+    F16: '\x1b[29~',
+    F17: '\x1b[31~',
+    F18: '\x1b[32~',
+    F19: '\x1b[33~',
+    F20: '\x1b[34~',
+    // Arrow keys
+    UP: '\x1b[A',
+    DOWN: '\x1b[B',
+    RIGHT: '\x1b[C',
+    LEFT: '\x1b[D',
+    // Editing keys
+    HOME: '\x1b[1~',
+    INSERT: '\x1b[2~',
+    DELETE: '\x1b[3~',
+    END: '\x1b[4~',
+    PAGEUP: '\x1b[5~',
+    PAGEDOWN: '\x1b[6~',
+    // Special keys
+    ENTER: '\r',
+    TAB: '\t',
+    BACKSPACE: '\x7f',
+    ESCAPE: '\x1b',
+};
+// ---------------------------------------------------------------------------
+// SGR (Select Graphic Rendition) attribute codes
+// ---------------------------------------------------------------------------
+export const SGR = {
+    RESET: 0,
+    BOLD: 1,
+    DIM: 2,
+    ITALIC: 3,
+    UNDERLINE: 4,
+    BLINK: 5,
+    RAPID_BLINK: 6,
+    REVERSE: 7,
+    HIDDEN: 8,
+    STRIKETHROUGH: 9,
+    // Turn off attributes
+    NORMAL_INTENSITY: 22,
+    NO_ITALIC: 23,
+    NO_UNDERLINE: 24,
+    NO_BLINK: 25,
+    NO_REVERSE: 27,
+    NO_HIDDEN: 28,
+    NO_STRIKETHROUGH: 29,
+    // Foreground colors
+    FG_BLACK: 30,
+    FG_RED: 31,
+    FG_GREEN: 32,
+    FG_YELLOW: 33,
+    FG_BLUE: 34,
+    FG_MAGENTA: 35,
+    FG_CYAN: 36,
+    FG_WHITE: 37,
+    FG_DEFAULT: 39,
+    // Background colors
+    BG_BLACK: 40,
+    BG_RED: 41,
+    BG_GREEN: 42,
+    BG_YELLOW: 43,
+    BG_BLUE: 44,
+    BG_MAGENTA: 45,
+    BG_CYAN: 46,
+    BG_WHITE: 47,
+    BG_DEFAULT: 49,
+    // Bright foreground colors
+    FG_BRIGHT_BLACK: 90,
+    FG_BRIGHT_RED: 91,
+    FG_BRIGHT_GREEN: 92,
+    FG_BRIGHT_YELLOW: 93,
+    FG_BRIGHT_BLUE: 94,
+    FG_BRIGHT_MAGENTA: 95,
+    FG_BRIGHT_CYAN: 96,
+    FG_BRIGHT_WHITE: 97,
+    // Bright background colors
+    BG_BRIGHT_BLACK: 100,
+    BG_BRIGHT_RED: 101,
+    BG_BRIGHT_GREEN: 102,
+    BG_BRIGHT_YELLOW: 103,
+    BG_BRIGHT_BLUE: 104,
+    BG_BRIGHT_MAGENTA: 105,
+    BG_BRIGHT_CYAN: 106,
+    BG_BRIGHT_WHITE: 107,
+};