green-screen-proxy 0.3.0

package/dist/mock/mock-routes.js

@@ -0,0 +1,231 @@
+import { Router } from 'express';
+import { createHash } from 'crypto';
+const router = Router();
+const state = {
+    currentScreen: 'signon',
+    cursorRow: 6,
+    cursorCol: 53,
+    username: '',
+    password: '',
+    connected: false,
+};
+function pad(str, len) {
+    return str.padEnd(len).substring(0, len);
+}
+function signonScreen() {
+    const lines = [
+        pad('                         Sign On', 80),
+        pad('                                                         System  . . : PUB400', 80),
+        pad('                                                         Subsystem . : QINTER', 80),
+        pad('                                                         Display . . : QPADEV0001', 80),
+        pad('', 80),
+        pad('', 80),
+        pad(' User  . . . . . . . . . . . . . .   ' + pad(state.username, 10), 80),
+        pad(' Password  . . . . . . . . . . . .   ' + pad('', 10), 80),
+        pad(' Program/procedure . . . . . . . .   ' + pad('', 10), 80),
+        pad(' Menu  . . . . . . . . . . . . . .   ' + pad('', 10), 80),
+        pad(' Current library . . . . . . . . .   ' + pad('', 10), 80),
+        pad('', 80),
+        pad('', 80),
+        pad('', 80),
+        pad('', 80),
+        pad('', 80),
+        pad('', 80),
+        pad('', 80),
+        pad('', 80),
+        pad('', 80),
+        pad('', 80),
+        pad('', 80),
+        pad('                  (C) COPYRIGHT IBM CORP. 1980, 2024.', 80),
+        pad('', 80),
+    ];
+    return lines.join('\n');
+}
+function menuScreen() {
+    const lines = [
+        pad('  MAIN                        AS/400 Main Menu                                ', 80),
+        pad('                                                        System:   PUB400', 80),
+        pad(' Select one of the following:', 80),
+        pad('', 80),
+        pad('      1. User tasks', 80),
+        pad('      2. Office tasks', 80),
+        pad('      3. General system tasks', 80),
+        pad('      4. Files, libraries, and folders', 80),
+        pad('      5. Programming', 80),
+        pad('      6. Communications', 80),
+        pad('      7. Define or change the system', 80),
+        pad('      8. Problem handling', 80),
+        pad('      9. Display a menu', 80),
+        pad('     10. Information Assistant options', 80),
+        pad('     11. Client Access/400 tasks', 80),
+        pad('', 80),
+        pad('     90. Sign off', 80),
+        pad('', 80),
+        pad('', 80),
+        pad(' Selection or command', 80),
+        pad(' ===> ' + pad('', 74), 80),
+        pad('', 80),
+        pad(' F3=Exit   F4=Prompt   F9=Retrieve   F12=Cancel', 80),
+        pad(' F13=Information Assistant   F23=Set initial menu', 80),
+    ];
+    return lines.join('\n');
+}
+function getScreenData() {
+    const content = state.currentScreen === 'signon' ? signonScreen() : menuScreen();
+    const hash = createHash('md5').update(content).digest('hex').substring(0, 12);
+    const fields = state.currentScreen === 'signon'
+        ? [
+            { row: 6, col: 53, length: 10, is_input: true, is_protected: false },
+            { row: 7, col: 53, length: 10, is_input: true, is_protected: false, is_reverse: true },
+            { row: 8, col: 53, length: 10, is_input: true, is_protected: false },
+            { row: 9, col: 53, length: 10, is_input: true, is_protected: false },
+            { row: 10, col: 53, length: 10, is_input: true, is_protected: false },
+        ]
+        : [
+            { row: 20, col: 7, length: 73, is_input: true, is_protected: false },
+        ];
+    return {
+        content,
+        cursor_row: state.cursorRow,
+        cursor_col: state.cursorCol,
+        rows: 24,
+        cols: 80,
+        fields,
+        screen_signature: hash,
+        timestamp: new Date().toISOString(),
+    };
+}
+// POST /connect
+router.post('/connect', (_req, res) => {
+    state.connected = true;
+    state.currentScreen = 'signon';
+    state.cursorRow = 6;
+    state.cursorCol = 53;
+    state.username = '';
+    state.password = '';
+    const screen = getScreenData();
+    res.json({
+        success: true,
+        sessionId: 'mock-session',
+        cursor_row: screen.cursor_row,
+        cursor_col: screen.cursor_col,
+        content: screen.content,
+        screen_signature: screen.screen_signature,
+    });
+});
+// POST /disconnect
+router.post('/disconnect', (_req, res) => {
+    state.connected = false;
+    state.currentScreen = 'signon';
+    res.json({ success: true });
+});
+// POST /reconnect
+router.post('/reconnect', (_req, res) => {
+    state.connected = true;
+    state.currentScreen = 'signon';
+    state.cursorRow = 6;
+    state.cursorCol = 53;
+    state.username = '';
+    state.password = '';
+    const screen = getScreenData();
+    res.json({
+        success: true,
+        cursor_row: screen.cursor_row,
+        cursor_col: screen.cursor_col,
+        content: screen.content,
+        screen_signature: screen.screen_signature,
+    });
+});
+// GET /status
+router.get('/status', (_req, res) => {
+    res.json({
+        connected: state.connected,
+        status: state.connected
+            ? (state.currentScreen === 'menu' ? 'authenticated' : 'connected')
+            : 'disconnected',
+        host: state.connected ? 'mock-ibmi' : undefined,
+        username: state.currentScreen === 'menu' ? (state.username || 'MOCKUSER') : undefined,
+    });
+});
+// GET /screen
+router.get('/screen', (_req, res) => {
+    if (!state.connected) {
+        return res.status(503).json(null);
+    }
+    res.json(getScreenData());
+});
+// POST /send-text
+router.post('/send-text', (req, res) => {
+    if (!state.connected) {
+        return res.status(404).json({ success: false, error: 'Not connected' });
+    }
+    const { text } = req.body || {};
+    if (typeof text !== 'string') {
+        return res.status(400).json({ success: false, error: 'text is required' });
+    }
+    // Insert text at cursor
+    if (state.currentScreen === 'signon') {
+        if (state.cursorRow === 6) {
+            state.username = (state.username + text).substring(0, 10);
+            state.cursorCol = 53 + state.username.length;
+        }
+        else if (state.cursorRow === 7) {
+            state.password = (state.password + text).substring(0, 10);
+            state.cursorCol = 53 + state.password.length;
+        }
+    }
+    const screen = getScreenData();
+    res.json({
+        success: true,
+        cursor_row: state.cursorRow,
+        cursor_col: state.cursorCol,
+        content: screen.content,
+        screen_signature: screen.screen_signature,
+    });
+});
+// POST /send-key
+router.post('/send-key', (req, res) => {
+    if (!state.connected) {
+        return res.status(404).json({ success: false, error: 'Not connected' });
+    }
+    const { key } = req.body || {};
+    if (typeof key !== 'string') {
+        return res.status(400).json({ success: false, error: 'key is required' });
+    }
+    if (key === 'Enter') {
+        if (state.currentScreen === 'signon') {
+            // Transition to menu
+            state.currentScreen = 'menu';
+            state.cursorRow = 20;
+            state.cursorCol = 7;
+        }
+    }
+    else if (key === 'Tab') {
+        // Move to next field
+        if (state.currentScreen === 'signon') {
+            if (state.cursorRow < 10) {
+                state.cursorRow++;
+                state.cursorCol = 53;
+            }
+        }
+    }
+    else if (key === 'F3') {
+        // Go back / sign off
+        if (state.currentScreen === 'menu') {
+            state.currentScreen = 'signon';
+            state.cursorRow = 6;
+            state.cursorCol = 53;
+            state.username = '';
+            state.password = '';
+        }
+    }
+    const screen = getScreenData();
+    res.json({
+        success: true,
+        cursor_row: state.cursorRow,
+        cursor_col: state.cursorCol,
+        content: screen.content,
+        screen_signature: screen.screen_signature,
+    });
+});
+export default router;

