@hcu-lab.me/mcp-device 1.0.0

package/dist/device/runtime-owner.js

@@ -0,0 +1,177 @@
+import crypto from 'crypto';
+import fs from 'fs/promises';
+import net from 'net';
+import path from 'path';
+import { deviceStatePaths, migrateLegacyDeviceState } from './device-state.js';
+function endpointFor(paths, platform = process.platform) {
+    const digest = crypto.createHash('sha256').update(paths.root, 'utf8').digest('hex').slice(0, 24);
+    if (platform === 'win32')
+        return `\\\\.\\pipe\\mcp-device-${digest}`;
+    return path.join(paths.root, `runtime-${digest}.sock`);
+}
+function controlFileFor(paths) {
+    return path.join(paths.root, 'runtime-control.json');
+}
+async function request(endpoint, message, timeoutMs = 800) {
+    return await new Promise(resolve => {
+        const socket = net.createConnection(endpoint);
+        let data = '';
+        const finish = (value) => {
+            socket.destroy();
+            resolve(value);
+        };
+        socket.setEncoding('utf8');
+        socket.setTimeout(timeoutMs, () => finish(null));
+        socket.once('error', () => finish(null));
+        socket.on('data', chunk => { data += chunk; });
+        socket.once('end', () => {
+            try {
+                finish(JSON.parse(data));
+            }
+            catch {
+                finish(null);
+            }
+        });
+        socket.once('connect', () => socket.write(`${JSON.stringify(message)}\n`));
+    });
+}
+export async function probeRuntimeOwner(paths = deviceStatePaths(), platform = process.platform) {
+    const response = await request(endpointFor(paths, platform), { action: 'status' });
+    return response?.ok === true && response.status?.product === 'MCP Device' ? response.status : null;
+}
+export class RuntimeOwner {
+    constructor({ paths = deviceStatePaths(), platform = process.platform, mode, onStop }) {
+        this.paths = paths;
+        this.platform = platform;
+        this.endpoint = endpointFor(paths, platform);
+        this.mode = mode;
+        this.nonce = crypto.randomBytes(32).toString('base64url');
+        this.onStop = onStop;
+        this.status = {
+            product: 'MCP Device',
+            mode,
+            pid: process.pid,
+            startedAt: Date.now(),
+            executable: path.resolve(process.execPath),
+            entrypoint: path.resolve(process.argv[1] || process.execPath),
+            deviceId: null
+        };
+    }
+    async acquire() {
+        await fs.mkdir(this.paths.root, { recursive: true, mode: 0o700 });
+        const existing = await probeRuntimeOwner(this.paths, this.platform);
+        if (existing)
+            throw new Error(`MCP Device runtime is already owned by PID ${existing.pid} (${existing.mode}).`);
+        if (this.platform !== 'win32') {
+            try {
+                await fs.unlink(this.endpoint);
+            }
+            catch (error) {
+                if (error?.code !== 'ENOENT')
+                    throw error;
+            }
+        }
+        this.server = net.createServer(socket => {
+            socket.setEncoding('utf8');
+            socket.on('error', () => { });
+            let data = '';
+            socket.on('data', async (chunk) => {
+                data += chunk;
+                const newline = data.indexOf('\n');
+                if (newline < 0)
+                    return;
+                const frame = data.slice(0, newline);
+                data = data.slice(newline + 1);
+                let message = null;
+                try {
+                    message = JSON.parse(frame);
+                }
+                catch { }
+                if (message?.action === 'status') {
+                    socket.end(JSON.stringify({ ok: true, status: this.status }));
+                    return;
+                }
+                if (message?.action === 'stop' && message?.nonce === this.nonce) {
+                    socket.end(JSON.stringify({ ok: true }));
+                    await this.onStop?.();
+                    return;
+                }
+                socket.end(JSON.stringify({ ok: false }));
+            });
+        });
+        await new Promise((resolve, reject) => {
+            this.server.once('error', reject);
+            this.server.listen(this.endpoint, resolve);
+        });
+        await fs.writeFile(controlFileFor(this.paths), JSON.stringify({ endpoint: this.endpoint, nonce: this.nonce }, null, 2), { mode: 0o600 });
+    }
+    async bootstrap() {
+        await migrateLegacyDeviceState(this.paths);
+    }
+    setDeviceId(deviceId) {
+        this.status.deviceId = String(deviceId || '').trim() || null;
+    }
+    async release() {
+        if (this.server) {
+            const server = this.server;
+            this.server = undefined;
+            await new Promise(resolve => server.close(() => resolve()));
+        }
+        try {
+            await fs.unlink(controlFileFor(this.paths));
+        }
+        catch (error) {
+            if (error?.code !== 'ENOENT')
+                throw error;
+        }
+        if (this.platform !== 'win32') {
+            try {
+                await fs.unlink(this.endpoint);
+            }
+            catch (error) {
+                if (error?.code !== 'ENOENT')
+                    throw error;
+            }
+        }
+    }
+}
+export async function stopRuntimeOwner(paths = deviceStatePaths(), platform = process.platform) {
+    let control;
+    try {
+        control = JSON.parse(await fs.readFile(controlFileFor(paths), 'utf8'));
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+    if (String(control.endpoint || '') !== endpointFor(paths, platform) || !control.nonce)
+        return false;
+    const response = await request(String(control.endpoint), { action: 'stop', nonce: control.nonce }, 1500);
+    return response?.ok === true;
+}
+export async function acquireRuntimeOwner(owner, { confirmTakeover, waitMs = 5000, pollMs = 50 } = {}) {
+    const existing = await probeRuntimeOwner(owner.paths);
+    if (!existing) {
+        await owner.acquire();
+        return { takenOver: false, previous: null };
+    }
+    if (existing.mode === 'bootstrap') {
+        throw new Error(`MCP Device bootstrap is busy in PID ${existing.pid}; retry after it completes.`);
+    }
+    if (!confirmTakeover || !await confirmTakeover(existing)) {
+        throw new Error(`MCP Device is already running in ${existing.mode} mode; takeover declined.`);
+    }
+    if (!await stopRuntimeOwner(owner.paths)) {
+        throw new Error('MCP Device owner did not accept authenticated stop.');
+    }
+    const deadline = Date.now() + Math.max(1, waitMs);
+    while (Date.now() < deadline) {
+        if (!await probeRuntimeOwner(owner.paths)) {
+            await owner.acquire();
+            return { takenOver: true, previous: existing };
+        }
+        await new Promise(resolve => setTimeout(resolve, Math.max(1, pollMs)));
+    }
+    throw new Error(`MCP Device owner PID ${existing.pid} did not release runtime ownership.`);
+}

package/dist/device/windows-dpapi.d.ts

@@ -0,0 +1,11 @@
+type DpapiLabel = 'identity' | 'proxy';
+type PowerShellRunner = (script: string, input: string) => Promise<string>;
+export declare function protectWindowsSecret(secret: Buffer | Uint8Array | string, label: DpapiLabel, options?: {
+    platform?: NodeJS.Platform | string;
+    runner?: PowerShellRunner;
+}): Promise<string>;
+export declare function unprotectWindowsSecret(blob: string, label: DpapiLabel, options?: {
+    platform?: NodeJS.Platform | string;
+    runner?: PowerShellRunner;
+}): Promise<Buffer>;
+export {};

package/dist/device/windows-dpapi.js

@@ -0,0 +1,67 @@
+import { spawn } from 'child_process';
+const ENTROPY = {
+    identity: 'hcu-device-identity-private-key-v1',
+    proxy: 'hcu-device-proxy-url-v1'
+};
+function assertLabel(label) {
+    if (!(label in ENTROPY))
+        throw new Error('Unsupported DPAPI secret label.');
+}
+async function runPowerShell(script, input) {
+    return await new Promise((resolve, reject) => {
+        const child = spawn('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', script], {
+            windowsHide: true,
+            stdio: ['pipe', 'pipe', 'pipe']
+        });
+        const stdout = [];
+        const stderr = [];
+        child.stdout.on('data', chunk => stdout.push(Buffer.from(chunk)));
+        child.stderr.on('data', chunk => stderr.push(Buffer.from(chunk)));
+        child.once('error', reject);
+        child.once('close', code => {
+            if (code !== 0) {
+                reject(new Error(Buffer.concat(stderr).toString('utf8').trim() || `DPAPI PowerShell failed with exit code ${code}`));
+                return;
+            }
+            resolve(Buffer.concat(stdout).toString('utf8').trim());
+        });
+        child.stdin.end(input, 'utf8');
+    });
+}
+function dpapiScript(action, label) {
+    const entropy = Buffer.from(ENTROPY[label], 'utf8').toString('base64');
+    return [
+        "$ErrorActionPreference = 'Stop'",
+        'Add-Type -AssemblyName System.Security',
+        '$inputB64 = [Console]::In.ReadToEnd().Trim()',
+        '$data = [Convert]::FromBase64String($inputB64)',
+        `$entropy = [Convert]::FromBase64String('${entropy}')`,
+        '$scope = [System.Security.Cryptography.DataProtectionScope]::CurrentUser',
+        `$output = [System.Security.Cryptography.ProtectedData]::${action}($data, $entropy, $scope)`,
+        '[Console]::Out.Write([Convert]::ToBase64String($output))'
+    ].join('; ');
+}
+export async function protectWindowsSecret(secret, label, options = {}) {
+    const platform = options.platform || process.platform;
+    if (platform !== 'win32')
+        throw new Error('Windows DPAPI is only available on Windows.');
+    assertLabel(label);
+    const bytes = typeof secret === 'string' ? Buffer.from(secret, 'utf8') : Buffer.from(secret);
+    const output = await (options.runner || runPowerShell)(dpapiScript('Protect', label), bytes.toString('base64'));
+    if (!output)
+        throw new Error('Windows DPAPI returned an empty protected value.');
+    return output;
+}
+export async function unprotectWindowsSecret(blob, label, options = {}) {
+    const platform = options.platform || process.platform;
+    if (platform !== 'win32')
+        throw new Error('Windows DPAPI is only available on Windows.');
+    assertLabel(label);
+    const input = String(blob || '').trim();
+    if (!input)
+        throw new Error('Windows DPAPI protected value is empty.');
+    const output = await (options.runner || runPowerShell)(dpapiScript('Unprotect', label), input);
+    if (!output)
+        throw new Error('Windows DPAPI returned an empty unprotected value.');
+    return Buffer.from(output, 'base64');
+}

