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

package/dist/device/execution-engine.js

@@ -1,4 +1,4 @@
-import { spawn } from 'child_process';
+import { randomUUID } from 'crypto';
 import path from 'path';
 import fs from 'fs/promises';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
@@ -8,134 +8,109 @@ import { captureRemote } from '../utils/capture.js';
 import { deviceStatePaths } from './device-state.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-export class DesktopCommanderIntegration {
+export class LocalExecutionEngine {
     constructor() {
         this.mcpClient = null;
         this.mcpTransport = null;
         this.isReady = false;
+        this.runtimeReason = 'LOCAL_EXECUTION_ENGINE_UNAVAILABLE';
+        this.runtimeGeneration = null;
+    }
+    markUnavailable(client) {
+        if (client && this.mcpClient !== client)
+            return;
+        this.isReady = false;
+        this.runtimeReason = 'LOCAL_EXECUTION_ENGINE_UNAVAILABLE';
+        this.runtimeGeneration = null;
     }
     async initialize() {
-        console.debug('[DEBUG] DesktopCommanderIntegration.initialize() called');
-        const config = await this.resolveMcpConfig();
-        if (!config) {
-            console.debug('[DEBUG] No MCP config found');
-            throw new Error('Desktop Commander MCP not found. Please install it globally via `npm install -g @wonderwhy-er/desktop-commander` or build the local project.');
-        }
-        console.log(` - ⏳ Connecting to Local Desktop Commander MCP using: ${config.command} ${config.args.join(' ')}`);
-        console.debug('[DEBUG] MCP config:', JSON.stringify(config, null, 2));
+        console.debug('[DEBUG] LocalExecutionEngine.initialize() called');
+        this.markUnavailable();
         try {
-            console.debug('[DEBUG] Creating StdioClientTransport');
-            // MCP_DEVICE_REMOTE tells the spawned server it is serving remote
-            // services, so it suppresses local-only behavior like opening the
-            // welcome page in a browser the remote user would never see.
-            this.mcpTransport = new StdioClientTransport({
+            const config = await this.resolveMcpConfig();
+            if (!config)
+                throw new Error('Bundled local execution engine is unavailable. Reinstall MCP Device.');
+            const transport = new StdioClientTransport({
                 ...config,
                 env: {
                     ...getDefaultEnvironment(),
                     ...config.env,
-                    MCP_DEVICE_REMOTE: 'true',
-                    DESKTOP_COMMANDER_DISABLE_TELEMETRY: 'true'
+                    MCP_DEVICE_REMOTE: 'true'
                 }
             });
-            // Create MCP client
-            console.debug('[DEBUG] Creating MCP Client');
-            this.mcpClient = new Client({
-                name: "desktop-commander-client",
-                version: "1.0.0"
-            }, {
-                capabilities: {}
-            });
-            // Connect to Desktop Commander
-            console.debug('[DEBUG] Connecting MCP client to transport');
-            await this.mcpClient.connect(this.mcpTransport);
+            const client = new Client({ name: 'mcp-device-local-engine', version: '1.0.0' }, { capabilities: {} });
+            this.mcpTransport = transport;
+            this.mcpClient = client;
+            client.onclose = () => this.markUnavailable(client);
+            await client.connect(transport);
+            if (this.mcpClient !== client || this.mcpTransport !== transport || transport.pid === null) {
+                throw new Error('Local execution engine closed during startup.');
+            }
+            this.runtimeGeneration = randomUUID();
             this.isReady = true;
-            console.log(' - 🔌 Connected to Desktop Commander MCP');
-            console.debug('[DEBUG] Desktop Commander MCP connection successful');
+            this.runtimeReason = null;
+            console.log(' - Local execution engine ready');
         }
         catch (error) {
-            console.error(' - ❌ Failed to connect to Desktop Commander MCP:', error);
-            console.debug('[DEBUG] MCP connection error:', error);
-            await captureRemote('desktop_integration_init_failed', { error });
-            throw error;
+            console.error(' - Failed to start local execution engine:', error);
+            await captureRemote('local_engine_init_failed', { error });
+            try {
+                await this.mcpClient?.close();
+            }
+            catch { }
+            try {
+                await this.mcpTransport?.close();
+            }
+            catch { }
+            this.mcpClient = null;
+            this.mcpTransport = null;
+            this.markUnavailable();
         }
     }
     async resolveMcpConfig() {
-        console.debug('[DEBUG] Resolving MCP config...');
-        // Option 1: Development/Local Build
-        // Adjusting path resolution since we are now in src/device and dist is in root/dist
-        // Original: path.resolve(__dirname, '../../dist/index.js')
-        const devPath = path.resolve(__dirname, '../../dist/index.js');
-        console.debug('[DEBUG] Checking local dev path:', devPath);
+        const localEngine = path.resolve(__dirname, '../../dist/index.js');
         try {
-            await fs.access(devPath);
-            console.debug(' - 🔍 Found local MCP server at:', devPath);
-            const runtimeDir = deviceStatePaths().runtime;
-            await fs.mkdir(runtimeDir, { recursive: true, mode: 0o700 });
-            return {
-                command: process.execPath, // Use the current node executable
-                args: [devPath],
-                cwd: runtimeDir
-            };
+            await fs.access(localEngine);
         }
         catch {
-            console.debug('[DEBUG] Local dev path not found, trying global installation');
-            // Local file not found, continue...
+            return null;
         }
-        // Option 2: Global Installation
-        const commandName = 'desktop-commander';
-        console.debug('[DEBUG] Checking for global command:', commandName);
-        try {
-            await new Promise((resolve, reject) => {
-                // Use platform-appropriate command to check if the command exists in PATH
-                // We can't run it directly as it's an stdio MCP server that waits for input
-                const whichCommand = process.platform === 'win32' ? 'where' : 'which';
-                console.debug('[DEBUG] Using platform command:', whichCommand, 'on platform:', process.platform);
-                const check = spawn(whichCommand, [commandName], { windowsHide: true }); // Prevent visible console windows on Windows
-                check.on('error', (err) => {
-                    console.debug('[DEBUG] Spawn error for', whichCommand, ':', err.message);
-                    reject(err);
-                });
-                check.on('close', (code) => {
-                    console.debug('[DEBUG]', whichCommand, 'exited with code:', code);
-                    return code === 0 ? resolve() : reject(new Error('Command not found'));
-                });
-            });
-            console.debug(' - Found global desktop-commander CLI');
-            return {
-                command: commandName,
-                args: []
-            };
-        }
-        catch (err) {
-            console.debug('[DEBUG] Global command not found:', err);
-            // Global command not found
-        }
-        console.debug('[DEBUG] No MCP config resolved');
-        return null;
+        const runtimeDir = deviceStatePaths().runtime;
+        await fs.mkdir(runtimeDir, { recursive: true, mode: 0o700 });
+        return {
+            command: process.execPath,
+            args: [localEngine],
+            cwd: runtimeDir
+        };
     }
     getChildPid() {
         return this.mcpTransport?.pid ?? null;
     }
+    getRuntimeState() {
+        return {
+            runtime_ready: this.isReady,
+            runtime_reason: this.isReady ? null : this.runtimeReason,
+            execution_runtime_generation: this.isReady ? this.runtimeGeneration : null
+        };
+    }
+    assertReady() {
+        if (this.isReady && this.mcpClient)
+            return;
+        const error = new Error('Local execution engine is unavailable.');
+        error.code = 'DEVICE_NOT_READY';
+        throw error;
+    }
     async callClientTool(toolName, args, metadata) {
-        if (!this.isReady || !this.mcpClient) {
-            console.debug('[DEBUG] callClientTool() failed - not ready or no client');
-            throw new Error('DesktopIntegration not initialized');
-        }
-        // Proxy other tools to MCP server
+        this.assertReady();
         try {
-            console.debug('[DEBUG] Calling MCP tool:', toolName, 'args:', JSON.stringify(args).substring(0, 100));
-            const result = await this.mcpClient.callTool({
+            return await this.mcpClient.callTool({
                 name: toolName,
                 arguments: args,
                 _meta: { remote: true, ...metadata || {} }
             });
-            console.debug('[DEBUG] Tool call successful:', toolName);
-            return result;
         }
         catch (error) {
-            console.error(`Error executing tool ${toolName}:`, error);
-            console.debug('[DEBUG] Tool call error details:', error);
-            await captureRemote('desktop_integration_tool_call_failed', { error, toolName });
+            await captureRemote('local_engine_tool_call_failed', { error, toolName });
             throw error;
         }
     }
@@ -143,59 +118,37 @@ export class DesktopCommanderIntegration {
         if (!this.mcpClient)
             return { tools: [] };
         try {
-            // List tools from MCP server
             const mcpTools = await this.mcpClient.listTools();
-            // Merge tools
-            return {
-                tools: mcpTools.tools || []
-            };
+            return { tools: mcpTools.tools || [] };
         }
         catch (error) {
-            console.error('Error fetching capabilities:', error);
-            await captureRemote('desktop_integration_list_tools_failed', { error });
-            // Fallback to local tools
-            return {
-                tools: []
-            };
+            await captureRemote('local_engine_list_tools_failed', { error });
+            return { tools: [] };
         }
     }
     async shutdown() {
-        console.debug('[DEBUG] DesktopCommanderIntegration.shutdown() called');
-        const closeWithTimeout = async (operation, name, timeoutMs = 3000) => {
-            return Promise.race([
-                operation(),
-                new Promise((_, reject) => setTimeout(() => reject(new Error(`${name} timeout after ${timeoutMs}ms`)), timeoutMs))
-            ]);
-        };
+        const closeWithTimeout = async (operation, name, timeoutMs = 3000) => Promise.race([
+            operation(),
+            new Promise((_, reject) => setTimeout(() => reject(new Error(`${name} timeout after ${timeoutMs}ms`)), timeoutMs))
+        ]);
         if (this.mcpClient) {
             try {
-                console.log('  → Closing MCP client...');
-                console.debug('[DEBUG] Calling mcpClient.close() with timeout');
                 await closeWithTimeout(() => this.mcpClient.close(), 'MCP client close');
-                console.log('  ✓ MCP client closed');
             }
-            catch (e) {
-                console.warn('  ⚠️  MCP client close timeout or error:', e.message);
-                console.debug('[DEBUG] MCP client close error:', e);
-                await captureRemote('desktop_integration_shutdown_error', { error: e, component: 'client' });
+            catch (error) {
+                await captureRemote('local_engine_shutdown_error', { error, component: 'client' });
             }
             this.mcpClient = null;
         }
         if (this.mcpTransport) {
             try {
-                console.log('  → Closing MCP transport...');
-                console.debug('[DEBUG] Calling mcpTransport.close() with timeout');
                 await closeWithTimeout(() => this.mcpTransport.close(), 'MCP transport close');
-                console.log('  ✓ MCP transport closed');
             }
-            catch (e) {
-                console.warn('  ⚠️  MCP transport close timeout or error:', e.message);
-                console.debug('[DEBUG] MCP transport close error:', e);
-                await captureRemote('desktop_integration_shutdown_error', { error: e, component: 'transport' });
+            catch (error) {
+                await captureRemote('local_engine_shutdown_error', { error, component: 'transport' });
             }
             this.mcpTransport = null;
         }
-        this.isReady = false;
-        console.debug('[DEBUG] Desktop Commander integration shutdown complete');
+        this.markUnavailable();
     }
 }

package/dist/device/gateway-channel.d.ts

@@ -14,6 +14,11 @@ export interface GatewayChannelOptions {
     securityProtocolFloor?: number;
     appCaPem?: string;
     adapter: GatewayToolAdapter;
+    runtimeState?: () => {
+        runtime_ready: boolean;
+        runtime_reason: string | null;
+        execution_runtime_generation: string | null;
+    };
     agentVersion?: string;
     onStatus?: (payload: any) => void | Promise<void>;
     onUpdateRequest?: (targetVersion: string, context: {
@@ -40,6 +45,7 @@ export declare class GatewayDeviceChannel {
     private authMode;
     private updateInFlight?;
     constructor(options: GatewayChannelOptions);
+    private runtimePayload;
     start(): Promise<void>;
     private startV2Transport;
     stop(): Promise<void>;

package/dist/device/gateway-channel.js

@@ -19,6 +19,19 @@ export class GatewayDeviceChannel {
         this.authMode = 'reconnect';
         this.identity = options.identity || new GatewayDeviceIdentity();
     }
+    runtimePayload() {
+        if (!this.options.runtimeState)
+            return {};
+        const state = this.options.runtimeState();
+        const ready = state?.runtime_ready === true;
+        const reason = ready ? null : String(state?.runtime_reason || 'LOCAL_EXECUTION_ENGINE_UNAVAILABLE').slice(0, 96);
+        const generation = String(state?.execution_runtime_generation || '').trim().slice(0, 128) || null;
+        return {
+            runtime_ready: ready,
+            runtime_reason: reason,
+            execution_runtime_generation: generation
+        };
+    }
     async start() {
         this.authenticatedDeviceId = undefined;
         this.connectionEpoch = undefined;
@@ -150,6 +163,7 @@ export class GatewayDeviceChannel {
                 arch: process.arch,
                 path_style: process.platform === 'win32' ? 'windows' : 'posix',
                 capabilities: [...GATEWAY_CAPABILITIES],
+                ...this.runtimePayload(),
                 ...(enrolling || pairing ? { public_key_pem: record.publicKeyPem } : {})
             }
         });
@@ -173,6 +187,7 @@ export class GatewayDeviceChannel {
                 arch: process.arch,
                 path_style: process.platform === 'win32' ? 'windows' : 'posix',
                 capabilities: [...GATEWAY_CAPABILITIES],
+                ...this.runtimePayload(),
                 ...(pairing || enrolling ? { public_key_pem: record.publicKeyPem, enrollment_grant: grant } : {})
             }
         });
@@ -432,7 +447,7 @@ export class GatewayDeviceChannel {
                 type: 'heartbeat',
                 device_id: record.deviceId,
                 timestamp: Date.now(),
-                payload: {}
+                payload: this.runtimePayload()
             });
         }, HEARTBEAT_MS);
         this.heartbeat.unref?.();

package/dist/device/gateway-tool-adapter.d.ts

@@ -1,15 +1,15 @@
-import { DesktopCommanderIntegration } from './execution-engine.js';
+import { LocalExecutionEngine } from './execution-engine.js';
 export declare const GATEWAY_CAPABILITIES: readonly ["read_text_file", "write_file", "edit_file", "shell_execute", "start_process", "read_process_output", "interact_with_process", "terminate_process", "image_preview", "project_inspect"];
 export interface GatewayToolAdapterOptions {
     allowedRoots?: string[];
     pathValidator?: (requestedPath: string) => Promise<string>;
 }
 export declare class GatewayToolAdapter {
-    private desktop;
+    private engine;
     private allowedRoots;
     private pathValidator;
     private canonicalRoots?;
-    constructor(desktop: DesktopCommanderIntegration, options?: GatewayToolAdapterOptions);
+    constructor(engine: LocalExecutionEngine, options?: GatewayToolAdapterOptions);
     private guardPath;
     private imagePreview;
     call(tool: string, args?: any): Promise<any>;

package/dist/device/gateway-tool-adapter.js

@@ -63,7 +63,7 @@ function parsePid(result) {
     const match = textFromResult(result).match(/PID\s+(-?\d+)/i);
     const pid = Number(match?.[1]);
     if (!Number.isInteger(pid))
-        throw new Error('Desktop Commander did not return a process PID');
+        throw new Error('Local execution engine did not return a process PID');
     return pid;
 }
 async function runShell(args) {
@@ -120,8 +120,8 @@ async function runShell(args) {
     }
 }
 export class GatewayToolAdapter {
-    constructor(desktop, options = {}) {
-        this.desktop = desktop;
+    constructor(engine, options = {}) {
+        this.engine = engine;
         this.allowedRoots = options.allowedRoots ?? configuredGatewayRoots();
         this.pathValidator = options.pathValidator ?? validatePath;
     }
@@ -188,6 +188,7 @@ export class GatewayToolAdapter {
         throw new Error(`REMOTE_IMAGE_TOO_LARGE: unable to fit preview within ${MAX_REMOTE_IMAGE_PREVIEW_BYTES} bytes`);
     }
     async call(tool, args = {}) {
+        this.engine.assertReady();
         if (tool === 'read_text_file') {
             if (args.head !== undefined && args.tail !== undefined)
                 throw new Error('Use either head or tail, not both');
@@ -199,10 +200,10 @@ export class GatewayToolAdapter {
             else if (args.tail !== undefined) {
                 mapped.offset = -Number(args.tail);
             }
-            return assertSuccess(await this.desktop.callClientTool('read_file', mapped), 'read_file');
+            return assertSuccess(await this.engine.callClientTool('read_file', mapped), 'read_file');
         }
         if (tool === 'write_file') {
-            return assertSuccess(await this.desktop.callClientTool('write_file', {
+            return assertSuccess(await this.engine.callClientTool('write_file', {
                 path: await this.guardPath(args.path),
                 content: args.content,
                 mode: 'rewrite'
@@ -214,7 +215,7 @@ export class GatewayToolAdapter {
             return await runShell({ ...args, working_directory: await this.guardPath(args.working_directory) });
         if (tool === 'start_process') {
             const workingDirectory = await this.guardPath(args.working_directory);
-            const result = assertSuccess(await this.desktop.callClientTool('start_process', {
+            const result = assertSuccess(await this.engine.callClientTool('start_process', {
                 command: args.command,
                 timeout_ms: Number(args.timeout_ms || 10000),
                 working_directory: workingDirectory
@@ -222,7 +223,7 @@ export class GatewayToolAdapter {
             return { ...result, pid: parsePid(result), session_id: String(parsePid(result)) };
         }
         if (tool === 'read_process_output') {
-            return assertSuccess(await this.desktop.callClientTool('read_process_output', {
+            return assertSuccess(await this.engine.callClientTool('read_process_output', {
                 pid: Number(args.session_id),
                 offset: args.offset,
                 length: args.length,
@@ -230,14 +231,14 @@ export class GatewayToolAdapter {
             }), 'read_process_output');
         }
         if (tool === 'interact_with_process') {
-            return assertSuccess(await this.desktop.callClientTool('interact_with_process', {
+            return assertSuccess(await this.engine.callClientTool('interact_with_process', {
                 pid: Number(args.session_id),
                 input: String(args.input ?? ''),
                 timeout_ms: Number(args.timeout_ms || 8000)
             }), 'interact_with_process');
         }
         if (tool === 'terminate_process') {
-            return assertSuccess(await this.desktop.callClientTool('force_terminate', {
+            return assertSuccess(await this.engine.callClientTool('force_terminate', {
                 pid: Number(args.session_id)
             }), 'force_terminate');
         }
@@ -258,7 +259,7 @@ export class GatewayToolAdapter {
             throw new Error('expected_replacements must be a positive integer');
         }
         if (args.dry_run === true) {
-            const read = assertSuccess(await this.desktop.callClientTool('read_file', {
+            const read = assertSuccess(await this.engine.callClientTool('read_file', {
                 path: args.path,
                 offset: 0,
                 length: 100000
@@ -274,7 +275,7 @@ export class GatewayToolAdapter {
                         }) }]
             };
         }
-        return assertSuccess(await this.desktop.callClientTool('edit_block', {
+        return assertSuccess(await this.engine.callClientTool('edit_block', {
             file_path: args.path,
             old_string: args.old_text,
             new_string: args.new_text,

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

@@ -22,6 +22,7 @@ export declare class SystemdUserDeviceService {
     private nodePath;
     private entrypoint;
     private pathValue;
+    private runtimeDir;
     constructor(options?: {
         platform?: NodeJS.Platform | string;
         execFile?: ExecFileFn;
@@ -29,6 +30,7 @@ export declare class SystemdUserDeviceService {
         nodePath?: string;
         entrypoint?: string;
         pathValue?: string;
+        runtimeDir?: string;
     });
     private assertLinux;
     private unitExists;
@@ -47,6 +49,7 @@ export declare class Pm2DeviceService {
     private entrypoint;
     private user;
     private pm2Home;
+    private runtimeDir;
     constructor(options?: {
         platform?: NodeJS.Platform | string;
         execFile?: ExecFileFn;
@@ -55,6 +58,7 @@ export declare class Pm2DeviceService {
         entrypoint?: string;
         user?: string;
         pm2Home?: string;
+        runtimeDir?: string;
     });
     private assertLinux;
     private processRow;

package/dist/device/linux-service.js

@@ -4,6 +4,7 @@ import os from 'os';
 import path from 'path';
 import readline from 'readline/promises';
 import { promisify } from 'util';
+import { deviceStatePaths } from './device-state.js';
 const execFileAsync = promisify(execFileCallback);
 export const SYSTEMD_UNIT = 'mcp-device.service';
 const SYSTEMD_OWNER_MARKER = '# Managed by MCP Device';
@@ -55,6 +56,7 @@ export class SystemdUserDeviceService {
         this.nodePath = options.platform === 'linux' && options.nodePath ? String(options.nodePath) : path.resolve(options.nodePath || process.execPath);
         this.entrypoint = options.platform === 'linux' && options.entrypoint ? String(options.entrypoint) : path.resolve(options.entrypoint || process.argv[1]);
         this.pathValue = String(options.pathValue ?? process.env.PATH ?? '/usr/local/bin:/usr/bin:/bin');
+        this.runtimeDir = options.platform === 'linux' && options.runtimeDir ? String(options.runtimeDir) : path.resolve(options.runtimeDir || deviceStatePaths().runtime);
     }
     assertLinux() {
         if (this.platform !== 'linux')
@@ -89,6 +91,7 @@ export class SystemdUserDeviceService {
             '[Service]',
             'Type=simple',
             `Environment="PATH=${this.pathValue.replace(/["\\]/g, match => `\\${match}`)}"`,
+            `WorkingDirectory=${quoteSystemdArg(this.runtimeDir)}`,
             `ExecStart=${quoteSystemdArg(this.nodePath)} ${quoteSystemdArg(this.entrypoint)} --service --manager=systemd`,
             'Restart=on-failure',
             'RestartSec=3',
@@ -102,6 +105,7 @@ export class SystemdUserDeviceService {
         this.assertLinux();
         await this.assertOwnedUnitIfPresent();
         await this.execFile('systemctl', ['--user', 'show-environment']);
+        await fs.mkdir(this.runtimeDir, { recursive: true, mode: 0o700 });
         await fs.mkdir(path.dirname(this.unitPath), { recursive: true });
         await fs.writeFile(this.unitPath, this.unitText(), { mode: 0o600 });
         await this.execFile('systemctl', ['--user', 'daemon-reload']);
@@ -152,6 +156,7 @@ export class Pm2DeviceService {
         this.entrypoint = options.platform === 'linux' && options.entrypoint ? String(options.entrypoint) : path.resolve(options.entrypoint || process.argv[1]);
         this.user = String(options.user || process.env.USER || process.env.LOGNAME || os.userInfo().username);
         this.pm2Home = options.platform === 'linux' && options.pm2Home ? String(options.pm2Home) : path.resolve(options.pm2Home || process.env.PM2_HOME || path.join(os.homedir(), '.pm2'));
+        this.runtimeDir = options.platform === 'linux' && options.runtimeDir ? String(options.runtimeDir) : path.resolve(options.runtimeDir || deviceStatePaths().runtime);
     }
     assertLinux() {
         if (this.platform !== 'linux')
@@ -209,13 +214,15 @@ export class Pm2DeviceService {
     }
     async install() {
         await this.proveStartup();
+        await fs.mkdir(this.runtimeDir, { recursive: true, mode: 0o700 });
         const existing = await this.processRow();
         this.assertOwnedProcess(existing);
         if (!existing) {
-            await this.execFile(this.pm2Path, ['start', this.entrypoint, '--name', PM2_NAME, '--interpreter', this.nodePath, '--', '--service', '--manager=pm2']);
+            await this.execFile(this.pm2Path, ['start', this.entrypoint, '--name', PM2_NAME, '--interpreter', this.nodePath, '--cwd', this.runtimeDir, '--', '--service', '--manager=pm2']);
         }
-        else if (String(existing?.pm2_env?.status || '').toLowerCase() !== 'online') {
-            await this.execFile(this.pm2Path, ['restart', PM2_NAME]);
+        else if (String(existing?.pm2_env?.status || '').toLowerCase() !== 'online' ||
+            String(existing?.pm2_env?.pm_cwd || '') !== this.runtimeDir) {
+            await this.execFile(this.pm2Path, ['restart', PM2_NAME, '--cwd', this.runtimeDir]);
         }
         await this.execFile(this.pm2Path, ['save']);
         const status = await this.status();

package/dist/device/runtime-owner.js

@@ -2,7 +2,7 @@ import crypto from 'crypto';
 import fs from 'fs/promises';
 import net from 'net';
 import path from 'path';
-import { deviceStatePaths, migrateLegacyDeviceState } from './device-state.js';
+import { deviceStatePaths } 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')
@@ -106,7 +106,7 @@ export class RuntimeOwner {
         await fs.writeFile(runtimeOwnerControlFileFor(this.paths), JSON.stringify({ endpoint: this.endpoint, nonce: this.nonce }, null, 2), { mode: 0o600 });
     }
     async bootstrap() {
-        await migrateLegacyDeviceState(this.paths);
+        await fs.mkdir(this.paths.root, { recursive: true, mode: 0o700 });
     }
     setDeviceId(deviceId) {
         this.status.deviceId = String(deviceId || '').trim() || null;

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

@@ -9,6 +9,7 @@ export declare function buildWindowsRunnerScript(options: {
     allowedRoots?: string;
     nodePath: string;
     entrypoint: string;
+    runtimeDir?: string;
 }): string;
 export type WindowsDeviceServiceStatus = {
     installed: boolean;
@@ -21,24 +22,22 @@ export declare class WindowsDeviceService {
     private platform;
     private execFile;
     private runnerPath;
-    private legacyRunnerPath;
     private nodePath;
     private entrypoint;
+    private runtimeDir;
     constructor(options?: {
         platform?: NodeJS.Platform | string;
         execFile?: ExecFileFn;
         runnerPath?: string;
-        legacyRunnerPath?: string;
         nodePath?: string;
         entrypoint?: string;
+        runtimeDir?: string;
     });
     private assertWindows;
     private runnerExists;
     private hasUserRunEntry;
     private scheduledTaskState;
     private deleteRegistrations;
-    private commandReferencesLegacyRunner;
-    private deleteVerifiedLegacyRegistrations;
     private createAutostartRegistration;
     private startUserProcess;
     private userProcessRunning;