package/dist/protocols/hp6530-handler.d.ts

@@ -0,0 +1,29 @@
+import { ProtocolHandler, ScreenData, ProtocolOptions, ProtocolType } from './types.js';
+import { HP6530Connection } from '../hp6530/connection.js';
+import { HP6530Screen } from '../hp6530/screen.js';
+import { HP6530Parser } from '../hp6530/parser.js';
+import { HP6530Encoder } from '../hp6530/encoder.js';
+/**
+ * HP 6530 protocol handler — implements the ProtocolHandler interface
+ * for HP NonStop (Tandem) terminal connections.
+ *
+ * HP 6530 terminals are block-mode ASCII terminals used with HP NonStop
+ * systems in payment processing, stock exchanges, and telecom.
+ */
+export declare class HP6530Handler extends ProtocolHandler {
+    readonly protocol: ProtocolType;
+    readonly connection: HP6530Connection;
+    readonly screen: HP6530Screen;
+    readonly parser: HP6530Parser;
+    readonly encoder: HP6530Encoder;
+    constructor();
+    get isConnected(): boolean;
+    connect(host: string, port: number, _options?: ProtocolOptions): Promise<void>;
+    disconnect(): void;
+    getScreenData(): ScreenData;
+    sendText(text: string): boolean;
+    sendKey(keyName: string): boolean;
+    sendRaw(data: Buffer): void;
+    destroy(): void;
+    private onData;
+}

