green-screen-proxy 0.3.0

package/dist/hp6530/parser.d.ts

@@ -0,0 +1,45 @@
+import { HP6530Screen } from './screen.js';
+/**
+ * Parses HP 6530 escape sequences from a data stream and applies
+ * them to the screen buffer.
+ *
+ * The HP 6530 uses an escape-sequence protocol that is somewhat
+ * similar to VT terminals but with HP-specific extensions for
+ * block-mode operation, protected fields, and display attributes.
+ */
+export declare class HP6530Parser {
+    private screen;
+    private state;
+    /** Accumulated numeric parameter for CSI sequences */
+    private csiParams;
+    constructor(screen: HP6530Screen);
+    /**
+     * Parse a chunk of data from the host.
+     * Returns true if the screen was modified.
+     */
+    parse(data: Buffer): boolean;
+    /**
+     * Process a single byte through the state machine.
+     * Returns true if the screen was modified.
+     */
+    private processByte;
+    /** Process a byte in NORMAL state */
+    private processNormal;
+    /** Process a byte after ESC */
+    private processEsc;
+    /**
+     * Process bytes inside a CSI sequence: ESC [ param ; param H
+     * We accumulate digits and ';' until we see the final character.
+     */
+    private processCsi;
+    /** Process a byte after ESC & */
+    private processAmp;
+    /** Process the attribute code byte after ESC & d */
+    private processAmpD;
+    /** Handle CSI cursor position: ESC [ row ; col H */
+    private handleCursorPosition;
+    /** Handle CSI erase display: ESC [ n J */
+    private handleEraseDisplay;
+    /** Handle tab: move to next unprotected field or next tab stop */
+    private handleTab;
+}

package/dist/hp6530/parser.js

