mcp-for-i 0.2.0 → 0.3.0

package/dist/mcp/modules/tn5250.js

@@ -1,15 +1,50 @@
-import { clampNumber, enforceWritable, getConnectionName, json } from "../tools.js";
+import { EventEmitter } from "events";
+import { clampNumber, enforceWritable, enforceWritableForPerson, getConnectionName, json } from "../tools.js";
 import { getPassword } from "../../security/credentialStore.js";
 import { REDACTED } from "../../security/redact.js";
-import { Tn5250Client, aidForKey, checkTlsCertificate } from "../../ibmi/tn5250/index.js";
+import { Tn5250Client, aidForKey, checkTlsCertificate, hostKeyFor } from "../../ibmi/tn5250/index.js";
+import { SUPPORTED_CCSIDS } from "../../ibmi/tn5250/ebcdic.js";
 import { AID_WITHOUT_DATA } from "../../ibmi/tn5250/datastream.js";
+import { startLiveServer } from "./tn5250Live.js";
 const sessions = new Map();
+/** "changed" (connectionName) whenever a session's screen or state may have changed. */
+export const liveEvents = new EventEmitter();
+liveEvents.setMaxListeners(100);
+/** The agent waits this long after the person typed or clicked in the live view. */
+export const PERSON_HOLD_MS = 4000;
+let liveServer;
+let liveServerStarting;
+/** Context of the MCP process, used for input that comes from the live view. */
+let liveCtx;
 /** Replaceable dependencies (tests swap these). */
 export const tn5250Deps = {
     getPassword: (connectionName) => getPassword(connectionName),
     checkCertificate: (info) => checkTlsCertificate({ host: info.host, port: info.port, certificate: info.certificate, authorized: info.authorized })
 };