package/dist/protocols/hp6530-handler.js

@@ -0,0 +1,64 @@
+import { ProtocolHandler } from './types.js';
+import { HP6530Connection } from '../hp6530/connection.js';
+import { HP6530Screen } from '../hp6530/screen.js';
+import { HP6530Parser } from '../hp6530/parser.js';
+import { HP6530Encoder } from '../hp6530/encoder.js';
+/**
+ * HP 6530 protocol handler — implements the ProtocolHandler interface
+ * for HP NonStop (Tandem) terminal connections.
+ *
+ * HP 6530 terminals are block-mode ASCII terminals used with HP NonStop
+ * systems in payment processing, stock exchanges, and telecom.
+ */
+export class HP6530Handler extends ProtocolHandler {
+    protocol = 'hp6530';
+    connection;
+    screen;
+    parser;
+    encoder;
+    constructor() {
+        super();
+        this.screen = new HP6530Screen();
+        this.connection = new HP6530Connection();
+        this.parser = new HP6530Parser(this.screen);
+        this.encoder = new HP6530Encoder(this.screen);
+        this.connection.on('data', (data) => this.onData(data));
+        this.connection.on('disconnected', () => this.emit('disconnected'));
+        this.connection.on('error', (err) => this.emit('error', err));
+    }
+    get isConnected() {
+        return this.connection.isConnected;
+    }
+    async connect(host, port, _options) {
+        await this.connection.connect(host, port);
+    }
+    disconnect() {
+        this.connection.disconnect();
+    }
+    getScreenData() {
+        return this.screen.toScreenData();
+    }
+    sendText(text) {
+        return this.encoder.insertText(text);
+    }
+    sendKey(keyName) {
+        const response = this.encoder.buildKeyResponse(keyName);
+        if (!response)
+            return false;
+        this.connection.sendRaw(response);
+        return true;
+    }
+    sendRaw(data) {
+        this.connection.sendRaw(data);
+    }
+    destroy() {
+        this.disconnect();
+        this.removeAllListeners();
+    }
+    onData(data) {
+        const modified = this.parser.parse(data);
+        if (modified) {
+            this.emit('screenChange', this.screen.toScreenData());
+        }
+    }
+}

package/dist/protocols/index.d.ts