@@ -0,0 +1,255 @@
+import { CTRL } from './constants.js';
+/**
+ * Parses HP 6530 escape sequences from a data stream and applies
+ * them to the screen buffer.
+ *
+ * The HP 6530 uses an escape-sequence protocol that is somewhat
+ * similar to VT terminals but with HP-specific extensions for
+ * block-mode operation, protected fields, and display attributes.
+ */
+export class HP6530Parser {
+    screen;
+    state = 0 /* State.NORMAL */;
+    /** Accumulated numeric parameter for CSI sequences */
+    csiParams = '';
+    constructor(screen) {
+        this.screen = screen;
+    }
+    /**
+     * Parse a chunk of data from the host.
+     * Returns true if the screen was modified.
+     */
+    parse(data) {
+        let modified = false;
+        for (let i = 0; i < data.length; i++) {
+            const byte = data[i];
+            const changed = this.processByte(byte);
+            if (changed)
+                modified = true;
+        }
+        if (modified) {
+            this.screen.buildFields();
+        }
+        return modified;
+    }
+    /**
+     * Process a single byte through the state machine.
+     * Returns true if the screen was modified.
+     */
+    processByte(byte) {
+        switch (this.state) {
+            case 0 /* State.NORMAL */:
+                return this.processNormal(byte);
+            case 1 /* State.ESC */:
+                return this.processEsc(byte);
+            case 2 /* State.CSI */:
+                return this.processCsi(byte);
+            case 3 /* State.AMP */:
+                return this.processAmp(byte);
+            case 4 /* State.AMP_D */:
+                return this.processAmpD(byte);
+            default:
+                this.state = 0 /* State.NORMAL */;
+                return false;
+        }
+    }
+    /** Process a byte in NORMAL state */
+    processNormal(byte) {
+        // ESC starts an escape sequence
+        if (byte === CTRL.ESC) {
+            this.state = 1 /* State.ESC */;
+            return false;
+        }
+        // Control characters
+        switch (byte) {
+            case CTRL.CR:
+                this.screen.cursorCol = 0;
+                return true;
+            case CTRL.LF:
+                this.screen.cursorRow++;
+                if (this.screen.cursorRow >= this.screen.rows) {
+                    this.screen.cursorRow = this.screen.rows - 1;
+                    // In a real terminal this would scroll; for block mode we stay put
+                }
+                return true;
+            case CTRL.BS:
+                if (this.screen.cursorCol > 0) {
+                    this.screen.cursorCol--;
+                }
+                return true;
+            case CTRL.HT:
+                // Tab: advance to next tab stop (every 8 columns) or next unprotected field
+                this.handleTab();
+                return true;
+            case CTRL.BEL:
+                // Bell — no screen change
+                return false;
+            case CTRL.FF:
+                // Form feed — clear screen
+                this.screen.clear();
+                return true;
+            case CTRL.NUL:
+                // Ignore NULs
+                return false;
+        }
+        // Printable ASCII (0x20–0x7E)
+        if (byte >= 0x20 && byte <= 0x7E) {
+            this.screen.putChar(String.fromCharCode(byte));
+            return true;
+        }
+        // High-bit characters (0x80–0xFF) — pass through as-is
+        if (byte >= 0x80) {
+            this.screen.putChar(String.fromCharCode(byte));
+            return true;
+        }
+        // Other control chars: ignore
+        return false;
+    }
+    /** Process a byte after ESC */
+    processEsc(byte) {
+        this.state = 0 /* State.NORMAL */;
+        switch (byte) {
+            // ESC [ — CSI (cursor addressing)
+            case 0x5B: // '['
+                this.state = 2 /* State.CSI */;
+                this.csiParams = '';
+                return false;
+            // ESC & — start of attribute sequence
+            case 0x26: // '&'
+                this.state = 3 /* State.AMP */;
+                return false;
+            // ESC J — Clear to end of display
+            case 0x4A: // 'J'
+                this.screen.clearToEndOfScreen();
+                return true;
+            // ESC K — Clear to end of line
+            case 0x4B: // 'K'
+                this.screen.clearToEndOfLine();
+                return true;
+            // ESC ) — Start protected field
+            case 0x29: // ')'
+                this.screen.startProtected();
+                return true;
+            // ESC ( — End protected field (start unprotected)
+            case 0x28: // '('
+                this.screen.endProtected();
+                return true;
+            default:
+                // Unknown ESC sequence — ignore
+                return false;
+        }
+    }
+    /**
+     * Process bytes inside a CSI sequence: ESC [ param ; param H
+     * We accumulate digits and ';' until we see the final character.
+     */
+    processCsi(byte) {
+        // Digits and semicolons are parameter characters
+        if ((byte >= 0x30 && byte <= 0x39) || byte === 0x3B) {
+            this.csiParams += String.fromCharCode(byte);
+            return false;
+        }
+        // Final byte determines the command
+        this.state = 0 /* State.NORMAL */;
+        switch (byte) {
+            case 0x48: // 'H' — Cursor Position (CUP)
+                return this.handleCursorPosition();
+            case 0x4A: // 'J' — Erase in Display (ED)
+                return this.handleEraseDisplay();
+            case 0x4B: // 'K' — Erase in Line (EL)
+                this.screen.clearToEndOfLine();
+                return true;
+            default:
+                // Unknown CSI command
+                return false;
+        }
+    }
+    /** Process a byte after ESC & */
+    processAmp(byte) {
+        if (byte === 0x64) { // 'd'
+            this.state = 4 /* State.AMP_D */;
+            return false;
+        }
+        // Unknown ESC & X sequence
+        this.state = 0 /* State.NORMAL */;
+        return false;
+    }
+    /** Process the attribute code byte after ESC & d */
+    processAmpD(byte) {
+        this.state = 0 /* State.NORMAL */;
+        this.screen.setAttrFromCode(byte);
+        return true;
+    }
+    /** Handle CSI cursor position: ESC [ row ; col H */
+    handleCursorPosition() {
+        const parts = this.csiParams.split(';');
+        // Parameters are 1-based; default to 1 if missing
+        const row = (parts[0] ? parseInt(parts[0], 10) : 1) - 1;
+        const col = (parts[1] ? parseInt(parts[1], 10) : 1) - 1;
+        this.screen.setCursor(row, col);
+        return true;
+    }
+    /** Handle CSI erase display: ESC [ n J */
+    handleEraseDisplay() {
+        const param = this.csiParams ? parseInt(this.csiParams, 10) : 0;
+        switch (param) {
+            case 0:
+                // Clear from cursor to end of screen
+                this.screen.clearToEndOfScreen();
+                return true;
+            case 1: {
+                // Clear from start of screen to cursor
+                const end = this.screen.offset(this.screen.cursorRow, this.screen.cursorCol) + 1;
+                for (let i = 0; i < end && i < this.screen.size; i++) {
+                    this.screen.buffer[i] = ' ';
+                }
+                return true;
+            }
+            case 2:
+                // Clear entire screen
+                this.screen.clear();
+                return true;
+            default:
+                return false;
+        }
+    }
+    /** Handle tab: move to next unprotected field or next tab stop */
+    handleTab() {
+        // If we have fields, tab to the next unprotected field
+        if (this.screen.fields.length > 0) {
+            const curOff = this.screen.offset(this.screen.cursorRow, this.screen.cursorCol);
+            // Find the next unprotected field after cursor
+            let best = null;
+            let bestOff = Infinity;
+            let wrapBest = null;
+            let wrapBestOff = Infinity;
+            for (const field of this.screen.fields) {
+                if (field.isProtected)
+                    continue;
+                const fOff = this.screen.offset(field.row, field.col);
+                if (fOff > curOff && fOff < bestOff) {
+                    bestOff = fOff;
+                    best = { row: field.row, col: field.col };
+                }
+                if (fOff < wrapBestOff) {
+                    wrapBestOff = fOff;
+                    wrapBest = { row: field.row, col: field.col };
+                }
+            }
+            const target = best || wrapBest;
+            if (target) {
+                this.screen.setCursor(target.row, target.col);
+                return;
+            }
+        }
+        // No fields — use tab stops every 8 columns
+        const nextTab = (Math.floor(this.screen.cursorCol / 8) + 1) * 8;
+        if (nextTab < this.screen.cols) {
+            this.screen.cursorCol = nextTab;
+        }
+        else {
+            this.screen.cursorCol = 0;
+            this.screen.cursorRow = (this.screen.cursorRow + 1) % this.screen.rows;
+        }
+    }
+}

