green-screen-proxy 0.3.0

package/dist/tn5250/connection.js

@@ -0,0 +1,254 @@
+import * as net from 'net';
+import { EventEmitter } from 'events';
+import { TELNET, TERMINAL_TYPE } from './constants.js';
+/**
+ * Manages raw TCP socket to IBM i, handles Telnet negotiation,
+ * and extracts 5250 data records (delimited by IAC EOR).
+ */
+export class TN5250Connection extends EventEmitter {
+    socket = null;
+    host = '';
+    port = 23;
+    connected = false;
+    recvBuffer = Buffer.alloc(0);
+    negotiationDone = false;
+    get isConnected() {
+        return this.connected;
+    }
+    get remoteHost() {
+        return this.host;
+    }
+    get remotePort() {
+        return this.port;
+    }
+    connect(host, port) {
+        return new Promise((resolve, reject) => {
+            if (this.socket) {
+                this.disconnect();
+            }
+            this.host = host;
+            this.port = port;
+            this.recvBuffer = Buffer.alloc(0);
+            this.negotiationDone = false;
+            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) {
+        // Append to receive buffer
+        this.recvBuffer = Buffer.concat([this.recvBuffer, data]);
+        // Process all complete messages in the buffer
+        this.processBuffer();
+    }
+    processBuffer() {
+        while (this.recvBuffer.length > 0) {
+            // Check for Telnet commands (IAC ...)
+            if (this.recvBuffer[0] === TELNET.IAC && this.recvBuffer.length >= 2) {
+                const cmd = this.recvBuffer[1];
+                // IAC IAC = escaped 0xFF byte (part of data, not a command)
+                if (cmd === TELNET.IAC) {
+                    // This is data, not a command — handled below with record extraction
+                    break;
+                }
+                // Subnegotiation: IAC SB ... IAC SE
+                if (cmd === TELNET.SB) {
+                    const seIdx = this.findSubnegEnd();
+                    if (seIdx === -1)
+                        return; // Wait for more data
+                    const subData = this.recvBuffer.subarray(2, seIdx);
+                    this.recvBuffer = this.recvBuffer.subarray(seIdx + 2); // skip IAC SE
+                    this.handleSubnegotiation(subData);
+                    continue;
+                }
+                // DO/DONT/WILL/WONT: 3 bytes
+                if (cmd === TELNET.DO || cmd === TELNET.DONT || cmd === TELNET.WILL || cmd === TELNET.WONT) {
+                    if (this.recvBuffer.length < 3)
+                        return; // Wait for option byte
+                    const option = this.recvBuffer[2];
+                    this.recvBuffer = this.recvBuffer.subarray(3);
+                    this.handleNegotiation(cmd, option);
+                    continue;
+                }
+                // Other IAC commands (EOR handled in record extraction below)
+                if (cmd === TELNET.EOR) {
+                    // Should not happen here at start of buffer in isolation
+                    this.recvBuffer = this.recvBuffer.subarray(2);
+                    continue;
+                }
+                // Unknown 2-byte IAC command, skip
+                this.recvBuffer = this.recvBuffer.subarray(2);
+                continue;
+            }
+            // Extract a 5250 record: data terminated by IAC EOR
+            const recordEnd = this.findRecordEnd();
+            if (recordEnd === -1)
+                return; // Wait for more data
+            // Extract the record data (removing IAC EOR and unescaping IAC IAC)
+            const rawRecord = this.recvBuffer.subarray(0, recordEnd);
+            this.recvBuffer = this.recvBuffer.subarray(recordEnd + 2); // skip IAC EOR
+            const record = this.unescapeIAC(rawRecord);
+            if (record.length > 0) {
+                this.emit('data', record);
+            }
+            continue;
+        }
+    }
+    /** Find IAC SE sequence for subnegotiation end */
+    findSubnegEnd() {
+        for (let i = 2; i < this.recvBuffer.length - 1; i++) {
+            if (this.recvBuffer[i] === TELNET.IAC && this.recvBuffer[i + 1] === TELNET.SE) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    /** Find IAC EOR (end of 5250 record) */
+    findRecordEnd() {
+        for (let i = 0; i < this.recvBuffer.length - 1; i++) {
+            if (this.recvBuffer[i] === TELNET.IAC && this.recvBuffer[i + 1] === TELNET.EOR) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    /** Remove IAC IAC escaping from data */
+    unescapeIAC(data) {
+        const result = [];
+        for (let i = 0; i < data.length; i++) {
+            if (data[i] === TELNET.IAC && i + 1 < data.length && data[i + 1] === TELNET.IAC) {
+                result.push(TELNET.IAC);
+                i++; // skip doubled IAC
+            }
+            else {
+                result.push(data[i]);
+            }
+        }
+        return Buffer.from(result);
+    }
+    handleNegotiation(cmd, option) {
+        switch (cmd) {
+            case TELNET.DO:
+                // Server asks us to enable something
+                if (option === TELNET.OPT_TTYPE ||
+                    option === TELNET.OPT_EOR ||
+                    option === TELNET.OPT_BINARY ||
+                    option === TELNET.OPT_NEW_ENVIRON ||
+                    option === TELNET.OPT_TN5250E) {
+                    this.sendTelnet(TELNET.WILL, option);
+                }
+                else {
+                    this.sendTelnet(TELNET.WONT, option);
+                }
+                break;
+            case TELNET.WILL:
+                // Server offers to enable something
+                if (option === TELNET.OPT_EOR ||
+                    option === TELNET.OPT_BINARY ||
+                    option === TELNET.OPT_TN5250E) {
+                    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) {
+            // Server asks for terminal type — respond with our type
+            this.sendTerminalType();
+        }
+        else if (option === TELNET.OPT_NEW_ENVIRON) {
+            // Server asks for environment variables — send empty response
+            this.sendEnviron(data);
+        }
+        else if (option === TELNET.OPT_TN5250E) {
+            // TN5250E subnegotiation — handle device name etc.
+            this.handleTN5250ESubneg(data);
+        }
+    }
+    sendTerminalType() {
+        const typeStr = TERMINAL_TYPE;
+        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);
+    }
+    sendEnviron(data) {
+        // Send empty NEW-ENVIRON response
+        const buf = Buffer.from([
+            TELNET.IAC, TELNET.SB, TELNET.OPT_NEW_ENVIRON,
+            0x00, // IS
+            TELNET.IAC, TELNET.SE,
+        ]);
+        this.sendRaw(buf);
+    }
+    handleTN5250ESubneg(data) {
+        // For TN5250E, we may need to send device info
+        // Minimal: just acknowledge. Most servers work with basic TTYPE negotiation.
+        // The actual device name negotiation via TN5250E is optional.
+    }
+    sendTelnet(cmd, option) {
+        this.sendRaw(Buffer.from([TELNET.IAC, cmd, option]));
+    }
+}

package/dist/tn5250/constants.d.ts

@@ -0,0 +1,128 @@
+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 EOR: 239;
+    readonly NOP: 241;
+    readonly OPT_BINARY: 0;
+    readonly OPT_ECHO: 1;
+    readonly OPT_SGA: 3;
+    readonly OPT_TTYPE: 24;
+    readonly OPT_EOR: 25;
+    readonly OPT_NAWS: 31;
+    readonly OPT_NEW_ENVIRON: 39;
+    readonly OPT_TN5250E: 40;
+    readonly TTYPE_IS: 0;
+    readonly TTYPE_SEND: 1;
+};
+export declare const RECORD_TYPE: {
+    readonly GDS: 4768;
+};
+export declare const OPCODE: {
+    readonly NO_OP: 0;
+    readonly INVITE: 1;
+    readonly OUTPUT: 2;
+    readonly PUT_GET: 3;
+    readonly SAVE_SCREEN: 4;
+    readonly RESTORE_SCREEN: 5;
+    readonly READ_IMMEDIATE: 6;
+    readonly RESERVED: 7;
+    readonly READ_SCREEN: 8;
+    readonly CANCEL_INVITE: 10;
+    readonly TURN_ON_MSG_LIGHT: 11;
+    readonly TURN_OFF_MSG_LIGHT: 12;
+};
+export declare const CMD: {
+    readonly CLEAR_UNIT: 64;
+    readonly CLEAR_FORMAT_TABLE: 80;
+    readonly CLEAR_UNIT_ALT: 32;
+    readonly WRITE_TO_DISPLAY: 17;
+    readonly WRITE_ERROR_CODE: 33;
+    readonly WRITE_ERROR_CODE_WIN: 34;
+    readonly READ_MDT_FIELDS: 82;
+    readonly READ_INPUT_FIELDS: 66;
+    readonly READ_IMMEDIATE: 114;
+    readonly WRITE_STRUCTURED_FIELD: 243;
+    readonly SAVE_SCREEN: 2;
+    readonly RESTORE_SCREEN: 18;
+    readonly ROLL: 35;
+};
+export declare const ORDER: {
+    readonly SBA: 17;
+    readonly IC: 19;
+    readonly MC: 20;
+    readonly RA: 2;
+    readonly EA: 3;
+    readonly SOH: 1;
+    readonly TD: 16;
+    readonly WEA: 4;
+    readonly SF: 29;
+    readonly SA: 40;
+};
+export declare const AID: {
+    readonly ENTER: 241;
+    readonly F1: 49;
+    readonly F2: 50;
+    readonly F3: 51;
+    readonly F4: 52;
+    readonly F5: 53;
+    readonly F6: 54;
+    readonly F7: 55;
+    readonly F8: 56;
+    readonly F9: 57;
+    readonly F10: 58;
+    readonly F11: 59;
+    readonly F12: 60;
+    readonly F13: 177;
+    readonly F14: 178;
+    readonly F15: 179;
+    readonly F16: 180;
+    readonly F17: 181;
+    readonly F18: 182;
+    readonly F19: 183;
+    readonly F20: 184;
+    readonly F21: 185;
+    readonly F22: 186;
+    readonly F23: 187;
+    readonly F24: 188;
+    readonly PAGE_UP: 244;
+    readonly PAGE_DOWN: 245;
+    readonly CLEAR: 189;
+    readonly HELP: 243;
+    readonly PRINT: 246;
+    readonly RECORD_BACKSPACE: 248;
+    readonly SYS_REQUEST: 1;
+};
+export declare const KEY_TO_AID: Record<string, number>;
+export declare const FFW: {
+    readonly BYPASS: 32;
+    readonly DUP_ENABLE: 16;
+    readonly MDT: 8;
+    readonly SHIFT_MASK: 7;
+    readonly AUTO_ENTER: 128;
+    readonly FER: 64;
+    readonly MONOCASE: 32;
+    readonly MANDATORY_ENTRY: 8;
+    readonly RIGHT_ADJUST_MASK: 7;
+};
+export declare const ATTR: {
+    readonly NORMAL: 32;
+    readonly REVERSE: 33;
+    readonly HIGH_INTENSITY: 34;
+    readonly UNDERSCORE: 36;
+    readonly BLINK: 37;
+    readonly NON_DISPLAY: 39;
+    readonly COLUMN_SEPARATOR: 35;
+};
+export declare const SCREEN: {
+    readonly ROWS_24: 24;
+    readonly COLS_80: 80;
+    readonly ROWS_27: 27;
+    readonly COLS_132: 132;
+};
+export declare const TERMINAL_TYPE = "IBM-3179-2";
+export declare const TERMINAL_TYPE_WIDE = "IBM-3477-FC";

package/dist/tn5250/constants.js

@@ -0,0 +1,156 @@
+// === Telnet Constants ===
+export const TELNET = {
+    IAC: 0xFF, // Interpret As Command
+    DONT: 0xFE,
+    DO: 0xFD,
+    WONT: 0xFC,
+    WILL: 0xFB,
+    SB: 0xFA, // Subnegotiation Begin
+    SE: 0xF0, // Subnegotiation End
+    EOR: 0xEF, // End of Record
+    NOP: 0xF1,
+    // Telnet options
+    OPT_BINARY: 0x00,
+    OPT_ECHO: 0x01,
+    OPT_SGA: 0x03, // Suppress Go Ahead
+    OPT_TTYPE: 0x18, // Terminal Type
+    OPT_EOR: 0x19, // End of Record
+    OPT_NAWS: 0x1F, // Negotiate About Window Size
+    OPT_NEW_ENVIRON: 0x27, // New Environment
+    OPT_TN5250E: 0x28, // TN5250E (40 decimal)
+    // Terminal type subneg
+    TTYPE_IS: 0x00,
+    TTYPE_SEND: 0x01,
+};
+// === 5250 Data Stream Constants ===
+// Record types
+export const RECORD_TYPE = {
+    GDS: 0x12A0, // General Data Stream
+};
+// 5250 opcodes (in the header)
+export const OPCODE = {
+    NO_OP: 0x00,
+    INVITE: 0x01,
+    OUTPUT: 0x02,
+    PUT_GET: 0x03,
+    SAVE_SCREEN: 0x04,
+    RESTORE_SCREEN: 0x05,
+    READ_IMMEDIATE: 0x06,
+    RESERVED: 0x07,
+    READ_SCREEN: 0x08,
+    CANCEL_INVITE: 0x0A,
+    TURN_ON_MSG_LIGHT: 0x0B,
+    TURN_OFF_MSG_LIGHT: 0x0C,
+};
+// 5250 command codes (within WTD, etc.)
+export const CMD = {
+    CLEAR_UNIT: 0x40,
+    CLEAR_FORMAT_TABLE: 0x50,
+    CLEAR_UNIT_ALT: 0x20,
+    WRITE_TO_DISPLAY: 0x11, // WTD
+    WRITE_ERROR_CODE: 0x21,
+    WRITE_ERROR_CODE_WIN: 0x22,
+    READ_MDT_FIELDS: 0x52,
+    READ_INPUT_FIELDS: 0x42,
+    READ_IMMEDIATE: 0x72,
+    WRITE_STRUCTURED_FIELD: 0xF3,
+    SAVE_SCREEN: 0x02,
+    RESTORE_SCREEN: 0x12,
+    ROLL: 0x23,
+};
+// 5250 order codes
+export const ORDER = {
+    SBA: 0x11, // Set Buffer Address
+    IC: 0x13, // Insert Cursor
+    MC: 0x14, // Move Cursor
+    RA: 0x02, // Repeat to Address
+    EA: 0x03, // Erase to Address
+    SOH: 0x01, // Start of Header
+    TD: 0x10, // Transparent Data
+    WEA: 0x04, // Write Extended Attribute
+    SF: 0x1D, // Start Field (used in field attribute)
+    SA: 0x28, // Set Attribute
+};
+// 5250 Aid key bytes (sent from client to host)
+export const AID = {
+    ENTER: 0xF1,
+    F1: 0x31,
+    F2: 0x32,
+    F3: 0x33,
+    F4: 0x34,
+    F5: 0x35,
+    F6: 0x36,
+    F7: 0x37,
+    F8: 0x38,
+    F9: 0x39,
+    F10: 0x3A,
+    F11: 0x3B,
+    F12: 0x3C,
+    F13: 0xB1,
+    F14: 0xB2,
+    F15: 0xB3,
+    F16: 0xB4,
+    F17: 0xB5,
+    F18: 0xB6,
+    F19: 0xB7,
+    F20: 0xB8,
+    F21: 0xB9,
+    F22: 0xBA,
+    F23: 0xBB,
+    F24: 0xBC,
+    PAGE_UP: 0xF4, // Roll Down
+    PAGE_DOWN: 0xF5, // Roll Up
+    CLEAR: 0xBD,
+    HELP: 0xF3,
+    PRINT: 0xF6,
+    RECORD_BACKSPACE: 0xF8,
+    SYS_REQUEST: 0x01, // Attention key
+};
+// Map key names (from frontend) to AID bytes
+export const KEY_TO_AID = {
+    'Enter': AID.ENTER,
+    'F1': AID.F1, 'F2': AID.F2, 'F3': AID.F3, 'F4': AID.F4,
+    'F5': AID.F5, 'F6': AID.F6, 'F7': AID.F7, 'F8': AID.F8,
+    'F9': AID.F9, 'F10': AID.F10, 'F11': AID.F11, 'F12': AID.F12,
+    'F13': AID.F13, 'F14': AID.F14, 'F15': AID.F15, 'F16': AID.F16,
+    'F17': AID.F17, 'F18': AID.F18, 'F19': AID.F19, 'F20': AID.F20,
+    'F21': AID.F21, 'F22': AID.F22, 'F23': AID.F23, 'F24': AID.F24,
+    'PageUp': AID.PAGE_UP,
+    'PageDown': AID.PAGE_DOWN,
+    'Clear': AID.CLEAR,
+    'Help': AID.HELP,
+    'Print': AID.PRINT,
+};
+// Field attribute bits (in the FFW - Field Format Word)
+export const FFW = {
+    BYPASS: 0x20, // Bypass (protected/output-only)
+    DUP_ENABLE: 0x10,
+    MDT: 0x08, // Modified Data Tag
+    SHIFT_MASK: 0x07, // Data type shift bits
+    // Second byte flags
+    AUTO_ENTER: 0x80,
+    FER: 0x40, // Field Exit Required
+    MONOCASE: 0x20,
+    MANDATORY_ENTRY: 0x08,
+    RIGHT_ADJUST_MASK: 0x07,
+};
+// Field attribute display attributes (SA order)
+export const ATTR = {
+    NORMAL: 0x20,
+    REVERSE: 0x21,
+    HIGH_INTENSITY: 0x22,
+    UNDERSCORE: 0x24,
+    BLINK: 0x25,
+    NON_DISPLAY: 0x27,
+    COLUMN_SEPARATOR: 0x23,
+};
+// Screen dimensions
+export const SCREEN = {
+    ROWS_24: 24,
+    COLS_80: 80,
+    ROWS_27: 27,
+    COLS_132: 132,
+};
+// Terminal type strings for negotiation
+export const TERMINAL_TYPE = 'IBM-3179-2';
+export const TERMINAL_TYPE_WIDE = 'IBM-3477-FC';

package/dist/tn5250/ebcdic.d.ts

@@ -0,0 +1,10 @@
+/** Convert an EBCDIC byte to a UTF-8 character */
+export declare function ebcdicToChar(byte: number): string;
+/** Convert a UTF-8 character to an EBCDIC byte */
+export declare function charToEbcdic(char: string): number;
+/** Convert an EBCDIC buffer to a UTF-8 string */
+export declare function ebcdicBufferToString(buf: Buffer, start?: number, length?: number): string;
+/** Convert a UTF-8 string to an EBCDIC buffer */
+export declare function stringToEbcdicBuffer(str: string): Buffer;
+export declare const EBCDIC_SPACE = 64;
+export declare const EBCDIC_NULL = 0;

package/dist/tn5250/ebcdic.js

@@ -0,0 +1,89 @@
+// EBCDIC CCSID 37 (US/Canada) ↔ UTF-8 conversion tables
+// EBCDIC byte → Unicode code point (CCSID 37)
+const EBCDIC_TO_UNICODE = [
+    // 0x00-0x0F
+    0x0000, 0x0001, 0x0002, 0x0003, 0x009C, 0x0009, 0x0086, 0x007F,
+    0x0097, 0x008D, 0x008E, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+    // 0x10-0x1F
+    0x0010, 0x0011, 0x0012, 0x0013, 0x009D, 0x0085, 0x0008, 0x0087,
+    0x0018, 0x0019, 0x0092, 0x008F, 0x001C, 0x001D, 0x001E, 0x001F,
+    // 0x20-0x2F
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x000A, 0x0017, 0x001B,
+    0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x0005, 0x0006, 0x0007,
+    // 0x30-0x3F
+    0x0090, 0x0091, 0x0016, 0x0093, 0x0094, 0x0095, 0x0096, 0x0004,
+    0x0098, 0x0099, 0x009A, 0x009B, 0x0014, 0x0015, 0x009E, 0x001A,
+    // 0x40-0x4F
+    0x0020, 0x00A0, 0x00E2, 0x00E4, 0x00E0, 0x00E1, 0x00E3, 0x00E5,
+    0x00E7, 0x00F1, 0x00A2, 0x002E, 0x003C, 0x0028, 0x002B, 0x007C,
+    // 0x50-0x5F
+    0x0026, 0x00E9, 0x00EA, 0x00EB, 0x00E8, 0x00ED, 0x00EE, 0x00EF,
+    0x00EC, 0x00DF, 0x0021, 0x0024, 0x002A, 0x0029, 0x003B, 0x00AC,
+    // 0x60-0x6F
+    0x002D, 0x002F, 0x00C2, 0x00C4, 0x00C0, 0x00C1, 0x00C3, 0x00C5,
+    0x00C7, 0x00D1, 0x00A6, 0x002C, 0x0025, 0x005F, 0x003E, 0x003F,
+    // 0x70-0x7F
+    0x00F8, 0x00C9, 0x00CA, 0x00CB, 0x00C8, 0x00CD, 0x00CE, 0x00CF,
+    0x00CC, 0x0060, 0x003A, 0x0023, 0x0040, 0x0027, 0x003D, 0x0022,
+    // 0x80-0x8F
+    0x00D8, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+    0x0068, 0x0069, 0x00AB, 0x00BB, 0x00F0, 0x00FD, 0x00FE, 0x00B1,
+    // 0x90-0x9F
+    0x00B0, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F, 0x0070,
+    0x0071, 0x0072, 0x00AA, 0x00BA, 0x00E6, 0x00B8, 0x00C6, 0x00A4,
+    // 0xA0-0xAF
+    0x00B5, 0x007E, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078,
+    0x0079, 0x007A, 0x00A1, 0x00BF, 0x00D0, 0x00DD, 0x00DE, 0x00AE,
+    // 0xB0-0xBF
+    0x005E, 0x00A3, 0x00A5, 0x00B7, 0x00A9, 0x00A7, 0x00B6, 0x00BC,
+    0x00BD, 0x00BE, 0x005B, 0x005D, 0x00AF, 0x00A8, 0x00B4, 0x00D7,
+    // 0xC0-0xCF
+    0x007B, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+    0x0048, 0x0049, 0x00AD, 0x00F4, 0x00F6, 0x00F2, 0x00F3, 0x00F5,
+    // 0xD0-0xDF
+    0x007D, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F, 0x0050,
+    0x0051, 0x0052, 0x00B9, 0x00FB, 0x00FC, 0x00F9, 0x00FA, 0x00FF,
+    // 0xE0-0xEF
+    0x005C, 0x00F7, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058,
+    0x0059, 0x005A, 0x00B2, 0x00D4, 0x00D6, 0x00D2, 0x00D3, 0x00D5,
+    // 0xF0-0xFF
+    0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+    0x0038, 0x0039, 0x00B3, 0x00DB, 0x00DC, 0x00D9, 0x00DA, 0x009F,
+];
+// Build reverse lookup: Unicode code point → EBCDIC byte
+const UNICODE_TO_EBCDIC = new Map();
+for (let i = 0; i < 256; i++) {
+    UNICODE_TO_EBCDIC.set(EBCDIC_TO_UNICODE[i], i);
+}
+/** Convert an EBCDIC byte to a UTF-8 character */
+export function ebcdicToChar(byte) {
+    const cp = EBCDIC_TO_UNICODE[byte & 0xFF];
+    return String.fromCharCode(cp);
+}
+/** Convert a UTF-8 character to an EBCDIC byte */
+export function charToEbcdic(char) {
+    const cp = char.charCodeAt(0);
+    const eb = UNICODE_TO_EBCDIC.get(cp);
+    return eb !== undefined ? eb : 0x40; // default to EBCDIC space
+}
+/** Convert an EBCDIC buffer to a UTF-8 string */
+export function ebcdicBufferToString(buf, start = 0, length) {
+    const end = length !== undefined ? start + length : buf.length;
+    let result = '';
+    for (let i = start; i < end; i++) {
+        result += ebcdicToChar(buf[i]);
+    }
+    return result;
+}
+/** Convert a UTF-8 string to an EBCDIC buffer */
+export function stringToEbcdicBuffer(str) {
+    const buf = Buffer.alloc(str.length);
+    for (let i = 0; i < str.length; i++) {
+        buf[i] = charToEbcdic(str[i]);
+    }
+    return buf;
+}
+// EBCDIC space = 0x40
+export const EBCDIC_SPACE = 0x40;
+// EBCDIC null = 0x00
+export const EBCDIC_NULL = 0x00;

package/dist/tn5250/encoder.d.ts

@@ -0,0 +1,30 @@
+import { ScreenBuffer } from './screen.js';
+/**
+ * Encodes client responses (aid keys + field data) into 5250 data stream
+ * for sending back to the IBM i host.
+ */
+export declare class TN5250Encoder {
+    private screen;
+    constructor(screen: ScreenBuffer);
+    /**
+     * 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: string): Buffer | null;
+    /**
+     * Build a GDS (General Data Stream) header for a response.
+     */
+    private buildGDSHeader;
+    /**
+     * Wrap data with Telnet IAC EOR framing.
+     * Also escapes any 0xFF bytes in the data as IAC IAC.
+     */
+    private wrapWithEOR;
+    /**
+     * 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: string): boolean;
+}