@@ -0,0 +1,11 @@
+export { ProtocolHandler, ProtocolType, ProtocolOptions, ScreenData } from './types.js';
+export { TN5250Handler } from './tn5250-handler.js';
+export { TN3270Handler } from './tn3270-handler.js';
+export { VTHandler } from './vt-handler.js';
+export { HP6530Handler } from './hp6530-handler.js';
+import { ProtocolHandler, ProtocolType } from './types.js';
+/**
+ * Create a protocol handler for the given protocol type.
+ * Throws if the protocol is not yet implemented.
+ */
+export declare function createProtocolHandler(protocol?: ProtocolType): ProtocolHandler;

package/dist/protocols/index.js

@@ -0,0 +1,27 @@
+export { ProtocolHandler } from './types.js';
+export { TN5250Handler } from './tn5250-handler.js';
+export { TN3270Handler } from './tn3270-handler.js';
+export { VTHandler } from './vt-handler.js';
+export { HP6530Handler } from './hp6530-handler.js';
+import { TN5250Handler } from './tn5250-handler.js';
+import { TN3270Handler } from './tn3270-handler.js';
+import { VTHandler } from './vt-handler.js';
+import { HP6530Handler } from './hp6530-handler.js';
+/**
+ * Create a protocol handler for the given protocol type.
+ * Throws if the protocol is not yet implemented.
+ */
+export function createProtocolHandler(protocol = 'tn5250') {
+    switch (protocol) {
+        case 'tn5250':
+            return new TN5250Handler();
+        case 'tn3270':
+            return new TN3270Handler();
+        case 'vt':
+            return new VTHandler();
+        case 'hp6530':
+            return new HP6530Handler();
+        default:
+            throw new Error(`Protocol "${protocol}" is not yet implemented. Supported: tn5250, tn3270, vt, hp6530`);
+    }
+}

package/dist/protocols/tn3270-handler.d.ts

@@ -0,0 +1,26 @@
+import { ProtocolHandler, ScreenData, ProtocolOptions, ProtocolType } from './types.js';
+import { TN3270Connection } from '../tn3270/connection.js';
+import { ScreenBuffer3270 } from '../tn3270/screen.js';
+import { TN3270Parser } from '../tn3270/parser.js';
+import { TN3270Encoder } from '../tn3270/encoder.js';
+/**
+ * TN3270 protocol handler — implements the ProtocolHandler interface
+ * for IBM z/OS (mainframe) 3270 terminal connections.
+ */
+export declare class TN3270Handler extends ProtocolHandler {
+    readonly protocol: ProtocolType;
+    readonly connection: TN3270Connection;
+    readonly screen: ScreenBuffer3270;
+    readonly parser: TN3270Parser;
+    readonly encoder: TN3270Encoder;
+    constructor();
+    get isConnected(): boolean;
+    connect(host: string, port: number, _options?: ProtocolOptions): Promise<void>;
+    disconnect(): void;
+    getScreenData(): ScreenData;
+    sendText(text: string): boolean;
+    sendKey(keyName: string): boolean;
+    sendRaw(data: Buffer): void;
+    destroy(): void;
+    private onRecord;
+}

package/dist/protocols/tn3270-handler.js