package/dist/device/windows-service.d.ts

@@ -0,0 +1,56 @@
+type ExecFileResult = {
+    stdout: string;
+    stderr: string;
+};
+type ExecFileFn = (file: string, args: string[]) => Promise<ExecFileResult>;
+export declare function buildWindowsTaskName(deviceId: string): string;
+export declare function buildWindowsRunnerScript(options: {
+    gatewayUrl?: string;
+    allowedRoots?: string;
+    nodePath: string;
+    entrypoint: string;
+}): string;
+export type WindowsDeviceServiceStatus = {
+    installed: boolean;
+    running: boolean;
+    autostart: boolean;
+    registration: 'task' | 'run' | 'manual' | 'stale';
+    taskName: string;
+};
+export declare class WindowsDeviceService {
+    private platform;
+    private execFile;
+    private runnerPath;
+    private legacyRunnerPath;
+    private nodePath;
+    private entrypoint;
+    constructor(options?: {
+        platform?: NodeJS.Platform | string;
+        execFile?: ExecFileFn;
+        runnerPath?: string;
+        legacyRunnerPath?: string;
+        nodePath?: string;
+        entrypoint?: string;
+    });
+    private assertWindows;
+    private runnerExists;
+    private hasUserRunEntry;
+    private scheduledTaskState;
+    private deleteRegistrations;
+    private commandReferencesLegacyRunner;
+    private deleteVerifiedLegacyRegistrations;
+    private createAutostartRegistration;
+    private startUserProcess;
+    private userProcessRunning;
+    install(options: {
+        deviceId: string;
+        gatewayUrl?: string;
+        allowedRoots?: string;
+    }): Promise<void>;
+    setAutostart(deviceId: string, enabled: boolean): Promise<void>;
+    start(deviceId: string): Promise<void>;
+    stop(deviceId: string): Promise<void>;
+    status(deviceId: string): Promise<WindowsDeviceServiceStatus>;
+    uninstall(deviceId: string): Promise<void>;
+}
+export {};

