green-screen-proxy 0.3.0

package/dist/protocols/vt-handler.js

@@ -0,0 +1,67 @@
+import { ProtocolHandler } 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 class VTHandler extends ProtocolHandler {
+    protocol = 'vt';
+    connection;
+    screen;
+    parser;
+    encoder;
+    constructor() {
+        super();
+        this.screen = new VTScreenBuffer();
+        this.connection = new VTConnection();
+        this.parser = new VTParser(this.screen);
+        this.encoder = new VTEncoder(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) {
+        const encoded = this.encoder.encodeText(text);
+        this.connection.sendRaw(encoded);
+        return true;
+    }
+    sendKey(keyName) {
+        const encoded = this.encoder.encodeKey(keyName);
+        if (!encoded)
+            return false;
+        this.connection.sendRaw(encoded);
+        return true;
+    }
+    sendRaw(data) {
+        this.connection.sendRaw(data);
+    }
+    destroy() {
+        this.disconnect();
+        this.removeAllListeners();
+    }
+    onData(data) {
+        const modified = this.parser.feed(data);
+        if (modified) {
+            this.emit('screenChange', this.screen.toScreenData());
+        }
+    }
+}

package/dist/routes.d.ts

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/dist/routes.js

@@ -0,0 +1,141 @@
+import { Router } from 'express';
+import { createSession, getSession, getDefaultSession, destroySession, } from './session.js';
+import { bindSessionToWebSocket } from './websocket.js';
+const router = Router();
+/** Resolve session from header, query param, or default */
+function resolveSession(req) {
+    const sessionId = req.headers['x-session-id'] ||
+        req.query.sessionId;
+    if (sessionId) {
+        return getSession(sessionId);
+    }
+    return getDefaultSession();
+}
+// POST /connect
+router.post('/connect', async (req, res) => {
+    try {
+        const { host = 'pub400.com', port = 23, protocol = 'tn5250' } = req.body || {};
+        const session = createSession(protocol);
+        // Store session ID in response header
+        res.setHeader('X-Session-Id', session.id);
+        bindSessionToWebSocket(session);
+        await session.connect(host, port);
+        // Wait briefly for initial screen data
+        await new Promise(resolve => setTimeout(resolve, 2000));
+        const screenData = session.getScreenData();
+        res.json({
+            success: true,
+            sessionId: session.id,
+            cursor_row: screenData.cursor_row,
+            cursor_col: screenData.cursor_col,
+            content: screenData.content,
+            screen_signature: screenData.screen_signature,
+        });
+    }
+    catch (err) {
+        res.status(500).json({
+            success: false,
+            error: err.message || 'Connection failed',
+        });
+    }
+});
+// POST /disconnect
+router.post('/disconnect', (req, res) => {
+    const session = resolveSession(req);
+    if (!session) {
+        return res.json({ success: true }); // Already disconnected
+    }
+    destroySession(session.id);
+    res.json({ success: true });
+});
+// POST /reconnect
+router.post('/reconnect', async (req, res) => {
+    const session = resolveSession(req);
+    if (!session) {
+        return res.status(404).json({ success: false, error: 'No active session' });
+    }
+    try {
+        await session.reconnect();
+        await new Promise(resolve => setTimeout(resolve, 2000));
+        const screenData = session.getScreenData();
+        res.json({
+            success: true,
+            cursor_row: screenData.cursor_row,
+            cursor_col: screenData.cursor_col,
+            content: screenData.content,
+            screen_signature: screenData.screen_signature,
+        });
+    }
+    catch (err) {
+        res.status(500).json({ success: false, error: err.message });
+    }
+});
+// GET /status
+router.get('/status', (req, res) => {
+    const session = resolveSession(req);
+    if (!session) {
+        return res.json({
+            connected: false,
+            status: 'disconnected',
+        });
+    }
+    res.json(session.status);
+});
+// GET /screen
+router.get('/screen', (req, res) => {
+    const session = resolveSession(req);
+    if (!session) {
+        return res.status(503).json(null);
+    }
+    if (!session.status.connected) {
+        return res.status(503).json(null);
+    }
+    res.json(session.getScreenData());
+});
+// POST /send-text
+router.post('/send-text', (req, res) => {
+    const session = resolveSession(req);
+    if (!session) {
+        return res.status(404).json({ success: false, error: 'No active session' });
+    }
+    const { text } = req.body || {};
+    if (typeof text !== 'string') {
+        return res.status(400).json({ success: false, error: 'text is required' });
+    }
+    const ok = session.sendText(text);
+    const screenData = session.getScreenData();
+    res.json({
+        success: ok,
+        cursor_row: screenData.cursor_row,
+        cursor_col: screenData.cursor_col,
+        content: screenData.content,
+        screen_signature: screenData.screen_signature,
+        error: ok ? undefined : 'Cannot type at current cursor position',
+    });
+});
+// POST /send-key
+router.post('/send-key', async (req, res) => {
+    const session = resolveSession(req);
+    if (!session) {
+        return res.status(404).json({ success: false, error: 'No active session' });
+    }
+    const { key } = req.body || {};
+    if (typeof key !== 'string') {
+        return res.status(400).json({ success: false, error: 'key is required' });
+    }
+    const ok = session.sendKey(key);
+    if (!ok) {
+        return res.json({ success: false, error: `Unknown key: ${key}` });
+    }
+    // Wait for the host to respond with a new screen
+    await new Promise(resolve => setTimeout(resolve, 1500));
+    const screenData = session.getScreenData();
+    res.json({
+        success: true,
+        cursor_row: screenData.cursor_row,
+        cursor_col: screenData.cursor_col,
+        content: screenData.content,
+        screen_signature: screenData.screen_signature,
+    });
+});
+export default router;

package/dist/server.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server.js

@@ -0,0 +1,34 @@
+import express from 'express';
+import cors from 'cors';
+import { createServer } from 'http';
+const isMock = process.argv.includes('--mock');
+const PORT = parseInt(process.env.PORT || '3001', 10);
+const app = express();
+app.use(cors());
+app.use(express.json());
+if (isMock) {
+    import('./mock/mock-routes.js').then(({ default: mockRoutes }) => {
+        app.use('/', mockRoutes);
+        startServer();
+    });
+}
+else {
+    Promise.all([
+        import('./routes.js'),
+        import('./websocket.js'),
+    ]).then(([{ default: routes }, { setupWebSocket }]) => {
+        app.use('/', routes);
+        startServer(setupWebSocket);
+    });
+}
+function startServer(setupWebSocket) {
+    const server = createServer(app);
+    if (setupWebSocket)
+        setupWebSocket(server);
+    server.listen(PORT, () => {
+        console.log(`Green Screen proxy server running on http://localhost:${PORT}`);
+        if (isMock) {
+            console.log('Running in MOCK mode (no real IBM i connection)');
+        }
+    });
+}

package/dist/session.d.ts

@@ -0,0 +1,32 @@
+import { EventEmitter } from 'events';
+import { ProtocolHandler, ProtocolType, ScreenData } from './protocols/index.js';
+export interface SessionStatus {
+    connected: boolean;
+    status: 'disconnected' | 'connecting' | 'connected' | 'authenticated' | 'error';
+    protocol?: ProtocolType;
+    host?: string;
+    username?: string;
+    error?: string;
+}
+export declare class Session extends EventEmitter {
+    readonly id: string;
+    readonly handler: ProtocolHandler;
+    readonly protocol: ProtocolType;
+    private _status;
+    private _host;
+    private _port;
+    constructor(protocol?: ProtocolType);
+    get status(): SessionStatus;
+    connect(host: string, port: number): Promise<void>;
+    disconnect(): void;
+    reconnect(): Promise<void>;
+    sendText(text: string): boolean;
+    sendKey(keyName: string): boolean;
+    getScreenData(): ScreenData;
+    destroy(): void;
+}
+export declare function createSession(protocol?: ProtocolType): Session;
+export declare function getSession(id: string): Session | undefined;
+export declare function destroySession(id: string): void;
+export declare function getDefaultSession(): Session | undefined;
+export declare function getAllSessions(): Map<string, Session>;

package/dist/session.js

@@ -0,0 +1,88 @@
+import { randomUUID } from 'crypto';
+import { EventEmitter } from 'events';
+import { createProtocolHandler } from './protocols/index.js';
+export class Session extends EventEmitter {
+    id;
+    handler;
+    protocol;
+    _status = { connected: false, status: 'disconnected' };
+    _host = '';
+    _port = 23;
+    constructor(protocol = 'tn5250') {
+        super();
+        this.id = randomUUID();
+        this.protocol = protocol;
+        this.handler = createProtocolHandler(protocol);
+        this.handler.on('screenChange', (screenData) => {
+            this.emit('screenChange', screenData);
+        });
+        this.handler.on('disconnected', () => {
+            this._status = { connected: false, status: 'disconnected', protocol: this.protocol, host: this._host };
+            this.emit('statusChange', this._status);
+        });
+        this.handler.on('error', (err) => {
+            this._status = { connected: false, status: 'error', protocol: this.protocol, host: this._host, error: err.message };
+            this.emit('statusChange', this._status);
+        });
+    }
+    get status() {
+        return { ...this._status };
+    }
+    async connect(host, port) {
+        this._host = host;
+        this._port = port;
+        this._status = { connected: false, status: 'connecting', protocol: this.protocol, host };
+        this.emit('statusChange', this._status);
+        await this.handler.connect(host, port);
+        this._status = { connected: true, status: 'connected', protocol: this.protocol, host };
+        this.emit('statusChange', this._status);
+    }
+    disconnect() {
+        this.handler.disconnect();
+        this._status = { connected: false, status: 'disconnected', protocol: this.protocol, host: this._host };
+        this.emit('statusChange', this._status);
+    }
+    async reconnect() {
+        this.disconnect();
+        await this.connect(this._host, this._port);
+    }
+    sendText(text) {
+        return this.handler.sendText(text);
+    }
+    sendKey(keyName) {
+        return this.handler.sendKey(keyName);
+    }
+    getScreenData() {
+        return this.handler.getScreenData();
+    }
+    destroy() {
+        this.handler.destroy();
+        this.removeAllListeners();
+    }
+}
+// Session manager
+const sessions = new Map();
+export function createSession(protocol = 'tn5250') {
+    const session = new Session(protocol);
+    sessions.set(session.id, session);
+    return session;
+}
+export function getSession(id) {
+    return sessions.get(id);
+}
+export function destroySession(id) {
+    const session = sessions.get(id);
+    if (session) {
+        session.destroy();
+        sessions.delete(id);
+    }
+}
+export function getDefaultSession() {
+    if (sessions.size === 1) {
+        return sessions.values().next().value;
+    }
+    return undefined;
+}
+export function getAllSessions() {
+    return sessions;
+}

package/dist/tn3270/connection.d.ts

@@ -0,0 +1,31 @@
+import { EventEmitter } from 'events';
+/**
+ * Manages raw TCP socket to a z/OS (or other 3270) host.
+ * Handles Telnet negotiation and extracts 3270 data records (IAC EOR delimited).
+ *
+ * Supports basic TN3270 (RFC 1576) negotiation.
+ * TN3270E (RFC 2355) is handled at a basic level.
+ */
+export declare class TN3270Connection extends EventEmitter {
+    private socket;
+    private host;
+    private port;
+    private connected;
+    private recvBuffer;
+    private tn3270eMode;
+    get isConnected(): boolean;
+    connect(host: string, port: number): Promise<void>;
+    disconnect(): void;
+    sendRaw(data: Buffer): void;
+    private cleanup;
+    private onData;
+    private processBuffer;
+    private findSubnegEnd;
+    private findRecordEnd;
+    private unescapeIAC;
+    private handleNegotiation;
+    private handleSubnegotiation;
+    private sendTerminalType;
+    private handleTN3270ESubneg;
+    private sendTelnet;
+}

package/dist/tn3270/connection.js

@@ -0,0 +1,266 @@
+import * as net from 'net';
+import { EventEmitter } from 'events';
+import { TELNET } from '../tn5250/constants.js';
+import { TERMINAL_TYPE } from './constants.js';
+/**
+ * Manages raw TCP socket to a z/OS (or other 3270) host.
+ * Handles Telnet negotiation and extracts 3270 data records (IAC EOR delimited).
+ *
+ * Supports basic TN3270 (RFC 1576) negotiation.
+ * TN3270E (RFC 2355) is handled at a basic level.
+ */
+export class TN3270Connection extends EventEmitter {
+    socket = null;
+    host = '';
+    port = 23;
+    connected = false;
+    recvBuffer = Buffer.alloc(0);
+    tn3270eMode = false;
+    get isConnected() {
+        return this.connected;
+    }
+    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.tn3270eMode = 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();
+        }
+    }
+    sendRaw(data) {
+        if (this.socket && this.connected) {
+            this.socket.write(data);
+        }
+    }
+    cleanup() {
+        this.connected = false;
+        if (this.socket) {
+            this.socket.removeAllListeners();
+            this.socket.destroy();
+            this.socket = null;
+        }
+    }
+    onData(data) {
+        this.recvBuffer = Buffer.concat([this.recvBuffer, data]);
+        this.processBuffer();
+    }
+    processBuffer() {
+        while (this.recvBuffer.length > 0) {
+            // Check for Telnet commands
+            if (this.recvBuffer[0] === TELNET.IAC && this.recvBuffer.length >= 2) {
+                const cmd = this.recvBuffer[1];
+                if (cmd === TELNET.IAC) {
+                    // Escaped 0xFF — part of data stream
+                    break;
+                }
+                // Subnegotiation
+                if (cmd === TELNET.SB) {
+                    const seIdx = this.findSubnegEnd();
+                    if (seIdx === -1)
+                        return;
+                    const subData = this.recvBuffer.subarray(2, seIdx);
+                    this.recvBuffer = this.recvBuffer.subarray(seIdx + 2);
+                    this.handleSubnegotiation(subData);
+                    continue;
+                }
+                // DO/DONT/WILL/WONT
+                if (cmd === TELNET.DO || cmd === TELNET.DONT || cmd === TELNET.WILL || cmd === TELNET.WONT) {
+                    if (this.recvBuffer.length < 3)
+                        return;
+                    const option = this.recvBuffer[2];
+                    this.recvBuffer = this.recvBuffer.subarray(3);
+                    this.handleNegotiation(cmd, option);
+                    continue;
+                }
+                if (cmd === TELNET.EOR) {
+                    this.recvBuffer = this.recvBuffer.subarray(2);
+                    continue;
+                }
+                // Skip unknown 2-byte commands
+                this.recvBuffer = this.recvBuffer.subarray(2);
+                continue;
+            }
+            // Extract a 3270 record: data terminated by IAC EOR
+            const recordEnd = this.findRecordEnd();
+            if (recordEnd === -1)
+                return;
+            const rawRecord = this.recvBuffer.subarray(0, recordEnd);
+            this.recvBuffer = this.recvBuffer.subarray(recordEnd + 2);
+            const record = this.unescapeIAC(rawRecord);
+            if (record.length > 0) {
+                // In TN3270E mode, strip the 5-byte header
+                if (this.tn3270eMode && record.length > 5) {
+                    const dataRecord = record.subarray(5);
+                    if (dataRecord.length > 0) {
+                        this.emit('data', dataRecord);
+                    }
+                }
+                else {
+                    this.emit('data', record);
+                }
+            }
+        }
+    }
+    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;
+    }
+    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;
+    }
+    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++;
+            }
+            else {
+                result.push(data[i]);
+            }
+        }
+        return Buffer.from(result);
+    }
+    handleNegotiation(cmd, option) {
+        switch (cmd) {
+            case TELNET.DO:
+                if (option === TELNET.OPT_TTYPE ||
+                    option === TELNET.OPT_EOR ||
+                    option === TELNET.OPT_BINARY) {
+                    this.sendTelnet(TELNET.WILL, option);
+                }
+                else if (option === 0x28) {
+                    // TN3270E — accept
+                    this.sendTelnet(TELNET.WILL, option);
+                    this.tn3270eMode = true;
+                }
+                else {
+                    this.sendTelnet(TELNET.WONT, option);
+                }
+                break;
+            case TELNET.WILL:
+                if (option === TELNET.OPT_EOR ||
+                    option === TELNET.OPT_BINARY) {
+                    this.sendTelnet(TELNET.DO, option);
+                }
+                else if (option === 0x28) {
+                    this.sendTelnet(TELNET.DO, option);
+                    this.tn3270eMode = true;
+                }
+                else {
+                    this.sendTelnet(TELNET.DONT, option);
+                }
+                break;
+            case TELNET.DONT:
+                this.sendTelnet(TELNET.WONT, option);
+                break;
+            case TELNET.WONT:
+                this.sendTelnet(TELNET.DONT, option);
+                break;
+        }
+    }
+    handleSubnegotiation(data) {
+        if (data.length === 0)
+            return;
+        const option = data[0];
+        if (option === TELNET.OPT_TTYPE && data.length >= 2 && data[1] === TELNET.TTYPE_SEND) {
+            this.sendTerminalType();
+        }
+        else if (option === 0x28) {
+            // TN3270E subnegotiation
+            this.handleTN3270ESubneg(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);
+    }
+    handleTN3270ESubneg(data) {
+        if (data.length < 2)
+            return;
+        const msgType = data[1];
+        // TN3270E DEVICE-TYPE SEND (0x08 0x02)
+        if (msgType === 0x02) {
+            // Send device type response
+            const typeStr = TERMINAL_TYPE;
+            const resp = Buffer.alloc(4 + typeStr.length + 2);
+            let i = 0;
+            resp[i++] = TELNET.IAC;
+            resp[i++] = TELNET.SB;
+            resp[i++] = 0x28; // TN3270E
+            resp[i++] = 0x02; // DEVICE-TYPE IS
+            for (let j = 0; j < typeStr.length; j++) {
+                resp[i++] = typeStr.charCodeAt(j);
+            }
+            resp[i++] = TELNET.IAC;
+            resp[i++] = TELNET.SE;
+            this.sendRaw(resp);
+        }
+        // TN3270E FUNCTIONS REQUEST (0x08 0x04)
+        if (msgType === 0x04) {
+            // Accept no functions
+            this.sendRaw(Buffer.from([
+                TELNET.IAC, TELNET.SB, 0x28,
+                0x04, // FUNCTIONS IS
+                TELNET.IAC, TELNET.SE,
+            ]));
+        }
+    }
+    sendTelnet(cmd, option) {
+        this.sendRaw(Buffer.from([TELNET.IAC, cmd, option]));
+    }
+}