-const LOCAL_KEYS = new Set(["TAB", "BACKTAB", "HOME", "RESET", "ERASEEOF", "FIELDEXIT"]);
+/** Keys handled on the local screen (nothing is sent to the IBM i), by every name they go by. */
+const LOCAL_KEY_ALIASES = {
+    TAB: "TAB", FIELDADVANCE: "TAB",
+    BACKTAB: "BACKTAB", SHIFTTAB: "BACKTAB", FIELDBACKSPACE: "BACKTAB",
+    HOME: "HOME",
+    END: "END", ENDOFFIELD: "END",
+    RESET: "RESET",
+    ERASEEOF: "ERASEEOF", ERASEEOFIELD: "ERASEEOF", ERASEENDOFFIELD: "ERASEEOF",
+    ERASEINPUT: "ERASEINPUT",
+    FIELDEXIT: "FIELDEXIT",
+    FIELDPLUS: "FIELDPLUS",
+    FIELDMINUS: "FIELDMINUS",
+    DUP: "DUP", DUPLICATE: "DUP",
+    INSERT: "INSERT", INS: "INSERT",
+    DELETE: "DELETE", DEL: "DELETE",
+    UP: "UP", ARROWUP: "UP", CURSORUP: "UP",
+    DOWN: "DOWN", ARROWDOWN: "DOWN", CURSORDOWN: "DOWN",
+    LEFT: "LEFT", ARROWLEFT: "LEFT", CURSORLEFT: "LEFT", BACKSPACE: "LEFT",
+    RIGHT: "RIGHT", ARROWRIGHT: "RIGHT", CURSORRIGHT: "RIGHT",
+    NEWLINE: "NEWLINE"
+};
+const LOCAL_KEYS = new Set(Object.values(LOCAL_KEY_ALIASES));
+/** How long Attn / SysReq wait for any answer before the keyboard is unlocked again. */
+const HOST_KEY_ANSWER_MS = 2000;
 const CONNECTION_NAME = { type: "string", description: "Saved IBM i connection name (defaults to the active connection)." };
 const TIMEOUT_MS = { type: "number", description: "How long to wait for the host, in milliseconds." };
 const FIELD_ID = {
@@ -31,6 +66,10 @@ const tools = [
                 signOn: { type: "boolean", default: false, description: "Sign on with the stored credentials." },
                 deviceName: { type: "string", description: "Virtual device name to request (1-10 characters)." },
                 screenSize: { type: "string", enum: ["24x80", "27x132"], description: "27x132 announces an IBM-3477-FC display." },
+                ccsid: {
+                    type: "number",
+                    description: `Single-byte EBCDIC code page for screen text (default: the tn5250Ccsid setting, else 37). Supported: ${SUPPORTED_CCSIDS.join(", ")}.`
+                },
                 timeoutMs: TIMEOUT_MS,
                 approve: { type: "boolean", description: "Set true to approve guarded-policy operations (signOn)." }
             },
@@ -66,7 +105,9 @@ const tools = [
     {
         name: "ibmi.tn5250.sendKeys",
         description: "Type text at the cursor and/or press keys, then wait for the host to answer. keys is a space-separated list: local keys " +
-            "(Tab, BackTab, Home, Reset, EraseEOF, FieldExit) and at most one AID key at the end (Enter, F1-F24, PageUp, PageDown, Clear, Help, Print, Attn, SysReq). " +
+            "(Tab, BackTab, Home, End, Reset, EraseEOF, EraseInput, FieldExit, Field+, Field-, Dup, Insert, Delete, Up, Down, Left, Right, NewLine; " +
+            "add *N to repeat, for example Down*3) and at most one host key at the end (Enter, F1-F24, PageUp, PageDown, Clear, Help, Print, Attn, SysReq). " +
+            "As in IBM emulators, Esc is Attn (Attention, which opens the job's attention menu or program) and Shift+Esc is SysReq (System Request). " +
             "Pressing an AID key sends the screen to the IBM i: read-only connections refuse it, and text on a recognised command line (===>) is checked against the command policy as cl.run.",
         inputSchema: {
             type: "object",
@@ -83,6 +124,27 @@ const tools = [
         },
         annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false }
     },
+    {
+        name: "ibmi.tn5250.click",
+        description: "Click on the 5250 screen the way an emulator mouse does: a click moves the cursor to row/col; a click on a function-key legend " +
+            "(for example \"F3=Exit\") presses that key, and on \"More...\" presses PageDown; doubleClick moves the cursor and presses Enter. " +
+            "Pressing a key goes through the same checks as sendKeys.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                connectionName: CONNECTION_NAME,
+                row: { type: "number", description: "1-based row." },
+                col: { type: "number", description: "1-based column." },
+                doubleClick: { type: "boolean", default: false, description: "Move the cursor and press Enter." },
+                hotspots: { type: "boolean", default: true, description: "Press the key named by a function-key legend under the click." },
+                timeoutMs: TIMEOUT_MS,
+                approve: { type: "boolean", description: "Set true to approve guarded-policy operations." }
+            },
+            required: ["row", "col"],
+            additionalProperties: false
+        },
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false }
+    },
     {
         name: "ibmi.tn5250.waitFor",
         description: "Wait until text appears on the screen and/or the keyboard unlocks (the host is waiting for input). With no text it waits for the keyboard.",
@@ -112,6 +174,17 @@ const tools = [
     }
 ];
 async function handle(ctx, name, args) {
+    liveCtx = ctx;
+    try {
+        return await handleTool(ctx, name, args);
+    }
+    finally {
+        const connectionName = args?.connectionName || ctx.activeName;
+        if (connectionName && sessions.has(connectionName))
+            liveEvents.emit("changed", connectionName);
+    }
+}
+async function handleTool(ctx, name, args) {
     switch (name) {
         case "ibmi.tn5250.connect":
             return connect(ctx, args || {});
@@ -121,6 +194,8 @@ async function handle(ctx, name, args) {
             return setField(ctx, args || {});
         case "ibmi.tn5250.sendKeys":
             return sendKeys(ctx, args || {});
+        case "ibmi.tn5250.click":
+            return click(ctx, args || {});
         case "ibmi.tn5250.waitFor":
             return waitFor(ctx, args || {});
         case "ibmi.tn5250.snapshot": {
@@ -158,6 +233,7 @@ async function connect(ctx, args) {
     const deviceName = optionalDeviceName(args.deviceName ?? settings.tn5250DeviceName);
     const terminalType = args.screenSize === "27x132" ? "IBM-3477-FC" : "IBM-3179-2";
     const timeoutMs = clampNumber(args.timeoutMs, 20000, 1000, 120000);
+    const ccsid = requireCcsid(args.ccsid ?? settings.tn5250Ccsid ?? 37);
     let password;
     if (args.signOn) {
         const conn = await ctx.ensureActive(connectionName);
@@ -172,14 +248,20 @@ async function connect(ctx, args) {
         tls: useTls,
         terminalType,
         deviceName,
+        ccsid,
         // The password is only offered in the telnet negotiation when it is encrypted by TLS.
         autoSignOn: password && useTls ? { user: stored.username, password } : undefined,
         connectTimeoutMs: timeoutMs,
         checkCertificate: info => tn5250Deps.checkCertificate(info)
     });
     await client.connect();
-    const session = { connectionName, host: stored.host, port, tls: useTls, client, createdAt: new Date().toISOString() };
+    const attnWaitMs = settings.tn5250AttnWaitMs !== undefined ? clampNumber(settings.tn5250AttnWaitMs, HOST_KEY_ANSWER_MS, 250, 15000) : HOST_KEY_ANSWER_MS;
+    const session = { connectionName, host: stored.host, port, tls: useTls, client, createdAt: new Date().toISOString(), attnWaitMs };
     sessions.set(connectionName, session);
+    client.on("update", () => liveEvents.emit("changed", connectionName));
+    client.on("close", () => liveEvents.emit("changed", connectionName));
+    if (settings.tn5250LiveView !== false)
+        await ensureLiveServer(settings.tn5250LiveViewPort);
     try {
         let settled = await client.waitForSettled(timeoutMs);
         session.device = deviceFromScreen(client.screen) || deviceName;
@@ -219,6 +301,7 @@ function signOnFields(screen) {
 }
 async function setField(ctx, args) {
     const session = requireOpenSession(ctx, args);
+    holdForPerson(session);
     const screen = session.client.screen;
     const field = resolveField(screen, args);
     if (!field)
@@ -242,10 +325,16 @@ async function setField(ctx, args) {
     if (screen.inputInhibited)
         screen.reset();
     screen.setFieldValue(field, value);
+    session.lastActor = "agent";
     return json(sessionView(session));
 }
 async function sendKeys(ctx, args) {
     const session = requireOpenSession(ctx, args);
+    holdForPerson(session);
+    return json(await runInput(ctx, session, args, "agent"));
+}
+/** Type, press local keys and at most one host key; shared by the tools (agent) and the live view (person). */
+async function runInput(ctx, session, args, actor) {
     const { client } = session;
     const screen = client.screen;
     const keys = parseKeys(args.keys);
@@ -254,8 +343,9 @@ async function sendKeys(ctx, args) {
         throw new Error("keys or text is required");
     const aidIndex = keys.findIndex(isAidKey);
     for (const key of keys) {
-        if (!LOCAL_KEYS.has(key) && !isAidKey(key))
-            throw new Error(`Unsupported key: ${key}`);
+        if (!LOCAL_KEYS.has(key) && !isAidKey(key)) {
+            throw new Error(`Unsupported key: ${key}. Esc is Attn and Shift+Esc is SysReq; see the tool description for the key names.`);
+        }
     }
     if (aidIndex >= 0 && aidIndex !== keys.length - 1) {
         throw new Error("Only one AID key (Enter, F1-F24, PageUp, ...) is allowed, and it must be the last key");
@@ -269,10 +359,12 @@ async function sendKeys(ctx, args) {
     }
     if (text)
         screen.typeText(text);
+    session.lastActor = actor;
     const localKeys = aidIndex >= 0 ? keys.slice(0, aidIndex) : keys;
     for (const key of localKeys)
         applyLocalKey(screen, key);
     let settled;
+    let note;
     const aidKey = aidIndex >= 0 ? keys[aidIndex] : undefined;
     if (aidKey) {
         if (screen.keyboardLocked && !screen.inputInhibited && !["ATTN", "SYSREQ"].includes(aidKey)) {
@@ -282,23 +374,140 @@ async function sendKeys(ctx, args) {
         const gateArgs = { ...args, connectionName: session.connectionName };
         const aid = aidForKey(aidKey);
         const commands = aid !== undefined && !AID_WITHOUT_DATA.has(aid) ? commandLineEntries(screen) : [];
+        const gate = actor === "person" ? enforceWritableForPerson : enforceWritable;
         if (commands.length > 0) {
             // Text on a command line is run as CL by the host, so it gets the cl.run checks.
             for (const command of commands)
-                await enforceWritable(ctx, conn, "cl.run", { ...gateArgs, command, environment: "ile" });
+                await gate(ctx, conn, "cl.run", { ...gateArgs, command, environment: "ile" });
         }
         else {
-            await enforceWritable(ctx, conn, "tn5250.sendKeys", gateArgs);
+            await gate(ctx, conn, "tn5250.sendKeys", gateArgs);
         }
+        const hostKey = aidKey === "ATTN" || aidKey === "SYSREQ";
+        const wasLocked = screen.keyboardLocked;
+        const recordsBefore = client.recordsReceived;
         client.sendKey(aidKey);
         session.lastKey = aidKey;
-        settled = await client.waitForSettled(timeoutMs);
+        if (hostKey) {
+            // The host may not answer Attn (no attention program) or SysReq; don't leave the keyboard locked forever.
+            const startedAt = Date.now();
+            const waitMs = Math.min(timeoutMs, session.attnWaitMs ?? HOST_KEY_ANSWER_MS);
+            const answered = await client.waitFor(() => client.recordsReceived > recordsBefore, waitMs);
+            if (!answered) {
+                screen.keyboardLocked = wasLocked;
+                settled = !wasLocked;
+                note = aidKey === "ATTN"
+                    ? "This screen has no attention menu: no attention program is active here. Use F3 to exit or F12 to cancel to go back. The keyboard was unlocked again."
+                    : "The host did not answer System Request on this screen. The keyboard was unlocked again.";
+            }
+            else {
+                settled = await client.waitForSettled(Math.max(250, timeoutMs - (Date.now() - startedAt)));
+            }
+        }
+        else {
+            settled = await client.waitForSettled(timeoutMs);
+        }
     }
-    return json({
+    return {
         ...sessionView(session),
         ...(aidKey ? { sent: aidKey, settled } : {}),
+        ...(note ? { note } : {}),
         ...(autoReset ? { autoReset: true } : {})
-    });
+    };
+}
+async function click(ctx, args) {
+    const session = requireOpenSession(ctx, args);
+    holdForPerson(session);
+    return json(await runClick(ctx, session, args, "agent"));
+}
+async function runClick(ctx, session, args, actor) {
+    const screen = session.client.screen;
+    const row = Number(args.row);
+    const col = Number(args.col);
+    screen.address(row, col); // validates the position
+    const key = args.doubleClick ? "ENTER" : args.hotspots === false ? undefined : screen.hotspotAt(row, col);
+    if (key) {
+        return runInput(ctx, session, { connectionName: session.connectionName, cursorRow: row, cursorCol: col, keys: key, timeoutMs: args.timeoutMs, approve: args.approve }, actor);
+    }
+    if (screen.inputInhibited)
+        screen.reset();
+    screen.setCursor(row, col);
+    screen.version += 1;
+    session.lastActor = actor;
+    return sessionView(session);
+}
+/** The agent must not type over the person: refuse while they are using the live view. */
+function holdForPerson(session) {
+    if (session.personInputAt && Date.now() - session.personInputAt < PERSON_HOLD_MS) {
+        throw new Error("The person is typing in the live 5250 view. Wait a few seconds, read the screen again (ibmi.tn5250.readScreen) and then continue.");
+    }
+}
+async function ensureLiveServer(port) {
+    if (liveServer)
+        return liveServer;
+    if (!liveServerStarting) {
+        const preferred = Number.isInteger(Number(port)) && Number(port) >= 0 && Number(port) <= 65535 && port !== undefined ? Number(port) : 3981;
+        liveServerStarting = startLiveServer(liveProvider, preferred)
+            .then(server => { liveServer = server; return server; })
+            .catch(() => undefined)
+            .finally(() => { liveServerStarting = undefined; });
+    }
+    return liveServerStarting;
+}
+/** What the live view server reads and drives. */
+const liveProvider = {
+    events: liveEvents,
+    list: () => [...sessions.values()].map(session => ({
+        connectionName: session.connectionName,
+        host: session.host,
+        connected: !session.client.closed,
+        signedOn: Boolean(session.signedOn),
+        lastActor: session.lastActor
+    })),
+    screen: (connectionName) => {
+        const session = sessions.get(connectionName);
+        if (!session)
+            return undefined;
+        const screen = session.client.screen;
+        return { ...sessionView(session), runs: screen.renderRuns(), personHoldMs: PERSON_HOLD_MS };
+    },
+    input: async (connectionName, input) => {
+        const session = sessions.get(connectionName);
+        if (!session)
+            throw new Error(`No 5250 session for ${connectionName}`);
+        if (session.client.closed)
+            throw new Error(`The 5250 session for ${connectionName} is closed`);
+        if (!liveCtx)
+            throw new Error("The MCP server is not ready");
+        session.personInputAt = Date.now();
+        try {
+            if (input.click) {
+                return await runClick(liveCtx, session, { ...input.click, timeoutMs: 30000 }, "person");
+            }
+            return await runInput(liveCtx, session, {
+                connectionName,
+                text: input.text,
+                keys: input.keys,
+                cursorRow: input.cursorRow,
+                cursorCol: input.cursorCol,
+                timeoutMs: 30000
+            }, "person");
+        }
+        finally {
+            session.personInputAt = Date.now();
+            liveEvents.emit("changed", connectionName);
+        }
+    }
+};
+/** Address of the live view for a session, once the live view server runs. */
+export function liveViewUrl(connectionName) {
+    return liveServer?.urlFor(connectionName);
+}
+/** For tests: stop the live view server. */
+export async function stopLiveServer() {
+    const server = liveServer;
+    liveServer = undefined;
+    await server?.close();
 }
 async function waitFor(ctx, args) {
     const session = requireSession(ctx, args);
@@ -324,27 +533,92 @@ function applyLocalKey(screen, key) {
         case "HOME":
             screen.home();
             break;
+        case "END":
+            screen.endOfField();
+            break;
         case "RESET":
             screen.reset();
             break;
         case "ERASEEOF":
             screen.eraseToEndOfField();
             break;
+        case "ERASEINPUT":
+            screen.eraseInput();
+            break;
         case "FIELDEXIT":
             screen.fieldExit();
             break;
+        case "FIELDPLUS":
+            screen.fieldSign(false);
+            break;
+        case "FIELDMINUS":
+            screen.fieldSign(true);
+            break;
+        case "DUP":
+            screen.dup();
+            break;
+        case "INSERT":
+            screen.toggleInsert();
+            break;
+        case "DELETE":
+            screen.deleteChar();
+            break;
+        case "UP":
+            screen.moveCursor(-1, 0);
+            break;
+        case "DOWN":
+            screen.moveCursor(1, 0);
+            break;
+        case "LEFT":
+            screen.moveCursor(0, -1);
+            break;
+        case "RIGHT":
+            screen.moveCursor(0, 1);
+            break;
+        case "NEWLINE":
+            screen.newLine();
+            break;
     }
 }
 function isAidKey(key) {
     return key === "ATTN" || key === "SYSREQ" || aidForKey(key) !== undefined;
 }
-function parseKeys(value) {
+/**
+ * Key names to canonical keys. Accepts "Field+", "Field-", "Shift+Tab",
+ * "Shift+Esc", "Tab+Enter" style chords and "Down*3" repeats.
+ */
+export function parseKeys(value) {
     if (value === undefined || value === null)
         return [];
-    return String(value)
-        .split(/[\s,+]+/)
-        .map(part => part.trim().toUpperCase().replace(/[_-]/g, ""))
-        .filter(Boolean);
+    const text = String(value).replace(/\bshift\s*\+\s*/gi, "SHIFT+");
+    const out = [];
+    for (const raw of text.split(/[\s,]+/).filter(Boolean)) {
+        const repeat = /^(.+?)\*(\d{1,3})$/.exec(raw);
+        const token = repeat ? repeat[1] : raw;
+        const count = repeat ? Number(repeat[2]) : 1;
+        const keys = canonicalKeys(token);
+        if (repeat && (keys.length !== 1 || !LOCAL_KEYS.has(keys[0])))
+            throw new Error(`Only a single local key can be repeated: ${raw}`);
+        if (count < 1 || count > 200)
+            throw new Error(`Repeat count must be 1-200: ${raw}`);
+        for (let n = 0; n < count; n += 1)
+            out.push(...keys);
+    }
+    return out;
+}
+function canonicalKeys(token) {
+    const upper = token.toUpperCase().replace(/_/g, "");
+    if (upper === "FIELD+")
+        return ["FIELDPLUS"];
+    if (upper === "FIELD-")
+        return ["FIELDMINUS"];
+    if (upper.startsWith("SHIFT+"))
+        return [canonicalKey(`SHIFT${upper.substring(6)}`)];
+    return upper.split("+").filter(Boolean).map(canonicalKey);
+}
+function canonicalKey(name) {
+    const key = name.replace(/-/g, "");
+    return LOCAL_KEY_ALIASES[key] || hostKeyFor(key) || key;
 }
 /**
  * Text in command lines (fields labelled ===>). Unmodified ones are included
@@ -390,6 +664,9 @@ function sessionView(session) {
         connected: !client.closed,
         ...(client.closed ? { closeReason: client.closeReason } : {}),
         lastKey: session.lastKey,
+        ...(session.lastActor ? { lastActor: session.lastActor } : {}),
+        ...(session.personInputAt && Date.now() - session.personInputAt < PERSON_HOLD_MS ? { personTyping: true } : {}),
+        ...(liveServer ? { liveViewUrl: liveServer.urlFor(session.connectionName) } : {}),
         ...client.screen.view(),
         ...(client.screen.warnings.length > 0 ? { warnings: client.screen.warnings.slice(-5) } : {})
     };
@@ -449,8 +726,16 @@ function closeSession(connectionName) {
         return false;
     session.client.close();
     sessions.delete(connectionName);
+    liveEvents.emit("changed", connectionName);
     return true;
 }
+function requireCcsid(value) {
+    const ccsid = Number(value);
+    if (!SUPPORTED_CCSIDS.includes(ccsid)) {
+        throw new Error(`Unsupported TN5250 CCSID: ${value}. Supported single-byte code pages: ${SUPPORTED_CCSIDS.join(", ")}`);
+    }
+    return ccsid;
+}
 function requirePort(value) {
     const port = Number(value);
     if (!Number.isInteger(port) || port < 1 || port > 65535)

package/dist/mcp/modules/tn5250App.js

@@ -0,0 +1,194 @@
+/**
+ * MCP Apps view for the 5250 tools: clients that support MCP Apps draw the
+ * screen inside the chat. The view talks to the host over postMessage
+ * (JSON-RPC, ui/* methods); it refreshes with ibmi.tn5250.readScreen and sends
+ * input with ibmi.tn5250.sendKeys / ibmi.tn5250.click, so the usual checks and
+ * confirmations apply. "Open live view" opens the localhost page.
+ *
+ * The client script must not contain backticks or "${" (it sits in a template literal).
+ */
+export const TN5250_APP_URI = "ui://mcp-for-i/tn5250-screen.html";
+export const MCP_APP_MIME_TYPE = "text/html;profile=mcp-app";
+/** Tools whose results the view can draw. */
+export const TN5250_APP_TOOLS = new Set([
+    "ibmi.tn5250.connect",
+    "ibmi.tn5250.readScreen",
+    "ibmi.tn5250.sendKeys",
+    "ibmi.tn5250.click",
+    "ibmi.tn5250.setField",
+    "ibmi.tn5250.waitFor",
+    "ibmi.tn5250.snapshot"
+]);
+export function renderTn5250App(version) {
+    return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>5250 screen</title>
+<style>
+  :root { color-scheme: light dark; --fg: #33ff66; --bg: #050805; --muted: #8aa094; --line: #24312a; --accent: #33ff66; --err: #ff6b6b; }
+  * { box-sizing: border-box; }
+  body { margin: 0; font: 12px/1.4 system-ui, -apple-system, "Segoe UI", sans-serif; color: var(--muted); background: transparent; }
+  .bar { display: flex; gap: 8px; align-items: center; padding: 6px 2px; flex-wrap: wrap; }
+  .bar b { color: inherit; font-weight: 600; }
+  button { font: inherit; border: 1px solid var(--line); border-radius: 6px; padding: 2px 8px; background: transparent; color: inherit; cursor: pointer; }
+  #term { background: var(--bg); color: var(--fg); border-radius: 8px; padding: 8px 10px; outline: none; overflow-x: auto; border: 1px solid var(--line); }
+  #term:focus { border-color: var(--accent); }
+  #screen { position: relative; font: 13px/1.25 "Cascadia Mono", Consolas, Menlo, monospace; white-space: pre; user-select: none; }
+  .row { height: 1.25em; }
+  .fld { text-decoration: underline; }
+  #cursor { position: absolute; width: 1ch; height: 1.25em; background: var(--accent); opacity: .5; pointer-events: none; }
+  #msg { min-height: 1.2em; color: var(--err); padding-top: 4px; }
+</style>
+</head>
+<body>
+<div class="bar"><b id="title">5250</b><span id="state"></span><span style="flex:1"></span><button id="live" hidden>Open live view</button><button id="refresh">Refresh</button></div>
+<div id="term" tabindex="0"><div id="screen"><div id="cursor"></div></div></div>
+<div id="msg"></div>
+<script>
+(function () {
+  var nextId = 1, pending = {}, view = null, connectionName = null, ready = false, typed = '', typeTimer = null, busy = false;
+  var screenEl = document.getElementById('screen'), cursorEl = document.getElementById('cursor'), term = document.getElementById('term');
+  var msg = document.getElementById('msg'), stateEl = document.getElementById('state'), titleEl = document.getElementById('title'), liveBtn = document.getElementById('live');
+
+  function post(obj) { window.parent.postMessage(obj, '*'); }
+  function request(method, params) {
+    var id = nextId++;
+    post({ jsonrpc: '2.0', id: id, method: method, params: params || {} });
+    return new Promise(function (resolve, reject) { pending[id] = { resolve: resolve, reject: reject }; });
+  }
+  function notify(method, params) { post({ jsonrpc: '2.0', method: method, params: params || {} }); }
+
+  window.addEventListener('message', function (ev) {
+    var m = ev.data;
+    if (!m || m.jsonrpc !== '2.0') return;
+    if (m.id !== undefined && pending[m.id]) {
+      var p = pending[m.id]; delete pending[m.id];
+      if (m.error) p.reject(new Error(m.error.message || 'request failed')); else p.resolve(m.result);
+      return;
+    }
+    if (m.method === 'ui/notifications/tool-result') showResult(m.params);
+    if (m.method === 'ui/notifications/tool-input' && m.params && m.params.arguments && m.params.arguments.connectionName) connectionName = m.params.arguments.connectionName;
+    if (m.method === 'ui/notifications/host-context-changed' && m.params) applyTheme(m.params.theme);
+    if (m.method === 'ui/resource-teardown' && m.id !== undefined) post({ jsonrpc: '2.0', id: m.id, result: {} });
+  });
+
+  function applyTheme(theme) {
+    if (theme === 'light') { document.documentElement.style.setProperty('--muted', '#4b5a52'); document.documentElement.style.setProperty('--line', '#c9d4ce'); }
+  }
+
+  function screenOf(result) {
+    var data = result && result.structuredContent && result.structuredContent.data;
+    if (!data) return null;
+    if (Array.isArray(data.text)) return data;
+    if (data.screen && Array.isArray(data.screen.text)) return data.screen;
+    return null;
+  }
+  function showResult(result) {
+    if (result && result.isError) { msg.textContent = textOf(result); return; }
+    var s = screenOf(result);
+    if (s) { msg.textContent = (result.structuredContent.data.note || ''); render(s); }
+  }
+  function textOf(result) { return (result && result.content && result.content[0] && result.content[0].text) || 'Error'; }
+
+  function render(s) {
+    view = s; connectionName = s.connectionName || connectionName;
+    titleEl.textContent = (s.connectionName || '5250') + ' ' + s.rows + 'x' + s.cols;
+    var st = [];
+    if (!s.connected && s.connected !== undefined) st.push('disconnected');
+    if (s.keyboardLocked && !s.inputInhibited) st.push('X System');
+    if (s.inputInhibited) st.push('input inhibited');
+    if (s.lastActor === 'person') st.push('you acted last');
+    stateEl.textContent = st.join(' · ');
+    liveBtn.hidden = !s.liveViewUrl;
+    var fieldsByRow = {};
+    (s.fields || []).forEach(function (f) { if (!f.protected) (fieldsByRow[f.row] = fieldsByRow[f.row] || []).push(f); });
+    var frag = document.createDocumentFragment();
+    s.text.forEach(function (line, i) {
+      var row = document.createElement('div'); row.className = 'row'; row.dataset.row = String(i + 1);
+      var fl = (fieldsByRow[i + 1] || []).sort(function (a, b) { return a.col - b.col; });
+      var pos = 0;
+      fl.forEach(function (f) {
+        var start = f.col - 1, end = Math.min(line.length, start + f.length);
+        if (start > pos) row.appendChild(document.createTextNode(line.substring(pos, start)));
+        var span = document.createElement('span'); span.className = 'fld'; span.textContent = line.substring(start, end); row.appendChild(span);
+        pos = end;
+      });
+      row.appendChild(document.createTextNode(line.substring(pos)));
+      frag.appendChild(row);
+    });
+    screenEl.querySelectorAll('.row').forEach(function (n) { n.remove(); });
+    screenEl.appendChild(frag);
+    cursorEl.style.left = (s.cursor.col - 1) + 'ch';
+    cursorEl.style.top = ((s.cursor.row - 1) * 1.25) + 'em';
+  }
+
+  function call(name, args) {
+    if (!connectionName) return Promise.resolve();
+    busy = true;
+    var a = Object.assign({ connectionName: connectionName }, args);
+    return request('tools/call', { name: name, arguments: a })
+      .then(function (r) { showResult(r); })
+      .catch(function (e) { msg.textContent = e.message; })
+      .then(function () { busy = false; });
+  }
+  function flush(keys) {
+    if (typeTimer) { clearTimeout(typeTimer); typeTimer = null; }
+    var args = {};
+    if (typed) { args.text = typed; typed = ''; }
+    if (keys) args.keys = keys;
+    if (args.text || args.keys) return call('ibmi.tn5250.sendKeys', args);
+  }
+
+  term.addEventListener('keydown', function (ev) {
+    if (ev.ctrlKey || ev.metaKey || ev.altKey) return;
+    var k = ev.key, name = null;
+    if (/^F([1-9]|1[0-2])$/.test(k)) name = 'F' + (Number(k.substring(1)) + (ev.shiftKey ? 12 : 0));
+    else if (k === 'Enter') name = 'Enter';
+    else if (k === 'Escape') name = ev.shiftKey ? 'SysReq' : 'Attn';
+    else if (k === 'Tab') name = ev.shiftKey ? 'BackTab' : 'Tab';
+    else if (k === 'ArrowUp') name = 'Up'; else if (k === 'ArrowDown') name = 'Down';
+    else if (k === 'ArrowLeft') name = 'Left'; else if (k === 'ArrowRight') name = 'Right';
+    else if (k === 'Home') name = 'Home'; else if (k === 'End') name = 'End';
+    else if (k === 'Delete') name = 'Delete'; else if (k === 'Backspace') name = 'Left Delete';
+    else if (k === 'PageUp') name = 'PageUp'; else if (k === 'PageDown') name = 'PageDown';
+    if (name) { ev.preventDefault(); flush(name); return; }
+    if (k.length === 1) { ev.preventDefault(); typed += k; if (typeTimer) clearTimeout(typeTimer); typeTimer = setTimeout(function () { flush(); }, 300); }
+  });
+  screenEl.addEventListener('click', function (ev) {
+    term.focus();
+    var row = ev.target.closest ? ev.target.closest('.row') : null;
+    if (!row || !view) return;
+    var rect = screenEl.getBoundingClientRect();
+    var chWidth = rect.width / view.cols;
+    var col = Math.max(1, Math.min(view.cols, Math.floor((ev.clientX - rect.left) / chWidth) + 1));
+    flush();
+    call('ibmi.tn5250.click', { row: Number(row.dataset.row), col: col, doubleClick: ev.detail >= 2 });
+  });
+  document.getElementById('refresh').addEventListener('click', function () { call('ibmi.tn5250.readScreen', {}); });
+  liveBtn.addEventListener('click', function () { if (view && view.liveViewUrl) request('ui/open-link', { url: view.liveViewUrl }).catch(function (e) { msg.textContent = e.message; }); });
+
+  setInterval(function () {
+    if (ready && connectionName && !busy && !typed && document.visibilityState === 'visible') call('ibmi.tn5250.readScreen', {});
+  }, 2000);
+
+  if (window.ResizeObserver) new ResizeObserver(function () {
+    notify('ui/notifications/size-changed', { width: document.documentElement.scrollWidth, height: document.documentElement.scrollHeight });
+  }).observe(document.body);
+
+  request('ui/initialize', {
+    protocolVersion: '2026-01-26',
+    capabilities: {},
+    clientInfo: { name: 'mcp-for-i-5250', version: '${version}' },
+    appCapabilities: { availableDisplayModes: ['inline', 'fullscreen'] }
+  }).then(function (res) {
+    ready = true;
+    if (res && res.hostContext) applyTheme(res.hostContext.theme);
+    notify('ui/notifications/initialized', {});
+  }).catch(function (e) { msg.textContent = 'Could not start: ' + e.message; });
+})();
+</script>
+</body>
+</html>`;
+}