package/dist/hp6530/screen.d.ts

@@ -0,0 +1,104 @@
+/** Display attribute for a single cell */
+export interface CellAttr {
+    halfBright: boolean;
+    underline: boolean;
+    blink: boolean;
+    inverse: boolean;
+}
+/** Field definition derived from protected/unprotected transitions */
+export interface HP6530Field {
+    row: number;
+    col: number;
+    length: number;
+    isProtected: boolean;
+    modified: boolean;
+}
+/**
+ * Screen buffer for an HP 6530 terminal.
+ *
+ * Characters are stored in ASCII (not EBCDIC). The screen tracks
+ * protected/unprotected regions — input fields are the unprotected
+ * regions between protected boundaries.
+ */
+export declare class HP6530Screen {
+    rows: number;
+    cols: number;
+    /** Character buffer (one char per cell) */
+    buffer: string[];
+    /** Per-cell display attributes */
+    attrs: CellAttr[];
+    /** Per-cell protection state (true = protected) */
+    protected: boolean[];
+    /** Current cursor position */
+    cursorRow: number;
+    cursorCol: number;
+    /** Current attribute state (applied to newly written characters) */
+    currentAttr: CellAttr;
+    /** Current protection state (applied to newly written characters) */
+    currentProtected: boolean;
+    /** Derived field list */
+    fields: HP6530Field[];
+    constructor(rows?: 24, cols?: 80);
+    get size(): number;
+    offset(row: number, col: number): number;
+    toRowCol(offset: number): {
+        row: number;
+        col: number;
+    };
+    /** Set a character at the current cursor position and advance */
+    putChar(char: string): void;
+    /** Set a character at a specific position (no cursor advance) */
+    setChar(row: number, col: number, char: string): void;
+    /** Get a character at a specific position */
+    getChar(row: number, col: number): string;
+    /** Set cursor position */
+    setCursor(row: number, col: number): void;
+    /** Advance cursor by one position, wrapping at end of line/screen */
+    advanceCursor(): void;
+    /** Set current display attribute from an attribute code */
+    setAttrFromCode(code: number): void;
+    /** Enter protected mode */
+    startProtected(): void;
+    /** Leave protected mode (start unprotected / input region) */
+    endProtected(): void;
+    /** Clear from cursor to end of display */
+    clearToEndOfScreen(): void;
+    /** Clear from cursor to end of line */
+    clearToEndOfLine(): void;
+    /** Clear the entire screen */
+    clear(): void;
+    /**
+     * Build the field list from protected/unprotected transitions.
+     *
+     * A "field" is a contiguous run of cells with the same protection state.
+     * Input fields are the unprotected regions; label/output fields are protected.
+     */
+    buildFields(): void;
+    /** Get the value (text) of a field */
+    getFieldValue(field: HP6530Field): string;
+    /** Set the value of a field */
+    setFieldValue(field: HP6530Field, value: string): void;
+    /** Find the field containing the cursor */
+    getFieldAtCursor(): HP6530Field | null;
+    /** Find the field containing a given position */
+    getFieldAt(row: number, col: number): HP6530Field | null;
+    /** Convert screen to the ScreenData format for the frontend */
+    toScreenData(): {
+        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;
+    };
+}

