@nataliapc/mcp-openmsx 1.2.9 → 1.2.11

package/dist/openmsx_windows.js

@@ -0,0 +1,316 @@
+/**
+ * Windows control-channel connector for openMSX.
+ *
+ * On Windows, openMSX is a /SUBSYSTEM:WINDOWS GUI app whose stdin/stdout cannot
+ * be piped, and its TCP control socket requires SSPI (Negotiate/NTLM) auth since
+ * openMSX 0.7.1. This module owns ALL Windows-specific transport details (mode
+ * selection, socket-file polling, TCP connect, SSPI handshake, proxy launch) so
+ * that `openmsx.ts` keeps only platform-agnostic orchestration: it consumes the
+ * returned {@link WindowsControlConnection} and attaches the same generic XML
+ * stream handlers it uses on Linux/macOS.
+ *
+ * Modes (env var `OPENMSX_WINDOWS_CONTROL`):
+ *   - `stdio-proxy` (default): launch the bundled .NET helper
+ *     `bin/win-x64/mcp-openmsx-sspi-proxy.exe <port>` which does SSPI and exposes
+ *     a clean XML stdio channel, exactly like `openmsx -control stdio` on Linux.
+ *   - `direct-sspi`: Node opens the TCP socket and authenticates with
+ *     `node-expose-sspi`. Fallback path.
+ *   - `socket`: alias of `direct-sspi`.
+ *   - `pipe`: reserved/not implemented.
+ *
+ * @author Natalia Pujol Cremades (@nataliapc)
+ * @license GPL2
+ */
+import fsSync from 'fs';
+import net from 'net';
+import os from 'os';
+import path from 'path';
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { sleep } from './utils.js';
+/** Directory of this module (works under both `src/` (tsx) and `dist/`). */
+const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
+/** Resolve the Windows temp directory openMSX writes its socket file into. */
+function windowsTempDir(env) {
+    return env.TEMP ?? env.TMP ?? path.join(os.homedir(), 'AppData', 'Local', 'Temp');
+}
+export class OpenMsxWindowsConnector {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    get env() {
+        return this.options.env ?? process.env;
+    }
+    /**
+     * Resolve the requested Windows control mode from `OPENMSX_WINDOWS_CONTROL`.
+     * Defaults to `stdio-proxy`. `socket` is a legacy alias of `direct-sspi`.
+     * Throws on an unrecognised value.
+     */
+    static getControlMode(env = process.env) {
+        const raw = env.OPENMSX_WINDOWS_CONTROL?.trim().toLowerCase() || 'stdio-proxy';
+        if (raw === 'socket')
+            return 'direct-sspi';
+        if (raw === 'stdio-proxy' || raw === 'direct-sspi' || raw === 'pipe')
+            return raw;
+        throw new Error(`Invalid OPENMSX_WINDOWS_CONTROL="${raw}". ` +
+            `Supported values: stdio-proxy, direct-sspi, socket, pipe.`);
+    }
+    /**
+     * Resolve the path to the SSPI proxy executable.
+     * Honours `OPENMSX_WINDOWS_PROXY_EXECUTABLE` for development overrides,
+     * otherwise points at the bundled `bin/win-x64/mcp-openmsx-sspi-proxy.exe`
+     * relative to this module (i.e. `../bin/win-x64/...` from `dist/`).
+     */
+    static resolveProxyExecutable(env = process.env) {
+        const override = env.OPENMSX_WINDOWS_PROXY_EXECUTABLE?.trim();
+        if (override)
+            return override;
+        return path.resolve(MODULE_DIR, '..', 'bin', 'win-x64', 'mcp-openmsx-sspi-proxy.exe');
+    }
+    /**
+     * Poll for openMSX's socket file and return the TCP control port it contains.
+     * The file appears at `%TEMP%\openmsx-default\socket.<pid>` and holds a port
+     * number (9938-9958).
+     */
+    async waitForWindowsSocketPort(socketFile, maxWaitMs = 8000, pollMs = 200) {
+        let elapsed = 0;
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            if (fsSync.existsSync(socketFile)) {
+                let raw;
+                try {
+                    raw = fsSync.readFileSync(socketFile, 'utf8').trim();
+                }
+                catch (e) {
+                    throw new Error(`Cannot read openMSX socket file: ${e instanceof Error ? e.message : e}`);
+                }
+                const port = parseInt(raw, 10);
+                if (!port || isNaN(port)) {
+                    throw new Error(`Invalid port in openMSX socket file: "${raw}"`);
+                }
+                return port;
+            }
+            elapsed += pollMs;
+            if (elapsed >= maxWaitMs) {
+                throw new Error(`openMSX socket file not found after ${maxWaitMs}ms: ${socketFile}`);
+            }
+            await sleep(pollMs);
+        }
+    }
+    /**
+     * Establish the Windows control channel for the configured mode and return a
+     * uniform connection. SSPI is fully completed before returning: for
+     * `direct-sspi` here in Node; for `stdio-proxy` inside the .NET helper. The
+     * caller only has to attach generic XML stream handlers and send
+     * `<openmsx-control>`.
+     */
+    async connect() {
+        const mode = OpenMsxWindowsConnector.getControlMode(this.env);
+        if (mode === 'pipe') {
+            throw new Error('OPENMSX_WINDOWS_CONTROL=pipe is reserved but not implemented yet');
+        }
+        const pid = this.options.openmsxProcess.pid;
+        if (!pid)
+            throw new Error('openMSX process has no pid');
+        const socketFile = path.join(windowsTempDir(this.env), 'openmsx-default', `socket.${pid}`);
+        this.options.diag(`waiting for openMSX socket file: ${socketFile}`);
+        const port = await this.waitForWindowsSocketPort(socketFile);
+        this.options.diag(`openMSX control port: ${port}`);
+        return mode === 'stdio-proxy'
+            ? this.connectStdioProxy(port)
+            : this.connectDirectSspi(port);
+    }
+    /**
+     * `stdio-proxy`: launch the bundled .NET helper (it connects to openMSX, does
+     * SSPI and pipes raw XML over its stdio). SSPI never touches Node.
+     */
+    connectStdioProxy(port) {
+        const proxyExe = OpenMsxWindowsConnector.resolveProxyExecutable(this.env);
+        if (!fsSync.existsSync(proxyExe)) {
+            throw new Error(`SSPI proxy executable not found: ${proxyExe}. ` +
+                `Build it with: pnpm build:proxy:win-x64:docker ` +
+                `(or set OPENMSX_WINDOWS_PROXY_EXECUTABLE to a built proxy).`);
+        }
+        this.options.diag(`launching SSPI proxy: "${proxyExe}" ${port}`);
+        const proxy = spawn(proxyExe, [String(port)], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            windowsHide: true,
+        });
+        if (!proxy.stdin || !proxy.stdout || !proxy.stderr) {
+            throw new Error('Failed to create SSPI proxy stdio pipes');
+        }
+        return {
+            mode: 'stdio-proxy',
+            controlProcess: proxy,
+            input: proxy.stdin,
+            output: proxy.stdout,
+            errorOutput: proxy.stderr,
+            close: () => { try {
+                proxy.stdin?.end();
+            }
+            catch { /* ignore */ } },
+            forceClose: () => { try {
+                if (!proxy.killed)
+                    proxy.kill('SIGKILL');
+            }
+            catch { /* ignore */ } },
+        };
+    }
+    /**
+     * `direct-sspi`: open the TCP socket and authenticate from Node with
+     * `node-expose-sspi`. The returned socket is a Duplex used for both XML
+     * directions.
+     */
+    async connectDirectSspi(port) {
+        const socket = await this.tcpConnect(port);
+        this.options.diag('starting SSPI authentication...');
+        await this.performSspiAuth(socket);
+        this.options.diag('SSPI authentication successful');
+        return {
+            mode: 'direct-sspi',
+            controlProcess: null,
+            tcpSocket: socket,
+            input: socket,
+            output: socket,
+            close: () => { try {
+                socket.end();
+            }
+            catch { /* ignore */ } },
+            forceClose: () => { try {
+                socket.destroy();
+            }
+            catch { /* ignore */ } },
+        };
+    }
+    /** Open a TCP connection to openMSX's loopback control port. */
+    tcpConnect(port) {
+        return new Promise((resolve, reject) => {
+            const socket = net.createConnection(port, '127.0.0.1');
+            socket.once('connect', () => resolve(socket));
+            socket.once('error', err => {
+                socket.destroy();
+                reject(new Error(`TCP connect to ${port} failed: ${err.message}`));
+            });
+        });
+    }
+    /**
+     * SSPI (Negotiate/NTLM) authentication handshake — Windows only.
+     * Required since openMSX 0.7.1 for TCP socket connections.
+     * Uses the optional `node-expose-sspi` v0.1.x 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 — the XML protocol begins.
+     *
+     * The socket is paused before returning so any data openMSX sends after auth
+     * buffers until the caller attaches its own `data` handler (no data is lost).
+     */
+    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.subarray(4, total);
+            sspiBuffer = sspiBuffer.subarray(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 the SSPI data listener and pause the socket so any post-auth
+            // bytes buffer until the caller attaches its own 'data' handler.
+            socket.removeListener('data', onSspiData);
+            socket.pause();
+        }
+    }
+}

