green-screen-proxy 0.3.0

package/dist/tn5250/encoder.js

@@ -0,0 +1,121 @@
+import { TELNET, KEY_TO_AID, AID } from './constants.js';
+import { charToEbcdic, EBCDIC_SPACE } from './ebcdic.js';
+/**
+ * Encodes client responses (aid keys + field data) into 5250 data stream
+ * for sending back to the IBM i host.
+ */
+export class TN5250Encoder {
+    screen;
+    constructor(screen) {
+        this.screen = screen;
+    }
+    /**
+     * Build a 5250 input response for an aid key press.
+     * Collects modified field data and builds the response record.
+     * Returns a Buffer ready to send over the TCP socket (with Telnet EOR framing).
+     */
+    buildAidResponse(keyName) {
+        const aidByte = KEY_TO_AID[keyName];
+        if (aidByte === undefined)
+            return null;
+        const parts = [];
+        // Row and column of cursor (1-based for the protocol)
+        const cursorRow = this.screen.cursorRow;
+        const cursorCol = this.screen.cursorCol;
+        // Build the response record
+        // Format: [row][col][aid_byte][field_data...]
+        // GDS header (6 bytes) + response data
+        const header = this.buildGDSHeader();
+        parts.push(header);
+        // Cursor position + AID byte
+        parts.push(Buffer.from([cursorRow, cursorCol, aidByte]));
+        // For certain aid keys (like SysReq), no field data is sent
+        if (aidByte === AID.SYS_REQUEST || aidByte === AID.CLEAR) {
+            return this.wrapWithEOR(Buffer.concat(parts));
+        }
+        // Collect modified fields and append their data
+        for (const field of this.screen.fields) {
+            if (!field.modified)
+                continue;
+            if (!this.screen.isInputField(field))
+                continue;
+            // SBA order to indicate field position
+            parts.push(Buffer.from([0x11, field.row, field.col])); // SBA + row + col
+            // Field data in EBCDIC
+            const value = this.screen.getFieldValue(field);
+            const ebcdicData = Buffer.alloc(value.length);
+            for (let i = 0; i < value.length; i++) {
+                ebcdicData[i] = charToEbcdic(value[i]);
+            }
+            // Trim trailing spaces
+            let trimLen = ebcdicData.length;
+            while (trimLen > 0 && ebcdicData[trimLen - 1] === EBCDIC_SPACE) {
+                trimLen--;
+            }
+            if (trimLen > 0) {
+                parts.push(ebcdicData.subarray(0, trimLen));
+            }
+        }
+        return this.wrapWithEOR(Buffer.concat(parts));
+    }
+    /**
+     * Build a GDS (General Data Stream) header for a response.
+     */
+    buildGDSHeader() {
+        // We'll fill in the length later, but for now use a placeholder
+        // The actual header format:
+        // Bytes 0-1: record length (will be filled)
+        // Bytes 2-3: record type = 0x12A0
+        // Byte 4: variable indicator (0x00)
+        // Byte 5: reserved (0x00)
+        // Byte 6: opcode (0x00 for response, 0x04 for response to save screen)
+        return Buffer.from([0x00, 0x00, 0x12, 0xA0, 0x00, 0x00, 0x00]);
+    }
+    /**
+     * Wrap data with Telnet IAC EOR framing.
+     * Also escapes any 0xFF bytes in the data as IAC IAC.
+     */
+    wrapWithEOR(data) {
+        // Update the record length in the GDS header
+        if (data.length >= 2) {
+            const len = data.length;
+            data[0] = (len >> 8) & 0xFF;
+            data[1] = len & 0xFF;
+        }
+        // Escape IAC bytes in data and append IAC EOR
+        const escaped = [];
+        for (let i = 0; i < data.length; i++) {
+            escaped.push(data[i]);
+            if (data[i] === TELNET.IAC) {
+                escaped.push(TELNET.IAC); // escape
+            }
+        }
+        escaped.push(TELNET.IAC, TELNET.EOR);
+        return Buffer.from(escaped);
+    }
+    /**
+     * Insert text at the current cursor position in the current field.
+     * Updates the screen buffer and marks the field as modified.
+     * Returns true if text was successfully inserted.
+     */
+    insertText(text) {
+        const field = this.screen.getFieldAtCursor();
+        if (!field || !this.screen.isInputField(field))
+            return false;
+        const fieldStart = this.screen.offset(field.row, field.col);
+        let cursorOffset = this.screen.offset(this.screen.cursorRow, this.screen.cursorCol);
+        const fieldEnd = fieldStart + field.length;
+        for (const ch of text) {
+            if (cursorOffset >= fieldEnd)
+                break; // Field is full
+            this.screen.buffer[cursorOffset] = ch;
+            cursorOffset++;
+        }
+        // Update cursor position
+        const newPos = this.screen.toRowCol(Math.min(cursorOffset, fieldEnd - 1));
+        this.screen.cursorRow = newPos.row;
+        this.screen.cursorCol = newPos.col;
+        field.modified = true;
+        return true;
+    }
+}

