mcp-for-i 0.2.0 → 0.3.0

package/dist/ibmi/tn5250/screen.js

@@ -35,6 +35,8 @@ export class Tn5250Field {
         return value === 5 ? "zero" : value === 6 ? "blank" : undefined;
     }
     get end() { return this.start + this.length - 1; }
+    /** The Dup key is allowed in this field. */
+    get dupEnabled() { return (this.ffw & 0x1000) !== 0; }
     contains(address) {
         return address >= this.start && address <= this.end;
     }
@@ -63,6 +65,8 @@ export class Screen {
     keyboardLocked = true;
     inputInhibited = false;
     messageWaiting = false;
+    /** Insert mode: typing shifts the rest of the field right instead of overwriting. */
+    insertMode = false;
     pendingRead = null;
     errorRow = 23;
     version = 0;
@@ -641,6 +645,16 @@ export class Screen {
         if (offset + bytes.length > field.length) {
             throw new Error(`Text is ${bytes.length} characters but only ${field.length - offset} fit in the field from the cursor`);
         }
+        if (this.insertMode) {
+            const tail = this.fieldBytes(field).slice(offset);
+            let used = tail.length;
+            while (used > 0 && (tail[used - 1] === 0 || tail[used - 1] === 0x40))
+                used -= 1;
+            if (offset + bytes.length + used > field.length) {
+                throw new Error("Insert mode: the field has no room to shift its text right");
+            }
+            tail.slice(0, used).forEach((byte, n) => { this.buffer[(field.start + offset + bytes.length + n) % this.size] = byte; });
+        }
         bytes.forEach((byte, n) => {
             const p = (field.start + offset + n) % this.size;
             this.buffer[p] = byte;
@@ -711,10 +725,146 @@ export class Screen {
         field.modified = true;
         this.version += 1;
     }
+    /** Field Exit: erase to the end of the field, right-adjust it if the field asks for that, go to the next field. */
     fieldExit() {
+        const field = this.currentInputField();
+        this.eraseToEndOfField();
+        const adjust = field.rightAdjust;
+        if (adjust)
+            this.rightAdjustField(field, adjust === "zero" ? 0xf0 : 0x40);
+        this.tab();
+    }
+    /** Field+ and Field-: like Field Exit; numeric fields are right-adjusted and Field- marks them negative. */
+    fieldSign(negative) {
+        const field = this.currentInputField();
+        if (negative && !field.numeric)
+            throw new Error("Field- is only valid in a numeric field");
         this.eraseToEndOfField();
+        if (field.numeric || field.rightAdjust) {
+            const fill = field.rightAdjust === "zero" ? 0xf0 : 0x40;
+            if (field.shift === 7) {
+                // Signed numeric: the last position holds the sign.
+                this.rightAdjustField(field, fill, 1);
+                this.buffer[field.end % this.size] = negative ? 0x60 : 0x40;
+            }
+            else {
+                this.rightAdjustField(field, fill);
+                if (negative) {
+                    const last = field.end % this.size;
+                    const byte = this.buffer[last];
+                    if (byte < 0xf0 || byte > 0xf9)
+                        throw new Error("Field- needs a digit in the last position of the field");
+                    this.buffer[last] = 0xd0 | (byte & 0x0f);
+                }
+            }
+        }
+        field.modified = true;
+        this.version += 1;
+        this.tab();
+    }
+    /** Dup: fill the field from the cursor with the DUP character (the host repeats the previous value). */
+    dup() {
+        this.requireInputAllowed();
+        const field = this.currentInputField();
+        if (!field.dupEnabled)
+            throw new Error("This field does not allow the Dup key");
+        for (let p = this.cursor; p <= field.end; p += 1) {
+            this.buffer[p % this.size] = 0x1c;
+            this.attrMap[p % this.size] = 0;
+        }
+        field.modified = true;
+        this.version += 1;
         this.tab();
     }
+    /** Delete the character at the cursor; the rest of the field shifts left. */
+    deleteChar() {
+        this.requireInputAllowed();
+        const field = this.currentInputField();
+        const offset = this.cursor - field.start;
+        const bytes = this.fieldBytes(field);
+        const shifted = [...bytes.slice(0, offset), ...bytes.slice(offset + 1), 0];
+        shifted.forEach((byte, n) => { this.buffer[(field.start + n) % this.size] = byte; });
+        field.modified = true;
+        this.version += 1;
+    }
+    /** Erase Input: clear every input field and put the cursor in the first one. */
+    eraseInput() {
+        this.requireInputAllowed();
+        for (const field of this.inputFields()) {
+            if (this.fieldHasValue(field))
+                field.modified = true;
+            this.nullField(field);
+        }
+        this.home();
+        this.version += 1;
+    }
+    toggleInsert() {
+        this.insertMode = !this.insertMode;
+    }
+    /** Move the cursor by rows and columns, wrapping around the screen like a terminal. */
+    moveCursor(rowDelta, colDelta) {
+        const size = this.size;
+        this.cursor = (((this.cursor + rowDelta * this.cols + colDelta) % size) + size) % size;
+    }
+    /** New Line: the first input field on a following row (or the first field on the screen). */
+    newLine() {
+        const inputs = this.inputFields();
+        const nextRow = (Math.floor(this.cursor / this.cols) + 1) * this.cols;
+        const next = inputs.find(f => f.start >= nextRow) || inputs[0];
+        this.cursor = next ? next.start : nextRow % this.size;
+    }
+    /** End: just after the last character entered in the current field. */
+    endOfField() {
+        const field = this.currentInputField();
+        const bytes = this.fieldBytes(field);
+        let used = bytes.length;
+        while (used > 0 && (bytes[used - 1] === 0 || bytes[used - 1] === 0x40))
+            used -= 1;
+        this.cursor = field.start + Math.min(used, field.length - 1);
+    }
+    currentInputField() {
+        const field = this.fieldAt(this.cursor);
+        if (!field || field.bypass) {
+            const { row, col } = this.rowCol(this.cursor);
+            throw new Error(`The cursor (row ${row}, column ${col}) is not in an input field`);
+        }
+        return field;
+    }
+    fieldBytes(field) {
+        const out = [];
+        for (let n = 0; n < field.length; n += 1)
+            out.push(this.buffer[(field.start + n) % this.size]);
+        return out;
+    }
+    /** Move the field's text to the right end (leaving `reserve` positions free) and fill the left with `fill`. */
+    rightAdjustField(field, fill, reserve = 0) {
+        const bytes = this.fieldBytes(field).filter(b => b !== 0 && b !== 0x40);
+        const width = field.length - reserve;
+        if (bytes.length > width)
+            throw new Error("The field's text does not fit when right-adjusted");
+        const adjusted = [...new Array(width - bytes.length).fill(fill), ...bytes];
+        adjusted.forEach((byte, n) => { this.buffer[(field.start + n) % this.size] = byte; });
+        field.modified = true;
+    }
+    /**
+     * What a mouse click on this position presses, as emulator "hotspots" do:
+     * a function-key legend such as "F3=Exit" gives that key, "More..." gives PageDown.
+     */
+    hotspotAt(row, col) {
+        const line = this.renderRows()[row - 1] || "";
+        const index = col - 1;
+        for (const match of line.matchAll(/\b(F(?:[1-9]|1[0-9]|2[0-4]))=\S+/g)) {
+            const start = match.index ?? 0;
+            if (index >= start && index < start + match[0].length)
+                return match[1];
+        }
+        for (const match of line.matchAll(/More\.\.\./g)) {
+            const start = match.index ?? 0;
+            if (index >= start && index < start + match[0].length)
+                return "PAGEDOWN";
+        }
+        return undefined;
+    }
     // ------------------------------------------------------------------- views
     /** Screen rows as text. Attributes, nulls and non-display areas are blanks. */
     renderRows() {
@@ -736,6 +886,9 @@ export class Screen {
             else if ((attr & 0x07) === 0x07 || hiddenMask[p]) {
                 line += " ";
             }
+            else if (this.buffer[p] === 0x1c) {
+                line += "*";
+            }
             else {
                 line += ebcdicToChar(this.buffer[p], this.ccsid);
             }
@@ -746,6 +899,47 @@ export class Screen {
         }
         return rows;
     }
+    /**
+     * Screen rows as runs of text with the same display attribute (color,
+     * reverse, underline), for drawing the screen. Hidden text is blank.
+     */
+    renderRuns() {
+        const rows = this.renderRows();
+        const out = [];
+        // Underline follows the field's defined length, not the attribute span: a
+        // real emulator underlines only the enterable positions, so a one-character
+        // field shows a one-character line, however far the host's underline
+        // attribute happens to run before the next attribute byte.
+        const underlineMask = new Uint8Array(this.size);
+        for (const field of this.fields) {
+            if (!attributeStyle(field.attr).underline)
+                continue;
+            for (let n = 0; n < field.length; n += 1)
+                underlineMask[(field.start + n) % this.size] = 1;
+        }
+        let attr = 0x20;
+        for (let r = 0; r < this.rows; r += 1) {
+            const runs = [];
+            for (let c = 0; c < this.cols; c += 1) {
+                const p = r * this.cols + c;
+                const isAttr = this.attrMap[p] !== 0;
+                if (isAttr)
+                    attr = this.buffer[p];
+                const style = attributeStyle(attr);
+                const underline = underlineMask[p] === 1;
+                const ch = rows[r][c];
+                const last = runs[runs.length - 1];
+                if (last && last.color === style.color && last.reverse === style.reverse && last.underline === underline && !isAttr) {
+                    last.text += ch;
+                }
+                else {
+                    runs.push({ text: ch, color: style.color, reverse: style.reverse, underline });
+                }
+            }
+            out.push(runs);
+        }
+        return out;
+    }
     fieldId(field) {
         const { row, col } = this.rowCol(field.start);
         return `r${row}c${col}`;
@@ -808,6 +1002,7 @@ export class Screen {
             inputInhibited: this.inputInhibited,
             messageWaiting: this.messageWaiting,
             readPending: this.pendingRead !== null,
+            insertMode: this.insertMode,
             text: rows,
             fields,
             version: this.version
@@ -822,6 +1017,17 @@ export class Screen {
             this.warnings.shift();
     }
 }
+/** Display style of a 5250 screen attribute byte (0x20-0x3F). */
+export function attributeStyle(attr) {
+    const group = attr & 0x38;
+    const alt = (attr & 0x02) !== 0;
+    const color = group === 0x20 ? (alt ? "white" : "green")
+        : group === 0x28 ? "red"
+            : group === 0x30 ? (alt ? "yellow" : "turquoise")
+                : alt ? "blue" : "pink";
+    const nonDisplay = (attr & 0x07) === 0x07;
+    return { color, reverse: !nonDisplay && (attr & 0x01) !== 0, underline: !nonDisplay && (attr & 0x04) !== 0 };
+}
 function hex(value) {
     return (value ?? 0).toString(16).padStart(2, "0");
 }

package/dist/index.js

@@ -15,6 +15,7 @@ import { appendAuditRecord } from "./mcp/audit.js";
 import { redactModuleArgs } from "./mcp/modules/index.js";
 import { runControlCommand } from "./controlplane/commands.js";
 import { ibmDocs } from "./ibmi/IbmDocs.js";
+import { MCP_APP_MIME_TYPE, TN5250_APP_TOOLS, TN5250_APP_URI, renderTn5250App } from "./mcp/modules/tn5250App.js";
 const argv = process.argv.slice(2);
 const firstArg = (argv[0] || "").toLowerCase();
 const packageVersion = readPackageVersion();
@@ -36,7 +37,10 @@ if (firstArg === "--help" || firstArg === "-h" || firstArg === "help") {
 const server = new Server({ name: "mcp-for-i", version: packageVersion }, { capabilities: { tools: {}, resources: {} } });
 const ctx = new McpContext();
 ctx.confirm = createElicitationConfirm(server);
-const tools = getTools();
+// 5250 tools point MCP Apps clients at the screen view; other clients ignore _meta.
+const tools = getTools().map(tool => (TN5250_APP_TOOLS.has(tool.name)
+    ? { ...tool, _meta: { ...(tool._meta || {}), ui: { resourceUri: TN5250_APP_URI } } }
+    : tool));
 const toolMap = new Map(tools.map(tool => [tool.name, tool]));
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools
@@ -49,6 +53,12 @@ server.setRequestHandler(ListResourcesRequestSchema, async () => ({
             description: "Release-aware allowlist of official IBM i documentation available through mcp-for-i.",
             mimeType: "application/json"
         },
+        {
+            uri: TN5250_APP_URI,
+            name: "5250 screen view",
+            description: "Interactive 5250 screen for MCP Apps clients (used by the ibmi.tn5250 tools).",
+            mimeType: MCP_APP_MIME_TYPE
+        },
         ...ibmDocs.listResources()
     ]
 }));
@@ -62,6 +72,11 @@ server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => ({
 }));
 server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
     const uri = request.params.uri;
+    if (uri === TN5250_APP_URI) {
+        return {
+            contents: [{ uri, mimeType: MCP_APP_MIME_TYPE, text: renderTn5250App(packageVersion), _meta: { ui: { prefersBorder: false } } }]
+        };
+    }
     const text = await ibmDocs.readResource(uri);
     return {
         contents: [{
@@ -132,7 +147,24 @@ function summarizeResult(result) {
     return {
         isError: Boolean(result?.isError),
         contentCount,
-        hasStructuredContent: typeof result?.structuredContent !== "undefined"
+        hasStructuredContent: typeof result?.structuredContent !== "undefined",
+        ...summarizeScreen(result?.structuredContent)
+    };
+}
+/** For 5250 results: the screen's first text line and state, so the audit shows where a session went. */
+function summarizeScreen(structured) {
+    const content = structured?.data ?? structured;
+    const screen = content && Array.isArray(content.text) ? content : content?.screen;
+    if (!screen || !Array.isArray(screen.text) || typeof screen.version !== "number")
+        return {};
+    const title = String(screen.text.find((line) => typeof line === "string" && line.trim()) || "").trim().substring(0, 80);
+    return {
+        screen: {
+            title: redactSecretsInText(title),
+            keyboardLocked: Boolean(screen.keyboardLocked),
+            ...(screen.errorLine ? { errorLine: redactSecretsInText(String(screen.errorLine).substring(0, 80)) } : {}),
+            ...(typeof content.sent === "string" ? { sent: content.sent } : {})
+        }
     };
 }
 function resolveConnectionName(tool, args, activeName) {
@@ -157,6 +189,8 @@ function printHelp() {
     process.stderr.write(`  mcp-for-i                 Start MCP stdio server\n`);
     process.stderr.write(`  mcp-for-i control         Start/open control plane UI\n`);
     process.stderr.write(`  mcp-for-i control status  Show control plane and background-service status\n`);
+    process.stderr.write(`  mcp-for-i control stop    Stop the running control plane\n`);
+    process.stderr.write(`  mcp-for-i control restart Stop the control plane and start it again\n`);
     process.stderr.write(`  mcp-for-i control enable  Enable background service for this platform\n`);
     process.stderr.write(`  mcp-for-i control disable Disable background service for this platform\n`);
     process.stderr.write(`  mcp-for-i --version       Print package version\n`);