@nataliapc/mcp-openmsx 1.2.9 → 1.2.11

package/dist/openmsx.js

@@ -5,21 +5,23 @@
  * @license GPL2
  */
 import fs from "fs/promises";
-import fsSync from "fs";
 import { extractDescriptionFromXML, decodeHtmlEntities, encodeHtmlEntities } from "./utils.js";
 import { spawn } from 'child_process';
-import net from 'net';
-import os from 'os';
 import path from 'path';
+import { OpenMsxWindowsConnector } from "./openmsx_windows.js";
 /** True when running on Windows. Evaluated once at module load. */
 const IS_WINDOWS = process.platform === 'win32';
 export class OpenMSX {
     lastMachine = null;
     process = null;
     isConnected = false;
-    // Windows TCP socket — bidirectional after SSPI auth
-    tcpSocket = null;
-    // Accumulated I/O data for readData() — shared by both platforms (never coexist)
+    // Active writable control channel: process.stdin (Linux/macOS) or the
+    // Windows connection's input (TCP socket / SSPI proxy stdin).
+    controlWritable = null;
+    // Windows-only control connection (TCP+SSPI or stdio proxy). Owns the
+    // transport and its teardown; null on Linux/macOS. See openmsx_windows.ts.
+    controlConnection = null;
+    // Accumulated I/O data for readData() — shared by all transports (never coexist)
     ioBuffer = '';
     // Notify callback: fired when new I/O data arrives — shared by both platforms
     ioNotify = null;
@@ -51,6 +53,23 @@ export class OpenMSX {
                 }
                 this.resetIO();
                 this.commandQueue = Promise.resolve(''); // reset queue for new session
+                // Resolve the Windows control mode up front so an invalid value
+                // fails before we spawn openMSX (avoids orphaned GUI processes).
+                let windowsMode = null;
+                if (IS_WINDOWS) {
+                    try {
+                        windowsMode = OpenMsxWindowsConnector.getControlMode();
+                    }
+                    catch (e) {
+                        safeResolve(`Error: ${e instanceof Error ? e.message : e}`);
+                        return;
+                    }
+                    if (windowsMode === 'pipe') {
+                        safeResolve('Error: OPENMSX_WINDOWS_CONTROL=pipe is reserved but not implemented yet');
+                        return;
+                    }
+                    diag(`Windows control mode: ${windowsMode}`);
+                }
                 // Build args
                 const args = [];
                 if (!IS_WINDOWS) {
@@ -169,85 +188,88 @@ export class OpenMSX {
         });
     }
     /**
-     * Windows connection: TCP socket + SSPI authentication.
-     * Polls for the socket file, connects, authenticates, and starts the XML session.
+     * Windows connection (both modes). All transport — socket-file polling, TCP
+     * connect, SSPI, or proxy launch — is delegated to {@link OpenMsxWindowsConnector},
+     * which returns a uniform connection with SSPI already done. Here we only
+     * attach the generic XML stream handlers and open the session. Both Windows
+     * modes use the TCP semantics: we send `<openmsx-control>` and openMSX replies
+     * with `<openmsx-output>`.
      */
     launchConnectWindows(ctx) {
-        const tmpDir = process.env.TEMP ?? process.env.TMP ??
-            path.join(os.homedir(), 'AppData', 'Local', 'Temp');
-        const socketFile = path.join(tmpDir, 'openmsx-default', `socket.${this.process.pid}`);
-        ctx.diag(`waiting for socket file: ${socketFile}`);
-        this.connectWindowsTCP(socketFile).then(async ({ socket, port }) => {
-            ctx.diag(`TCP connected on port ${port}`);
-            this.tcpSocket = socket;
+        const connector = new OpenMsxWindowsConnector({
+            openmsxProcess: this.process,
+            diag: ctx.diag,
+        });
+        connector.connect().then((connection) => {
+            this.controlConnection = connection;
+            this.controlWritable = connection.input;
             this.ioBuffer = '';
-            socket.on('error', e => {
+            // Diagnostics from the SSPI proxy (stderr only — never stdout).
+            connection.errorOutput?.on('data', (data) => {
+                const msg = data.toString().trim();
+                if (msg && !this.isConnected)
+                    ctx.diag(`control stderr: ${msg.substring(0, 300)}`);
+            });
+            // stdio-proxy: proxy exiting before we connect means SSPI/connect failed.
+            connection.controlProcess?.on('exit', (code, signal) => {
+                ctx.diag(`control process exit: code=${code} signal=${signal} isConnected=${this.isConnected}`);
+                if (!this.isConnected && !ctx.isResolved()) {
+                    ctx.safeResolve(`Error: control process exited before connecting (code=${code}, signal=${signal}).`);
+                }
+            });
+            // direct-sspi: TCP socket errors / close.
+            connection.tcpSocket?.on('error', e => {
                 ctx.diag(`TCP socket error: ${e.message}`);
                 if (!ctx.isResolved())
                     ctx.safeResolve(`Error: TCP socket error: ${e.message}`);
             });
-            socket.on('close', () => {
+            connection.tcpSocket?.on('close', () => {
                 ctx.diag('TCP socket closed');
-                this.tcpSocket = null;
                 this.isConnected = false;
             });
-            // Register the main data handler BEFORE performSspiAuth.
-            // This prevents any gap where data could be discarded:
-            // performSspiAuth adds its own 'data' listener that runs in
-            // parallel — both handlers receive data, but:
-            //  - during SSPI: ioBuffer accumulates binary SSPI tokens
-            //    (harmless, won't contain '<openmsx-output>')
-            //  - after SSPI: ioBuffer is cleared, then <openmsx-control>
-            //    is sent, and <openmsx-output> is detected normally.
-            socket.on('data', (data) => {
-                const chunk = data.toString();
-                // Accumulate all incoming data
-                this.ioBuffer += chunk;
-                // Signal readData() that new data arrived (notify pattern)
-                if (this.ioNotify) {
-                    const notify = this.ioNotify;
-                    this.ioNotify = null;
-                    notify();
-                }
-                // During launch: detect <openmsx-output> in the accumulated stream
-                if (!this.isConnected && this.ioBuffer.includes('<openmsx-output>')) {
-                    this.isConnected = true;
-                    // Discard everything up to and including <openmsx-output>
-                    this.ioBuffer = this.ioBuffer.substring(this.ioBuffer.indexOf('<openmsx-output>') + '<openmsx-output>'.length);
-                    setTimeout(async () => {
-                        if (!ctx.isResolved()) {
-                            try {
-                                await ctx.onReady(false);
-                            } // Windows: don't resend <openmsx-control>
-                            catch (e) {
-                                ctx.safeResolve(`Error: Failed to send control commands - ${e instanceof Error ? e.message : e}`);
-                            }
-                        }
-                    }, 300);
-                }
-            });
-            // SSPI authentication (adds its own parallel 'data' listener internally)
-            try {
-                ctx.diag('starting SSPI authentication...');
-                await this.performSspiAuth(socket);
-                ctx.diag('SSPI authentication successful');
-            }
-            catch (e) {
-                ctx.safeResolve(`Error: SSPI authentication failed: ${e instanceof Error ? e.message : e}. ` +
-                    `Make sure 'node-expose-sspi' is installed: npm install node-expose-sspi`);
-                return;
-            }
-            // Clear SSPI binary garbage from ioBuffer before XML session
-            this.ioBuffer = '';
-            // Send <openmsx-control> to initiate the XML session.
-            // On Windows/TCP, openMSX sends <openmsx-output> in response.
+            connection.output.on('error', (e) => ctx.diag(`control stream error: ${e.message}`));
+            this.attachOutputHandler(connection.output, ctx);
+            // Open the XML session: we send <openmsx-control>; openMSX replies with
+            // <openmsx-output>. (In stdio-proxy the proxy forwards it after SSPI.)
             ctx.diag('sending <openmsx-control> to start XML session');
-            socket.write('<openmsx-control>\n');
-        }).catch(err => {
-            ctx.diag(`connectWindowsTCP failed: ${err.message}`);
+            connection.input.write('<openmsx-control>\n');
+        }).catch((err) => {
+            ctx.diag(`windows connect failed: ${err.message}`);
             ctx.safeResolve(`Error: ${err.message}`);
         });
     }
+    /**
+     * Shared output handler for both Windows modes (proxy stdout or TCP socket):
+     * accumulate into `ioBuffer`, wake any pending `readData()`, and on the first
+     * `<openmsx-output>` mark connected and trigger the initial command sequence
+     * with `onReady(false)` (we already sent `<openmsx-control>`). Linux/macOS uses
+     * its own variant in {@link launchConnectLinux} (openMSX emits the tag unprompted).
+     */
+    attachOutputHandler(output, ctx) {
+        output.on('data', (data) => {
+            const chunk = data.toString();
+            this.ioBuffer += chunk;
+            if (this.ioNotify) {
+                const notify = this.ioNotify;
+                this.ioNotify = null;
+                notify();
+            }
+            if (!this.isConnected && this.ioBuffer.includes('<openmsx-output>')) {
+                this.isConnected = true;
+                this.ioBuffer = this.ioBuffer.substring(this.ioBuffer.indexOf('<openmsx-output>') + '<openmsx-output>'.length);
+                setTimeout(async () => {
+                    if (!ctx.isResolved()) {
+                        try {
+                            await ctx.onReady(false);
+                        } // <openmsx-control> already sent
+                        catch (e) {
+                            ctx.safeResolve(`Error: Failed to send control commands - ${e instanceof Error ? e.message : e}`);
+                        }
+                    }
+                }, 300);
+            }
+        });
+    }
     /**
      * Linux/macOS connection: stdio pipes.
      * Registers stdout handler for ioBuffer accumulation and <openmsx-output> detection.
@@ -255,6 +277,7 @@ export class OpenMSX {
     launchConnectLinux(ctx) {
         const FATAL_ERROR_GRACE_PERIOD = 500;
         let connectionTime = null;
+        this.controlWritable = this.process.stdin;
         this.process.stdout.on('data', (data) => {
             const output = data.toString();
             if (!this.isConnected) {
@@ -294,164 +317,17 @@ export class OpenMSX {
             }
         });
     }
-    /**
-     * SSPI (Negotiate/NTLM) authentication handshake — Windows only.
-     * Required since openMSX 0.7.1 for TCP socket connections.
-     * Uses `node-expose-sspi` v0.1.x optional npm package.
-     *
-     * Reference C++ implementation: openMSX debugger SspiNegotiateClient.cpp
-     * Protocol: loop until SEC_E_OK — each round:
-     *   client → [4-byte BE length][SSPI token]
-     *   server → [4-byte BE length][SSPI response]  (if SEC_I_CONTINUE_NEEDED)
-     * After SEC_E_OK: no server read — proceed directly with XML protocol.
-     */
-    async performSspiAuth(socket) {
-        let nes;
-        try {
-            const { createRequire } = await import('module');
-            const req = createRequire(import.meta.url);
-            nes = req('node-expose-sspi');
-        }
-        catch (e) {
-            throw new Error(`node-expose-sspi not available (${e instanceof Error ? e.message : e}). ` +
-                `Install with: npm install node-expose-sspi`);
-        }
-        // Accumulate TCP data for length-prefixed reads during SSPI phase.
-        // Pattern: onSspiData appends to buffer and NOTIFIES (does not clear).
-        // readLengthPrefixed checks the buffer size after each notification.
-        let sspiBuffer = Buffer.alloc(0);
-        let sspiNotify = null;
-        const onSspiData = (chunk) => {
-            sspiBuffer = Buffer.concat([sspiBuffer, chunk]);
-            if (sspiNotify) {
-                const notify = sspiNotify;
-                sspiNotify = null;
-                notify(); // just signal — buffer stays intact
-            }
-        };
-        socket.on('data', onSspiData);
-        // Wait until new data arrives (doesn't clear the buffer)
-        const waitMore = () => new Promise(resolve => {
-            sspiNotify = resolve;
-        });
-        const readLengthPrefixed = async () => {
-            // Wait until we have at least the 4-byte length prefix
-            while (sspiBuffer.length < 4)
-                await waitMore();
-            const len = sspiBuffer.readUInt32BE(0);
-            const total = 4 + len;
-            // Wait until the full payload has arrived
-            while (sspiBuffer.length < total)
-                await waitMore();
-            const result = sspiBuffer.slice(4, total);
-            sspiBuffer = sspiBuffer.slice(total); // consume only what we read
-            return result;
-        };
-        const sendToken = (token) => {
-            const buf = Buffer.from(token);
-            const lenBuf = Buffer.alloc(4);
-            lenBuf.writeUInt32BE(buf.length, 0);
-            socket.write(lenBuf);
-            socket.write(buf);
-        };
-        try {
-            // node-expose-sspi v0.1.x API:
-            //   AcquireCredentialsHandle → CredentialWithExpiry { credential, tsExpiry }
-            //   InitializeSecurityContextInput.credential = CredHandle (the .credential property)
-            //   InitializeSecurityContextInput.SecBufferDesc = server's token (NOT serverSecurityContext)
-            //   InitializeSecurityContextInput.contextReq = string[] of ISC_REQ_* flags
-            //   Flags from openMSX C++ ref: ISC_REQ_ALLOCATE_MEMORY | ISC_REQ_CONNECTION | ISC_REQ_STREAM
-            const credWithExpiry = nes.sspi.AcquireCredentialsHandle({
-                packageName: 'Negotiate',
-                credentialUse: 'SECPKG_CRED_OUTBOUND',
-            });
-            const credential = credWithExpiry.credential;
-            const packageInfo = nes.sspi.QuerySecurityPackageInfo('Negotiate');
-            const ISC_FLAGS = ['ISC_REQ_ALLOCATE_MEMORY', 'ISC_REQ_CONNECTION', 'ISC_REQ_STREAM'];
-            let contextHandle = undefined;
-            let serverSecBufDesc = undefined;
-            // Loop until SEC_E_OK (mirrors C++ reference implementation)
-            while (true) {
-                const ctxInput = {
-                    credential,
-                    targetName: '',
-                    cbMaxToken: packageInfo.cbMaxToken,
-                    contextReq: ISC_FLAGS,
-                    targetDataRep: 'SECURITY_NETWORK_DREP',
-                };
-                if (contextHandle !== undefined)
-                    ctxInput.contextHandle = contextHandle;
-                if (serverSecBufDesc !== undefined)
-                    ctxInput.SecBufferDesc = serverSecBufDesc;
-                const clientCtx = nes.sspi.InitializeSecurityContext(ctxInput);
-                contextHandle = clientCtx.contextHandle;
-                // Send our token to the server (if non-empty)
-                const tokenBuf = clientCtx.SecBufferDesc?.buffers?.[0];
-                if (tokenBuf && tokenBuf.byteLength > 0) {
-                    sendToken(tokenBuf);
-                }
-                if (clientCtx.SECURITY_STATUS === 'SEC_E_OK') {
-                    // Auth complete — no final read from server, proceed to XML
-                    break;
-                }
-                if (clientCtx.SECURITY_STATUS !== 'SEC_I_CONTINUE_NEEDED') {
-                    throw new Error(`SSPI error: ${clientCtx.SECURITY_STATUS}`);
-                }
-                // Read server's response token
-                const response = await readLengthPrefixed();
-                const responseAB = response.buffer.slice(response.byteOffset, response.byteOffset + response.byteLength);
-                serverSecBufDesc = { ulVersion: 0, buffers: [responseAB] };
-            }
-        }
-        finally {
-            // Remove SSPI data handler — main handler will be added after this returns
-            socket.removeListener('data', onSspiData);
-        }
-    }
-    /**
-     * Poll for the TCP socket file, read the port, connect.
-     */
-    connectWindowsTCP(socketFile) {
-        return new Promise((resolve, reject) => {
-            const maxWaitMs = 8000;
-            const pollMs = 200;
-            let elapsed = 0;
-            const poll = () => {
-                if (fsSync.existsSync(socketFile)) {
-                    let port;
-                    try {
-                        port = parseInt(fsSync.readFileSync(socketFile, 'utf8').trim(), 10);
-                    }
-                    catch (e) {
-                        return reject(new Error(`Cannot read socket file: ${e}`));
-                    }
-                    if (!port || isNaN(port))
-                        return reject(new Error(`Invalid port in socket file`));
-                    const sock = net.createConnection(port, '127.0.0.1');
-                    sock.once('connect', () => resolve({ socket: sock, port }));
-                    sock.once('error', err => { sock.destroy(); reject(new Error(`TCP connect to ${port} failed: ${err.message}`)); });
-                }
-                else {
-                    elapsed += pollMs;
-                    if (elapsed >= maxWaitMs) {
-                        reject(new Error(`openMSX socket file not found after ${maxWaitMs}ms: ${socketFile}`));
-                    }
-                    else {
-                        setTimeout(poll, pollMs);
-                    }
-                }
-            };
-            poll();
-        });
-    }
     resetIO() {
-        if (this.tcpSocket) {
+        // Tear down the Windows control connection (TCP socket / SSPI proxy).
+        // No-op on Linux/macOS where controlConnection is null.
+        if (this.controlConnection) {
             try {
-                this.tcpSocket.destroy();
+                this.controlConnection.forceClose();
             }
             catch (_) { /* ignore */ }
-            this.tcpSocket = null;
+            this.controlConnection = null;
         }
+        this.controlWritable = null;
         this.ioBuffer = '';
         this.ioNotify = null;
     }
@@ -472,6 +348,7 @@ export class OpenMSX {
                 this.lastMachine = null;
                 this.isConnected = false;
                 this.process = null;
+                // resetIO() also tears down the Windows control connection (proxy/socket).
                 this.resetIO();
                 safeResolve("Ok: Emulator process closed successfully");
             });
@@ -572,16 +449,10 @@ export class OpenMSX {
     writeData(data) {
         if (!this.process || !this.isConnected)
             throw new Error('openMSX process not running or not connected');
-        if (IS_WINDOWS) {
-            if (!this.tcpSocket || this.tcpSocket.destroyed)
-                throw new Error('Windows TCP socket not open');
-            this.tcpSocket.write(data);
-        }
-        else {
-            if (!this.process.stdin)
-                throw new Error('openMSX stdin not available');
-            this.process.stdin.write(data);
-        }
+        const channel = this.controlWritable;
+        if (!channel || channel.destroyed)
+            throw new Error('openMSX control channel not available');
+        channel.write(data);
     }
     readData() {
         return new Promise((resolve, reject) => {
@@ -589,19 +460,11 @@ export class OpenMSX {
                 reject(new Error('openMSX process not running or not connected'));
                 return;
             }
-            if (IS_WINDOWS) {
-                if (!this.tcpSocket || this.tcpSocket.destroyed) {
-                    reject(new Error('Windows TCP socket not open'));
-                    return;
-                }
-            }
-            else {
-                if (!this.process?.stdout) {
-                    reject(new Error('openMSX stdout not available'));
-                    return;
-                }
+            if (!this.controlWritable) {
+                reject(new Error('openMSX control channel not available'));
+                return;
             }
-            // Unified for both platforms: accumulate in ioBuffer until a complete
+            // Unified for all transports: accumulate in ioBuffer until a complete
             // <reply>…</reply> block, then extract and return it.
             const RESPONSE_TIMEOUT = 10000;
             const timer = setTimeout(() => {
@@ -629,14 +492,16 @@ export class OpenMSX {
             await this.emu_close();
     }
     forceClose() {
+        // Kill the openMSX emulator; resetIO() force-closes the control connection
+        // (TCP socket / SSPI proxy) on Windows.
         if (this.process && !this.process.killed) {
             try {
                 this.process.kill('SIGKILL');
             }
             catch (_) { /* ignore */ }
-            this.process = null;
-            this.isConnected = false;
         }
+        this.process = null;
+        this.isConnected = false;
         this.resetIO();
     }
 }