package/dist/tn5250/parser.d.ts

@@ -0,0 +1,33 @@
+import { ScreenBuffer } from './screen.js';
+/**
+ * Parses 5250 data stream records and updates the screen buffer.
+ */
+export declare class TN5250Parser {
+    private screen;
+    constructor(screen: ScreenBuffer);
+    /**
+     * Parse a complete 5250 record (after Telnet framing is removed).
+     * Returns true if the screen was modified.
+     */
+    parseRecord(record: Buffer): boolean;
+    /** Try to parse data that doesn't have a proper GDS header */
+    private tryParseRawData;
+    /** Parse one or more 5250 commands starting at offset */
+    private parseCommands;
+    /**
+     * Parse orders and text data within a WTD (or similar) command.
+     * Updates the screen buffer and returns the new position.
+     */
+    private parseOrders;
+    /** Try to detect if a byte in the 0x20-0x3F range is a field attribute vs regular character */
+    private isLikelyFieldAttribute;
+    /** Parse a field attribute byte and the following FFW/FCW */
+    private parseFieldAttribute;
+    /** Parse explicit SF order field definition */
+    private parseFieldDefinition;
+    /**
+     * After parsing a complete screen, calculate field lengths.
+     * Call this after all records for a screen have been parsed.
+     */
+    calculateFieldLengths(): void;
+}

package/dist/tn5250/parser.js

