@hcu-lab.me/mcp-device 1.0.0

package/dist/npm-scripts/remote.js

@@ -0,0 +1,314 @@
+import os from 'os';
+import readline from 'readline/promises';
+import { MCPDevice } from '../device/device.js';
+import { GatewayDeviceChannel } from '../device/gateway-channel.js';
+import { GatewayDeviceConfigStore, captureGatewayConfigFromEnvironment, createGatewayProxyAgent } from '../device/gateway-config.js';
+import { GatewayDeviceIdentity, deviceIdentityNeedsPairing } from '../device/gateway-identity.js';
+import { pairGatewayDevice } from '../device/gateway-pairing.js';
+import { bootstrapOfficialGatewayTrust } from '../device/official-trust.js';
+import { GatewayDeviceStatusStore, effectiveGatewayStatus, formatGatewayStatus } from '../device/device-status.js';
+import { chooseLinuxManager, discoverLinuxManagers, Pm2DeviceService, SystemdUserDeviceService } from '../device/linux-service.js';
+import { RuntimeOwner, acquireRuntimeOwner, probeRuntimeOwner, stopRuntimeOwner } from '../device/runtime-owner.js';
+import { WindowsDeviceService } from '../device/windows-service.js';
+function commandName() {
+    const value = String(process.argv[3] || '').trim().toLowerCase();
+    if (['help', '-h', '--help'].includes(value))
+        return 'help';
+    if (!value || value.startsWith('--'))
+        return 'start';
+    return value;
+}
+function printRemoteUsage() {
+    console.log([
+        'Usage: mcp-device [command]',
+        '',
+        'Commands: start, login, logout, status, install, stop, uninstall'
+    ].join('\n'));
+}
+async function persistGatewayPayload(store, gatewayUrl, identity, payload) {
+    const record = await identity.loadOrCreate();
+    const current = await store.load();
+    return await store.update({
+        gatewayUrl,
+        deviceId: record.deviceId,
+        deviceName: payload?.device?.name || current.deviceName || os.hostname(),
+        identityPresent: true,
+        account: payload?.account || current.account,
+        connection: {
+            online: payload?.device?.online !== false,
+            connectionEpoch: payload?.device?.connectionEpoch ?? current.connection.connectionEpoch,
+            lastConnectedAt: payload?.device?.connectedAt || Date.now()
+        },
+        usage: payload?.usage ?? current.usage,
+        schema: payload?.schema ?? current.schema,
+        usageFreshAt: Date.now()
+    });
+}
+function controlAdapter() {
+    return { async call() { throw new Error('Tool calls are disabled for this control-only connection.'); } };
+}
+async function lifecycleSnapshot(status) {
+    const owner = await probeRuntimeOwner();
+    if (process.platform === 'win32' && status.deviceId) {
+        const service = await new WindowsDeviceService().status(status.deviceId);
+        const managers = service.installed ? [{
+                manager: service.registration === 'task' ? 'windows-task' : service.registration === 'run' ? 'windows-run' : 'windows-manual',
+                installed: service.installed,
+                running: service.running,
+                autostart: service.autostart
+            }] : [];
+        return { owner, service, managers };
+    }
+    if (process.platform === 'linux') {
+        const managers = await discoverLinuxManagers();
+        const installed = managers.some(manager => manager.installed);
+        const running = managers.some(manager => manager.running);
+        const autostart = managers.some(manager => manager.autostart);
+        return { owner, service: { installed, running, autostart }, managers };
+    }
+    return { owner, service: { installed: false, running: false, autostart: false }, managers: [] };
+}
+async function confirmRuntimeTakeover(existing) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY)
+        return false;
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = await rl.question(`MCP Device is running in ${existing.mode} mode (PID ${existing.pid}). Stop it and take over? [Y/n] `);
+        return !['n', 'no'].includes(String(answer || '').trim().toLowerCase());
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function applyServiceCommandStatus(store, command) {
+    if (command === 'stop' || command === 'uninstall')
+        await store.markOffline();
+}
+async function showStatus(json) {
+    const store = new GatewayDeviceStatusStore();
+    const status = await store.load();
+    const config = await new GatewayDeviceConfigStore().load();
+    const lifecycle = await lifecycleSnapshot(status);
+    const effectiveStatus = effectiveGatewayStatus(status, { runtimeOwned: Boolean(lifecycle.owner), serviceRunning: lifecycle.service.running });
+    console.log(formatGatewayStatus(effectiveStatus, {
+        json,
+        service: lifecycle.service,
+        runtime: lifecycle.owner ? { mode: lifecycle.owner.mode, pid: lifecycle.owner.pid } : null,
+        managers: lifecycle.managers,
+        security: { protocolFloor: config.securityProtocolFloor, appCaProvisioned: Boolean(config.appCaPem) },
+        proxy: { mode: config.proxy.mode }
+    }));
+}
+async function withBootstrapOwner(action, allowTakeover = true) {
+    const owner = new RuntimeOwner({ mode: 'bootstrap' });
+    await acquireRuntimeOwner(owner, { confirmTakeover: allowTakeover ? confirmRuntimeTakeover : undefined });
+    try {
+        await owner.bootstrap();
+        await bootstrapOfficialGatewayTrust(new GatewayDeviceConfigStore());
+        return await action();
+    }
+    finally {
+        await owner.release();
+    }
+}
+async function ensureLinkedDeviceUnderOwner(forcePair = false) {
+    const store = new GatewayDeviceStatusStore();
+    const current = await store.load();
+    const config = await captureGatewayConfigFromEnvironment(new GatewayDeviceConfigStore(), { fallbackGatewayUrl: current.gatewayUrl });
+    const gatewayUrl = String(config.gatewayUrl || '').trim();
+    const identity = new GatewayDeviceIdentity();
+    const record = await identity.loadOrCreate();
+    await store.update({
+        gatewayUrl,
+        deviceId: record.deviceId,
+        deviceName: current.deviceName || os.hostname(),
+        identityPresent: true
+    });
+    if (!forcePair && !deviceIdentityNeedsPairing(record)) {
+        return { deviceId: record.deviceId, accountLabel: current.account.label };
+    }
+    const proxy = createGatewayProxyAgent(config);
+    let channel;
+    try {
+        const pairing = await pairGatewayDevice({ gatewayUrl, identity, proxyAgent: proxy.agent, deviceName: os.hostname() });
+        await store.update({
+            gatewayUrl,
+            deviceId: record.deviceId,
+            deviceName: os.hostname(),
+            identityPresent: true,
+            account: { connected: false, label: pairing.account.label },
+            connection: { ...current.connection, online: false }
+        });
+        channel = new GatewayDeviceChannel({
+            gatewayUrl,
+            pairingGrant: pairing.enrollmentGrant,
+            identity,
+            proxyAgent: proxy.agent,
+            securityProtocolFloor: config.securityProtocolFloor,
+            appCaPem: config.appCaPem || undefined,
+            adapter: controlAdapter(),
+            agentVersion: process.env.npm_package_version,
+            onStatus: async (payload) => { await persistGatewayPayload(store, gatewayUrl, identity, payload); }
+        });
+        await channel.start();
+        const linked = await store.load();
+        return { deviceId: record.deviceId, accountLabel: linked.account.label };
+    }
+    finally {
+        await channel?.stop().catch(() => { });
+        proxy.agent.destroy();
+        await store.markOffline().catch(() => { });
+    }
+}
+async function login() {
+    return await withBootstrapOwner(async () => {
+        const linked = await ensureLinkedDeviceUnderOwner(true);
+        console.log(`Account connected: ${linked.accountLabel || 'gateway account'}`);
+    });
+}
+async function logout() {
+    return await withBootstrapOwner(async () => {
+        const store = new GatewayDeviceStatusStore();
+        const current = await store.load();
+        const config = await new GatewayDeviceConfigStore().load();
+        const gatewayUrl = String(config.gatewayUrl || current.gatewayUrl || '').trim();
+        if (!gatewayUrl || !current.identityPresent)
+            throw new Error('No connected gateway identity is available to log out.');
+        const proxy = createGatewayProxyAgent(config);
+        const identity = new GatewayDeviceIdentity();
+        const channel = new GatewayDeviceChannel({
+            gatewayUrl,
+            identity,
+            proxyAgent: proxy.agent,
+            securityProtocolFloor: config.securityProtocolFloor,
+            appCaPem: config.appCaPem || undefined,
+            adapter: controlAdapter(),
+            agentVersion: process.env.npm_package_version,
+            onStatus: async (payload) => { await persistGatewayPayload(store, gatewayUrl, identity, payload); }
+        });
+        try {
+            await channel.start();
+            await channel.logoutAccount();
+            console.log('Account disconnected from this device.');
+        }
+        finally {
+            await channel.stop().catch(() => { });
+            proxy.agent.destroy();
+            await store.markOffline().catch(() => { });
+        }
+    });
+}
+async function waitForOwnerRelease(timeoutMs = 5000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (!await probeRuntimeOwner())
+            return;
+        await new Promise(resolve => setTimeout(resolve, 50));
+    }
+    throw new Error('MCP Device runtime did not release ownership after authenticated stop.');
+}
+async function serviceCommand(command) {
+    const store = new GatewayDeviceStatusStore();
+    const owner = await probeRuntimeOwner();
+    if ((command === 'stop' || command === 'uninstall') && owner) {
+        if (!await stopRuntimeOwner())
+            throw new Error('MCP Device runtime did not accept authenticated stop.');
+        await waitForOwnerRelease();
+        await store.markOffline();
+        if (command === 'stop') {
+            console.log('MCP Device stop requested.');
+            return;
+        }
+    }
+    if (!['win32', 'linux'].includes(process.platform)) {
+        throw new Error('Background lifecycle is currently supported on Windows and Linux only.');
+    }
+    if (command === 'install') {
+        const linuxManager = process.platform === 'linux' ? await chooseLinuxManager() : null;
+        const deviceId = await withBootstrapOwner(async () => {
+            const linked = await ensureLinkedDeviceUnderOwner(false);
+            if (process.platform === 'win32')
+                await new WindowsDeviceService().install({ deviceId: linked.deviceId });
+            else if (linuxManager === 'pm2')
+                await new Pm2DeviceService().install();
+            else
+                await new SystemdUserDeviceService().install();
+            return linked.deviceId;
+        });
+        if (process.platform === 'win32')
+            await new WindowsDeviceService().start(deviceId);
+        console.log(`Background device installed and started: ${deviceId}`);
+        return;
+    }
+    if (command === 'stop') {
+        const status = await store.load();
+        if (process.platform === 'win32') {
+            if (!status.deviceId || !status.identityPresent)
+                throw new Error('No installed MCP Device identity was found.');
+            await new WindowsDeviceService().stop(status.deviceId);
+        }
+        else {
+            const systemd = new SystemdUserDeviceService();
+            const pm2 = new Pm2DeviceService();
+            if ((await systemd.status()).installed)
+                await systemd.stop();
+            if ((await pm2.status()).installed)
+                await pm2.stop();
+        }
+        await applyServiceCommandStatus(store, command);
+        console.log('MCP Device background runtime stop requested.');
+        return;
+    }
+    await withBootstrapOwner(async () => {
+        const status = await store.load();
+        if (process.platform === 'win32') {
+            if (!status.deviceId || !status.identityPresent)
+                throw new Error('No installed MCP Device identity was found.');
+            await new WindowsDeviceService().uninstall(status.deviceId);
+        }
+        else {
+            await new SystemdUserDeviceService().uninstall();
+            await new Pm2DeviceService().uninstall();
+        }
+        await applyServiceCommandStatus(store, command);
+    }, false);
+    console.log('MCP Device background registration removed; identity and account state were preserved.');
+}
+export async function runRemote() {
+    // MCP Device owns its account-scoped usage telemetry at the gateway.
+    // Never send inherited Desktop Commander analytics from the remote execution path.
+    process.env.DESKTOP_COMMANDER_DISABLE_TELEMETRY = 'true';
+    const disableNoSleep = process.argv.includes('--disable-no-sleep');
+    const verbose = process.argv.includes('--debug');
+    if (!verbose)
+        console.debug = () => { };
+    else
+        console.debug('[DEBUG] Verbose mode:', verbose);
+    const command = commandName();
+    if (command === 'help')
+        return printRemoteUsage();
+    if (command === 'status')
+        return await showStatus(process.argv.includes('--json'));
+    if (command === 'login')
+        return await login();
+    if (command === 'logout')
+        return await logout();
+    if (command === 'install' || command === 'stop' || command === 'uninstall') {
+        return await serviceCommand(command);
+    }
+    if (command !== 'start') {
+        throw new Error('Unknown MCP Device command. Use start, status, login, logout, install, stop, or uninstall.');
+    }
+    if (!disableNoSleep && os.platform() === 'darwin') {
+        try {
+            const { default: caffeinate } = await import('caffeinate');
+            caffeinate({ pid: process.pid });
+            console.log('No sleep mode enabled');
+        }
+        catch (error) {
+            console.warn('Failed to start caffeinate:', error);
+        }
+    }
+    const device = new MCPDevice();
+    await device.start({ confirmTakeover: process.argv.includes('--service') ? undefined : confirmRuntimeTakeover });
+}

