@wonderwhy-er/desktop-commander 0.2.38 → 0.2.39

package/dist/tools/macos-control/cdp-adapter.js

@@ -1,402 +0,0 @@
-import net from 'net';
-import tls from 'tls';
-import { randomBytes, randomUUID } from 'crypto';
-import { URL } from 'url';
-function makeError(code, message, details) {
-    return {
-        ok: false,
-        error: {
-            code: code,
-            message,
-            details,
-        },
-    };
-}
-class SimpleWebSocketClient {
-    constructor() {
-        this.socket = null;
-        this.readBuffer = Buffer.alloc(0);
-        this.onTextMessage = null;
-        this.onCloseHandler = null;
-    }
-    setMessageHandler(handler) {
-        this.onTextMessage = handler;
-    }
-    setCloseHandler(handler) {
-        this.onCloseHandler = handler;
-    }
-    async connect(wsUrl, timeoutMs = 6000) {
-        const url = new URL(wsUrl);
-        const isSecure = url.protocol === 'wss:';
-        const port = Number(url.port || (isSecure ? 443 : 80));
-        const path = `${url.pathname || '/'}${url.search || ''}`;
-        const key = randomBytes(16).toString('base64');
-        const socket = isSecure
-            ? tls.connect({ host: url.hostname, port, servername: url.hostname })
-            : net.connect({ host: url.hostname, port });
-        this.socket = socket;
-        await new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                reject(new Error(`WebSocket connect timeout after ${timeoutMs}ms`));
-            }, timeoutMs);
-            const cleanup = () => {
-                clearTimeout(timeout);
-                socket.removeListener('error', onError);
-                socket.removeListener('data', onData);
-            };
-            const onError = (error) => {
-                cleanup();
-                reject(error);
-            };
-            let handshakeBuffer = '';
-            const onData = (chunk) => {
-                handshakeBuffer += chunk.toString('utf8');
-                const headerEnd = handshakeBuffer.indexOf('\r\n\r\n');
-                if (headerEnd === -1) {
-                    return;
-                }
-                const headers = handshakeBuffer.slice(0, headerEnd);
-                const remaining = Buffer.from(handshakeBuffer.slice(headerEnd + 4), 'utf8');
-                if (!headers.startsWith('HTTP/1.1 101')) {
-                    cleanup();
-                    reject(new Error(`WebSocket handshake failed: ${headers.split('\r\n')[0]}`));
-                    return;
-                }
-                cleanup();
-                if (remaining.length > 0) {
-                    this.readBuffer = Buffer.concat([this.readBuffer, remaining]);
-                    this.consumeFrames();
-                }
-                resolve();
-            };
-            socket.once('error', onError);
-            socket.on('data', onData);
-            const request = [
-                `GET ${path} HTTP/1.1`,
-                `Host: ${url.hostname}:${port}`,
-                'Upgrade: websocket',
-                'Connection: Upgrade',
-                `Sec-WebSocket-Key: ${key}`,
-                'Sec-WebSocket-Version: 13',
-                '\r\n',
-            ].join('\r\n');
-            socket.write(request);
-        });
-        socket.on('data', (chunk) => {
-            this.readBuffer = Buffer.concat([this.readBuffer, chunk]);
-            this.consumeFrames();
-        });
-        socket.on('close', () => {
-            this.onCloseHandler?.();
-        });
-        socket.on('error', () => {
-            this.onCloseHandler?.();
-        });
-    }
-    sendText(text) {
-        if (!this.socket) {
-            throw new Error('WebSocket is not connected');
-        }
-        const payload = Buffer.from(text, 'utf8');
-        const frame = this.encodeClientFrame(payload, 0x1);
-        this.socket.write(frame);
-    }
-    close() {
-        if (!this.socket) {
-            return;
-        }
-        try {
-            const closeFrame = this.encodeClientFrame(Buffer.alloc(0), 0x8);
-            this.socket.write(closeFrame);
-        }
-        catch {
-            // Ignore close frame errors
-        }
-        this.socket.end();
-        this.socket.destroy();
-        this.socket = null;
-    }
-    consumeFrames() {
-        while (this.readBuffer.length >= 2) {
-            const b0 = this.readBuffer[0];
-            const b1 = this.readBuffer[1];
-            const opcode = b0 & 0x0f;
-            const isMasked = (b1 & 0x80) !== 0;
-            let payloadLength = b1 & 0x7f;
-            let offset = 2;
-            if (payloadLength === 126) {
-                if (this.readBuffer.length < offset + 2) {
-                    return;
-                }
-                payloadLength = this.readBuffer.readUInt16BE(offset);
-                offset += 2;
-            }
-            else if (payloadLength === 127) {
-                if (this.readBuffer.length < offset + 8) {
-                    return;
-                }
-                const lenBig = this.readBuffer.readBigUInt64BE(offset);
-                payloadLength = Number(lenBig);
-                offset += 8;
-            }
-            let maskKey = null;
-            if (isMasked) {
-                if (this.readBuffer.length < offset + 4) {
-                    return;
-                }
-                maskKey = this.readBuffer.subarray(offset, offset + 4);
-                offset += 4;
-            }
-            if (this.readBuffer.length < offset + payloadLength) {
-                return;
-            }
-            let payload = this.readBuffer.subarray(offset, offset + payloadLength);
-            this.readBuffer = this.readBuffer.subarray(offset + payloadLength);
-            if (isMasked && maskKey) {
-                const unmasked = Buffer.allocUnsafe(payload.length);
-                for (let i = 0; i < payload.length; i++) {
-                    unmasked[i] = payload[i] ^ maskKey[i % 4];
-                }
-                payload = unmasked;
-            }
-            if (opcode === 0x1) {
-                this.onTextMessage?.(payload.toString('utf8'));
-            }
-            else if (opcode === 0x8) {
-                this.close();
-                return;
-            }
-            else if (opcode === 0x9) {
-                if (this.socket) {
-                    const pong = this.encodeClientFrame(payload, 0xA);
-                    this.socket.write(pong);
-                }
-            }
-        }
-    }
-    encodeClientFrame(payload, opcode) {
-        const mask = randomBytes(4);
-        const headerParts = [];
-        const firstByte = 0x80 | (opcode & 0x0f);
-        headerParts.push(Buffer.from([firstByte]));
-        if (payload.length < 126) {
-            headerParts.push(Buffer.from([0x80 | payload.length]));
-        }
-        else if (payload.length < 65536) {
-            const len = Buffer.alloc(3);
-            len[0] = 0x80 | 126;
-            len.writeUInt16BE(payload.length, 1);
-            headerParts.push(len);
-        }
-        else {
-            const len = Buffer.alloc(9);
-            len[0] = 0x80 | 127;
-            len.writeBigUInt64BE(BigInt(payload.length), 1);
-            headerParts.push(len);
-        }
-        headerParts.push(mask);
-        const maskedPayload = Buffer.allocUnsafe(payload.length);
-        for (let i = 0; i < payload.length; i++) {
-            maskedPayload[i] = payload[i] ^ mask[i % 4];
-        }
-        return Buffer.concat([...headerParts, maskedPayload]);
-    }
-}
-export class CdpAdapter {
-    constructor() {
-        this.sessions = new Map();
-    }
-    async fetchTargets(host, port) {
-        const listUrl = `http://${host}:${port}/json/list`;
-        try {
-            const response = await fetch(listUrl, { method: 'GET' });
-            if (!response.ok) {
-                return makeError('CDP_CONNECT_FAILED', `Failed to query CDP targets: HTTP ${response.status}`);
-            }
-            const data = await response.json();
-            if (!Array.isArray(data)) {
-                return makeError('CDP_CONNECT_FAILED', 'Invalid CDP target list response');
-            }
-            const targets = data.map((item) => ({
-                id: String(item?.id ?? ''),
-                type: String(item?.type ?? ''),
-                title: String(item?.title ?? ''),
-                url: String(item?.url ?? ''),
-                webSocketDebuggerUrl: item?.webSocketDebuggerUrl ? String(item.webSocketDebuggerUrl) : undefined,
-            }));
-            return { ok: true, data: targets };
-        }
-        catch (error) {
-            return makeError('CDP_CONNECT_FAILED', `Failed to query CDP endpoint: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    bindSessionHandlers(session) {
-        session.wsClient.setMessageHandler((message) => {
-            try {
-                const parsed = JSON.parse(message);
-                if (typeof parsed?.id === 'number') {
-                    const pending = session.pending.get(parsed.id);
-                    if (!pending) {
-                        return;
-                    }
-                    clearTimeout(pending.timeout);
-                    session.pending.delete(parsed.id);
-                    if (parsed.error) {
-                        pending.reject(new Error(String(parsed.error?.message || 'CDP call failed')));
-                        return;
-                    }
-                    pending.resolve(parsed.result ?? null);
-                }
-            }
-            catch {
-                // Ignore non-JSON frames/events
-            }
-        });
-        session.wsClient.setCloseHandler(() => {
-            for (const [id, pending] of session.pending) {
-                clearTimeout(pending.timeout);
-                pending.reject(new Error('CDP websocket closed'));
-                session.pending.delete(id);
-            }
-            this.sessions.delete(session.id);
-        });
-    }
-    async sendCommand(session, method, params, timeoutMs = 6000) {
-        return await new Promise((resolve, reject) => {
-            const id = ++session.nextMessageId;
-            const timeout = setTimeout(() => {
-                session.pending.delete(id);
-                reject(new Error(`CDP call timeout: ${method}`));
-            }, timeoutMs);
-            session.pending.set(id, { resolve, reject, timeout });
-            try {
-                session.wsClient.sendText(JSON.stringify({ id, method, params }));
-            }
-            catch (error) {
-                clearTimeout(timeout);
-                session.pending.delete(id);
-                reject(error instanceof Error ? error : new Error(String(error)));
-            }
-        });
-    }
-    async attach(args) {
-        const host = args.host || '127.0.0.1';
-        const port = args.port || 9222;
-        const targetsResult = await this.fetchTargets(host, port);
-        if (!targetsResult.ok) {
-            return {
-                ok: false,
-                error: targetsResult.error,
-            };
-        }
-        const targets = targetsResult.data || [];
-        if (targets.length === 0) {
-            return makeError('CDP_CONNECT_FAILED', `No CDP targets found on ${host}:${port}`);
-        }
-        const pageTargets = targets.filter((target) => ['page', 'webview'].includes(target.type));
-        const candidateTargets = pageTargets.length > 0 ? pageTargets : targets;
-        let target;
-        if (args.targetId) {
-            target = candidateTargets.find((item) => item.id === args.targetId);
-        }
-        else {
-            target = candidateTargets[args.targetIndex ?? 0];
-        }
-        if (!target) {
-            return makeError('CDP_CONNECT_FAILED', 'Requested CDP target not found', {
-                targetId: args.targetId,
-                targetIndex: args.targetIndex,
-                availableTargets: candidateTargets.map((item) => item.id),
-            });
-        }
-        if (!target.webSocketDebuggerUrl) {
-            return makeError('CDP_CONNECT_FAILED', 'Selected CDP target has no websocket debugger URL', { targetId: target.id });
-        }
-        const wsClient = new SimpleWebSocketClient();
-        try {
-            await wsClient.connect(target.webSocketDebuggerUrl);
-        }
-        catch (error) {
-            return makeError('CDP_CONNECT_FAILED', `Failed to connect to CDP websocket: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        const sessionId = randomUUID();
-        const session = {
-            id: sessionId,
-            wsClient,
-            nextMessageId: 0,
-            pending: new Map(),
-            host,
-            port,
-            target,
-        };
-        this.bindSessionHandlers(session);
-        this.sessions.set(sessionId, session);
-        try {
-            await this.sendCommand(session, 'Runtime.enable');
-            await this.sendCommand(session, 'Page.enable');
-        }
-        catch (error) {
-            wsClient.close();
-            this.sessions.delete(sessionId);
-            return makeError('CDP_CONNECT_FAILED', `Failed to initialize CDP domains: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        return {
-            ok: true,
-            data: {
-                sessionId,
-                host,
-                port,
-                targetId: target.id,
-                targetTitle: target.title,
-                targetUrl: target.url,
-                availableTargets: candidateTargets.map((item) => ({
-                    id: item.id,
-                    title: item.title,
-                    url: item.url,
-                    type: item.type,
-                })),
-            },
-        };
-    }
-    async evaluate(args) {
-        const session = this.sessions.get(args.sessionId);
-        if (!session) {
-            return makeError('CDP_NOT_CONNECTED', `Unknown CDP session: ${args.sessionId}`);
-        }
-        try {
-            const result = await this.sendCommand(session, 'Runtime.evaluate', {
-                expression: args.expression,
-                returnByValue: args.returnByValue ?? true,
-                awaitPromise: args.awaitPromise ?? true,
-            }, 12000);
-            if (result?.exceptionDetails) {
-                return makeError('CDP_CALL_FAILED', String(result.exceptionDetails?.text || 'Runtime.evaluate failed'));
-            }
-            return {
-                ok: true,
-                data: {
-                    result: result?.result?.value ?? result?.result,
-                    type: result?.result?.type,
-                    subtype: result?.result?.subtype,
-                    description: result?.result?.description,
-                },
-            };
-        }
-        catch (error) {
-            return makeError('CDP_CALL_FAILED', `CDP evaluate failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    async disconnect(sessionId) {
-        const session = this.sessions.get(sessionId);
-        if (!session) {
-            return makeError('CDP_NOT_CONNECTED', `Unknown CDP session: ${sessionId}`);
-        }
-        session.wsClient.close();
-        this.sessions.delete(sessionId);
-        return {
-            ok: true,
-            data: { sessionId },
-        };
-    }
-}
-export const cdpAdapter = new CdpAdapter();

package/dist/tools/macos-control/orchestrator.d.ts

@@ -1,77 +0,0 @@
-import { AxBatchCommand, AxBatchResult, AxElement, MacosControlResult } from './types.js';
-export declare class MacosControlOrchestrator {
-    axStatus(): Promise<MacosControlResult<import("./types.js").AxStatus>>;
-    axListApps(): Promise<MacosControlResult<import("./types.js").AxAppInfo[]>>;
-    axListElements(args: {
-        scope?: 'top_window' | 'app' | 'all';
-        app?: string;
-        text?: string;
-        role?: string;
-        depth?: number;
-        limit?: number;
-    }): Promise<MacosControlResult<AxElement[]>>;
-    axFind(args: {
-        app: string;
-        text?: string;
-        role?: string;
-        index?: number;
-        depth?: number;
-        limit?: number;
-    }): Promise<MacosControlResult<AxElement[]>>;
-    axClick(args: {
-        id?: string;
-        app?: string;
-        text?: string;
-        role?: string;
-        index?: number;
-        depth?: number;
-        limit?: number;
-    }): Promise<MacosControlResult<Record<string, unknown>>>;
-    axGetState(args: {
-        app: string;
-        text?: string;
-        role?: string;
-        index?: number;
-        depth?: number;
-        limit?: number;
-    }): Promise<MacosControlResult<Record<string, unknown>>>;
-    axFindAndClick(args: {
-        app: string;
-        text?: string;
-        role?: string;
-        index?: number;
-        depth?: number;
-        limit?: number;
-        timeout_ms?: number;
-        if_exists?: boolean;
-    }): Promise<MacosControlResult<Record<string, unknown>>>;
-    axType(text: string): Promise<MacosControlResult<Record<string, unknown>>>;
-    axKey(key: string, modifiers?: string[]): Promise<MacosControlResult<Record<string, unknown>>>;
-    axActivate(app: string): Promise<MacosControlResult<Record<string, unknown>>>;
-    axWaitFor(args: {
-        app: string;
-        text: string;
-        role?: string;
-        timeout_ms?: number;
-        depth?: number;
-    }): Promise<MacosControlResult<AxElement>>;
-    axBatch(commands: AxBatchCommand[], stopOnError?: boolean): Promise<MacosControlResult<AxBatchResult>>;
-    electronDebugAttach(args: {
-        host?: string;
-        port?: number;
-        targetIndex?: number;
-        targetId?: string;
-    }): Promise<MacosControlResult<import("./types.js").ElectronDebugAttachResult>>;
-    electronDebugEval(args: {
-        sessionId: string;
-        expression: string;
-        returnByValue?: boolean;
-        awaitPromise?: boolean;
-    }): Promise<MacosControlResult<import("./types.js").ElectronDebugEvalResult>>;
-    electronDebugDisconnect(args: {
-        sessionId: string;
-    }): Promise<MacosControlResult<{
-        sessionId: string;
-    }>>;
-}
-export declare const macosControlOrchestrator: MacosControlOrchestrator;

package/dist/tools/macos-control/orchestrator.js

@@ -1,136 +0,0 @@
-import { axAdapter } from './ax-adapter.js';
-import { cdpAdapter } from './cdp-adapter.js';
-function fail(code, message) {
-    return {
-        ok: false,
-        error: {
-            code: code,
-            message,
-        },
-    };
-}
-function isMacOS() {
-    return process.platform === 'darwin';
-}
-export class MacosControlOrchestrator {
-    async axStatus() {
-        return axAdapter.status();
-    }
-    async axListApps() {
-        return axAdapter.listApps();
-    }
-    async axListElements(args) {
-        return axAdapter.listElements(args);
-    }
-    async axFind(args) {
-        return axAdapter.find(args);
-    }
-    async axClick(args) {
-        if (args.id) {
-            return axAdapter.clickById(args.id, args.app);
-        }
-        if (!args.app || !args.text) {
-            return fail('INVALID_ARGUMENT', 'Provide either id or app+text for macos_ax_click');
-        }
-        const found = await axAdapter.find({
-            app: args.app,
-            text: args.text,
-            role: args.role,
-            depth: args.depth,
-            limit: args.limit,
-            index: args.index,
-        });
-        if (!found.ok) {
-            return {
-                ok: false,
-                error: found.error,
-            };
-        }
-        const target = found.data?.[0];
-        if (!target) {
-            return fail('NOT_FOUND', `No element matched text "${args.text}" in ${args.app}`);
-        }
-        return axAdapter.clickById(target.id, args.app);
-    }
-    async axGetState(args) {
-        return axAdapter.getState(args);
-    }
-    async axFindAndClick(args) {
-        const timeoutMs = args.timeout_ms ?? 0;
-        if (timeoutMs > 0 && args.text) {
-            const waited = await this.axWaitFor({
-                app: args.app,
-                text: args.text,
-                role: args.role,
-                timeout_ms: timeoutMs,
-                depth: args.depth,
-            });
-            if (!waited.ok) {
-                if (args.if_exists && waited.error?.code === 'TIMEOUT') {
-                    return { ok: true, data: { skipped: true } };
-                }
-                return { ok: false, error: waited.error };
-            }
-        }
-        const found = await this.axFind({
-            app: args.app,
-            text: args.text,
-            role: args.role,
-            index: args.index,
-            depth: args.depth,
-            limit: args.limit,
-        });
-        if (!found.ok) {
-            if (args.if_exists && found.error?.code === 'NOT_FOUND') {
-                return { ok: true, data: { skipped: true } };
-            }
-            return { ok: false, error: found.error };
-        }
-        const element = found.data?.[0];
-        if (!element) {
-            if (args.if_exists) {
-                return { ok: true, data: { skipped: true } };
-            }
-            return fail('NOT_FOUND', `No element matched criteria in ${args.app}`);
-        }
-        const clickResult = await axAdapter.clickById(element.id, args.app);
-        if (!clickResult.ok) {
-            return { ok: false, error: clickResult.error };
-        }
-        return {
-            ok: true,
-            data: {
-                element,
-                click_result: clickResult.data,
-            },
-        };
-    }
-    async axType(text) {
-        return axAdapter.typeText(text);
-    }
-    async axKey(key, modifiers = []) {
-        return axAdapter.pressKey(key, modifiers);
-    }
-    async axActivate(app) {
-        return axAdapter.activate(app);
-    }
-    async axWaitFor(args) {
-        return axAdapter.waitFor(args);
-    }
-    async axBatch(commands, stopOnError = true) {
-        if (!isMacOS()) {
-            return fail('UNSUPPORTED_PLATFORM', 'macOS control tools are only available on macOS.');
-        }
-        return axAdapter.batch(commands, stopOnError);
-    }
-    async electronDebugAttach(args) {
-        return cdpAdapter.attach(args);
-    }
-    async electronDebugEval(args) {
-        return cdpAdapter.evaluate(args);
-    }
-    async electronDebugDisconnect(args) {
-        return cdpAdapter.disconnect(args.sessionId);
-    }
-}
-export const macosControlOrchestrator = new MacosControlOrchestrator();

package/dist/tools/macos-control/role-aliases.d.ts

@@ -1,5 +0,0 @@
-export declare const ROLE_ALIASES: Record<string, string[]>;
-/**
- * Expands aliases like "toggle" or "axswitch" into concrete AX roles.
- */
-export declare function expandRoleAlias(role?: string | null): string[] | undefined;

package/dist/tools/macos-control/role-aliases.js

@@ -1,34 +0,0 @@
-export const ROLE_ALIASES = {
-    toggle: ['AXSwitch', 'AXCheckBox', 'AXToggle'],
-    switch: ['AXSwitch', 'AXCheckBox', 'AXToggle'],
-    button: ['AXButton', 'AXToolbarButton', 'AXMenuButton'],
-    text: ['AXTextField', 'AXTextArea', 'AXSearchField'],
-    input: ['AXTextField', 'AXTextArea', 'AXSearchField', 'AXSecureTextField'],
-    menu: ['AXMenuItem', 'AXMenuBarItem'],
-    link: ['AXLink', 'AXButton'],
-    row: ['AXRow', 'AXCell'],
-    list: ['AXList', 'AXOutline', 'AXTable'],
-};
-/**
- * Expands aliases like "toggle" or "axswitch" into concrete AX roles.
- */
-export function expandRoleAlias(role) {
-    if (!role) {
-        return undefined;
-    }
-    const trimmed = role.trim();
-    if (!trimmed) {
-        return undefined;
-    }
-    const lower = trimmed.toLowerCase();
-    if (ROLE_ALIASES[lower]) {
-        return ROLE_ALIASES[lower];
-    }
-    if (lower.startsWith('ax')) {
-        const withoutPrefix = lower.slice(2);
-        if (ROLE_ALIASES[withoutPrefix]) {
-            return ROLE_ALIASES[withoutPrefix];
-        }
-    }
-    return [trimmed];
-}