green-screen-proxy 0.3.0

package/dist/vt/screen.d.ts

@@ -0,0 +1,101 @@
+import type { ScreenData } from '../protocols/types.js';
+/**
+ * Character attributes for a single cell in the VT screen buffer.
+ */
+export interface CellAttrs {
+    bold: boolean;
+    dim: boolean;
+    italic: boolean;
+    underline: boolean;
+    blink: boolean;
+    reverse: boolean;
+    hidden: boolean;
+    strikethrough: boolean;
+    fg: number;
+    bg: number;
+}
+/** Create a default (reset) attribute set */
+export declare function defaultAttrs(): CellAttrs;
+/** Synthetic field detected from VT screen content */
+export interface SyntheticField {
+    row: number;
+    col: number;
+    length: number;
+    is_input: boolean;
+    is_protected: boolean;
+    is_highlighted?: boolean;
+    is_reverse?: boolean;
+}
+/**
+ * VT terminal screen buffer.
+ *
+ * A simple character grid with per-cell attributes. No native field concept —
+ * fields are detected synthetically by scanning for common patterns like
+ * "Label: ____" or prompt strings.
+ */
+export declare class VTScreenBuffer {
+    rows: number;
+    cols: number;
+    /** Character grid */
+    buffer: string[];
+    /** Per-cell attributes */
+    attrs: CellAttrs[];
+    cursorRow: number;
+    cursorCol: number;
+    /** Scroll region (top and bottom row, inclusive, 0-indexed) */
+    scrollTop: number;
+    scrollBottom: number;
+    /** Saved cursor state (DECSC / DECRC) */
+    private savedCursor;
+    /** Current drawing attributes (applied to new characters) */
+    currentAttrs: CellAttrs;
+    /** Line-wrapping mode (DECAWM) */
+    autoWrap: boolean;
+    /** Origin mode (DECOM) — cursor addressing relative to scroll region */
+    originMode: boolean;
+    /** Pending wrap — the next printable char wraps to next line */
+    pendingWrap: boolean;
+    constructor(rows?: number, cols?: number);
+    get size(): number;
+    offset(row: number, col: number): number;
+    /** Write a character at the current cursor position and advance cursor */
+    writeChar(ch: string): void;
+    /** Set a character at a specific position without moving cursor */
+    setChar(row: number, col: number, ch: string, cellAttrs?: CellAttrs): void;
+    getChar(row: number, col: number): string;
+    setCursor(row: number, col: number): void;
+    private clampRow;
+    private clampCol;
+    lineFeed(): void;
+    reverseLineFeed(): void;
+    /** Scroll the scroll region up by n lines (new blank lines at bottom) */
+    scrollUp(n: number): void;
+    /** Scroll the scroll region down by n lines (new blank lines at top) */
+    scrollDown(n: number): void;
+    /** ED — Erase in Display */
+    eraseInDisplay(mode: number): void;
+    /** EL — Erase in Line */
+    eraseInLine(mode: number): void;
+    /** ECH — Erase Characters */
+    eraseCharacters(n: number): void;
+    private eraseRange;
+    /** IL — Insert n blank lines at cursor row */
+    insertLines(n: number): void;
+    /** DL — Delete n lines at cursor row */
+    deleteLines(n: number): void;
+    /** ICH — Insert n blank characters at cursor */
+    insertCharacters(n: number): void;
+    /** DCH — Delete n characters at cursor */
+    deleteCharacters(n: number): void;
+    saveCursor(): void;
+    restoreCursor(): void;
+    reset(): void;
+    tabForward(): void;
+    /**
+     * Detect synthetic fields from the screen content. Best-effort heuristic —
+     * VT terminals have no native field concept.
+     */
+    detectFields(): SyntheticField[];
+    /** Convert to the protocol-agnostic ScreenData format */
+    toScreenData(): ScreenData;
+}

package/dist/vt/screen.js

