@hcu-lab.me/mcp-device 1.0.0

package/dist/handlers/search-handlers.js

@@ -0,0 +1,224 @@
+import { searchManager } from '../search-manager.js';
+import { StartSearchArgsSchema, GetMoreSearchResultsArgsSchema, StopSearchArgsSchema } from '../tools/schemas.js';
+import { capture } from '../utils/capture.js';
+/**
+ * Handle start_search command
+ */
+export async function handleStartSearch(args) {
+    const parsed = StartSearchArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        return {
+            content: [{ type: "text", text: `Invalid arguments for start_search: ${parsed.error}` }],
+            isError: true,
+        };
+    }
+    try {
+        const result = await searchManager.startSearch({
+            rootPath: parsed.data.path,
+            pattern: parsed.data.pattern,
+            searchType: parsed.data.searchType,
+            filePattern: parsed.data.filePattern,
+            ignoreCase: parsed.data.ignoreCase,
+            maxResults: parsed.data.maxResults,
+            includeHidden: parsed.data.includeHidden,
+            contextLines: parsed.data.contextLines,
+            timeout: parsed.data.timeout_ms,
+            earlyTermination: parsed.data.earlyTermination,
+            literalSearch: parsed.data.literalSearch,
+        });
+        const searchTypeText = parsed.data.searchType === 'content' ? 'content search' : 'file search';
+        let output = `Started ${searchTypeText} session: ${result.sessionId}\n`;
+        output += `Pattern: "${parsed.data.pattern}"\n`;
+        output += `Path: ${parsed.data.path}\n`;
+        output += `Status: ${result.isComplete ? 'COMPLETED' : 'RUNNING'}\n`;
+        output += `Runtime: ${Math.round(result.runtime)}ms\n`;
+        output += `Total results: ${result.totalResults}\n\n`;
+        if (result.results.length > 0) {
+            output += "Initial results:\n";
+            for (const searchResult of result.results.slice(0, 10)) {
+                if (searchResult.type === 'content') {
+                    output += `📄 ${searchResult.file}:${searchResult.line} - ${searchResult.match?.substring(0, 100)}${searchResult.match && searchResult.match.length > 100 ? '...' : ''}\n`;
+                }
+                else {
+                    output += `📁 ${searchResult.file}\n`;
+                }
+            }
+            if (result.results.length > 10) {
+                output += `... and ${result.results.length - 10} more results\n`;
+            }
+        }
+        if (result.isComplete) {
+            output += `\n✅ Search completed.`;
+        }
+        else {
+            output += `\n🔄 Search in progress. Use get_more_search_results to get more results.`;
+        }
+        return {
+            content: [{ type: "text", text: output }],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        capture('search_session_start_error', { error: errorMessage });
+        return {
+            content: [{ type: "text", text: `Error starting search session: ${errorMessage}` }],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle get_more_search_results command
+ */
+export async function handleGetMoreSearchResults(args) {
+    const parsed = GetMoreSearchResultsArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        return {
+            content: [{ type: "text", text: `Invalid arguments for get_more_search_results: ${parsed.error}` }],
+            isError: true,
+        };
+    }
+    try {
+        const results = searchManager.readSearchResults(parsed.data.sessionId, parsed.data.offset, parsed.data.length);
+        // Only return error if we have no results AND there's an actual error
+        // Permission errors should not block returning found results
+        if (results.isError && results.totalResults === 0 && results.error?.trim()) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Search session ${parsed.data.sessionId} encountered an error: ${results.error}`
+                    }],
+                isError: true,
+            };
+        }
+        // Format results for display
+        let output = `Search session: ${parsed.data.sessionId}\n`;
+        output += `Status: ${results.isComplete ? 'COMPLETED' : 'IN PROGRESS'}\n`;
+        output += `Runtime: ${Math.round(results.runtime / 1000)}s\n`;
+        output += `Total results found: ${results.totalResults} (${results.totalMatches} matches)\n`;
+        const offset = parsed.data.offset;
+        if (offset < 0) {
+            // Negative offset - tail behavior
+            output += `Showing last ${results.returnedCount} results\n\n`;
+        }
+        else {
+            // Positive offset - range behavior
+            const startPos = offset;
+            const endPos = startPos + results.returnedCount - 1;
+            output += `Showing results ${startPos}-${endPos}\n\n`;
+        }
+        if (results.results.length === 0) {
+            if (results.isComplete) {
+                output += results.totalResults === 0 ? "No matches found." : "No results in this range.";
+            }
+            else {
+                output += "No results yet, search is still running...";
+            }
+        }
+        else {
+            output += "Results:\n";
+            for (const result of results.results) {
+                if (result.type === 'content') {
+                    output += `📄 ${result.file}:${result.line} - ${result.match?.substring(0, 100)}${result.match && result.match.length > 100 ? '...' : ''}\n`;
+                }
+                else {
+                    output += `📁 ${result.file}\n`;
+                }
+            }
+        }
+        // Add pagination hints
+        if (offset >= 0 && results.hasMoreResults) {
+            const nextOffset = offset + results.returnedCount;
+            output += `\n📖 More results available. Use get_more_search_results with offset: ${nextOffset}`;
+        }
+        if (results.isComplete) {
+            output += `\n✅ Search completed.`;
+            // Warn users if search was incomplete due to permission issues
+            if (results.wasIncomplete) {
+                output += `\n⚠️  Warning: Some files were inaccessible due to permissions. Results may be incomplete.`;
+            }
+        }
+        return {
+            content: [{ type: "text", text: output }],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: "text", text: `Error reading search results: ${errorMessage}` }],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle stop_search command
+ */
+export async function handleStopSearch(args) {
+    const parsed = StopSearchArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        return {
+            content: [{ type: "text", text: `Invalid arguments for stop_search: ${parsed.error}` }],
+            isError: true,
+        };
+    }
+    try {
+        const success = searchManager.terminateSearch(parsed.data.sessionId);
+        if (success) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Search session ${parsed.data.sessionId} terminated successfully.`
+                    }],
+            };
+        }
+        else {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Search session ${parsed.data.sessionId} not found or already completed.`
+                    }],
+            };
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: "text", text: `Error terminating search session: ${errorMessage}` }],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle list_searches command
+ */
+export async function handleListSearches() {
+    try {
+        const sessions = searchManager.listSearchSessions();
+        if (sessions.length === 0) {
+            return {
+                content: [{ type: "text", text: "No active searches." }],
+            };
+        }
+        let output = `Active Searches (${sessions.length}):\n\n`;
+        for (const session of sessions) {
+            const status = session.isComplete
+                ? (session.isError ? '❌ ERROR' : '✅ COMPLETED')
+                : '🔄 RUNNING';
+            output += `Session: ${session.id}\n`;
+            output += `  Type: ${session.searchType}\n`;
+            output += `  Pattern: "${session.pattern}"\n`;
+            output += `  Status: ${status}\n`;
+            output += `  Runtime: ${Math.round(session.runtime / 1000)}s\n`;
+            output += `  Results: ${session.totalResults}\n\n`;
+        }
+        return {
+            content: [{ type: "text", text: output }],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: "text", text: `Error listing search sessions: ${errorMessage}` }],
+            isError: true,
+        };
+    }
+}

package/dist/handlers/terminal-handlers.d.ts

@@ -0,0 +1,21 @@
+import { ServerResult } from '../types.js';
+/**
+ * Handle start_process command (improved execute_command)
+ */
+export declare function handleStartProcess(args: unknown): Promise<ServerResult>;
+/**
+ * Handle read_process_output command (improved read_output)
+ */
+export declare function handleReadProcessOutput(args: unknown): Promise<ServerResult>;
+/**
+ * Handle interact_with_process command (improved send_input)
+ */
+export declare function handleInteractWithProcess(args: unknown): Promise<ServerResult>;
+/**
+ * Handle force_terminate command
+ */
+export declare function handleForceTerminate(args: unknown): Promise<ServerResult>;
+/**
+ * Handle list_sessions command
+ */
+export declare function handleListSessions(): Promise<ServerResult>;

package/dist/handlers/terminal-handlers.js

@@ -0,0 +1,35 @@
+import { startProcess, readProcessOutput, interactWithProcess, forceTerminate, listSessions } from '../tools/improved-process-tools.js';
+import { StartProcessArgsSchema, ReadProcessOutputArgsSchema, ForceTerminateArgsSchema } from '../tools/schemas.js';
+/**
+ * Handle start_process command (improved execute_command)
+ */
+export async function handleStartProcess(args) {
+    const parsed = StartProcessArgsSchema.parse(args);
+    return startProcess(parsed);
+}
+/**
+ * Handle read_process_output command (improved read_output)
+ */
+export async function handleReadProcessOutput(args) {
+    const parsed = ReadProcessOutputArgsSchema.parse(args);
+    return readProcessOutput(parsed);
+}
+/**
+ * Handle interact_with_process command (improved send_input)
+ */
+export async function handleInteractWithProcess(args) {
+    return interactWithProcess(args);
+}
+/**
+ * Handle force_terminate command
+ */
+export async function handleForceTerminate(args) {
+    const parsed = ForceTerminateArgsSchema.parse(args);
+    return forceTerminate(parsed);
+}
+/**
+ * Handle list_sessions command
+ */
+export async function handleListSessions() {
+    return listSessions();
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import './bootstrap.js';

package/dist/index.js

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+// MUST be first: raises the libuv threadpool size before any fs work is
+// submitted. See src/bootstrap.ts for why import order matters.
+import './bootstrap.js';
+import { FilteredStdioServerTransport } from './custom-stdio.js';
+import { server, flushDeferredMessages } from './server.js';
+import { configManager } from './config-manager.js';
+import { featureFlagManager } from './utils/feature-flags.js';
+import { capture } from './utils/capture.js';
+import { logToStderr, logger } from './utils/logger.js';
+import { runRemote } from './npm-scripts/remote.js';
+import { ensureChromeAvailable } from './tools/pdf/markdown.js';
+// Store messages to defer until after initialization
+const deferredMessages = [];
+function deferLog(level, message) {
+    deferredMessages.push({ level, message });
+}
+async function runServer() {
+    try {
+        // Check if first argument is "remote"
+        if (process.argv[2] === 'remote') {
+            await runRemote();
+            return;
+        }
+        // Parse command line arguments for onboarding control
+        const DISABLE_ONBOARDING = process.argv.includes('--no-onboarding');
+        if (DISABLE_ONBOARDING) {
+            logToStderr('info', 'Onboarding disabled via --no-onboarding flag');
+        }
+        // Set global flag for onboarding control
+        global.disableOnboarding = DISABLE_ONBOARDING;
+        // Create transport FIRST so all logging gets properly buffered
+        // This must happen before any code that might use logger.*
+        const transport = new FilteredStdioServerTransport();
+        // Export transport for use throughout the application
+        global.mcpTransport = transport;
+        try {
+            deferLog('info', 'Loading configuration...');
+            await configManager.loadConfig();
+            deferLog('info', 'Configuration loaded successfully');
+            // Initialize feature flags (non-blocking)
+            deferLog('info', 'Initializing feature flags...');
+            await featureFlagManager.initialize();
+        }
+        catch (configError) {
+            deferLog('error', `Failed to load configuration: ${configError instanceof Error ? configError.message : String(configError)}`);
+            if (configError instanceof Error && configError.stack) {
+                deferLog('debug', `Stack trace: ${configError.stack}`);
+            }
+            deferLog('warning', 'Continuing with in-memory configuration only');
+            // Continue anyway - we'll use an in-memory config
+        }
+        // Handle uncaught exceptions
+        process.on('uncaughtException', async (error) => {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            // If this is a JSON parsing error, log it to stderr but don't crash
+            if (errorMessage.includes('JSON') && errorMessage.includes('Unexpected token')) {
+                logger.error(`JSON parsing error: ${errorMessage}`);
+                return; // Don't exit on JSON parsing errors
+            }
+            capture('run_server_uncaught_exception', {
+                error: errorMessage
+            });
+            logger.error(`Uncaught exception: ${errorMessage}`);
+            process.exit(1);
+        });
+        // Handle unhandled rejections
+        process.on('unhandledRejection', async (reason) => {
+            const errorMessage = reason instanceof Error ? reason.message : String(reason);
+            // If this is a JSON parsing error, log it to stderr but don't crash
+            if (errorMessage.includes('JSON') && errorMessage.includes('Unexpected token')) {
+                logger.error(`JSON parsing rejection: ${errorMessage}`);
+                return; // Don't exit on JSON parsing errors
+            }
+            capture('run_server_unhandled_rejection', {
+                error: errorMessage
+            });
+            logger.error(`Unhandled rejection: ${errorMessage}`);
+            process.exit(1);
+        });
+        capture('run_server_start');
+        deferLog('info', 'Connecting server...');
+        // Set up event-driven initialization completion handler
+        server.oninitialized = () => {
+            // This callback is triggered after the client sends the "initialized" notification
+            // At this point, the MCP protocol handshake is fully complete
+            transport.enableNotifications();
+            // Flush all deferred messages from both index.ts and server.ts
+            while (deferredMessages.length > 0) {
+                const msg = deferredMessages.shift();
+                transport.sendLog('info', msg.message);
+            }
+            flushDeferredMessages();
+            // Now we can send regular logging messages
+            transport.sendLog('info', 'Server connected successfully');
+            transport.sendLog('info', 'MCP fully initialized, all startup messages sent');
+            // Preemptively check/download Chrome for PDF generation (runs in background)
+            ensureChromeAvailable();
+        };
+        await server.connect(transport);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error(`FATAL ERROR: ${errorMessage}`);
+        if (error instanceof Error && error.stack) {
+            logger.debug(error.stack);
+        }
+        // Send a structured error notification
+        const errorNotification = {
+            jsonrpc: "2.0",
+            method: "notifications/message",
+            params: {
+                level: "error",
+                logger: "mcp-device",
+                data: `Failed to start server: ${errorMessage} (${new Date().toISOString()})`
+            }
+        };
+        process.stdout.write(JSON.stringify(errorNotification) + '\n');
+        capture('run_server_failed_start_error', {
+            error: errorMessage
+        });
+        process.exit(1);
+    }
+}
+runServer().catch(async (error) => {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`RUNTIME ERROR: ${errorMessage}`);
+    console.error(error instanceof Error && error.stack ? error.stack : 'No stack trace available');
+    process.stderr.write(JSON.stringify({
+        type: 'error',
+        timestamp: new Date().toISOString(),
+        message: `Fatal error running server: ${errorMessage}`
+    }) + '\n');
+    capture('run_server_fatal_error', {
+        error: errorMessage
+    });
+    process.exit(1);
+});

package/dist/mcp-device.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/mcp-device.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+// MCP Device publishes only the authenticated device runtime surface.
+if (process.argv[2] !== 'remote')
+    process.argv.splice(2, 0, 'remote');
+const { runRemote } = await import('./npm-scripts/remote.js');
+await runRemote();
+export {};

package/dist/npm-scripts/remote.d.ts

@@ -0,0 +1,3 @@
+import { GatewayDeviceStatusStore } from '../device/device-status.js';
+export declare function applyServiceCommandStatus(store: GatewayDeviceStatusStore, command: 'install' | 'start' | 'stop' | 'uninstall'): Promise<void>;
+export declare function runRemote(): Promise<void>;