@@ -0,0 +1,61 @@
+import { ProtocolHandler } from './types.js';
+import { TN3270Connection } from '../tn3270/connection.js';
+import { ScreenBuffer3270 } from '../tn3270/screen.js';
+import { TN3270Parser } from '../tn3270/parser.js';
+import { TN3270Encoder } from '../tn3270/encoder.js';
+/**
+ * TN3270 protocol handler — implements the ProtocolHandler interface
+ * for IBM z/OS (mainframe) 3270 terminal connections.
+ */
+export class TN3270Handler extends ProtocolHandler {
+    protocol = 'tn3270';
+    connection;
+    screen;
+    parser;
+    encoder;
+    constructor() {
+        super();
+        this.screen = new ScreenBuffer3270();
+        this.connection = new TN3270Connection();
+        this.parser = new TN3270Parser(this.screen);
+        this.encoder = new TN3270Encoder(this.screen);
+        this.connection.on('data', (record) => this.onRecord(record));
+        this.connection.on('disconnected', () => this.emit('disconnected'));
+        this.connection.on('error', (err) => this.emit('error', err));
+    }
+    get isConnected() {
+        return this.connection.isConnected;
+    }
+    async connect(host, port, _options) {
+        await this.connection.connect(host, port);
+    }
+    disconnect() {
+        this.connection.disconnect();
+    }
+    getScreenData() {
+        return this.screen.toScreenData();
+    }
+    sendText(text) {
+        return this.encoder.insertText(text);
+    }
+    sendKey(keyName) {
+        const response = this.encoder.buildAidResponse(keyName);
+        if (!response)
+            return false;
+        this.connection.sendRaw(response);
+        return true;
+    }
+    sendRaw(data) {
+        this.connection.sendRaw(data);
+    }
+    destroy() {
+        this.disconnect();
+        this.removeAllListeners();
+    }
+    onRecord(record) {
+        const modified = this.parser.parseRecord(record);
+        if (modified) {
+            this.emit('screenChange', this.screen.toScreenData());
+        }
+    }
+}

package/dist/protocols/tn5250-handler.d.ts

@@ -0,0 +1,26 @@
+import { ProtocolHandler, ScreenData, ProtocolOptions, ProtocolType } from './types.js';
+import { TN5250Connection } from '../tn5250/connection.js';
+import { ScreenBuffer } from '../tn5250/screen.js';
+import { TN5250Parser } from '../tn5250/parser.js';
+import { TN5250Encoder } from '../tn5250/encoder.js';
+/**
+ * TN5250 protocol handler — implements the ProtocolHandler interface
+ * for IBM i (AS/400) TN5250 terminal connections.
+ */
+export declare class TN5250Handler extends ProtocolHandler {
+    readonly protocol: ProtocolType;
+    readonly connection: TN5250Connection;
+    readonly screen: ScreenBuffer;
+    readonly parser: TN5250Parser;
+    readonly encoder: TN5250Encoder;
+    constructor();
+    get isConnected(): boolean;
+    connect(host: string, port: number, _options?: ProtocolOptions): Promise<void>;
+    disconnect(): void;
+    getScreenData(): ScreenData;
+    sendText(text: string): boolean;
+    sendKey(keyName: string): boolean;
+    sendRaw(data: Buffer): void;
+    destroy(): void;
+    private onRecord;
+}

package/dist/protocols/tn5250-handler.js

@@ -0,0 +1,62 @@
+import { ProtocolHandler } from './types.js';
+import { TN5250Connection } from '../tn5250/connection.js';
+import { ScreenBuffer } from '../tn5250/screen.js';
+import { TN5250Parser } from '../tn5250/parser.js';
+import { TN5250Encoder } from '../tn5250/encoder.js';
+/**
+ * TN5250 protocol handler — implements the ProtocolHandler interface
+ * for IBM i (AS/400) TN5250 terminal connections.
+ */
+export class TN5250Handler extends ProtocolHandler {
+    protocol = 'tn5250';
+    connection;
+    screen;
+    parser;
+    encoder;
+    constructor() {
+        super();
+        this.screen = new ScreenBuffer();
+        this.connection = new TN5250Connection();
+        this.parser = new TN5250Parser(this.screen);
+        this.encoder = new TN5250Encoder(this.screen);
+        this.connection.on('data', (record) => this.onRecord(record));
+        this.connection.on('disconnected', () => this.emit('disconnected'));
+        this.connection.on('error', (err) => this.emit('error', err));
+    }
+    get isConnected() {
+        return this.connection.isConnected;
+    }
+    async connect(host, port, _options) {
+        await this.connection.connect(host, port);
+    }
+    disconnect() {
+        this.connection.disconnect();
+    }
+    getScreenData() {
+        return this.screen.toScreenData();
+    }
+    sendText(text) {
+        return this.encoder.insertText(text);
+    }
+    sendKey(keyName) {
+        const response = this.encoder.buildAidResponse(keyName);
+        if (!response)
+            return false;
+        this.connection.sendRaw(response);
+        return true;
+    }
+    sendRaw(data) {
+        this.connection.sendRaw(data);
+    }
+    destroy() {
+        this.disconnect();
+        this.removeAllListeners();
+    }
+    onRecord(record) {
+        const modified = this.parser.parseRecord(record);
+        if (modified) {
+            this.parser.calculateFieldLengths();
+            this.emit('screenChange', this.screen.toScreenData());
+        }
+    }
+}

