@amaster.ai/pi-computer-use 0.1.2-beta.8 → 0.1.2-beta.80

package/dist/mcp-client.js

@@ -1,91 +1,595 @@
+import { execFile, spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
 import { accessSync, chmodSync, constants, existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { tmpdir } from 'node:os';
 import path from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { promisify } from 'node:util';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { getDefaultEnvironment, StdioClientTransport, } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { AjvJsonSchemaValidator } from '@modelcontextprotocol/sdk/validation/ajv';
 const MCP_TIMEOUT_MS = 60_000;
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const DAEMON_START_TIMEOUT_MS = 10_000;
+const PERMANENT_STATUS_ERROR_CODES = new Set(['EACCES', 'ENOENT', 'EPERM']);
+const DAEMON_LEASE_SCRIPT = `
+if IFS= read -r _; then exit 0; fi
+attempt=0
+while [ "$attempt" -lt 100 ]; do
+  if [ -S "$2" ]; then
+    "$1" stop --socket "$2" >/dev/null 2>&1
+    status=$("$1" status --socket "$2" 2>&1)
+    if [ -S "$2" ] && [ "$status" = "Cua Driver daemon is not running" ]; then
+      /bin/rm -f -- "$2"
+    fi
+    exit 0
+  fi
+  attempt=$((attempt + 1))
+  sleep 0.1
+done
+`;
+const execFileAsync = promisify(execFile);
+const localRequire = createRequire(import.meta.url);
+function requestOptions(signal) {
+    return signal ? { signal, timeout: MCP_TIMEOUT_MS } : { timeout: MCP_TIMEOUT_MS };
+}
+function abortError(signal) {
+    if (signal?.reason instanceof Error)
+        return signal.reason;
+    return new Error('Cua Driver operation aborted.');
+}
+export async function waitForPromise(promise, signal) {
+    if (!signal)
+        return promise;
+    if (signal.aborted)
+        throw abortError(signal);
+    return new Promise((resolve, reject) => {
+        const onAbort = () => reject(abortError(signal));
+        signal.addEventListener('abort', onAbort, { once: true });
+        void promise.then((value) => {
+            signal.removeEventListener('abort', onAbort);
+            resolve(value);
+        }, (error) => {
+            signal.removeEventListener('abort', onAbort);
+            reject(error);
+        });
+    });
+}
+function delay(milliseconds, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(abortError(signal));
+            return;
+        }
+        const onAbort = () => {
+            clearTimeout(timeout);
+            reject(abortError(signal));
+        };
+        const timeout = setTimeout(() => {
+            signal?.removeEventListener('abort', onAbort);
+            resolve();
+        }, milliseconds);
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}
+export function resolveBundledTarget(platform, arch) {
+    if (platform === 'darwin')
+        return 'darwin-universal';
+    return `${platform}-${arch}`;
+}
+function resolveDriverPackageRoot(platform, arch) {
+    const target = resolveBundledTarget(platform, arch);
+    const packageName = `@amaster.ai/pi-computer-use-cua-driver-${target}`;
+    try {
+        return path.dirname(localRequire.resolve(`${packageName}/package.json`));
+    }
+    catch {
+        throw new Error(`Cua Driver runtime package is not installed for ${target}.`);
+    }
+}
+export function resolveUnixSocketPath(tempDir, suffix) {
+    const filename = `pi-cua-${suffix}.sock`;
+    const configuredTmpPath = path.join(tempDir, filename);
+    // sockaddr_un.sun_path is only 104 bytes on macOS and 108 bytes on Linux.
+    return Buffer.byteLength(configuredTmpPath) <= 90
+        ? configuredTmpPath
+        : path.join('/tmp', filename);
+}
+export async function waitForDaemonStatus(binaryPath, socket, signal, checkStatus = () => execFileAsync(binaryPath, ['status', '--socket', socket], {
+    signal,
+    timeout: 250,
+    windowsHide: true,
+})) {
+    const deadline = Date.now() + DAEMON_START_TIMEOUT_MS;
+    let lastError;
+    while (Date.now() < deadline) {
+        try {
+            await checkStatus();
+            return;
+        }
+        catch (error) {
+            if (signal?.aborted)
+                throw abortError(signal);
+            lastError = error;
+            const code = error && typeof error === 'object' && 'code' in error && typeof error.code === 'string'
+                ? error.code
+                : undefined;
+            if (code && PERMANENT_STATUS_ERROR_CODES.has(code)) {
+                throw new Error(`Cua Driver status check failed (${code}).`, { cause: error });
+            }
+        }
+        await delay(50, signal);
+    }
+    throw new Error('Cua Driver daemon did not respond to a status check.', { cause: lastError });
+}
+export function resolveDriverLayout(config, rootDir = undefined, platform = process.platform, arch = process.arch) {
+    if (config.mode === 'path' && config.binaryPath) {
+        return { binaryPath: config.binaryPath, embedded: platform === 'darwin' };
+    }
+    const binDir = rootDir
+        ? path.join(rootDir, 'bin', resolveBundledTarget(platform, arch))
+        : path.join(resolveDriverPackageRoot(platform, arch), 'bin');
+    if (platform === 'darwin') {
+        const appPath = path.join(binDir, 'CuaDriver.app');
+        return {
+            appPath,
+            binaryPath: path.join(appPath, 'Contents', 'MacOS', 'cua-driver'),
+            embedded: false,
+        };
+    }
+    return {
+        binaryPath: path.join(binDir, platform === 'win32' ? 'cua-driver.exe' : 'cua-driver'),
+        embedded: false,
+    };
+}
+/** schemars emits these non-standard `format` values for Rust integer types; ajv warns on each. */
+const INTEGER_FORMAT_BOUNDS = {
+    int8: { minimum: -128, maximum: 127 },
+    int16: { minimum: -32_768, maximum: 32_767 },
+    int32: { minimum: -2_147_483_648, maximum: 2_147_483_647 },
+    int64: {},
+    uint8: { minimum: 0, maximum: 255 },
+    uint16: { minimum: 0, maximum: 65_535 },
+    uint32: { minimum: 0, maximum: 4_294_967_295 },
+    uint64: { minimum: 0 },
+};
+/** Schema keys whose values are instance data, not subschemas — never rewrite inside them. */
+const NON_SCHEMA_KEYS = new Set(['const', 'default', 'enum', 'examples']);
+/**
+ * Keywords whose values are maps of property name → subschema. Inside these maps the
+ * keys are property names, not schema keywords, so NON_SCHEMA_KEYS must not apply:
+ * a property literally named "default" or "enum" still needs its subschema sanitized.
+ */
+const PROPERTY_MAP_KEYS = new Set([
+    'properties',
+    'patternProperties',
+    'dependentSchemas',
+    '$defs',
+    'definitions',
+]);
+/**
+ * Returns a copy of the schema with schemars' non-standard integer `format`
+ * annotations ("uint64", ...) replaced by standard constraints ajv can enforce.
+ * The input schema is not modified.
+ */
+export function sanitizeSchemaFormats(schema) {
+    return sanitizeSchemaNode(schema);
+}
+function sanitizeSchemaNode(node) {
+    if (Array.isArray(node))
+        return node.map(sanitizeSchemaNode);
+    if (node === null || typeof node !== 'object')
+        return node;
+    // Null-prototype copy: a schema from the wire may carry an own "__proto__"
+    // key (JSON.parse creates one), and assigning it on a plain object would hit
+    // the inherited setter — dropping the key and replacing the copy's prototype.
+    const result = Object.create(null);
+    for (const [key, value] of Object.entries(node)) {
+        result[key] = sanitizeSchemaValue(key, value);
+    }
+    const format = result.format;
+    if (typeof format !== 'string')
+        return result;
+    // Own-property check: a plain table lookup would match Object.prototype keys
+    // ("constructor", "toString", ...) on hostile or malformed schemas.
+    const bounds = Object.hasOwn(INTEGER_FORMAT_BOUNDS, format)
+        ? INTEGER_FORMAT_BOUNDS[format]
+        : undefined;
+    if (!bounds)
+        return result;
+    // Only rewrite integer schemas; injecting numeric bounds into a node that
+    // declares another type would misannotate it.
+    if (!isIntegerType(result.type))
+        return result;
+    delete result.format;
+    result.type ??= 'integer';
+    if (bounds.minimum !== undefined && result.minimum === undefined) {
+        result.minimum = bounds.minimum;
+    }
+    if (bounds.maximum !== undefined && result.maximum === undefined) {
+        result.maximum = bounds.maximum;
+    }
+    return result;
+}
+function sanitizeSchemaValue(key, value) {
+    if (NON_SCHEMA_KEYS.has(key))
+        return value;
+    if (PROPERTY_MAP_KEYS.has(key) && isRecord(value)) {
+        const map = Object.create(null);
+        for (const [name, subschema] of Object.entries(value)) {
+            map[name] = sanitizeSchemaNode(subschema);
+        }
+        return map;
+    }
+    return sanitizeSchemaNode(value);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isIntegerType(type) {
+    if (type === undefined)
+        return true;
+    if (Array.isArray(type))
+        return type.includes('integer');
+    return type === 'integer';
+}
+/**
+ * Wraps the SDK's default ajv validator, sanitizing non-standard integer formats
+ * before compilation so ajv stays silent and the integer bounds stay enforced.
+ */
+export class SanitizingJsonSchemaValidator {
+    inner = new AjvJsonSchemaValidator();
+    getValidator(schema) {
+        return this.inner.getValidator(sanitizeSchemaFormats(schema));
+    }
+}
+/** Owns the Cua Driver daemon and its stdio MCP proxy as one adapter. */
 export class CuaDriverClient {
-    client = null;
-    transport = null;
     config;
+    client = null;
+    daemonProcess = null;
+    daemonLease = null;
+    daemonSocket = null;
+    activeLayout = null;
+    state = 'disconnected';
+    connectPromise = null;
+    lifecycleController = new AbortController();
+    generation = 0;
+    hasConnected = false;
+    explicitlyClosed = false;
     constructor(config) {
         this.config = config;
     }
-    async connect() {
-        const binaryPath = await this.resolveBinaryPath();
-        const args = ['mcp', ...(this.config.extraArgs ?? [])];
-        this.transport = new StdioClientTransport({
-            command: binaryPath,
-            args,
-            stderr: 'pipe',
-        });
-        this.transport.onerror = (error) => {
-            console.error(`[pi-computer-use] cua-driver transport error: ${error.message}`);
-        };
-        this.client = new Client({ name: 'pi-computer-use', version: '0.1.0' }, { capabilities: {} });
-        await this.client.connect(this.transport);
+    getState() {
+        return this.state;
     }
-    async listAllTools() {
-        if (!this.client)
-            throw new Error('CuaDriverClient not connected');
-        const allTools = [];
-        let cursor;
-        do {
-            const result = await this.client.listTools(cursor ? { cursor } : undefined, {
-                timeout: MCP_TIMEOUT_MS,
+    async connect(signal) {
+        if (this.explicitlyClosed)
+            throw new Error('Cua Driver client is closed.');
+        if (this.state === 'ready')
+            return;
+        if (!this.connectPromise) {
+            const connection = this.openConnection(this.lifecycleController.signal);
+            this.connectPromise = connection;
+            const clearConnection = () => {
+                if (this.connectPromise === connection)
+                    this.connectPromise = null;
+            };
+            void connection.then(clearConnection, clearConnection);
+        }
+        await waitForPromise(this.connectPromise, signal);
+    }
+    async openConnection(signal) {
+        this.state = this.hasConnected ? 'reconnecting' : 'connecting';
+        const generation = ++this.generation;
+        let client = null;
+        try {
+            const layout = resolveDriverLayout(this.config);
+            this.ensureExecutable(layout.binaryPath);
+            this.activeLayout = layout;
+            const socket = await this.ensureDaemon(layout, signal);
+            const mcpArgs = [
+                'mcp',
+                ...(layout.embedded ? ['--embedded'] : []),
+                '--socket',
+                socket,
+                ...(this.config.extraArgs ?? []),
+            ];
+            const env = layout.embedded
+                ? { ...getDefaultEnvironment(), CUA_DRIVER_EMBEDDED: '1' }
+                : getDefaultEnvironment();
+            const transport = new StdioClientTransport({
+                command: layout.binaryPath,
+                args: mcpArgs,
+                env,
+                stderr: 'pipe',
             });
-            allTools.push(...result.tools);
-            cursor = result.nextCursor;
-        } while (cursor);
-        return allTools;
+            client = new Client({ name: 'pi-computer-use', version: '0.2.0' }, { capabilities: {}, jsonSchemaValidator: new SanitizingJsonSchemaValidator() });
+            this.client = client;
+            transport.onerror = (error) => {
+                if (generation !== this.generation)
+                    return;
+                console.error(`[pi-computer-use] cua-driver transport error (${error.name})`);
+                void this.disconnectUnhealthyClient(generation);
+            };
+            transport.onclose = () => void this.disconnectUnhealthyClient(generation);
+            await client.connect(transport, requestOptions(signal));
+            if (generation !== this.generation)
+                return;
+            this.state = 'ready';
+            this.hasConnected = true;
+        }
+        catch (error) {
+            if (generation === this.generation) {
+                ++this.generation;
+                this.client = null;
+                this.state = 'failed';
+            }
+            try {
+                await client?.close();
+            }
+            catch {
+                // A failed transport may already be closed.
+            }
+            await this.stopDaemon();
+            if (signal?.aborted)
+                throw abortError(signal);
+            const errorName = error instanceof Error ? error.name : 'UnknownError';
+            console.error(`[pi-computer-use] cua-driver connection failed (${errorName})`);
+            if (process.env.DEBUG?.includes('pi-computer-use')) {
+                const message = error instanceof Error ? error.message : String(error);
+                console.error(`[pi-computer-use] connection detail: ${message}`);
+            }
+            throw new Error('Cua Driver connection failed.');
+        }
     }
-    async callTool(name, args) {
-        if (!this.client)
-            throw new Error('CuaDriverClient not connected');
-        return (await this.client.callTool({ name, arguments: args }, undefined, {
-            timeout: MCP_TIMEOUT_MS,
-        }));
+    createSocketPath() {
+        const suffix = `${process.pid}-${randomUUID().slice(0, 8)}`;
+        return process.platform === 'win32'
+            ? `\\\\.\\pipe\\pi-computer-use-${suffix}`
+            : resolveUnixSocketPath(tmpdir(), suffix);
     }
-    async close() {
-        if (this.client) {
-            await this.client.close();
-            this.client = null;
+    daemonEnvironment(embedded) {
+        return embedded ? { ...process.env, CUA_DRIVER_EMBEDDED: '1' } : process.env;
+    }
+    async ensureDaemon(layout, signal) {
+        if (this.daemonSocket)
+            return this.daemonSocket;
+        const socket = this.createSocketPath();
+        this.daemonSocket = socket;
+        if (process.platform !== 'win32') {
+            // This anonymous pipe is the lease: owner death closes it even after SIGKILL.
+            const lease = spawn('/bin/sh', ['-c', DAEMON_LEASE_SCRIPT, 'pi-computer-use-lease', layout.binaryPath, socket], {
+                env: this.daemonEnvironment(layout.embedded),
+                stdio: ['pipe', 'ignore', 'ignore'],
+            });
+            this.daemonLease = lease;
+            await new Promise((resolve, reject) => {
+                const onError = (error) => {
+                    lease.removeListener('spawn', onSpawn);
+                    reject(error);
+                };
+                const onSpawn = () => {
+                    lease.removeListener('error', onError);
+                    resolve();
+                };
+                lease.once('error', onError);
+                lease.once('spawn', onSpawn);
+            });
+            lease.unref?.();
+            lease.stdin?.unref?.();
+            lease.once('error', () => {
+                if (this.daemonLease !== lease)
+                    return;
+                console.error('[pi-computer-use] failed to start daemon lease');
+                void this.stopDaemon();
+            });
+        }
+        if (process.platform === 'darwin' && layout.appPath && !layout.embedded) {
+            const launcher = spawn('/usr/bin/open', ['-n', '-g', layout.appPath, '--args', 'serve', '--socket', socket, '--no-overlay'], { stdio: 'ignore' });
+            await this.waitForLauncher(launcher, signal);
+            await this.waitForSocket(socket, signal);
+            return socket;
         }
-        this.transport = null;
+        const args = [
+            'serve',
+            ...(layout.embedded ? ['--embedded'] : []),
+            '--socket',
+            socket,
+            '--no-overlay',
+        ];
+        const daemon = spawn(layout.binaryPath, args, {
+            env: this.daemonEnvironment(layout.embedded),
+            stdio: ['ignore', 'ignore', 'pipe'],
+        });
+        this.daemonProcess = daemon;
+        await this.waitForDaemonReady(daemon, socket, signal);
+        if (process.platform === 'win32') {
+            await waitForDaemonStatus(layout.binaryPath, socket, signal);
+        }
+        return socket;
+    }
+    waitForLauncher(child, signal) {
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => reject(new Error('Cua Driver LaunchServices startup timed out.')), DAEMON_START_TIMEOUT_MS);
+            const finish = (error) => {
+                clearTimeout(timeout);
+                signal?.removeEventListener('abort', onAbort);
+                error ? reject(error) : resolve();
+            };
+            const onAbort = () => {
+                child.kill();
+                finish(abortError(signal));
+            };
+            signal?.addEventListener('abort', onAbort, { once: true });
+            child.once('error', finish);
+            child.once('exit', (code) => code === 0 ? finish() : finish(new Error(`LaunchServices exited with code ${code ?? -1}.`)));
+        });
     }
-    async resolveBinaryPath() {
-        if (this.config.mode === 'path' && this.config.binaryPath) {
-            return this.config.binaryPath;
+    async waitForSocket(socket, signal) {
+        const deadline = Date.now() + DAEMON_START_TIMEOUT_MS;
+        while (Date.now() < deadline) {
+            if (existsSync(socket))
+                return;
+            await delay(50, signal);
         }
-        const platform = process.platform === 'win32' ? 'win32-x64' : `${process.platform}-${process.arch}`;
-        const binDir = path.resolve(__dirname, '..', 'bin', platform);
-        let binPath;
-        if (process.platform === 'darwin') {
-            binPath = path.join(binDir, 'CuaDriver.app', 'Contents', 'MacOS', 'cua-driver');
+        throw new Error('Cua Driver daemon socket did not become ready.');
+    }
+    waitForDaemonReady(daemon, socket, signal) {
+        return new Promise((resolve, reject) => {
+            let stderr = '';
+            const timeout = setTimeout(() => finish(new Error('Cua Driver daemon startup timed out.')), DAEMON_START_TIMEOUT_MS);
+            const finish = (error) => {
+                clearTimeout(timeout);
+                signal?.removeEventListener('abort', onAbort);
+                daemon.stderr?.removeListener('data', onData);
+                error ? reject(error) : resolve();
+            };
+            const onAbort = () => {
+                daemon.kill();
+                finish(abortError(signal));
+            };
+            const onData = (chunk) => {
+                stderr = `${stderr}${chunk.toString()}`.slice(-4_096);
+                if (stderr.includes('daemon listening on'))
+                    finish();
+            };
+            signal?.addEventListener('abort', onAbort, { once: true });
+            daemon.stderr?.on('data', onData);
+            daemon.once('error', finish);
+            daemon.once('exit', (code) => {
+                if (this.state !== 'closing') {
+                    const detail = process.env.DEBUG?.includes('pi-computer-use') ? `: ${stderr.trim()}` : '';
+                    finish(new Error(`Cua Driver daemon exited with code ${code ?? -1}${detail}.`));
+                }
+            });
+            if (process.platform !== 'win32' && existsSync(socket))
+                finish();
+        });
+    }
+    ensureExecutable(binaryPath) {
+        if (!existsSync(binaryPath)) {
+            throw new Error(`cua-driver binary not found for ${resolveBundledTarget(process.platform, process.arch)}.`);
         }
-        else {
-            const ext = process.platform === 'win32' ? '.exe' : '';
-            binPath = path.join(binDir, `cua-driver${ext}`);
+        if (process.platform === 'win32')
+            return;
+        try {
+            accessSync(binaryPath, constants.X_OK);
         }
-        if (!existsSync(binPath)) {
-            throw new Error(`[pi-computer-use] cua-driver binary not found at ${binPath}. ` +
-                `Platform "${platform}" may not be supported, or set mode: "path" with binaryPath in config.`);
+        catch {
+            try {
+                chmodSync(binaryPath, 0o755);
+            }
+            catch {
+                throw new Error('cua-driver binary is not executable.');
+            }
         }
+    }
+    markDisconnected(generation) {
+        if (generation !== this.generation || this.state === 'closing')
+            return;
+        ++this.generation;
+        this.client = null;
+        this.state = 'disconnected';
+    }
+    async disconnectUnhealthyClient(generation) {
+        if (generation !== this.generation || this.state === 'closing')
+            return;
+        const failedClient = this.client;
+        this.markDisconnected(generation);
+        // Clear owned-daemon state before awaiting the MCP close so an immediate retry
+        // cannot attach to a socket that is in the process of being torn down.
+        const stopPromise = this.stopDaemon();
+        try {
+            await failedClient?.close();
+        }
+        catch {
+            console.error('[pi-computer-use] failed to close unhealthy MCP client');
+        }
+        finally {
+            await stopPromise;
+        }
+    }
+    async ensureReady(signal) {
+        if (this.explicitlyClosed)
+            throw new Error('Cua Driver client is closed.');
+        if (this.state === 'ready' && this.client)
+            return;
+        await this.connect(signal);
+    }
+    async listAllTools(signal) {
+        await this.ensureReady(signal);
+        const client = this.client;
+        if (!client)
+            throw new Error('Cua Driver client not connected.');
+        const allTools = [];
+        let cursor;
+        do {
+            const result = await client.listTools(cursor ? { cursor } : undefined, requestOptions(signal));
+            allTools.push(...result.tools);
+            cursor = result.nextCursor;
+        } while (cursor);
+        return allTools;
+    }
+    async callTool(name, args, signal) {
+        await this.ensureReady(signal);
+        const client = this.client;
+        if (!client)
+            throw new Error('Cua Driver client not connected.');
         try {
-            accessSync(binPath, constants.X_OK);
+            return (await client.callTool({ name, arguments: args }, undefined, requestOptions(signal)));
         }
         catch {
+            if (signal?.aborted)
+                throw abortError(signal);
+            await this.disconnectUnhealthyClient(this.generation);
+            throw new Error('Cua Driver connection lost; retry the tool.');
+        }
+    }
+    async stopDaemon() {
+        const socket = this.daemonSocket;
+        const layout = this.activeLayout;
+        const daemonProcess = this.daemonProcess;
+        const daemonLease = this.daemonLease;
+        this.daemonSocket = null;
+        this.activeLayout = null;
+        this.daemonProcess = null;
+        this.daemonLease = null;
+        if (daemonLease?.stdin?.writable)
+            daemonLease.stdin.end('cancel\n');
+        else
+            daemonLease?.kill();
+        if (socket && layout) {
             try {
-                chmodSync(binPath, 0o755);
+                await execFileAsync(layout.binaryPath, ['stop', '--socket', socket], {
+                    env: this.daemonEnvironment(layout.embedded),
+                    timeout: 3_000,
+                });
             }
-            catch (chmodErr) {
-                throw new Error(`[pi-computer-use] cua-driver binary at ${binPath} is not executable. ` +
-                    `Auto-fix failed (${chmodErr instanceof Error ? chmodErr.message : String(chmodErr)}). ` +
-                    `Run: sudo chmod +x "${binPath}"`);
+            catch {
+                console.error('[pi-computer-use] failed to stop owned daemon');
             }
         }
-        return binPath;
+        daemonProcess?.kill();
+    }
+    async close() {
+        if (this.explicitlyClosed)
+            return;
+        this.explicitlyClosed = true;
+        this.state = 'closing';
+        const connection = this.connectPromise;
+        this.lifecycleController.abort(new Error('Cua Driver client is closing.'));
+        if (connection)
+            await Promise.allSettled([connection]);
+        const client = this.client;
+        ++this.generation;
+        this.client = null;
+        try {
+            await client?.close();
+        }
+        finally {
+            await this.stopDaemon();
+            this.state = 'disconnected';
+        }
     }
 }
 //# sourceMappingURL=mcp-client.js.map