package/dist/hp6530/screen.js

@@ -0,0 +1,252 @@
+import { createHash } from 'crypto';
+import { SCREEN, ATTR } from './constants.js';
+const DEFAULT_ATTR = {
+    halfBright: false,
+    underline: false,
+    blink: false,
+    inverse: false,
+};
+/**
+ * Screen buffer for an HP 6530 terminal.
+ *
+ * Characters are stored in ASCII (not EBCDIC). The screen tracks
+ * protected/unprotected regions — input fields are the unprotected
+ * regions between protected boundaries.
+ */
+export class HP6530Screen {
+    rows;
+    cols;
+    /** Character buffer (one char per cell) */
+    buffer;
+    /** Per-cell display attributes */
+    attrs;
+    /** Per-cell protection state (true = protected) */
+    protected;
+    /** Current cursor position */
+    cursorRow = 0;
+    cursorCol = 0;
+    /** Current attribute state (applied to newly written characters) */
+    currentAttr = { ...DEFAULT_ATTR };
+    /** Current protection state (applied to newly written characters) */
+    currentProtected = false;
+    /** Derived field list */
+    fields = [];
+    constructor(rows = SCREEN.ROWS, cols = SCREEN.COLS) {
+        this.rows = rows;
+        this.cols = cols;
+        const size = rows * cols;
+        this.buffer = new Array(size).fill(' ');
+        this.attrs = new Array(size).fill(null).map(() => ({ ...DEFAULT_ATTR }));
+        this.protected = new Array(size).fill(false);
+    }
+    get size() {
+        return this.rows * this.cols;
+    }
+    offset(row, col) {
+        return row * this.cols + col;
+    }
+    toRowCol(offset) {
+        return {
+            row: Math.floor(offset / this.cols),
+            col: offset % this.cols,
+        };
+    }
+    /** Set a character at the current cursor position and advance */
+    putChar(char) {
+        const off = this.offset(this.cursorRow, this.cursorCol);
+        if (off >= 0 && off < this.size) {
+            this.buffer[off] = char;
+            this.attrs[off] = { ...this.currentAttr };
+            this.protected[off] = this.currentProtected;
+        }
+        this.advanceCursor();
+    }
+    /** Set a character at a specific position (no cursor advance) */
+    setChar(row, col, char) {
+        const off = this.offset(row, col);
+        if (off >= 0 && off < this.size) {
+            this.buffer[off] = char;
+        }
+    }
+    /** Get a character at a specific position */
+    getChar(row, col) {
+        const off = this.offset(row, col);
+        return off >= 0 && off < this.size ? this.buffer[off] : ' ';
+    }
+    /** Set cursor position */
+    setCursor(row, col) {
+        this.cursorRow = Math.max(0, Math.min(row, this.rows - 1));
+        this.cursorCol = Math.max(0, Math.min(col, this.cols - 1));
+    }
+    /** Advance cursor by one position, wrapping at end of line/screen */
+    advanceCursor() {
+        this.cursorCol++;
+        if (this.cursorCol >= this.cols) {
+            this.cursorCol = 0;
+            this.cursorRow++;
+            if (this.cursorRow >= this.rows) {
+                this.cursorRow = 0; // wrap to top
+            }
+        }
+    }
+    /** Set current display attribute from an attribute code */
+    setAttrFromCode(code) {
+        switch (code) {
+            case ATTR.NORMAL:
+                this.currentAttr = { ...DEFAULT_ATTR };
+                break;
+            case ATTR.HALF_BRIGHT:
+                this.currentAttr = { ...DEFAULT_ATTR, halfBright: true };
+                break;
+            case ATTR.UNDERLINE:
+                this.currentAttr = { ...DEFAULT_ATTR, underline: true };
+                break;
+            case ATTR.BLINK:
+                this.currentAttr = { ...DEFAULT_ATTR, blink: true };
+                break;
+            case ATTR.INVERSE:
+                this.currentAttr = { ...DEFAULT_ATTR, inverse: true };
+                break;
+            case ATTR.UNDERLINE_INVERSE:
+                this.currentAttr = { ...DEFAULT_ATTR, underline: true, inverse: true };
+                break;
+        }
+    }
+    /** Enter protected mode */
+    startProtected() {
+        this.currentProtected = true;
+    }
+    /** Leave protected mode (start unprotected / input region) */
+    endProtected() {
+        this.currentProtected = false;
+    }
+    /** Clear from cursor to end of display */
+    clearToEndOfScreen() {
+        const start = this.offset(this.cursorRow, this.cursorCol);
+        for (let i = start; i < this.size; i++) {
+            this.buffer[i] = ' ';
+            this.attrs[i] = { ...DEFAULT_ATTR };
+            this.protected[i] = false;
+        }
+    }
+    /** Clear from cursor to end of line */
+    clearToEndOfLine() {
+        const start = this.offset(this.cursorRow, this.cursorCol);
+        const lineEnd = this.offset(this.cursorRow, this.cols - 1) + 1;
+        for (let i = start; i < lineEnd && i < this.size; i++) {
+            this.buffer[i] = ' ';
+            this.attrs[i] = { ...DEFAULT_ATTR };
+            this.protected[i] = false;
+        }
+    }
+    /** Clear the entire screen */
+    clear() {
+        this.buffer.fill(' ');
+        this.attrs = new Array(this.size).fill(null).map(() => ({ ...DEFAULT_ATTR }));
+        this.protected.fill(false);
+        this.fields = [];
+        this.cursorRow = 0;
+        this.cursorCol = 0;
+        this.currentAttr = { ...DEFAULT_ATTR };
+        this.currentProtected = false;
+    }
+    /**
+     * Build the field list from protected/unprotected transitions.
+     *
+     * A "field" is a contiguous run of cells with the same protection state.
+     * Input fields are the unprotected regions; label/output fields are protected.
+     */
+    buildFields() {
+        this.fields = [];
+        if (this.size === 0)
+            return;
+        let currentProt = this.protected[0];
+        let startOff = 0;
+        for (let off = 1; off <= this.size; off++) {
+            const prot = off < this.size ? this.protected[off] : !currentProt; // force flush at end
+            if (prot !== currentProt) {
+                const pos = this.toRowCol(startOff);
+                this.fields.push({
+                    row: pos.row,
+                    col: pos.col,
+                    length: off - startOff,
+                    isProtected: currentProt,
+                    modified: false,
+                });
+                currentProt = prot;
+                startOff = off;
+            }
+        }
+    }
+    /** Get the value (text) of a field */
+    getFieldValue(field) {
+        const start = this.offset(field.row, field.col);
+        return this.buffer.slice(start, start + field.length).join('');
+    }
+    /** Set the value of a field */
+    setFieldValue(field, value) {
+        const start = this.offset(field.row, field.col);
+        for (let i = 0; i < field.length; i++) {
+            this.buffer[start + i] = i < value.length ? value[i] : ' ';
+        }
+        field.modified = true;
+    }
+    /** Find the field containing the cursor */
+    getFieldAtCursor() {
+        return this.getFieldAt(this.cursorRow, this.cursorCol);
+    }
+    /** Find the field containing a given position */
+    getFieldAt(row, col) {
+        const pos = this.offset(row, col);
+        for (const field of this.fields) {
+            const start = this.offset(field.row, field.col);
+            if (pos >= start && pos < start + field.length) {
+                return field;
+            }
+        }
+        return null;
+    }
+    /** Convert screen to the ScreenData format for the frontend */
+    toScreenData() {
+        // Build content as newline-separated rows
+        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');
+        // Map fields to frontend format
+        const fields = this.fields.map(f => {
+            // Check if any cell in the field has special attributes
+            const start = this.offset(f.row, f.col);
+            let hasInverse = false;
+            let hasHighlight = false;
+            for (let i = start; i < start + f.length && i < this.size; i++) {
+                if (this.attrs[i].inverse)
+                    hasInverse = true;
+                if (this.attrs[i].halfBright)
+                    hasHighlight = true;
+            }
+            return {
+                row: f.row,
+                col: f.col,
+                length: f.length,
+                is_input: !f.isProtected,
+                is_protected: f.isProtected,
+                is_highlighted: hasHighlight || undefined,
+                is_reverse: hasInverse || undefined,
+            };
+        });
+        const hash = createHash('md5').update(content).digest('hex').substring(0, 12);
+        return {
+            content,
+            cursor_row: this.cursorRow,
+            cursor_col: this.cursorCol,
+            rows: this.rows,
+            cols: this.cols,
+            fields,
+            screen_signature: hash,
+            timestamp: new Date().toISOString(),
+        };
+    }
+}

package/dist/mock/mock-routes.d.ts

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