green-screen-proxy 0.3.0

package/dist/tn3270/parser.js

@@ -0,0 +1,284 @@
+import { CMD, SNA_CMD, ORDER, FA, EXT_ATTR, decodeAddress } from './constants.js';
+import { ebcdicToChar } from '../tn5250/ebcdic.js';
+/**
+ * Parses 3270 data stream records and updates the screen buffer.
+ */
+export class TN3270Parser {
+    screen;
+    constructor(screen) {
+        this.screen = screen;
+    }
+    /**
+     * Parse a 3270 data stream record.
+     * Returns true if the screen was modified.
+     */
+    parseRecord(record) {
+        if (record.length < 1)
+            return false;
+        const cmd = record[0];
+        let modified = false;
+        switch (cmd) {
+            case CMD.WRITE:
+            case SNA_CMD.WRITE:
+                modified = this.parseWrite(record, 1, false);
+                break;
+            case CMD.ERASE_WRITE:
+            case SNA_CMD.ERASE_WRITE:
+                this.screen.clear();
+                modified = this.parseWrite(record, 1, false);
+                break;
+            case CMD.ERASE_WRITE_ALTERNATE:
+            case SNA_CMD.ERASE_WRITE_ALTERNATE:
+                this.screen.clear();
+                modified = this.parseWrite(record, 1, false);
+                break;
+            case CMD.ERASE_ALL_UNPROTECTED:
+            case SNA_CMD.ERASE_ALL_UNPROTECTED:
+                this.screen.clearUnprotected();
+                modified = true;
+                break;
+            case CMD.WRITE_STRUCTURED_FIELD:
+            case SNA_CMD.WRITE_STRUCTURED_FIELD:
+                // Structured fields — parse each SF
+                modified = this.parseStructuredFields(record, 1);
+                break;
+            case CMD.READ_BUFFER:
+            case CMD.READ_MODIFIED:
+            case CMD.READ_MODIFIED_ALL:
+            case SNA_CMD.READ_BUFFER:
+            case SNA_CMD.READ_MODIFIED:
+            case SNA_CMD.READ_MODIFIED_ALL:
+                // Read commands — don't modify screen, but may need to trigger a response
+                // Handled at the handler level
+                break;
+            default:
+                // Try parsing as a write command anyway (some servers omit the command byte)
+                if (record.length > 1) {
+                    modified = this.parseWrite(record, 0, true);
+                }
+                break;
+        }
+        if (modified) {
+            this.screen.rebuildFields();
+        }
+        return modified;
+    }
+    /**
+     * Parse a Write or Erase/Write command body.
+     * Starts at `offset` which points to the WCC byte.
+     */
+    parseWrite(data, offset, skipWCC) {
+        let pos = offset;
+        // Parse WCC (Write Control Character)
+        if (!skipWCC && pos < data.length) {
+            const wcc = data[pos++];
+            // WCC bit 0: reset MDT flags
+            if (wcc & 0x01) {
+                for (const field of this.screen.fields) {
+                    field.modified = false;
+                    // Clear MDT bit in attribute buffer too
+                    const attr = this.screen.attrBuffer[field.attrAddr];
+                    if (attr !== 0) {
+                        this.screen.attrBuffer[field.attrAddr] = attr & ~FA.MDT;
+                    }
+                }
+            }
+        }
+        let modified = false;
+        // Parse orders and data
+        while (pos < data.length) {
+            const byte = data[pos];
+            switch (byte) {
+                case ORDER.SBA: {
+                    // Set Buffer Address: 2 address bytes follow
+                    if (pos + 2 >= data.length)
+                        return modified;
+                    pos++;
+                    const addr = decodeAddress(data[pos], data[pos + 1]);
+                    pos += 2;
+                    this.screen.currentAddr = addr % this.screen.size;
+                    break;
+                }
+                case ORDER.SF: {
+                    // Start Field: 1 attribute byte follows
+                    if (pos + 1 >= data.length)
+                        return modified;
+                    pos++;
+                    const attr = data[pos++];
+                    this.screen.setFieldAttribute(this.screen.currentAddr, attr);
+                    this.screen.currentAddr = (this.screen.currentAddr + 1) % this.screen.size;
+                    modified = true;
+                    break;
+                }
+                case ORDER.SFE: {
+                    // Start Field Extended: pair count, then (type, value) pairs
+                    if (pos + 1 >= data.length)
+                        return modified;
+                    pos++;
+                    const pairCount = data[pos++];
+                    let fieldAttr = 0;
+                    let extHighlight = 0;
+                    let extColor = 0;
+                    for (let i = 0; i < pairCount && pos + 1 < data.length; i++) {
+                        const attrType = data[pos++];
+                        const attrValue = data[pos++];
+                        if (attrType === 0xC0) {
+                            // Basic field attribute
+                            fieldAttr = attrValue;
+                        }
+                        else if (attrType === EXT_ATTR.HIGHLIGHT) {
+                            extHighlight = attrValue;
+                        }
+                        else if (attrType === EXT_ATTR.COLOR) {
+                            extColor = attrValue;
+                        }
+                        // Other extended attributes ignored for now
+                    }
+                    this.screen.setFieldAttribute(this.screen.currentAddr, fieldAttr || FA.PROTECTED);
+                    this.screen.highlightBuffer[this.screen.currentAddr] = extHighlight;
+                    this.screen.colorBuffer[this.screen.currentAddr] = extColor;
+                    this.screen.currentAddr = (this.screen.currentAddr + 1) % this.screen.size;
+                    modified = true;
+                    break;
+                }
+                case ORDER.SA: {
+                    // Set Attribute: type + value
+                    if (pos + 2 >= data.length)
+                        return modified;
+                    pos++;
+                    const saType = data[pos++];
+                    const saValue = data[pos++];
+                    // SA affects subsequent characters until next SA/SF
+                    if (saType === EXT_ATTR.HIGHLIGHT) {
+                        this.screen.highlightBuffer[this.screen.currentAddr] = saValue;
+                    }
+                    else if (saType === EXT_ATTR.COLOR) {
+                        this.screen.colorBuffer[this.screen.currentAddr] = saValue;
+                    }
+                    break;
+                }
+                case ORDER.MF: {
+                    // Modify Field: pair count, then (type, value) pairs
+                    if (pos + 1 >= data.length)
+                        return modified;
+                    pos++;
+                    const mfPairCount = data[pos++];
+                    for (let i = 0; i < mfPairCount && pos + 1 < data.length; i++) {
+                        pos += 2; // Skip type + value
+                    }
+                    break;
+                }
+                case ORDER.IC: {
+                    // Insert Cursor: set cursor to current buffer address
+                    pos++;
+                    this.screen.cursorAddr = this.screen.currentAddr;
+                    break;
+                }
+                case ORDER.PT: {
+                    // Program Tab: advance to next unprotected field
+                    pos++;
+                    this.advanceToNextUnprotected();
+                    break;
+                }
+                case ORDER.RA: {
+                    // Repeat to Address: 2 address bytes + 1 char byte
+                    if (pos + 3 >= data.length)
+                        return modified;
+                    pos++;
+                    const targetAddr = decodeAddress(data[pos], data[pos + 1]);
+                    pos += 2;
+                    const charByte = data[pos++];
+                    let repeatChar;
+                    if (charByte === ORDER.GE && pos < data.length) {
+                        // Graphic escape — next byte is an APL/graphic char
+                        repeatChar = ebcdicToChar(data[pos++]);
+                    }
+                    else {
+                        repeatChar = ebcdicToChar(charByte);
+                    }
+                    const target = targetAddr % this.screen.size;
+                    let addr = this.screen.currentAddr;
+                    while (addr !== target) {
+                        this.screen.setCharAt(addr, repeatChar);
+                        addr = (addr + 1) % this.screen.size;
+                    }
+                    this.screen.currentAddr = target;
+                    modified = true;
+                    break;
+                }
+                case ORDER.EUA: {
+                    // Erase Unprotected to Address: 2 address bytes
+                    if (pos + 2 >= data.length)
+                        return modified;
+                    pos++;
+                    const euaTarget = decodeAddress(data[pos], data[pos + 1]);
+                    pos += 2;
+                    const euaEnd = euaTarget % this.screen.size;
+                    let euaAddr = this.screen.currentAddr;
+                    while (euaAddr !== euaEnd) {
+                        // Only erase if position is in an unprotected field
+                        const field = this.screen.getFieldAt(euaAddr);
+                        if (field && !this.screen.isProtected(field)) {
+                            this.screen.setCharAt(euaAddr, ' ');
+                        }
+                        euaAddr = (euaAddr + 1) % this.screen.size;
+                    }
+                    this.screen.currentAddr = euaEnd;
+                    modified = true;
+                    break;
+                }
+                case ORDER.GE: {
+                    // Graphic Escape: next byte is a graphic character
+                    pos++;
+                    if (pos < data.length) {
+                        const geChar = ebcdicToChar(data[pos++]);
+                        this.screen.setCharAt(this.screen.currentAddr, geChar);
+                        this.screen.currentAddr = (this.screen.currentAddr + 1) % this.screen.size;
+                        modified = true;
+                    }
+                    break;
+                }
+                default: {
+                    // Regular EBCDIC character data
+                    const ch = ebcdicToChar(byte);
+                    this.screen.setCharAt(this.screen.currentAddr, ch);
+                    this.screen.currentAddr = (this.screen.currentAddr + 1) % this.screen.size;
+                    pos++;
+                    modified = true;
+                    break;
+                }
+            }
+        }
+        return modified;
+    }
+    /** Parse structured fields */
+    parseStructuredFields(data, offset) {
+        let pos = offset;
+        let modified = false;
+        while (pos + 2 < data.length) {
+            const sfLen = (data[pos] << 8) | data[pos + 1];
+            if (sfLen < 3 || pos + sfLen > data.length)
+                break;
+            // Skip the structured field (we may implement query reply later)
+            pos += sfLen;
+            modified = true;
+        }
+        return modified;
+    }
+    /** Advance cursor to the start of the next unprotected field */
+    advanceToNextUnprotected() {
+        const startAddr = this.screen.currentAddr;
+        let addr = (startAddr + 1) % this.screen.size;
+        while (addr !== startAddr) {
+            // Check if there's a field attribute at this position
+            if (this.screen.attrBuffer[addr] !== 0) {
+                const field = this.screen.fields.find(f => f.attrAddr === addr);
+                if (field && !this.screen.isProtected(field)) {
+                    this.screen.currentAddr = field.startAddr;
+                    return;
+                }
+            }
+            addr = (addr + 1) % this.screen.size;
+        }
+    }
+}