package/dist/device/windows-service.js

@@ -0,0 +1,238 @@
+import { execFile as execFileCallback } from 'child_process';
+import fs from 'fs/promises';
+import path from 'path';
+import { promisify } from 'util';
+import { deviceStatePaths } from './device-state.js';
+const execFileAsync = promisify(execFileCallback);
+const USER_RUN_KEY = 'HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run';
+function psQuote(value) {
+    return `'${String(value).split("'").join("''")}'`;
+}
+function taskSafeDeviceId(deviceId) {
+    const value = String(deviceId || '').trim();
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(value))
+        throw new Error('Invalid device ID for Windows service.');
+    return value;
+}
+function isMissingRegistrationError(error) {
+    const message = String(error?.stderr || error?.message || error);
+    return /not running|cannot find|does not exist|not exist|cannot find the file/i.test(message);
+}
+export function buildWindowsTaskName(deviceId) {
+    return `MCP-Device-${taskSafeDeviceId(deviceId)}`;
+}
+function legacyWindowsTaskName(deviceId) {
+    return `HCU-Device-${taskSafeDeviceId(deviceId)}`;
+}
+export function buildWindowsRunnerScript(options) {
+    return [
+        "$ErrorActionPreference = 'Stop'",
+        `& ${psQuote(options.nodePath)} ${psQuote(options.entrypoint)} --service`,
+        'exit $LASTEXITCODE',
+        ''
+    ].join('\r\n');
+}
+export class WindowsDeviceService {
+    constructor(options = {}) {
+        this.platform = options.platform || process.platform;
+        this.execFile = options.execFile || (async (file, args) => {
+            const result = await execFileAsync(file, args, { windowsHide: true, encoding: 'utf8' });
+            return { stdout: String(result.stdout || ''), stderr: String(result.stderr || '') };
+        });
+        this.runnerPath = path.resolve(options.runnerPath || path.join(deviceStatePaths().root, 'run-device.ps1'));
+        this.legacyRunnerPath = path.resolve(options.legacyRunnerPath || path.join(deviceStatePaths().legacyRoot, 'run-device.ps1'));
+        this.nodePath = path.resolve(options.nodePath || process.execPath);
+        this.entrypoint = path.resolve(options.entrypoint || process.argv[1]);
+    }
+    assertWindows() {
+        if (this.platform !== 'win32')
+            throw new Error('Background MCP Device lifecycle is currently supported on Windows only.');
+    }
+    async runnerExists() {
+        try {
+            const stat = await fs.stat(this.runnerPath);
+            return stat.isFile();
+        }
+        catch (error) {
+            if (error?.code === 'ENOENT')
+                return false;
+            throw error;
+        }
+    }
+    async hasUserRunEntry(taskName) {
+        try {
+            await this.execFile('reg.exe', ['query', USER_RUN_KEY, '/v', taskName]);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async scheduledTaskState(taskName) {
+        try {
+            const command = `(Get-ScheduledTask -TaskName ${psQuote(taskName)} -ErrorAction Stop).State.ToString()`;
+            const result = await this.execFile('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', command]);
+            return String(result.stdout || '').trim();
+        }
+        catch {
+            return null;
+        }
+    }
+    async deleteRegistrations(taskName) {
+        try {
+            await this.execFile('schtasks.exe', ['/Delete', '/F', '/TN', taskName]);
+        }
+        catch (error) {
+            if (!isMissingRegistrationError(error))
+                throw error;
+        }
+        try {
+            await this.execFile('reg.exe', ['delete', USER_RUN_KEY, '/v', taskName, '/f']);
+        }
+        catch { /* absent is fine */ }
+    }
+    commandReferencesLegacyRunner(value) {
+        const normalize = (text) => String(text || '').replace(/\//g, '\\').toLowerCase();
+        return normalize(value).includes(normalize(this.legacyRunnerPath));
+    }
+    async deleteVerifiedLegacyRegistrations(taskName) {
+        let scheduledAction = null;
+        try {
+            const command = `(Get-ScheduledTask -TaskName ${psQuote(taskName)} -ErrorAction Stop).Actions | ForEach-Object { ($_.Execute + ' ' + $_.Arguments) }`;
+            scheduledAction = String((await this.execFile('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', command])).stdout || '');
+        }
+        catch { /* absent scheduled task is fine */ }
+        if (scheduledAction !== null && this.commandReferencesLegacyRunner(scheduledAction)) {
+            try {
+                await this.execFile('schtasks.exe', ['/Delete', '/F', '/TN', taskName]);
+            }
+            catch (error) {
+                if (!isMissingRegistrationError(error))
+                    throw error;
+            }
+        }
+        let runValue = null;
+        try {
+            runValue = String((await this.execFile('reg.exe', ['query', USER_RUN_KEY, '/v', taskName])).stdout || '');
+        }
+        catch { /* absent Run value is fine */ }
+        if (runValue !== null && this.commandReferencesLegacyRunner(runValue)) {
+            try {
+                await this.execFile('reg.exe', ['delete', USER_RUN_KEY, '/v', taskName, '/f']);
+            }
+            catch (error) {
+                if (!isMissingRegistrationError(error))
+                    throw error;
+            }
+        }
+    }
+    async createAutostartRegistration(taskName) {
+        const taskAction = `powershell.exe -NoProfile -ExecutionPolicy Bypass -File "${this.runnerPath}"`;
+        try {
+            await this.execFile('schtasks.exe', ['/Create', '/F', '/SC', 'ONLOGON', '/TN', taskName, '/TR', taskAction]);
+            try {
+                await this.execFile('reg.exe', ['delete', USER_RUN_KEY, '/v', taskName, '/f']);
+            }
+            catch { /* no stale fallback */ }
+            return 'task';
+        }
+        catch (error) {
+            const message = String(error?.stderr || error?.message || error);
+            if (!/access is denied/i.test(message))
+                throw error;
+            const runCommand = `powershell.exe -NoProfile -ExecutionPolicy Bypass -WindowStyle Hidden -File "${this.runnerPath}"`;
+            await this.execFile('reg.exe', ['add', USER_RUN_KEY, '/v', taskName, '/t', 'REG_SZ', '/d', runCommand, '/f']);
+            return 'run';
+        }
+    }
+    async startUserProcess() {
+        const command = `Start-Process -FilePath 'powershell.exe' -ArgumentList @('-NoProfile','-ExecutionPolicy','Bypass','-WindowStyle','Hidden','-File',${psQuote(this.runnerPath)}) -WindowStyle Hidden`;
+        await this.execFile('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', command]);
+    }
+    async userProcessRunning() {
+        const command = `$runner = ${psQuote(this.runnerPath)}; if (Get-CimInstance Win32_Process | Where-Object { $_.ProcessId -ne $PID -and $_.CommandLine -like ('*' + $runner + '*') }) { 'Running' } else { 'Stopped' }`;
+        const result = await this.execFile('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', command]);
+        return String(result.stdout || '').trim().toLowerCase() === 'running';
+    }
+    async install(options) {
+        this.assertWindows();
+        const taskName = buildWindowsTaskName(options.deviceId);
+        const legacyTaskName = legacyWindowsTaskName(options.deviceId);
+        const existing = await this.status(options.deviceId).catch(() => null);
+        const preserveManual = existing?.installed === true && existing.autostart === false;
+        const runner = buildWindowsRunnerScript({ nodePath: this.nodePath, entrypoint: this.entrypoint });
+        await fs.mkdir(path.dirname(this.runnerPath), { recursive: true });
+        await fs.writeFile(this.runnerPath, runner, { mode: 0o600 });
+        await this.deleteVerifiedLegacyRegistrations(legacyTaskName);
+        if (preserveManual) {
+            await this.deleteRegistrations(taskName);
+            return;
+        }
+        await this.deleteRegistrations(taskName);
+        await this.createAutostartRegistration(taskName);
+    }
+    async setAutostart(deviceId, enabled) {
+        this.assertWindows();
+        const taskName = buildWindowsTaskName(deviceId);
+        if (!await this.runnerExists())
+            throw new Error('Background device is not installed.');
+        await this.deleteRegistrations(taskName);
+        if (enabled)
+            await this.createAutostartRegistration(taskName);
+    }
+    async start(deviceId) {
+        this.assertWindows();
+        const taskName = buildWindowsTaskName(deviceId);
+        if (!await this.runnerExists())
+            throw new Error('Background device is not installed.');
+        const taskState = await this.scheduledTaskState(taskName);
+        if (taskState !== null) {
+            await this.execFile('schtasks.exe', ['/Run', '/TN', taskName]);
+            return;
+        }
+        if (!await this.userProcessRunning())
+            await this.startUserProcess();
+    }
+    async stop(deviceId) {
+        this.assertWindows();
+        const taskName = buildWindowsTaskName(deviceId);
+        try {
+            await this.execFile('schtasks.exe', ['/End', '/TN', taskName]);
+        }
+        catch (error) {
+            if (!isMissingRegistrationError(error))
+                throw error;
+        }
+        if (await this.runnerExists() && await this.userProcessRunning()) {
+            throw new Error('MCP Device runtime did not accept authenticated stop; refusing PID-only termination.');
+        }
+    }
+    async status(deviceId) {
+        this.assertWindows();
+        const taskName = buildWindowsTaskName(deviceId);
+        const installed = await this.runnerExists();
+        const taskState = await this.scheduledTaskState(taskName);
+        const runEntry = await this.hasUserRunEntry(taskName);
+        const running = installed ? await this.userProcessRunning() : false;
+        if (!installed && (taskState !== null || runEntry)) {
+            return { installed: false, running: false, autostart: true, registration: 'stale', taskName };
+        }
+        if (taskState !== null)
+            return { installed, running, autostart: true, registration: 'task', taskName };
+        if (runEntry)
+            return { installed, running, autostart: true, registration: 'run', taskName };
+        return { installed, running, autostart: false, registration: 'manual', taskName };
+    }
+    async uninstall(deviceId) {
+        this.assertWindows();
+        const taskName = buildWindowsTaskName(deviceId);
+        const legacyTaskName = legacyWindowsTaskName(deviceId);
+        try {
+            await this.stop(deviceId);
+        }
+        catch { /* registration cleanup remains authoritative; runtime is never PID-killed. */ }
+        await this.deleteRegistrations(taskName);
+        await this.deleteVerifiedLegacyRegistrations(legacyTaskName);
+        await fs.rm(this.runnerPath, { force: true });
+    }
+}