package/dist/protocols/types.d.ts

@@ -0,0 +1,59 @@
+import { EventEmitter } from 'events';
+/**
+ * Screen data returned by protocol handlers.
+ * Protocol-agnostic representation of the terminal screen.
+ */
+export interface ScreenData {
+    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;
+}
+export type ProtocolType = 'tn5250' | 'tn3270' | 'vt' | 'hp6530';
+export interface ProtocolOptions {
+    /** Terminal type string for negotiation */
+    terminalType?: string;
+    /** Screen dimensions */
+    rows?: number;
+    cols?: number;
+    /** Protocol-specific options */
+    [key: string]: unknown;
+}
+/**
+ * Interface that all protocol handlers must implement.
+ * Each protocol (TN5250, TN3270, VT, etc.) provides its own implementation.
+ */
+export declare abstract class ProtocolHandler extends EventEmitter {
+    abstract readonly protocol: ProtocolType;
+    /** Connect to a remote host */
+    abstract connect(host: string, port: number, options?: ProtocolOptions): Promise<void>;
+    /** Disconnect from the host */
+    abstract disconnect(): void;
+    /** Whether the connection is active */
+    abstract get isConnected(): boolean;
+    /** Get the current screen state */
+    abstract getScreenData(): ScreenData;
+    /** Send text input at the current cursor position */
+    abstract sendText(text: string): boolean;
+    /**
+     * Send a key action (ENTER, F1-F24, TAB, etc.).
+     * Returns raw bytes to send over the wire, or null if key is unknown.
+     */
+    abstract sendKey(keyName: string): boolean;
+    /** Send raw bytes over the connection */
+    abstract sendRaw(data: Buffer): void;
+    /** Clean up resources */
+    abstract destroy(): void;
+}

package/dist/protocols/types.js

@@ -0,0 +1,7 @@
+import { EventEmitter } from 'events';
+/**
+ * Interface that all protocol handlers must implement.
+ * Each protocol (TN5250, TN3270, VT, etc.) provides its own implementation.
+ */
+export class ProtocolHandler extends EventEmitter {
+}

package/dist/protocols/vt-handler.d.ts

@@ -0,0 +1,30 @@
+import { ProtocolHandler, ScreenData, ProtocolOptions, ProtocolType } from './types.js';
+import { VTConnection } from '../vt/connection.js';
+import { VTScreenBuffer } from '../vt/screen.js';
+import { VTParser } from '../vt/parser.js';
+import { VTEncoder } from '../vt/encoder.js';
+/**
+ * VT terminal protocol handler — implements the ProtocolHandler interface
+ * for VT100/VT220/VT320 terminal connections.
+ *
+ * VT terminals are stream-mode (character-at-a-time). Each keystroke is
+ * sent immediately; the host echoes characters back. Used by OpenVMS,
+ * Pick/MultiValue, Unix, and many other systems.
+ */
+export declare class VTHandler extends ProtocolHandler {
+    readonly protocol: ProtocolType;
+    readonly connection: VTConnection;
+    readonly screen: VTScreenBuffer;
+    readonly parser: VTParser;
+    readonly encoder: VTEncoder;
+    constructor();
+    get isConnected(): boolean;
+    connect(host: string, port: number, _options?: ProtocolOptions): Promise<void>;
+    disconnect(): void;
+    getScreenData(): ScreenData;
+    sendText(text: string): boolean;
+    sendKey(keyName: string): boolean;
+    sendRaw(data: Buffer): void;
+    destroy(): void;
+    private onData;
+}