@hcu-lab.me/mcp-device 1.0.5 → 1.0.6

package/dist/terminal-manager.js

@@ -205,6 +205,21 @@ export class TerminalManager {
         // Spawn the process with appropriate arguments
         const childProcess = spawn(spawnConfig.executable, spawnConfig.args, spawnOptions);
         let output = '';
+        // spawn() reports resolution/launch failures asynchronously via 'error'.
+        // A listener-less ChildProcess error becomes an uncaughtException and kills
+        // the inherited MCP server. Attach before any early-return path and keep
+        // the listener for the process lifetime.
+        let forwardProcessError = null;
+        let pendingProcessError = null;
+        childProcess.on('error', (err) => {
+            if (forwardProcessError) {
+                forwardProcessError(err);
+            }
+            else {
+                pendingProcessError = err;
+                console.error(`Process error for "${command}": ${err.message}`);
+            }
+        });
         // Ensure childProcess.pid is defined before proceeding
         if (!childProcess.pid) {
             // Return a consistent error object instead of throwing
@@ -259,6 +274,31 @@ export class TerminalManager {
                 }
                 resolve(result);
             };
+            // Once resolveOnce exists, route runtime/spawn errors into the normal
+            // command result path so callers do not hang and the session is retired.
+            forwardProcessError = (err) => {
+                // A late ChildProcess 'error' can arrive after the caller has already
+                // received a live/background session. Do not silently retire that
+                // session; the normal 'exit' event remains authoritative for cleanup.
+                if (resolved) {
+                    this.appendToLineBuffer(session, `\nProcess error: ${err.message}\n`);
+                    console.error(`Process error for "${command}": ${err.message}`);
+                    return;
+                }
+                if (childProcess.pid)
+                    this.sessions.delete(childProcess.pid);
+                exitReason = 'process_exit';
+                resolveOnce({
+                    pid: childProcess.pid ?? -1,
+                    output: output + `\nProcess error: ${err.message}`,
+                    isBlocked: false
+                });
+            };
+            // Spawn failures normally arrive on the next tick, but replay any error
+            // emitted between spawn() and resolver initialization.
+            if (pendingProcessError) {
+                forwardProcessError(pendingProcessError);
+            }
             childProcess.stdout.on('data', (data) => {
                 const text = data.toString();
                 const now = Date.now();

package/dist/utils/capture.js

@@ -443,7 +443,7 @@ const postTelemetryPayload = async (endpoint, payload) => {
 export const capture = async (event, properties) => {
     // Tool calls fired programmatically by the widget UIs must produce zero
     // telemetry — drop every event raised while serving one.
-    if (isInsideUiOriginCall()) {
+    if (isInsideUiOriginCall() || isTelemetryDisabledByEnv()) {
         return;
     }
     void (async () => {

package/dist/utils/files/factory.js

@@ -5,6 +5,7 @@
  * Each handler implements canHandle() which can be sync (extension-based)
  * or async (content-based like BinaryFileHandler using isBinaryFile)
  */
+import fs from 'fs/promises';
 import { TextFileHandler } from './text.js';
 import { ImageFileHandler } from './image.js';
 import { BinaryFileHandler } from './binary.js';
@@ -86,6 +87,25 @@ export async function getFileHandler(filePath) {
     if (getImageHandler().canHandle(filePath)) {
         return getImageHandler();
     }
+    // UTF-16LE text contains many NUL bytes and generic binary sniffers
+    // often classify it as binary. A BOM is authoritative, so route it to the
+    // text handler before content-based binary detection.
+    try {
+        const fd = await fs.open(filePath, 'r');
+        try {
+            const bom = Buffer.alloc(2);
+            const { bytesRead } = await fd.read(bom, 0, bom.length, 0);
+            if (bytesRead === 2 && bom[0] === 0xff && bom[1] === 0xfe) {
+                return getTextHandler();
+            }
+        }
+        finally {
+            await fd.close();
+        }
+    }
+    catch {
+        // Preserve existing fallback behavior if the file cannot be sampled.
+    }
     // Check Binary (content-based, async via isBinaryFile)
     if (await getBinaryHandler().canHandle(filePath)) {
         return getBinaryHandler();

package/dist/utils/files/text.d.ts

@@ -19,6 +19,7 @@ import { FileHandler, ReadOptions, FileResult, FileInfo } from './base.js';
  */
 export declare class TextFileHandler implements FileHandler {
     canHandle(_path: string): boolean;
+    private detectTextEncoding;
     read(filePath: string, options?: ReadOptions): Promise<FileResult>;
     write(path: string, content: string, mode?: 'rewrite' | 'append'): Promise<void>;
     getInfo(path: string): Promise<FileInfo>;

package/dist/utils/files/text.js

@@ -38,6 +38,17 @@ export class TextFileHandler {
         // The factory routes binary files to BinaryFileHandler before reaching here
         return true;
     }
+    async detectTextEncoding(filePath) {
+        const fd = await fs.open(filePath, 'r');
+        try {
+            const bom = Buffer.alloc(2);
+            const { bytesRead } = await fd.read(bom, 0, bom.length, 0);
+            return bytesRead === 2 && bom[0] === 0xff && bom[1] === 0xfe ? 'utf16le' : 'utf8';
+        }
+        finally {
+            await fd.close();
+        }
+    }
     async read(filePath, options) {
         const offset = options?.offset ?? 0;
         const length = options?.length ?? 1000; // Default from config
@@ -69,7 +80,11 @@ export class TextFileHandler {
         // For text files that aren't too large, count lines
         if (stats.isFile() && stats.size < FILE_SIZE_LIMITS.LINE_COUNT_LIMIT) {
             try {
-                const content = await fs.readFile(path, 'utf8');
+                const encoding = await this.detectTextEncoding(path);
+                let content = await fs.readFile(path, encoding);
+                if (encoding === 'utf16le' && content.charCodeAt(0) === 0xfeff) {
+                    content = content.slice(1);
+                }
                 const lineCount = TextFileHandler.countLines(content);
                 info.metadata.lineCount = lineCount;
             }
@@ -100,11 +115,14 @@ export class TextFileHandler {
     /**
      * Get file line count (for files under size limit)
      */
-    async getFileLineCount(filePath, signal) {
+    async getFileLineCount(filePath, signal, encoding = 'utf8') {
         try {
             const stats = await fs.stat(filePath);
             if (stats.size < FILE_SIZE_LIMITS.LINE_COUNT_LIMIT) {
-                const content = await fs.readFile(filePath, { encoding: 'utf8', signal });
+                let content = await fs.readFile(filePath, { encoding, signal });
+                if (encoding === 'utf16le' && content.charCodeAt(0) === 0xfeff) {
+                    content = content.slice(1);
+                }
                 return TextFileHandler.countLines(content);
             }
         }
@@ -182,7 +200,16 @@ export class TextFileHandler {
     async readFileWithSmartPositioning(filePath, offset, length, mimeType, includeStatusMessage = true, signal) {
         const stats = await fs.stat(filePath);
         const fileSize = stats.size;
-        const totalLines = await this.getFileLineCount(filePath, signal);
+        const encoding = await this.detectTextEncoding(filePath);
+        const totalLines = await this.getFileLineCount(filePath, signal, encoding);
+        // UTF-16LE needs character-aware streaming. Skip the BOM and preserve
+        // the same line pagination/status semantics as UTF-8.
+        if (encoding === 'utf16le') {
+            if (offset < 0) {
+                return await this.readFromEndWithReadline(filePath, Math.abs(offset), mimeType, includeStatusMessage, totalLines, signal, 'utf16le', 2);
+            }
+            return await this.readFromStartWithReadline(filePath, offset, length, mimeType, includeStatusMessage, totalLines, signal, 'utf16le', 2);
+        }
         // For negative offsets (tail behavior), use reverse reading
         if (offset < 0) {
             const requestedLines = Math.abs(offset);
@@ -252,9 +279,9 @@ export class TextFileHandler {
     /**
      * Read from end using readline with circular buffer
      */
-    async readFromEndWithReadline(filePath, requestedLines, mimeType, includeStatusMessage = true, fileTotalLines, signal) {
+    async readFromEndWithReadline(filePath, requestedLines, mimeType, includeStatusMessage = true, fileTotalLines, signal, encoding, start) {
         const rl = createInterface({
-            input: createReadStream(filePath, { signal }),
+            input: createReadStream(filePath, { signal, encoding, start }),
             crlfDelay: Infinity
         });
         const buffer = new Array(requestedLines);
@@ -284,22 +311,28 @@ export class TextFileHandler {
     /**
      * Read from start/middle using readline
      */
-    async readFromStartWithReadline(filePath, offset, length, mimeType, includeStatusMessage = true, fileTotalLines, signal) {
+    async readFromStartWithReadline(filePath, offset, length, mimeType, includeStatusMessage = true, fileTotalLines, signal, encoding, start) {
+        const stream = createReadStream(filePath, { signal, encoding, start });
         const rl = createInterface({
-            input: createReadStream(filePath, { signal }),
+            input: stream,
             crlfDelay: Infinity
         });
         const result = [];
         let lineNumber = 0;
-        for await (const line of rl) {
-            if (lineNumber >= offset && result.length < length) {
-                result.push(line);
+        try {
+            for await (const line of rl) {
+                if (lineNumber >= offset && result.length < length) {
+                    result.push(line);
+                }
+                if (result.length >= length)
+                    break;
+                lineNumber++;
             }
-            if (result.length >= length)
-                break;
-            lineNumber++;
         }
-        rl.close();
+        finally {
+            rl.close();
+            stream.destroy();
+        }
         if (includeStatusMessage) {
             const statusMessage = this.generateEnhancedStatusMessage(result.length, offset, fileTotalLines, false);
             const content = `${statusMessage}\n\n${result.join('\n')}`;
@@ -314,20 +347,26 @@ export class TextFileHandler {
      * Read from estimated byte position for very large files
      */
     async readFromEstimatedPosition(filePath, offset, length, mimeType, includeStatusMessage = true, fileTotalLines, signal) {
-        // First, do a quick scan to estimate lines per byte
+        // First, do a quick scan to estimate lines per byte.
+        const sampleStream = createReadStream(filePath, { signal });
         const rl = createInterface({
-            input: createReadStream(filePath, { signal }),
+            input: sampleStream,
             crlfDelay: Infinity
         });
         let sampleLines = 0;
         let bytesRead = 0;
-        for await (const line of rl) {
-            bytesRead += Buffer.byteLength(line, 'utf-8') + 1;
-            sampleLines++;
-            if (bytesRead >= READ_PERFORMANCE_THRESHOLDS.SAMPLE_SIZE)
-                break;
+        try {
+            for await (const line of rl) {
+                bytesRead += Buffer.byteLength(line, 'utf-8') + 1;
+                sampleLines++;
+                if (bytesRead >= READ_PERFORMANCE_THRESHOLDS.SAMPLE_SIZE)
+                    break;
+            }
+        }
+        finally {
+            rl.close();
+            sampleStream.destroy();
         }
-        rl.close();
         if (sampleLines === 0) {
             return await this.readFromStartWithReadline(filePath, offset, length, mimeType, includeStatusMessage, fileTotalLines, signal);
         }
@@ -345,19 +384,24 @@ export class TextFileHandler {
             });
             const result = [];
             let firstLineSkipped = false;
-            for await (const line of rl2) {
-                if (!firstLineSkipped && startPosition > 0) {
-                    firstLineSkipped = true;
-                    continue;
-                }
-                if (result.length < length) {
-                    result.push(line);
-                }
-                else {
-                    break;
+            try {
+                for await (const line of rl2) {
+                    if (!firstLineSkipped && startPosition > 0) {
+                        firstLineSkipped = true;
+                        continue;
+                    }
+                    if (result.length < length) {
+                        result.push(line);
+                    }
+                    else {
+                        break;
+                    }
                 }
             }
-            rl2.close();
+            finally {
+                rl2.close();
+                stream.destroy();
+            }
             const content = includeStatusMessage
                 ? `${this.generateEnhancedStatusMessage(result.length, offset, fileTotalLines, false)}\n\n${result.join('\n')}`
                 : result.join('\n');

package/dist/utils/trackTools.js

@@ -13,8 +13,29 @@ export async function trackToolCall(toolName, args) {
     try {
         // Get current timestamp
         const timestamp = new Date().toISOString();
-        // Format the log entry
-        const logEntry = `${timestamp} | ${toolName.padEnd(20, ' ')}${args ? `\t| Arguments: ${JSON.stringify(args)}` : ''}\n`;
+        // Remote MCP Device calls may contain commands, file contents, tokens or
+        // other secrets. Persist only bounded metadata in remote mode.
+        const remote = process.env.MCP_DEVICE_REMOTE === 'true';
+        let suffix = '';
+        if (args !== undefined) {
+            if (remote) {
+                let argBytes = 0;
+                let argCount = 0;
+                try {
+                    const serialized = JSON.stringify(args);
+                    argBytes = Buffer.byteLength(serialized || '', 'utf8');
+                    argCount = args && typeof args === 'object' && !Array.isArray(args)
+                        ? Object.keys(args).length
+                        : 1;
+                }
+                catch { /* metadata-only logging must never affect tool execution */ }
+                suffix = `\t| Args: count=${argCount} bytes=${argBytes}`;
+            }
+            else {
+                suffix = `\t| Arguments: ${JSON.stringify(args)}`;
+            }
+        }
+        const logEntry = `${timestamp} | ${toolName.padEnd(20, ' ')}${suffix}\n`;
         // Check if file exists and get its size
         let fileSize = 0;
         try {

package/dist/utils/usageTracker.js

@@ -52,6 +52,8 @@ class UsageTracker {
      * keeps a saturated libuv threadpool from gating tool responses on every call.
      */
     async saveStats(stats) {
+        if (process.env.MCP_DEVICE_REMOTE === 'true')
+            return;
         await configManager.setValueNonBlocking('usageStats', stats);
     }
     /**

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "1.0.5";
+export declare const VERSION = "1.0.6";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '1.0.5';
+export const VERSION = '1.0.6';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hcu-lab.me/mcp-device",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "MCP Device securely connects a user-owned computer to an authenticated Model Context Protocol gateway.",
   "license": "MIT",
   "author": "Hirohimeow",
@@ -26,14 +26,14 @@
     "device:start": "tsx src/device/device.ts",
     "device:start:dev": "nodemon --watch src/device --exec tsx src/device/device.ts",
     "sync-version": "node scripts/sync-version.js",
-    "version": "node scripts/sync-version.js && git add server.json src/version.ts package-lock.json",
+    "version": "node scripts/sync-version.js && git add src/version.ts package-lock.json",
     "release": "node scripts/release.js patch",
     "release:minor": "node scripts/release.js minor",
     "release:major": "node scripts/release.js major",
     "bump": "node scripts/sync-version.js --bump",
     "bump:minor": "node scripts/sync-version.js --bump --minor",
     "bump:major": "node scripts/sync-version.js --bump --major",
-    "build": "shx rm -rf dist/remote-device && shx rm -f dist/device/desktop-commander-integration.js dist/device/desktop-commander-integration.d.ts dist/device/windows-dpapi.js dist/device/windows-dpapi.d.ts && tsc && shx chmod +x dist/*.js && shx mkdir -p dist/data && shx cp src/data/onboarding-prompts.json dist/data/ && node scripts/copy-official-ca.cjs && node scripts/build-ui-runtime.cjs",
+    "build": "shx rm -rf dist/remote-device && shx rm -f dist/device/desktop-commander-integration.js dist/device/desktop-commander-integration.d.ts dist/device/windows-dpapi.js dist/device/windows-dpapi.d.ts && tsc && shx chmod +x dist/*.js && shx cp src/device/update-helper.cjs dist/device/update-helper.cjs && shx mkdir -p dist/data && shx cp src/data/onboarding-prompts.json dist/data/ && node scripts/copy-official-ca.cjs && node scripts/build-ui-runtime.cjs",
     "watch": "tsc --watch",
     "start": "node dist/mcp-device.js",
     "start:debug": "node --inspect-brk=9229 dist/mcp-device.js",