package/dist/error-handlers.d.ts

@@ -0,0 +1,7 @@
+import { ServerResult } from './types.js';
+/**
+ * Creates a standard error response for tools
+ * @param message The error message
+ * @returns A ServerResult with the error message
+ */
+export declare function createErrorResponse(message: string): ServerResult;

package/dist/error-handlers.js

@@ -0,0 +1,15 @@
+import { capture } from "./utils/capture.js";
+/**
+ * Creates a standard error response for tools
+ * @param message The error message
+ * @returns A ServerResult with the error message
+ */
+export function createErrorResponse(message) {
+    capture('server_request_error', {
+        error: message
+    });
+    return {
+        content: [{ type: "text", text: `Error: ${message}` }],
+        isError: true,
+    };
+}

package/dist/handlers/edit-search-handlers.d.ts

@@ -0,0 +1,6 @@
+import { handleEditBlock } from '../tools/edit.js';
+/**
+ * Handle edit_block command
+ * Uses the enhanced implementation with multiple occurrence support and fuzzy matching
+ */
+export { handleEditBlock };

package/dist/handlers/edit-search-handlers.js

@@ -0,0 +1,6 @@
+import { handleEditBlock } from '../tools/edit.js';
+/**
+ * Handle edit_block command
+ * Uses the enhanced implementation with multiple occurrence support and fuzzy matching
+ */
+export { handleEditBlock };

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