package/dist/tn3270/screen.d.ts

@@ -0,0 +1,89 @@
+export interface FieldDef3270 {
+    /** Buffer address where the field attribute byte is */
+    attrAddr: number;
+    /** Buffer address where the field data starts (attrAddr + 1) */
+    startAddr: number;
+    /** Field attribute byte */
+    attribute: number;
+    /** Extended attributes (highlight, color, etc.) */
+    extHighlight: number;
+    extColor: number;
+    /** Length of the field data (not including attribute byte) */
+    length: number;
+    /** Whether the MDT (Modified Data Tag) is set */
+    modified: boolean;
+}
+export declare class ScreenBuffer3270 {
+    rows: number;
+    cols: number;
+    /** Character buffer (EBCDIC decoded to UTF-8) */
+    buffer: string[];
+    /** Field attribute at each position (0 = no field attribute here) */
+    attrBuffer: number[];
+    /** Extended highlight per cell */
+    highlightBuffer: number[];
+    /** Extended color per cell */
+    colorBuffer: number[];
+    /** Field definitions */
+    fields: FieldDef3270[];
+    cursorAddr: number;
+    /** Current buffer address for write operations */
+    currentAddr: number;
+    constructor(rows?: 24, cols?: 80);
+    get size(): number;
+    get cursorRow(): number;
+    get cursorCol(): number;
+    addrToRowCol(addr: number): {
+        row: number;
+        col: number;
+    };
+    rowColToAddr(row: number, col: number): number;
+    /** Clear entire screen */
+    clear(): void;
+    /** Clear all unprotected fields */
+    clearUnprotected(): void;
+    /** Set character at buffer address */
+    setCharAt(addr: number, char: string): void;
+    /** Get character at buffer address */
+    getCharAt(addr: number): string;
+    /** Place a field attribute at an address */
+    setFieldAttribute(addr: number, attr: number): void;
+    /** Check if field is protected */
+    isProtected(field: FieldDef3270): boolean;
+    /** Check if field is numeric */
+    isNumeric(field: FieldDef3270): boolean;
+    /** Check if field is hidden (non-display) */
+    isHidden(field: FieldDef3270): boolean;
+    /** Check if field is intensified */
+    isIntensified(field: FieldDef3270): boolean;
+    /** Get the field containing the given address */
+    getFieldAt(addr: number): FieldDef3270 | null;
+    /** Get the field at cursor position */
+    getFieldAtCursor(): FieldDef3270 | null;
+    /** Get field value as string */
+    getFieldValue(field: FieldDef3270): string;
+    /**
+     * Rebuild field list from attribute bytes in the buffer.
+     * Called after processing a write command.
+     */
+    rebuildFields(): void;
+    /** Convert to protocol-agnostic ScreenData for the frontend */
+    toScreenData(): {
+        content: string;
+        cursor_row: number;
+        cursor_col: number;
+        rows: number;
+        cols: number;
+        fields: {
+            row: number;
+            col: number;
+            length: number;
+            is_input: boolean;
+            is_protected: boolean;
+            is_highlighted: true | undefined;
+            is_reverse: undefined;
+        }[];
+        screen_signature: string;
+        timestamp: string;
+    };
+}