@@ -0,0 +1,424 @@
+import { createHash } from 'crypto';
+import { DEFAULT_ROWS, DEFAULT_COLS } from './constants.js';
+/** Create a default (reset) attribute set */
+export function defaultAttrs() {
+    return {
+        bold: false,
+        dim: false,
+        italic: false,
+        underline: false,
+        blink: false,
+        reverse: false,
+        hidden: false,
+        strikethrough: false,
+        fg: 8, // default
+        bg: 8, // default
+    };
+}
+/**
+ * VT terminal screen buffer.
+ *
+ * A simple character grid with per-cell attributes. No native field concept —
+ * fields are detected synthetically by scanning for common patterns like
+ * "Label: ____" or prompt strings.
+ */
+export class VTScreenBuffer {
+    rows;
+    cols;
+    /** Character grid */
+    buffer;
+    /** Per-cell attributes */
+    attrs;
+    cursorRow = 0;
+    cursorCol = 0;
+    /** Scroll region (top and bottom row, inclusive, 0-indexed) */
+    scrollTop = 0;
+    scrollBottom;
+    /** Saved cursor state (DECSC / DECRC) */
+    savedCursor = null;
+    /** Current drawing attributes (applied to new characters) */
+    currentAttrs;
+    /** Line-wrapping mode (DECAWM) */
+    autoWrap = true;
+    /** Origin mode (DECOM) — cursor addressing relative to scroll region */
+    originMode = false;
+    /** Pending wrap — the next printable char wraps to next line */
+    pendingWrap = false;
+    constructor(rows = DEFAULT_ROWS, cols = DEFAULT_COLS) {
+        this.rows = rows;
+        this.cols = cols;
+        this.scrollBottom = rows - 1;
+        const size = rows * cols;
+        this.buffer = new Array(size).fill(' ');
+        this.attrs = new Array(size);
+        for (let i = 0; i < size; i++) {
+            this.attrs[i] = defaultAttrs();
+        }
+        this.currentAttrs = defaultAttrs();
+    }
+    get size() {
+        return this.rows * this.cols;
+    }
+    offset(row, col) {
+        return row * this.cols + col;
+    }
+    // ---------------------------------------------------------------------------
+    // Character operations
+    // ---------------------------------------------------------------------------
+    /** Write a character at the current cursor position and advance cursor */
+    writeChar(ch) {
+        if (this.pendingWrap) {
+            if (this.autoWrap) {
+                this.cursorCol = 0;
+                this.lineFeed();
+            }
+            this.pendingWrap = false;
+        }
+        const off = this.offset(this.cursorRow, this.cursorCol);
+        if (off >= 0 && off < this.size) {
+            this.buffer[off] = ch;
+            this.attrs[off] = { ...this.currentAttrs };
+        }
+        if (this.cursorCol < this.cols - 1) {
+            this.cursorCol++;
+        }
+        else {
+            // At last column — set pending wrap flag
+            this.pendingWrap = true;
+        }
+    }
+    /** Set a character at a specific position without moving cursor */
+    setChar(row, col, ch, cellAttrs) {
+        const off = this.offset(row, col);
+        if (off >= 0 && off < this.size) {
+            this.buffer[off] = ch;
+            if (cellAttrs)
+                this.attrs[off] = { ...cellAttrs };
+        }
+    }
+    getChar(row, col) {
+        const off = this.offset(row, col);
+        return off >= 0 && off < this.size ? this.buffer[off] : ' ';
+    }
+    // ---------------------------------------------------------------------------
+    // Cursor movement
+    // ---------------------------------------------------------------------------
+    setCursor(row, col) {
+        this.cursorRow = this.clampRow(row);
+        this.cursorCol = this.clampCol(col);
+        this.pendingWrap = false;
+    }
+    clampRow(row) {
+        return Math.max(0, Math.min(this.rows - 1, row));
+    }
+    clampCol(col) {
+        return Math.max(0, Math.min(this.cols - 1, col));
+    }
+    // ---------------------------------------------------------------------------
+    // Line feed / scrolling
+    // ---------------------------------------------------------------------------
+    lineFeed() {
+        if (this.cursorRow === this.scrollBottom) {
+            this.scrollUp(1);
+        }
+        else if (this.cursorRow < this.rows - 1) {
+            this.cursorRow++;
+        }
+    }
+    reverseLineFeed() {
+        if (this.cursorRow === this.scrollTop) {
+            this.scrollDown(1);
+        }
+        else if (this.cursorRow > 0) {
+            this.cursorRow--;
+        }
+    }
+    /** Scroll the scroll region up by n lines (new blank lines at bottom) */
+    scrollUp(n) {
+        for (let i = 0; i < n; i++) {
+            for (let r = this.scrollTop; r < this.scrollBottom; r++) {
+                const dstOff = r * this.cols;
+                const srcOff = (r + 1) * this.cols;
+                for (let c = 0; c < this.cols; c++) {
+                    this.buffer[dstOff + c] = this.buffer[srcOff + c];
+                    this.attrs[dstOff + c] = this.attrs[srcOff + c];
+                }
+            }
+            const bottomOff = this.scrollBottom * this.cols;
+            for (let c = 0; c < this.cols; c++) {
+                this.buffer[bottomOff + c] = ' ';
+                this.attrs[bottomOff + c] = defaultAttrs();
+            }
+        }
+    }
+    /** Scroll the scroll region down by n lines (new blank lines at top) */
+    scrollDown(n) {
+        for (let i = 0; i < n; i++) {
+            for (let r = this.scrollBottom; r > this.scrollTop; r--) {
+                const dstOff = r * this.cols;
+                const srcOff = (r - 1) * this.cols;
+                for (let c = 0; c < this.cols; c++) {
+                    this.buffer[dstOff + c] = this.buffer[srcOff + c];
+                    this.attrs[dstOff + c] = this.attrs[srcOff + c];
+                }
+            }
+            const topOff = this.scrollTop * this.cols;
+            for (let c = 0; c < this.cols; c++) {
+                this.buffer[topOff + c] = ' ';
+                this.attrs[topOff + c] = defaultAttrs();
+            }
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Erase operations
+    // ---------------------------------------------------------------------------
+    /** ED — Erase in Display */
+    eraseInDisplay(mode) {
+        switch (mode) {
+            case 0:
+                this.eraseRange(this.offset(this.cursorRow, this.cursorCol), this.size);
+                break;
+            case 1:
+                this.eraseRange(0, this.offset(this.cursorRow, this.cursorCol) + 1);
+                break;
+            case 2:
+            case 3:
+                this.eraseRange(0, this.size);
+                break;
+        }
+    }
+    /** EL — Erase in Line */
+    eraseInLine(mode) {
+        const rowStart = this.cursorRow * this.cols;
+        switch (mode) {
+            case 0:
+                this.eraseRange(this.offset(this.cursorRow, this.cursorCol), rowStart + this.cols);
+                break;
+            case 1:
+                this.eraseRange(rowStart, this.offset(this.cursorRow, this.cursorCol) + 1);
+                break;
+            case 2:
+                this.eraseRange(rowStart, rowStart + this.cols);
+                break;
+        }
+    }
+    /** ECH — Erase Characters */
+    eraseCharacters(n) {
+        const start = this.offset(this.cursorRow, this.cursorCol);
+        const end = Math.min(start + n, this.cursorRow * this.cols + this.cols);
+        this.eraseRange(start, end);
+    }
+    eraseRange(start, end) {
+        for (let i = start; i < end && i < this.size; i++) {
+            this.buffer[i] = ' ';
+            this.attrs[i] = defaultAttrs();
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Insert / Delete lines and characters
+    // ---------------------------------------------------------------------------
+    /** IL — Insert n blank lines at cursor row */
+    insertLines(n) {
+        if (this.cursorRow < this.scrollTop || this.cursorRow > this.scrollBottom)
+            return;
+        const oldTop = this.scrollTop;
+        this.scrollTop = this.cursorRow;
+        this.scrollDown(n);
+        this.scrollTop = oldTop;
+    }
+    /** DL — Delete n lines at cursor row */
+    deleteLines(n) {
+        if (this.cursorRow < this.scrollTop || this.cursorRow > this.scrollBottom)
+            return;
+        const oldTop = this.scrollTop;
+        this.scrollTop = this.cursorRow;
+        this.scrollUp(n);
+        this.scrollTop = oldTop;
+    }
+    /** ICH — Insert n blank characters at cursor */
+    insertCharacters(n) {
+        const rowOff = this.cursorRow * this.cols;
+        const curOff = rowOff + this.cursorCol;
+        const endOff = rowOff + this.cols;
+        for (let i = endOff - 1; i >= curOff + n; i--) {
+            this.buffer[i] = this.buffer[i - n];
+            this.attrs[i] = this.attrs[i - n];
+        }
+        for (let i = curOff; i < curOff + n && i < endOff; i++) {
+            this.buffer[i] = ' ';
+            this.attrs[i] = defaultAttrs();
+        }
+    }
+    /** DCH — Delete n characters at cursor */
+    deleteCharacters(n) {
+        const rowOff = this.cursorRow * this.cols;
+        const curOff = rowOff + this.cursorCol;
+        const endOff = rowOff + this.cols;
+        for (let i = curOff; i < endOff - n; i++) {
+            this.buffer[i] = this.buffer[i + n];
+            this.attrs[i] = this.attrs[i + n];
+        }
+        for (let i = endOff - n; i < endOff; i++) {
+            this.buffer[i] = ' ';
+            this.attrs[i] = defaultAttrs();
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Cursor save / restore (DECSC / DECRC)
+    // ---------------------------------------------------------------------------
+    saveCursor() {
+        this.savedCursor = {
+            row: this.cursorRow,
+            col: this.cursorCol,
+            attrs: { ...this.currentAttrs },
+        };
+    }
+    restoreCursor() {
+        if (this.savedCursor) {
+            this.cursorRow = this.savedCursor.row;
+            this.cursorCol = this.savedCursor.col;
+            this.currentAttrs = { ...this.savedCursor.attrs };
+            this.pendingWrap = false;
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Full reset
+    // ---------------------------------------------------------------------------
+    reset() {
+        this.buffer.fill(' ');
+        for (let i = 0; i < this.size; i++) {
+            this.attrs[i] = defaultAttrs();
+        }
+        this.cursorRow = 0;
+        this.cursorCol = 0;
+        this.scrollTop = 0;
+        this.scrollBottom = this.rows - 1;
+        this.currentAttrs = defaultAttrs();
+        this.autoWrap = true;
+        this.originMode = false;
+        this.pendingWrap = false;
+        this.savedCursor = null;
+    }
+    // ---------------------------------------------------------------------------
+    // Tab stops
+    // ---------------------------------------------------------------------------
+    tabForward() {
+        const nextTab = (Math.floor(this.cursorCol / 8) + 1) * 8;
+        this.cursorCol = Math.min(nextTab, this.cols - 1);
+        this.pendingWrap = false;
+    }
+    // ---------------------------------------------------------------------------
+    // Synthetic field detection
+    // ---------------------------------------------------------------------------
+    /**
+     * Detect synthetic fields from the screen content. Best-effort heuristic —
+     * VT terminals have no native field concept.
+     */
+    detectFields() {
+        const fields = [];
+        for (let r = 0; r < this.rows; r++) {
+            const rowStart = r * this.cols;
+            const line = this.buffer.slice(rowStart, rowStart + this.cols).join('');
+            // Pattern 1: Underscore runs (3+ consecutive underscores)
+            const underscoreRe = /_{3,}/g;
+            let match;
+            while ((match = underscoreRe.exec(line)) !== null) {
+                fields.push({
+                    row: r,
+                    col: match.index,
+                    length: match[0].length,
+                    is_input: true,
+                    is_protected: false,
+                });
+            }
+            // Pattern 2: Reverse-video runs (possible input fields)
+            let inReverse = false;
+            let reverseStart = 0;
+            for (let c = 0; c < this.cols; c++) {
+                const a = this.attrs[rowStart + c];
+                if (a.reverse && !inReverse) {
+                    inReverse = true;
+                    reverseStart = c;
+                }
+                else if (!a.reverse && inReverse) {
+                    inReverse = false;
+                    const len = c - reverseStart;
+                    if (len >= 3) {
+                        fields.push({
+                            row: r,
+                            col: reverseStart,
+                            length: len,
+                            is_input: true,
+                            is_protected: false,
+                            is_reverse: true,
+                        });
+                    }
+                }
+            }
+            if (inReverse) {
+                const len = this.cols - reverseStart;
+                if (len >= 3) {
+                    fields.push({
+                        row: r,
+                        col: reverseStart,
+                        length: len,
+                        is_input: true,
+                        is_protected: false,
+                        is_reverse: true,
+                    });
+                }
+            }
+            // Pattern 3: Prompt detection
+            const promptRe = /\b(Username|Login|Password|User|Passwd|Account|Host|Port)\s*:\s*/gi;
+            let pm;
+            while ((pm = promptRe.exec(line)) !== null) {
+                const afterPrompt = pm.index + pm[0].length;
+                const remaining = line.substring(afterPrompt);
+                const inputLen = remaining.length - remaining.trimEnd().length || remaining.length;
+                if (inputLen > 0) {
+                    fields.push({
+                        row: r,
+                        col: afterPrompt,
+                        length: Math.min(inputLen, this.cols - afterPrompt),
+                        is_input: true,
+                        is_protected: false,
+                    });
+                }
+            }
+        }
+        // Deduplicate overlapping fields
+        const deduped = [];
+        for (const f of fields) {
+            const overlaps = deduped.some((d) => d.row === f.row &&
+                f.col < d.col + d.length &&
+                f.col + f.length > d.col);
+            if (!overlaps)
+                deduped.push(f);
+        }
+        return deduped;
+    }
+    // ---------------------------------------------------------------------------
+    // Serialization
+    // ---------------------------------------------------------------------------
+    /** Convert to the protocol-agnostic ScreenData format */
+    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.detectFields();
+        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/websocket.d.ts

@@ -0,0 +1,6 @@
+import { WebSocketServer } from 'ws';
+import { Server as HttpServer } from 'http';
+import { Session } from './session.js';
+export declare function setupWebSocket(server: HttpServer): WebSocketServer;
+/** Subscribe to a session's events and push to connected WS clients */
+export declare function bindSessionToWebSocket(session: Session): void;

package/dist/websocket.js

@@ -0,0 +1,50 @@
+import { WebSocketServer, WebSocket } from 'ws';
+import { URL } from 'url';
+import { getSession, getDefaultSession } from './session.js';
+const clients = new Set();
+export function setupWebSocket(server) {
+    const wss = new WebSocketServer({ server, path: '/ws' });
+    wss.on('connection', (ws, req) => {
+        // Extract sessionId from query params
+        const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+        const sessionId = url.searchParams.get('sessionId');
+        const client = { ws, sessionId };
+        clients.add(client);
+        ws.on('close', () => {
+            clients.delete(client);
+        });
+        ws.on('error', () => {
+            clients.delete(client);
+        });
+        // Send current screen immediately if a session is available
+        const session = sessionId ? getSession(sessionId) : getDefaultSession();
+        if (session && session.status.connected) {
+            ws.send(JSON.stringify({ type: 'screen', data: session.getScreenData() }));
+            ws.send(JSON.stringify({ type: 'status', data: session.status }));
+        }
+    });
+    return wss;
+}
+/** Subscribe to a session's events and push to connected WS clients */
+export function bindSessionToWebSocket(session) {
+    session.on('screenChange', (screenData) => {
+        const msg = JSON.stringify({ type: 'screen', data: screenData });
+        broadcastToSession(session.id, msg);
+    });
+    session.on('statusChange', (status) => {
+        const msg = JSON.stringify({ type: 'status', data: status });
+        broadcastToSession(session.id, msg);
+    });
+}
+function broadcastToSession(sessionId, message) {
+    for (const client of clients) {
+        if (client.ws.readyState !== WebSocket.OPEN)
+            continue;
+        // Send to clients that are either:
+        // 1. Explicitly bound to this session
+        // 2. Not bound to any session (will receive from default/single session)
+        if (client.sessionId === sessionId || client.sessionId === null) {
+            client.ws.send(message);
+        }
+    }
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "green-screen-proxy",
+  "version": "0.3.0",
+  "description": "WebSocket/REST proxy server for green-screen-react — connects browsers to TN5250, TN3270, VT220, and HP 6530 hosts over TCP",
+  "type": "module",
+  "bin": {
+    "green-screen-proxy": "dist/cli.js"
+  },
+  "main": "dist/server.js",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "tsx watch src/server.ts",
+    "build": "tsc",
+    "start": "node dist/server.js",
+    "lint": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "terminal",
+    "proxy",
+    "tn5250",
+    "tn3270",
+    "vt220",
+    "hp6530",
+    "ibm-i",
+    "as400",
+    "mainframe",
+    "green-screen",
+    "telnet",
+    "websocket"
+  ],
+  "author": "VisionBridge Solutions",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/visionbridge-solutions/green-screen-react.git",
+    "directory": "proxy"
+  },
+  "homepage": "https://github.com/visionbridge-solutions/green-screen-react#proxy-setup",
+  "bugs": {
+    "url": "https://github.com/visionbridge-solutions/green-screen-react/issues"
+  },
+  "dependencies": {
+    "cors": "^2.8.5",
+    "express": "^4.21.0",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/cors": "^2.8.17",
+    "@types/express": "^4.17.21",
+    "@types/ws": "^8.5.12",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0"
+  }
+}