package/dist/search-manager.d.ts

@@ -0,0 +1,147 @@
+import { ChildProcess } from 'child_process';
+export interface SearchResult {
+    file: string;
+    line?: number;
+    match?: string;
+    type: 'file' | 'content';
+}
+export interface SearchSession {
+    id: string;
+    process: ChildProcess;
+    results: SearchResult[];
+    isComplete: boolean;
+    isError: boolean;
+    error?: string;
+    startTime: number;
+    lastReadTime: number;
+    options: SearchSessionOptions;
+    buffer: string;
+    totalMatches: number;
+    totalContextLines: number;
+    wasIncomplete?: boolean;
+}
+export interface SearchSessionOptions {
+    rootPath: string;
+    pattern: string;
+    searchType: 'files' | 'content';
+    filePattern?: string;
+    ignoreCase?: boolean;
+    maxResults?: number;
+    includeHidden?: boolean;
+    contextLines?: number;
+    timeout?: number;
+    earlyTermination?: boolean;
+    literalSearch?: boolean;
+}
+/**
+ * Search Session Manager - handles ripgrep processes like terminal sessions
+ * Supports both file search and content search with progressive results
+ */ export declare class SearchManager {
+    private sessions;
+    private sessionCounter;
+    /**
+     * Start a new search session (like start_process)
+     * Returns immediately with initial state and results
+     */
+    startSearch(options: SearchSessionOptions): Promise<{
+        sessionId: string;
+        isComplete: boolean;
+        isError: boolean;
+        results: SearchResult[];
+        totalResults: number;
+        runtime: number;
+    }>;
+    /**
+     * Read search results with offset-based pagination (like read_file)
+     * Supports both range reading and tail behavior
+     */
+    readSearchResults(sessionId: string, offset?: number, length?: number): {
+        results: SearchResult[];
+        returnedCount: number;
+        totalResults: number;
+        totalMatches: number;
+        isComplete: boolean;
+        isError: boolean;
+        error?: string;
+        hasMoreResults: boolean;
+        runtime: number;
+        wasIncomplete?: boolean;
+    };
+    /**
+     * Terminate a search session (like force_terminate)
+     */
+    terminateSearch(sessionId: string): boolean;
+    /**
+     * Get list of active search sessions (like list_sessions)
+     */
+    listSearchSessions(): Array<{
+        id: string;
+        searchType: string;
+        pattern: string;
+        isComplete: boolean;
+        isError: boolean;
+        runtime: number;
+        totalResults: number;
+    }>;
+    /**
+     * Search Excel files for content matches
+     * Called during content search to include Excel files alongside text files
+     * Searches ALL sheets in each Excel file (row-wise for cross-column matching)
+     *
+     * TODO: Refactor - Extract Excel search logic to separate module (src/utils/search/excel-search.ts)
+     * and inject into SearchManager, similar to how file handlers are structured in src/utils/files/
+     * This would allow adding other file type searches (PDF, etc.) without bloating search-manager.ts
+     */
+    private searchExcelFiles;
+    /**
+     * Find all Excel files in a directory recursively
+     */
+    private findExcelFiles;
+    /**
+     * Determine if DOCX search should be included based on context
+     */
+    private shouldIncludeDocxSearch;
+    /**
+     * Search DOCX files for content matches
+     * Extracts <w:t> text from document.xml and searches it
+     */
+    private searchDocxFiles;
+    /**
+     * Find all DOCX files in a directory recursively
+     */
+    private findDocxFiles;
+    /**
+     * Extract context around a match for display (show surrounding text)
+     */
+    private getMatchContext;
+    /**
+     * Clean up completed sessions older than specified time
+     * Called automatically by cleanup interval
+     */
+    cleanupSessions(maxAge?: number): void;
+    /**
+     * Get total number of active sessions (excluding completed ones)
+     */
+    getActiveSessionCount(): number;
+    /**
+     * Detect if pattern looks like an exact filename
+     * (has file extension and no glob wildcards)
+     */
+    private isExactFilename;
+    /**
+     * Detect if pattern contains glob wildcards
+     */
+    private isGlobPattern;
+    /**
+     * Determine if Excel search should be included based on context
+     * Only searches Excel files when:
+     * - filePattern explicitly targets Excel files (*.xlsx, *.xls, *.xlsm, *.xlsb)
+     * - or the rootPath itself is an Excel file
+     */
+    private shouldIncludeExcelSearch;
+    private buildRipgrepArgs;
+    private setupProcessHandlers;
+    private processBufferedOutput;
+    private parseLine;
+}
+export declare const searchManager: SearchManager;