@@ -0,0 +1,412 @@
+import { CMD, ORDER, OPCODE, ATTR } from './constants.js';
+import { ebcdicToChar } from './ebcdic.js';
+/**
+ * Parses 5250 data stream records and updates the screen buffer.
+ */
+export class TN5250Parser {
+    screen;
+    constructor(screen) {
+        this.screen = screen;
+    }
+    /**
+     * Parse a complete 5250 record (after Telnet framing is removed).
+     * Returns true if the screen was modified.
+     */
+    parseRecord(record) {
+        if (record.length < 2)
+            return false;
+        // 5250 record header:
+        // Bytes 0-1: record length
+        // Byte 2: record type (high byte)
+        // Byte 3: record type (low byte) — together 0x12A0 for GDS
+        // Byte 4: reserved (variable flag)
+        // Byte 5: reserved
+        // Byte 6: opcode
+        // Remaining: data
+        // Some records may be shorter or have different formats
+        // Try to parse the GDS header
+        if (record.length < 7) {
+            // Too short for a full GDS header — might be a short record
+            return false;
+        }
+        const recordLen = (record[0] << 8) | record[1];
+        const recordType = (record[2] << 8) | record[3];
+        const varFlag = record[4];
+        const reserved = record[5];
+        const opcode = record[6];
+        // Check for GDS record type
+        if (recordType !== 0x12A0) {
+            // Not a GDS record — might be raw data or something else
+            return this.tryParseRawData(record);
+        }
+        let modified = false;
+        switch (opcode) {
+            case OPCODE.OUTPUT:
+            case OPCODE.PUT_GET:
+                // Contains one or more 5250 commands after the header
+                modified = this.parseCommands(record, 7);
+                break;
+            case OPCODE.INVITE:
+                // Invite: server is ready for input (no screen data typically)
+                break;
+            case OPCODE.SAVE_SCREEN:
+            case OPCODE.RESTORE_SCREEN:
+                // We don't implement save/restore, just ignore
+                break;
+            default:
+                // Try parsing as commands anyway
+                if (record.length > 7) {
+                    modified = this.parseCommands(record, 7);
+                }
+                break;
+        }
+        return modified;
+    }
+    /** Try to parse data that doesn't have a proper GDS header */
+    tryParseRawData(record) {
+        // Some servers send command data without the full GDS wrapper
+        return this.parseCommands(record, 0);
+    }
+    /** Parse one or more 5250 commands starting at offset */
+    parseCommands(data, offset) {
+        let pos = offset;
+        let modified = false;
+        while (pos < data.length) {
+            const cmd = data[pos];
+            switch (cmd) {
+                case CMD.CLEAR_UNIT:
+                case CMD.CLEAR_UNIT_ALT:
+                    this.screen.clear();
+                    pos++;
+                    modified = true;
+                    break;
+                case CMD.CLEAR_FORMAT_TABLE:
+                    this.screen.fields = [];
+                    pos++;
+                    modified = true;
+                    break;
+                case CMD.WRITE_TO_DISPLAY: {
+                    pos++; // skip command byte
+                    // WTD has a CC (control character) — 2 bytes
+                    if (pos + 1 < data.length) {
+                        const cc1 = data[pos++];
+                        const cc2 = data[pos++];
+                        // CC1 bit 5: Reset MDT flags
+                        if (cc1 & 0x20) {
+                            for (const f of this.screen.fields) {
+                                f.modified = false;
+                            }
+                        }
+                        // CC1 bit 6: Clear all input fields (null fill)
+                        if (cc1 & 0x40) {
+                            for (const f of this.screen.fields) {
+                                if (this.screen.isInputField(f)) {
+                                    const start = this.screen.offset(f.row, f.col);
+                                    for (let i = start; i < start + f.length; i++) {
+                                        this.screen.buffer[i] = ' ';
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    // Parse orders and data following WTD
+                    pos = this.parseOrders(data, pos);
+                    modified = true;
+                    break;
+                }
+                case CMD.WRITE_ERROR_CODE:
+                case CMD.WRITE_ERROR_CODE_WIN: {
+                    pos++; // skip command byte
+                    // Skip the error line data — just advance past it
+                    // Error code commands are followed by data until next command
+                    pos = this.parseOrders(data, pos);
+                    modified = true;
+                    break;
+                }
+                case CMD.WRITE_STRUCTURED_FIELD: {
+                    pos++;
+                    // Structured fields have their own length prefix
+                    if (pos + 1 < data.length) {
+                        const sfLen = (data[pos] << 8) | data[pos + 1];
+                        pos += sfLen; // skip the entire structured field
+                    }
+                    break;
+                }
+                case CMD.ROLL: {
+                    pos++; // skip command byte
+                    if (pos + 1 < data.length) {
+                        const rollCC = data[pos++];
+                        const rollCount = data[pos++];
+                        // Simple roll: move content up or down
+                        // For now just mark as modified
+                        modified = true;
+                    }
+                    break;
+                }
+                default:
+                    // Not a recognized command at this position
+                    // Try treating remaining data as orders/text
+                    pos = this.parseOrders(data, pos);
+                    modified = true;
+                    break;
+            }
+        }
+        return modified;
+    }
+    /**
+     * Parse orders and text data within a WTD (or similar) command.
+     * Updates the screen buffer and returns the new position.
+     */
+    parseOrders(data, pos) {
+        let currentAddr = this.screen.offset(this.screen.cursorRow, this.screen.cursorCol);
+        let currentAttr = ATTR.NORMAL;
+        while (pos < data.length) {
+            const byte = data[pos];
+            // Check if we've hit another command byte — stop parsing orders
+            if (byte === CMD.WRITE_TO_DISPLAY || byte === CMD.CLEAR_UNIT ||
+                byte === CMD.CLEAR_FORMAT_TABLE || byte === CMD.WRITE_STRUCTURED_FIELD ||
+                byte === CMD.WRITE_ERROR_CODE || byte === CMD.ROLL) {
+                break;
+            }
+            switch (byte) {
+                case ORDER.SBA: {
+                    // Set Buffer Address: 2 bytes follow (row, col)
+                    if (pos + 2 >= data.length)
+                        return data.length;
+                    pos++;
+                    const row = data[pos++];
+                    const col = data[pos++];
+                    currentAddr = this.screen.offset(row, col);
+                    break;
+                }
+                case ORDER.IC: {
+                    // Insert Cursor: set cursor to current address
+                    pos++;
+                    const { row, col } = this.screen.toRowCol(currentAddr);
+                    this.screen.cursorRow = row;
+                    this.screen.cursorCol = col;
+                    break;
+                }
+                case ORDER.MC: {
+                    // Move Cursor: 2 bytes follow (row, col)
+                    if (pos + 2 >= data.length)
+                        return data.length;
+                    pos++;
+                    const row = data[pos++];
+                    const col = data[pos++];
+                    this.screen.cursorRow = row;
+                    this.screen.cursorCol = col;
+                    currentAddr = this.screen.offset(row, col);
+                    break;
+                }
+                case ORDER.RA: {
+                    // Repeat to Address: repeat a char up to an address
+                    if (pos + 3 >= data.length)
+                        return data.length;
+                    pos++;
+                    const toRow = data[pos++];
+                    const toCol = data[pos++];
+                    const charByte = data[pos++];
+                    const targetAddr = this.screen.offset(toRow, toCol);
+                    const ch = ebcdicToChar(charByte);
+                    while (currentAddr < targetAddr && currentAddr < this.screen.size) {
+                        this.screen.setCharAt(currentAddr, ch);
+                        currentAddr++;
+                    }
+                    break;
+                }
+                case ORDER.EA: {
+                    // Erase to Address: fill with spaces up to an address
+                    if (pos + 2 >= data.length)
+                        return data.length;
+                    pos++;
+                    const toRow = data[pos++];
+                    const toCol = data[pos++];
+                    const targetAddr = this.screen.offset(toRow, toCol);
+                    while (currentAddr < targetAddr && currentAddr < this.screen.size) {
+                        this.screen.setCharAt(currentAddr, ' ');
+                        currentAddr++;
+                    }
+                    break;
+                }
+                case ORDER.SOH: {
+                    // Start of Header: variable-length header for input fields
+                    if (pos + 1 >= data.length)
+                        return data.length;
+                    pos++;
+                    const hdrLen = data[pos++];
+                    // Skip header data (contains error line, etc.)
+                    pos += Math.max(0, hdrLen - 2); // length includes the length byte itself sometimes
+                    break;
+                }
+                case ORDER.TD: {
+                    // Transparent Data: length byte followed by raw data
+                    if (pos + 1 >= data.length)
+                        return data.length;
+                    pos++;
+                    const tdLen = data[pos++];
+                    for (let i = 0; i < tdLen && pos < data.length; i++) {
+                        this.screen.setCharAt(currentAddr++, ebcdicToChar(data[pos++]));
+                    }
+                    break;
+                }
+                case ORDER.WEA: {
+                    // Write Extended Attribute: 2 bytes (attr type + value)
+                    if (pos + 2 >= data.length)
+                        return data.length;
+                    pos++;
+                    const attrType = data[pos++];
+                    const attrValue = data[pos++];
+                    // Apply attribute at current position
+                    this.screen.setAttrAt(currentAddr, attrValue);
+                    break;
+                }
+                case ORDER.SA: {
+                    // Set Attribute: 2 bytes (attr type + value)
+                    if (pos + 2 >= data.length)
+                        return data.length;
+                    pos++;
+                    const saType = data[pos++];
+                    const saValue = data[pos++];
+                    currentAttr = saValue;
+                    break;
+                }
+                case ORDER.SF: {
+                    // Start Field: field attribute byte + FFW + optional FCW
+                    // Actually, in 5250, SF isn't always 0x1D. The field definition
+                    // comes after SBA as attribute byte (0x20-0x3F range).
+                    // But let's handle explicit SF if encountered:
+                    pos++;
+                    pos = this.parseFieldDefinition(data, pos, currentAddr, currentAttr);
+                    break;
+                }
+                default: {
+                    // Check for field attribute bytes (0x20-0x3F)
+                    if (byte >= 0x20 && byte <= 0x3F && this.isLikelyFieldAttribute(data, pos)) {
+                        pos = this.parseFieldAttribute(data, pos, currentAddr, currentAttr);
+                    }
+                    else {
+                        // Regular EBCDIC character data
+                        const ch = ebcdicToChar(byte);
+                        if (currentAddr < this.screen.size) {
+                            this.screen.setCharAt(currentAddr, ch);
+                            this.screen.setAttrAt(currentAddr, currentAttr);
+                            currentAddr++;
+                        }
+                        pos++;
+                    }
+                    break;
+                }
+            }
+        }
+        return pos;
+    }
+    /** Try to detect if a byte in the 0x20-0x3F range is a field attribute vs regular character */
+    isLikelyFieldAttribute(data, pos) {
+        // Field attributes in 5250 are typically preceded by SBA and followed by FFW bytes
+        // This is a heuristic — in practice, the WTD command structure makes this deterministic
+        // For the 0x20 byte specifically, it's also EBCDIC space, so we need context
+        const byte = data[pos];
+        // 0x20 is very common as both space and attribute — don't treat as field attr
+        if (byte === 0x20)
+            return false;
+        // For other bytes in 0x21-0x3F range, check if followed by FFW-like bytes
+        if (pos + 2 < data.length) {
+            const next = data[pos + 1];
+            const after = data[pos + 2];
+            // FFW first byte typically has specific bit patterns
+            // If followed by reasonable FFW bytes, treat as field attribute
+            return (next & 0x40) !== 0 || next === 0x00;
+        }
+        return false;
+    }
+    /** Parse a field attribute byte and the following FFW/FCW */
+    parseFieldAttribute(data, pos, addr, displayAttr) {
+        const attrByte = data[pos++];
+        // The attribute byte occupies a position on screen (but is not displayed)
+        // Mark this position with the attribute
+        if (addr < this.screen.size) {
+            this.screen.setCharAt(addr, ' '); // Attribute position shows as space
+        }
+        // Parse FFW (Field Format Word) — 2 bytes
+        if (pos + 1 >= data.length)
+            return pos;
+        const ffw1 = data[pos++];
+        const ffw2 = data[pos++];
+        // Check for FCW (Field Control Word) — optional, 2 bytes
+        let fcw1 = 0, fcw2 = 0;
+        if (pos + 1 < data.length) {
+            // FCW is present if the first byte has bit 7 set and is not another order
+            const maybeFcw = data[pos];
+            if (maybeFcw >= 0x80 && maybeFcw !== 0xFF) {
+                fcw1 = data[pos++];
+                fcw2 = data[pos++];
+            }
+        }
+        // Determine field length: from current position to next field attribute or end of screen
+        // We'll calculate it later when all fields are known; for now use a placeholder
+        const fieldStartAddr = addr + 1; // Field data starts after the attribute byte
+        const { row, col } = this.screen.toRowCol(fieldStartAddr);
+        // Determine display attribute from the attribute byte
+        let fieldDisplayAttr = displayAttr;
+        // Map attribute byte to display characteristics
+        if (attrByte & 0x04)
+            fieldDisplayAttr = ATTR.UNDERSCORE;
+        if (attrByte & 0x08)
+            fieldDisplayAttr = ATTR.HIGH_INTENSITY;
+        if (attrByte & 0x01)
+            fieldDisplayAttr = ATTR.REVERSE;
+        if (attrByte === 0x27 || (attrByte & 0x07) === 0x07)
+            fieldDisplayAttr = ATTR.NON_DISPLAY;
+        const field = {
+            row,
+            col,
+            length: 0, // Will be calculated
+            ffw1,
+            ffw2,
+            fcw1,
+            fcw2,
+            attribute: fieldDisplayAttr,
+            modified: false,
+        };
+        this.screen.fields.push(field);
+        return pos;
+    }
+    /** Parse explicit SF order field definition */
+    parseFieldDefinition(data, pos, addr, displayAttr) {
+        // Similar to parseFieldAttribute but for explicit SF order
+        return this.parseFieldAttribute(data, pos - 1, addr, displayAttr);
+    }
+    /**
+     * After parsing a complete screen, calculate field lengths.
+     * Call this after all records for a screen have been parsed.
+     */
+    calculateFieldLengths() {
+        const fields = this.screen.fields;
+        if (fields.length === 0)
+            return;
+        for (let i = 0; i < fields.length; i++) {
+            const current = fields[i];
+            const currentStart = this.screen.offset(current.row, current.col);
+            if (i + 1 < fields.length) {
+                const next = fields[i + 1];
+                const nextStart = this.screen.offset(next.row, next.col);
+                // Length extends to just before the next field's attribute byte
+                // (the attribute byte is 1 position before the next field's start)
+                current.length = Math.max(0, nextStart - currentStart - 1);
+            }
+            else {
+                // Last field extends to end of screen or a reasonable default
+                const endAddr = this.screen.size;
+                current.length = Math.max(0, endAddr - currentStart);
+                // Cap at a reasonable maximum
+                if (current.length > this.screen.cols * 2) {
+                    current.length = this.screen.cols - current.col;
+                }
+            }
+            // Ensure minimum length of 1
+            if (current.length <= 0)
+                current.length = 1;
+        }
+    }
+}

package/dist/tn5250/screen.d.ts

@@ -0,0 +1,80 @@
+export interface FieldDef {
+    row: number;
+    col: number;
+    length: number;
+    ffw1: number;
+    ffw2: number;
+    fcw1: number;
+    fcw2: number;
+    attribute: number;
+    modified: boolean;
+}
+export declare class ScreenBuffer {
+    rows: number;
+    cols: number;
+    /** Character buffer stored as UTF-8 characters */
+    buffer: string[];
+    /** Attribute buffer (display attribute per cell) */
+    attrBuffer: number[];
+    fields: FieldDef[];
+    cursorRow: number;
+    cursorCol: number;
+    constructor(rows?: 24, cols?: 80);
+    get size(): number;
+    /** Convert row,col to linear offset */
+    offset(row: number, col: number): number;
+    /** Convert linear offset to row,col */
+    toRowCol(offset: number): {
+        row: number;
+        col: number;
+    };
+    /** Set a character at row,col */
+    setChar(row: number, col: number, char: string): void;
+    /** Get a character at row,col */
+    getChar(row: number, col: number): string;
+    /** Set attribute at row,col */
+    setAttr(row: number, col: number, attr: number): void;
+    /** Set character at a linear address */
+    setCharAt(addr: number, char: string): void;
+    /** Set attribute at a linear address */
+    setAttrAt(addr: number, attr: number): void;
+    /** Clear the entire screen */
+    clear(): void;
+    /** Fill range [start, end) with a character */
+    fillRange(start: number, end: number, char: string): void;
+    /** Get the content of a field as a string */
+    getFieldValue(field: FieldDef): string;
+    /** Set the content of a field */
+    setFieldValue(field: FieldDef, value: string): void;
+    /** Find the field at cursor position */
+    getFieldAtCursor(): FieldDef | null;
+    /** Find the field containing a given position */
+    getFieldAt(row: number, col: number): FieldDef | null;
+    /** Whether a field is an input field (not bypass/protected) */
+    isInputField(field: FieldDef): boolean;
+    /** Whether a field is highlighted (high intensity) */
+    isHighlighted(field: FieldDef): boolean;
+    /** Whether a field is reverse video */
+    isReverse(field: FieldDef): boolean;
+    /** Whether a field is non-display (password) */
+    isNonDisplay(field: FieldDef): boolean;
+    /** Convert screen buffer to the ScreenData format expected by the frontend */
+    toScreenData(): {
+        content: string;
+        cursor_row: number;
+        cursor_col: number;
+        rows: number;
+        cols: number;
+        fields: Array<{
+            row: number;
+            col: number;
+            length: number;
+            is_input: boolean;
+            is_protected: boolean;
+            is_highlighted?: boolean;
+            is_reverse?: boolean;
+        }>;
+        screen_signature: string;
+        timestamp: string;
+    };
+}