package/dist/tn3270/screen.js

@@ -0,0 +1,207 @@
+import { createHash } from 'crypto';
+import { FA, SCREEN } from './constants.js';
+export class ScreenBuffer3270 {
+    rows;
+    cols;
+    /** Character buffer (EBCDIC decoded to UTF-8) */
+    buffer;
+    /** Field attribute at each position (0 = no field attribute here) */
+    attrBuffer;
+    /** Extended highlight per cell */
+    highlightBuffer;
+    /** Extended color per cell */
+    colorBuffer;
+    /** Field definitions */
+    fields = [];
+    cursorAddr = 0;
+    /** Current buffer address for write operations */
+    currentAddr = 0;
+    constructor(rows = SCREEN.MODEL_2_ROWS, cols = SCREEN.MODEL_2_COLS) {
+        this.rows = rows;
+        this.cols = cols;
+        const size = rows * cols;
+        this.buffer = new Array(size).fill(' ');
+        this.attrBuffer = new Array(size).fill(0);
+        this.highlightBuffer = new Array(size).fill(0);
+        this.colorBuffer = new Array(size).fill(0);
+    }
+    get size() {
+        return this.rows * this.cols;
+    }
+    get cursorRow() {
+        return Math.floor(this.cursorAddr / this.cols);
+    }
+    get cursorCol() {
+        return this.cursorAddr % this.cols;
+    }
+    addrToRowCol(addr) {
+        return {
+            row: Math.floor(addr / this.cols),
+            col: addr % this.cols,
+        };
+    }
+    rowColToAddr(row, col) {
+        return row * this.cols + col;
+    }
+    /** Clear entire screen */
+    clear() {
+        this.buffer.fill(' ');
+        this.attrBuffer.fill(0);
+        this.highlightBuffer.fill(0);
+        this.colorBuffer.fill(0);
+        this.fields = [];
+        this.cursorAddr = 0;
+        this.currentAddr = 0;
+    }
+    /** Clear all unprotected fields */
+    clearUnprotected() {
+        for (const field of this.fields) {
+            if (!this.isProtected(field)) {
+                for (let i = 0; i < field.length; i++) {
+                    const addr = (field.startAddr + i) % this.size;
+                    this.buffer[addr] = ' ';
+                }
+                field.modified = false;
+            }
+        }
+    }
+    /** Set character at buffer address */
+    setCharAt(addr, char) {
+        const a = addr % this.size;
+        this.buffer[a] = char;
+    }
+    /** Get character at buffer address */
+    getCharAt(addr) {
+        return this.buffer[addr % this.size];
+    }
+    /** Place a field attribute at an address */
+    setFieldAttribute(addr, attr) {
+        const a = addr % this.size;
+        this.attrBuffer[a] = attr;
+        this.buffer[a] = ' '; // attribute byte displays as space
+    }
+    /** Check if field is protected */
+    isProtected(field) {
+        return (field.attribute & FA.PROTECTED) !== 0;
+    }
+    /** Check if field is numeric */
+    isNumeric(field) {
+        return (field.attribute & FA.NUMERIC) !== 0;
+    }
+    /** Check if field is hidden (non-display) */
+    isHidden(field) {
+        return (field.attribute & FA.DISPLAY_MASK) === FA.DISPLAY_HIDDEN;
+    }
+    /** Check if field is intensified */
+    isIntensified(field) {
+        return (field.attribute & FA.DISPLAY_MASK) === FA.DISPLAY_INTENSIFIED;
+    }
+    /** Get the field containing the given address */
+    getFieldAt(addr) {
+        for (const field of this.fields) {
+            const start = field.startAddr;
+            const end = (start + field.length) % this.size;
+            if (start <= end) {
+                if (addr >= start && addr < end)
+                    return field;
+            }
+            else {
+                // Field wraps around screen
+                if (addr >= start || addr < end)
+                    return field;
+            }
+        }
+        return null;
+    }
+    /** Get the field at cursor position */
+    getFieldAtCursor() {
+        return this.getFieldAt(this.cursorAddr);
+    }
+    /** Get field value as string */
+    getFieldValue(field) {
+        let value = '';
+        for (let i = 0; i < field.length; i++) {
+            value += this.buffer[(field.startAddr + i) % this.size];
+        }
+        return value;
+    }
+    /**
+     * Rebuild field list from attribute bytes in the buffer.
+     * Called after processing a write command.
+     */
+    rebuildFields() {
+        this.fields = [];
+        const attrPositions = [];
+        // Find all field attribute positions
+        for (let i = 0; i < this.size; i++) {
+            if (this.attrBuffer[i] !== 0) {
+                attrPositions.push(i);
+            }
+        }
+        if (attrPositions.length === 0)
+            return;
+        // Build fields: each field goes from (attrPos + 1) to the next attrPos
+        for (let i = 0; i < attrPositions.length; i++) {
+            const attrAddr = attrPositions[i];
+            const startAddr = (attrAddr + 1) % this.size;
+            const nextAttrAddr = attrPositions[(i + 1) % attrPositions.length];
+            let length;
+            if (i + 1 < attrPositions.length) {
+                length = nextAttrAddr - startAddr;
+                if (length < 0)
+                    length += this.size;
+            }
+            else if (attrPositions.length > 1) {
+                // Last field wraps to first attribute
+                length = attrPositions[0] - startAddr;
+                if (length < 0)
+                    length += this.size;
+            }
+            else {
+                // Single field covers entire screen minus 1
+                length = this.size - 1;
+            }
+            this.fields.push({
+                attrAddr,
+                startAddr,
+                attribute: this.attrBuffer[attrAddr],
+                extHighlight: 0,
+                extColor: 0,
+                length,
+                modified: (this.attrBuffer[attrAddr] & FA.MDT) !== 0,
+            });
+        }
+    }
+    /** Convert to protocol-agnostic ScreenData for the frontend */
+    toScreenData() {
+        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');
+        const fields = this.fields.map(f => {
+            const { row, col } = this.addrToRowCol(f.startAddr);
+            return {
+                row,
+                col,
+                length: f.length,
+                is_input: !this.isProtected(f),
+                is_protected: this.isProtected(f),
+                is_highlighted: this.isIntensified(f) || undefined,
+                is_reverse: undefined,
+            };
+        });
+        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/tn5250/connection.d.ts

@@ -0,0 +1,41 @@
+import { EventEmitter } from 'events';
+export interface ConnectionEvents {
+    connected: () => void;
+    disconnected: () => void;
+    data: (record: Buffer) => void;
+    error: (err: Error) => void;
+}
+/**
+ * Manages raw TCP socket to IBM i, handles Telnet negotiation,
+ * and extracts 5250 data records (delimited by IAC EOR).
+ */
+export declare class TN5250Connection extends EventEmitter {
+    private socket;
+    private host;
+    private port;
+    private connected;
+    private recvBuffer;
+    private negotiationDone;
+    get isConnected(): boolean;
+    get remoteHost(): string;
+    get remotePort(): number;
+    connect(host: string, port: number): Promise<void>;
+    disconnect(): void;
+    /** Send raw bytes over the socket */
+    sendRaw(data: Buffer): void;
+    private cleanup;
+    private onData;
+    private processBuffer;
+    /** Find IAC SE sequence for subnegotiation end */
+    private findSubnegEnd;
+    /** Find IAC EOR (end of 5250 record) */
+    private findRecordEnd;
+    /** Remove IAC IAC escaping from data */
+    private unescapeIAC;
+    private handleNegotiation;
+    private handleSubnegotiation;
+    private sendTerminalType;
+    private sendEnviron;
+    private handleTN5250ESubneg;
+    private sendTelnet;
+}