package/dist/server.js

@@ -29,7 +29,12 @@ const require = createRequire(import.meta.url);
 export const PACKAGE_VERSION = require('../package.json').version;
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const resourcesDir = path.join(__dirname, "../resources");
-const vectorDbDir = path.join(__dirname, "../vector-db");
+// Index location. Defaults to the bundled `vector-db` next to the build, but can
+// be overridden with OPENMSX_VECTORDB_DIR. LanceDB/lance-io (Rust object_store)
+// cannot read a local index from a Windows *mapped network drive* (it drops the
+// drive letter when converting the path to a file:// URL). When the project lives
+// on a network share, point this at a copy of the index on a local disk.
+const vectorDbDir = process.env.OPENMSX_VECTORDB_DIR?.trim() || path.join(__dirname, "../vector-db");
 export const emuDirectories = {
     OPENMSX_SHARE_DIR: '',
     OPENMSX_EXECUTABLE: detectOpenMSXExecutable(),

package/dist/server_tools.js

@@ -1677,10 +1677,11 @@ The parameter scrbasename is the name of the filename (without path) to save the
     "vector_db_query", {
         title: "Vector DB query from resources",
         // Description of the tool (what it does)
-        description: `Query the Vector DB resources to obtain information about MSX system, cartridges, programming, and other development resources.
-The query is a string used to search within the Vector DB resources; it is case-insensitive and may contain spaces.
-The response is the list of the top 10 result resources that match the query, including their score, title, and resource URI, and are sorted in descending order by proximity score to the query.
-**Important Note**: The Vector DB resources are in english, japanese, or dutch.
+        description: `Query the documentation index to obtain information about MSX system, cartridges, programming, and other development resources.
+Uses hybrid search: semantic (multilingual embeddings) combined with keyword (BM25) matching, fused with Reciprocal Rank Fusion. Good for both conceptual questions and exact terms (mnemonics, register names, BIOS calls).
+The query is a string; it is case-insensitive and may contain spaces.
+The response is the list of the top 10 matching resource chunks, including their relevance score, title, and resource URI, sorted in descending order by score.
+**Important Note**: The documentation resources are in english, japanese, or dutch (the embedding model is multilingual).
 `,
         // Schema for the tool (input validation)
         inputSchema: {
@@ -1691,7 +1692,7 @@ The response is the list of the top 10 result resources that match the query, in
         },
         outputSchema: {
             results: z.array(z.object({
-                score: z.string().describe("Proximity score of the result to the query, higher is better."),
+                score: z.string().describe("Reciprocal Rank Fusion (RRF) relevance score combining semantic and keyword matches; higher is better. Only the relative ranking is meaningful, not the absolute value (typically ~0.01-0.03)."),
                 title: z.string().describe("Title of the resource."),
                 uri: z.string().describe("URI of the resource, which can be used to access the resource."),
                 document: z.string().describe("Document chunk of the resource, retrieved from the Vector DB."),

package/dist/vectordb.js

@@ -1,16 +1,53 @@
 /**
- * Vector Database wrapper class
+ * Vector Database wrapper class.
+ *
+ * Hybrid search over the MSX documentation corpus:
+ *   - dense vector search (cosine over 384-d embeddings, see embedder.ts)
+ *   - full-text search (BM25, LanceDB native FTS index)
+ *   - fused with Reciprocal Rank Fusion (RRF)
+ *
+ * Storage: LanceDB (columnar `.lance` table), replacing the previous Vectra
+ * `index.json`.
  *
  * @author Natalia Pujol Cremades (@nataliapc)
  * @license GPL2
  */
 import path from 'path';
-import { LocalIndex } from 'vectra';
-import embeddings from '@themaximalist/embeddings.js';
+import { pathToFileURL } from 'url';
+import * as lancedb from '@lancedb/lancedb';
+import { embedQuery } from './embedder.js';
+const TABLE_NAME = 'msxdocs';
+const TOP_K = 10; // final results returned
+const CANDIDATES = 30; // candidates fetched per branch before fusion
+const RRF_K = 60; // RRF constant
+/**
+ * Fuse two ranked result lists with Reciprocal Rank Fusion.
+ * Each document scores Σ 1/(k + rank) over the lists it appears in
+ * (rank is 0-based, so the +1 makes the top item contribute 1/(k+1)).
+ */
+export function fuseRRF(vecRows, ftsRows, k = RRF_K, topK = TOP_K) {
+    const acc = new Map();
+    const add = (rows) => {
+        rows.forEach((row, rank) => {
+            const id = String(row.id);
+            const inc = 1 / (k + rank + 1);
+            const cur = acc.get(id);
+            if (cur) {
+                cur.score += inc;
+            }
+            else {
+                acc.set(id, { score: inc, row });
+            }
+        });
+    };
+    add(vecRows);
+    add(ftsRows);
+    return [...acc.values()].sort((a, b) => b.score - a.score).slice(0, topK);
+}
 export class VectorDB {
-    static instance;
+    static instance = null;
     static vectorDbDir = path.join('..', 'vector-db');
-    index;
+    tablePromise = null;
     static getInstance() {
         if (!VectorDB.instance) {
             VectorDB.instance = new VectorDB();
@@ -20,42 +57,64 @@ export class VectorDB {
     static setIndexDirectory(dbDir) {
         VectorDB.vectorDbDir = dbDir;
     }
-    constructor(dbDir = VectorDB.vectorDbDir) {
-        this.index = new LocalIndex(dbDir);
-        if (!this.initDatabase()) {
-            throw new Error('Failed to initialize VectorDB: Index does not exist');
-        }
+    /**
+     * Resolve the directory into a value LanceDB can open.
+     *
+     * On Windows, LanceDB 0.30 (lance-io 7.0) mishandles drive-letter paths: it
+     * builds a malformed `file://` URL that drops the drive
+     * (`file:///mcp-server/vector-db/...`) and then fails to convert it back to a
+     * filesystem path. Passing an explicit, well-formed `file://` URI built by Node
+     * (`file:///M:/mcp-server/vector-db`) bypasses that broken path→URL step. On
+     * POSIX a plain path works fine, so we leave it untouched.
+     */
+    static resolveUri(dir) {
+        return process.platform === 'win32'
+            ? pathToFileURL(path.resolve(dir)).href
+            : dir;
     }
-    async initDatabase() {
-        return await this.index.isIndexCreated();
-    }
-    async getVector(text) {
-        const response = await embeddings(text);
-        if (!response || !Array.isArray(response) || response.length === 0) {
-            throw new Error('Failed to generate embedding vector');
+    getTable() {
+        if (!this.tablePromise) {
+            this.tablePromise = (async () => {
+                const db = await lancedb.connect(VectorDB.resolveUri(VectorDB.vectorDbDir));
+                return db.openTable(TABLE_NAME);
+            })().catch((err) => {
+                this.tablePromise = null;
+                throw new Error(`Failed to open LanceDB table '${TABLE_NAME}' at '${VectorDB.vectorDbDir}'. ` +
+                    `Has the index been generated? (${err instanceof Error ? err.message : err})`);
+            });
         }
-        return response;
+        return this.tablePromise;
     }
     async query(text) {
-        const vector = await this.getVector(text);
-        let results = [];
+        const tbl = await this.getTable();
+        const vector = await embedQuery(text);
+        // Vector branch (always available). No `.select()`: scoring queries warn
+        // when output columns are projected without `_distance`/`_score`, and the
+        // candidate set is tiny so fetching full rows is negligible.
+        const vecRows = await tbl
+            .query()
+            .nearestTo(vector)
+            .limit(CANDIDATES)
+            .toArray();
+        // Full-text (BM25) branch. Degrade gracefully to vector-only if the FTS
+        // index is missing or the query cannot be parsed.
+        let ftsRows = [];
         try {
-            results = await this.index.queryItems(vector, text, 10);
-            if (results.length > 0) {
-                return results.map(result => {
-                    return {
-                        score: result.score.toFixed(4),
-                        uri: result.item.metadata?.uri || 'unknown',
-                        title: result.item.metadata?.title || 'unknown',
-                        document: String(result.item.metadata?.document || ''),
-                        id: result.item.metadata?.id || 'unknown',
-                    };
-                });
-            }
+            ftsRows = await tbl
+                .query()
+                .nearestToText(text)
+                .limit(CANDIDATES)
+                .toArray();
         }
-        catch (error) {
-            throw new Error(`Query failed: ${error}`);
+        catch {
+            ftsRows = [];
         }
-        return results;
+        return fuseRRF(vecRows, ftsRows).map((r) => ({
+            score: r.score.toFixed(4),
+            uri: r.row.uri ?? 'unknown',
+            title: r.row.title ?? 'unknown',
+            document: String(r.row.text ?? ''),
+            id: r.row.id ?? 'unknown',
+        }));
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nataliapc/mcp-openmsx",
-  "version": "1.2.9",
+  "version": "1.2.11",
   "description": "Model context protocol server for openMSX automation and control",
   "main": "dist/server.js",
   "type": "module",
@@ -30,51 +30,49 @@
     "node": ">=18.0.0"
   },
   "scripts": {
-    "build": "node_modules/.bin/tsc && shx chmod +x dist/server.js",
-    "watch": "node_modules/.bin/tsc --watch",
+    "build": "shx rm -rf dist && tsc && shx chmod +x dist/server.js",
+    "watch": "tsc --watch",
     "start": "node dist/server.js",
     "dev": "tsx src/server.ts",
     "prepublishOnly": "npm run build",
     "test": "vitest run",
     "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage"
+    "test:coverage": "vitest run --coverage",
+    "build:proxy:win-x64": "dotnet publish helpers/openmsx-sspi-proxy/OpenMsxSspiProxy.csproj -c Release -r win-x64 --self-contained true -p:PublishSingleFile=true -p:IncludeNativeLibrariesForSelfExtract=true -p:PublishTrimmed=true -p:TrimMode=partial -p:EnableCompressionInSingleFile=true -o bin/win-x64",
+    "build:proxy:win-x64:docker": "docker run --rm --user $(id -u):$(id -g) -e HOME=/tmp -e DOTNET_CLI_HOME=/tmp -v \"$PWD\":/work -w /work mcr.microsoft.com/dotnet/sdk:8.0 dotnet publish helpers/openmsx-sspi-proxy/OpenMsxSspiProxy.csproj -c Release -r win-x64 --self-contained true -p:PublishSingleFile=true -p:IncludeNativeLibrariesForSelfExtract=true -p:PublishTrimmed=true -p:TrimMode=partial -p:EnableCompressionInSingleFile=true -o bin/win-x64",
+    "build:all": "pnpm build && pnpm build:proxy:win-x64:docker"
   },
   "optionalDependencies": {
     "node-expose-sspi": "^0.1.60"
   },
-  "pnpm": {
-    "overrides": {
-      "sharp": "$sharp"
-    }
-  },
   "dependencies": {
+    "@anush008/tokenizers": "^0.6.0",
+    "@lancedb/lancedb": "^0.30.0",
     "@modelcontextprotocol/sdk": "^1.26.0",
-    "@themaximalist/embeddings.js": "^0.1.3",
     "@types/express": "^5.0.6",
     "@types/mime-types": "^3.0.1",
-    "@xenova/transformers": "^2.17.2",
     "debug": "^4.4.3",
     "express": "^5.2.1",
     "mime-types": "^3.0.2",
-    "sanitize-html": "^2.17.0",
-    "sharp": "^0.34.5",
-    "tsx": "^4.21.0",
-    "vectra": "^0.11.1",
+    "onnxruntime-node": "^1.27.0",
+    "sanitize-html": "^2.17.4",
+    "tsx": "^4.22.0",
     "zod": "^3.25.76"
   },
   "devDependencies": {
     "@modelcontextprotocol/inspector": "^0.20.0",
-    "@types/node": "^25.2.3",
+    "@types/node": "^25.7.0",
     "@types/sanitize-html": "^2.16.0",
-    "@vitest/coverage-v8": "^4.1.4",
+    "@vitest/coverage-v8": "^4.1.6",
     "shx": "^0.4.0",
     "typescript": "^5.9.3",
-    "vitest": "^4.1.4"
+    "vitest": "^4.1.6"
   },
   "files": [
     "dist/**/*",
     "resources/**/*",
     "vector-db/**/*",
+    "bin/win-x64/**/*",
     "README.md",
     "LICENSE"
   ],