@@ -0,0 +1,38 @@
+import { ServerResult } from '../types.js';
+/**
+ * Resolve a file path to an absolute path for use in structured content.
+ * This ensures "Open in folder" always has a valid absolute path.
+ */
+export declare function resolveAbsolutePath(filePath: string): string;
+/**
+ * Handle read_file command
+ */
+export declare function handleReadFile(args: unknown): Promise<ServerResult>;
+/**
+ * Handle read_multiple_files command
+ */
+export declare function handleReadMultipleFiles(args: unknown): Promise<ServerResult>;
+/**
+ * Handle write_file command
+ */
+export declare function handleWriteFile(args: unknown): Promise<ServerResult>;
+/**
+ * Handle create_directory command
+ */
+export declare function handleCreateDirectory(args: unknown): Promise<ServerResult>;
+/**
+ * Handle list_directory command
+ */
+export declare function handleListDirectory(args: unknown): Promise<ServerResult>;
+/**
+ * Handle move_file command
+ */
+export declare function handleMoveFile(args: unknown): Promise<ServerResult>;
+/**
+ * Handle get_file_info command
+ */
+export declare function handleGetFileInfo(args: unknown): Promise<ServerResult>;
+/**
+ * Handle write_pdf command
+ */
+export declare function handleWritePdf(args: unknown): Promise<ServerResult>;