mobile-debug-mcp 0.23.0 → 0.24.0

package/dist/server/tool-handlers.js

@@ -0,0 +1,320 @@
+import { AndroidManage, iOSManage, ToolsManage } from '../manage/index.js';
+import { ToolsInteract } from '../interact/index.js';
+import { ToolsObserve } from '../observe/index.js';
+import { classifyActionOutcome } from '../interact/classify.js';
+import { ToolsNetwork } from '../network/index.js';
+import { getSystemStatus } from '../system/index.js';
+import { buildActionExecutionResult, captureActionFingerprint, inferGenericFailure, inferScrollFailure, wrapResponse } from './common.js';
+async function handleStartApp(args) {
+    const { platform, appId, deviceId } = args;
+    const uiFingerprintBefore = await captureActionFingerprint(platform, deviceId);
+    ToolsNetwork.notifyActionStart();
+    const res = await (platform === 'android' ? new AndroidManage().startApp(appId, deviceId) : new iOSManage().startApp(appId, deviceId));
+    const uiFingerprintAfter = await captureActionFingerprint(platform, deviceId);
+    return wrapResponse(buildActionExecutionResult({
+        actionType: 'start_app',
+        selector: { appId },
+        success: !!res.appStarted,
+        uiFingerprintBefore,
+        uiFingerprintAfter,
+        failure: res.appStarted ? undefined : inferGenericFailure(res.error)
+    }));
+}
+async function handleTerminateApp(args) {
+    const { platform, appId, deviceId } = args;
+    const res = await (platform === 'android' ? new AndroidManage().terminateApp(appId, deviceId) : new iOSManage().terminateApp(appId, deviceId));
+    const response = { device: res.device, appTerminated: res.appTerminated };
+    return wrapResponse(response);
+}
+async function handleRestartApp(args) {
+    const { platform, appId, deviceId } = args;
+    const uiFingerprintBefore = await captureActionFingerprint(platform, deviceId);
+    ToolsNetwork.notifyActionStart();
+    const res = await (platform === 'android' ? new AndroidManage().restartApp(appId, deviceId) : new iOSManage().restartApp(appId, deviceId));
+    const uiFingerprintAfter = await captureActionFingerprint(platform, deviceId);
+    return wrapResponse(buildActionExecutionResult({
+        actionType: 'restart_app',
+        selector: { appId },
+        success: !!res.appRestarted,
+        uiFingerprintBefore,
+        uiFingerprintAfter,
+        failure: res.appRestarted ? undefined : inferGenericFailure(res.error)
+    }));
+}
+async function handleResetAppData(args) {
+    const { platform, appId, deviceId } = args;
+    const res = await (platform === 'android' ? new AndroidManage().resetAppData(appId, deviceId) : new iOSManage().resetAppData(appId, deviceId));
+    const response = { device: res.device, dataCleared: res.dataCleared };
+    return wrapResponse(response);
+}
+async function handleInstallApp(args) {
+    const { platform, projectType, appPath, deviceId } = args;
+    const res = await ToolsManage.installAppHandler({ platform, appPath, deviceId, projectType });
+    const response = {
+        device: res.device,
+        installed: res.installed,
+        output: res.output,
+        error: res.error
+    };
+    return wrapResponse(response);
+}
+async function handleBuildApp(args) {
+    const { platform, projectType, projectPath, variant } = args;
+    const res = await ToolsManage.buildAppHandler({ platform, projectPath, variant, projectType });
+    return wrapResponse(res);
+}
+async function handleBuildAndInstall(args) {
+    const { platform, projectType, projectPath, deviceId, timeout } = args;
+    const res = await ToolsManage.buildAndInstallHandler({ platform, projectPath, deviceId, timeout, projectType });
+    return {
+        content: [
+            { type: 'text', text: res.ndjson },
+            { type: 'text', text: JSON.stringify(res.result, null, 2) }
+        ]
+    };
+}
+async function handleGetLogs(args) {
+    const { platform, appId, deviceId, pid, tag, level, contains, since_seconds, limit, lines } = args;
+    const res = await ToolsObserve.getLogsHandler({ platform, appId, deviceId, pid, tag, level, contains, since_seconds, limit, lines });
+    const filtered = !!(pid || tag || level || contains || since_seconds || appId);
+    return {
+        content: [
+            { type: 'text', text: JSON.stringify({ device: res.device, result: { count: res.logCount, filtered, crashLines: (res.crashLines || []), source: res.source, meta: res.meta || {} } }, null, 2) },
+            { type: 'text', text: JSON.stringify({ logs: res.logs }, null, 2) }
+        ]
+    };
+}
+async function handleListDevices(args) {
+    const { platform, appId } = args;
+    const res = await ToolsManage.listDevicesHandler({ platform, appId });
+    return wrapResponse(res);
+}
+async function handleGetSystemStatus() {
+    const result = await getSystemStatus();
+    return wrapResponse(result);
+}
+async function handleCaptureScreenshot(args) {
+    const { platform, deviceId } = args;
+    const res = await ToolsObserve.captureScreenshotHandler({ platform, deviceId });
+    const mime = res.screenshot_mime || 'image/png';
+    const content = [
+        { type: 'text', text: JSON.stringify({ device: res.device, result: { resolution: res.resolution, mimeType: mime } }, null, 2) },
+        { type: 'image', data: res.screenshot, mimeType: mime }
+    ];
+    if (res.screenshot_fallback) {
+        content.push({ type: 'text', text: JSON.stringify({ note: 'JPEG fallback included for compatibility', mimeType: res.screenshot_fallback_mime || 'image/jpeg' }) });
+        content.push({ type: 'image', data: res.screenshot_fallback, mimeType: res.screenshot_fallback_mime || 'image/jpeg' });
+    }
+    return { content };
+}
+async function handleCaptureDebugSnapshot(args) {
+    const { reason, includeLogs, logLines, platform, appId, deviceId, sessionId } = args;
+    const res = await ToolsObserve.captureDebugSnapshotHandler({ reason, includeLogs, logLines, platform, appId, deviceId, sessionId });
+    return wrapResponse(res);
+}
+async function handleGetUITree(args) {
+    const { platform, deviceId } = args;
+    const res = await ToolsObserve.getUITreeHandler({ platform, deviceId });
+    return wrapResponse(res);
+}
+async function handleGetCurrentScreen(args) {
+    const { deviceId } = args;
+    const res = await ToolsObserve.getCurrentScreenHandler({ deviceId });
+    return wrapResponse(res);
+}
+async function handleGetScreenFingerprint(args) {
+    const { platform, deviceId } = args;
+    const res = await ToolsObserve.getScreenFingerprintHandler({ platform, deviceId });
+    return wrapResponse(res);
+}
+async function handleWaitForScreenChange(args) {
+    const { platform, previousFingerprint, timeoutMs, pollIntervalMs, deviceId } = args;
+    const res = await ToolsInteract.waitForScreenChangeHandler({ platform, previousFingerprint, timeoutMs, pollIntervalMs, deviceId });
+    return wrapResponse(res);
+}
+async function handleExpectScreen(args) {
+    const { platform, fingerprint, screen, deviceId } = args;
+    const res = await ToolsInteract.expectScreenHandler({ platform, fingerprint, screen, deviceId });
+    return wrapResponse(res);
+}
+async function handleExpectElementVisible(args) {
+    const { selector, element_id, timeout_ms, poll_interval_ms, platform, deviceId } = args;
+    const res = await ToolsInteract.expectElementVisibleHandler({ selector, element_id, timeout_ms, poll_interval_ms, platform, deviceId });
+    return wrapResponse(res);
+}
+async function handleWaitForUI(args) {
+    const { selector, condition = 'exists', timeout_ms = 60000, poll_interval_ms = 300, match, retry, platform, deviceId } = args;
+    const res = await ToolsInteract.waitForUIHandler({ selector, condition, timeout_ms, poll_interval_ms, match, retry, platform, deviceId });
+    return wrapResponse(res);
+}
+async function handleFindElement(args) {
+    const { query, exact = false, timeoutMs = 3000, platform, deviceId } = args;
+    const res = await ToolsInteract.findElementHandler({ query, exact, timeoutMs, platform, deviceId });
+    return wrapResponse(res);
+}
+async function handleTap(args) {
+    const { platform, x, y, deviceId } = args;
+    const uiFingerprintBefore = await captureActionFingerprint(platform, deviceId);
+    ToolsNetwork.notifyActionStart();
+    const res = await ToolsInteract.tapHandler({ platform, x, y, deviceId });
+    const uiFingerprintAfter = await captureActionFingerprint(platform, deviceId);
+    return wrapResponse(buildActionExecutionResult({
+        actionType: 'tap',
+        selector: { x, y },
+        success: !!res.success,
+        uiFingerprintBefore,
+        uiFingerprintAfter,
+        failure: res.success ? undefined : inferGenericFailure(res.error)
+    }));
+}
+async function handleTapElement(args) {
+    const { elementId } = args;
+    ToolsNetwork.notifyActionStart();
+    const res = await ToolsInteract.tapElementHandler({ elementId });
+    return wrapResponse(res);
+}
+async function handleSwipe(args) {
+    const { platform = 'android', x1, y1, x2, y2, duration, deviceId } = args;
+    const uiFingerprintBefore = await captureActionFingerprint(platform, deviceId);
+    ToolsNetwork.notifyActionStart();
+    const res = await ToolsInteract.swipeHandler({ platform, x1, y1, x2, y2, duration, deviceId });
+    const uiFingerprintAfter = await captureActionFingerprint(platform, deviceId);
+    return wrapResponse(buildActionExecutionResult({
+        actionType: 'swipe',
+        selector: { x1, y1, x2, y2, duration },
+        success: !!res.success,
+        uiFingerprintBefore,
+        uiFingerprintAfter,
+        failure: res.success ? undefined : inferGenericFailure(res.error)
+    }));
+}
+async function handleScrollToElement(args) {
+    const { platform, selector, direction, maxScrolls, scrollAmount, deviceId } = args;
+    const uiFingerprintBefore = await captureActionFingerprint(platform, deviceId);
+    ToolsNetwork.notifyActionStart();
+    const res = await ToolsInteract.scrollToElementHandler({ platform, selector, direction, maxScrolls, scrollAmount, deviceId });
+    const uiFingerprintAfter = await captureActionFingerprint(platform, deviceId);
+    return wrapResponse(buildActionExecutionResult({
+        actionType: 'scroll_to_element',
+        selector,
+        resolved: res?.success && res?.element ? {
+            elementId: null,
+            text: res.element.text ?? null,
+            resource_id: res.element.resourceId ?? null,
+            accessibility_id: res.element.contentDesc ?? null,
+            class: res.element.className ?? null,
+            bounds: res.element.bounds ?? null,
+            index: null
+        } : null,
+        success: !!res.success,
+        uiFingerprintBefore,
+        uiFingerprintAfter,
+        failure: res.success ? undefined : inferScrollFailure(res.reason)
+    }));
+}
+async function handleTypeText(args) {
+    const { text, deviceId } = args;
+    const uiFingerprintBefore = await captureActionFingerprint('android', deviceId);
+    ToolsNetwork.notifyActionStart();
+    const res = await ToolsInteract.typeTextHandler({ text, deviceId });
+    const uiFingerprintAfter = await captureActionFingerprint('android', deviceId);
+    return wrapResponse(buildActionExecutionResult({
+        actionType: 'type_text',
+        selector: { text },
+        success: !!res.success,
+        uiFingerprintBefore,
+        uiFingerprintAfter,
+        failure: res.success ? undefined : inferGenericFailure(res.error)
+    }));
+}
+async function handlePressBack(args) {
+    const { deviceId } = args;
+    const uiFingerprintBefore = await captureActionFingerprint('android', deviceId);
+    ToolsNetwork.notifyActionStart();
+    const res = await ToolsInteract.pressBackHandler({ deviceId });
+    const uiFingerprintAfter = await captureActionFingerprint('android', deviceId);
+    return wrapResponse(buildActionExecutionResult({
+        actionType: 'press_back',
+        selector: { key: 'back' },
+        success: !!res.success,
+        uiFingerprintBefore,
+        uiFingerprintAfter,
+        failure: res.success ? undefined : inferGenericFailure(res.error)
+    }));
+}
+async function handleStartLogStream(args) {
+    const { platform, packageName, level, sessionId, deviceId } = args;
+    const res = await ToolsObserve.startLogStreamHandler({ platform, packageName, level, sessionId, deviceId });
+    return wrapResponse(res);
+}
+async function handleReadLogStream(args) {
+    const { platform, sessionId, limit, since } = args;
+    const res = await ToolsObserve.readLogStreamHandler({ platform, sessionId, limit, since });
+    return wrapResponse(res);
+}
+async function handleStopLogStream(args) {
+    const { platform, sessionId } = args;
+    const res = await ToolsObserve.stopLogStreamHandler({ platform, sessionId });
+    return wrapResponse(res);
+}
+function handleClassifyActionOutcome(args) {
+    const { uiChanged, expectedElementVisible, networkRequests, hasLogErrors } = args;
+    const result = classifyActionOutcome({
+        uiChanged: Boolean(uiChanged),
+        expectedElementVisible: expectedElementVisible ?? null,
+        networkRequests: networkRequests ?? null,
+        hasLogErrors: hasLogErrors ?? null
+    });
+    return Promise.resolve(wrapResponse(result));
+}
+async function handleGetNetworkActivity(args) {
+    const { platform, deviceId } = args;
+    const result = await ToolsNetwork.getNetworkActivity({ platform, deviceId });
+    return wrapResponse(result);
+}
+export const toolHandlers = {
+    start_app: handleStartApp,
+    terminate_app: handleTerminateApp,
+    restart_app: handleRestartApp,
+    reset_app_data: handleResetAppData,
+    install_app: handleInstallApp,
+    build_app: handleBuildApp,
+    build_and_install: handleBuildAndInstall,
+    get_logs: handleGetLogs,
+    list_devices: handleListDevices,
+    get_system_status: handleGetSystemStatus,
+    capture_screenshot: handleCaptureScreenshot,
+    capture_debug_snapshot: handleCaptureDebugSnapshot,
+    get_ui_tree: handleGetUITree,
+    get_current_screen: handleGetCurrentScreen,
+    get_screen_fingerprint: handleGetScreenFingerprint,
+    wait_for_screen_change: handleWaitForScreenChange,
+    expect_screen: handleExpectScreen,
+    expect_element_visible: handleExpectElementVisible,
+    wait_for_ui: handleWaitForUI,
+    find_element: handleFindElement,
+    tap: handleTap,
+    tap_element: handleTapElement,
+    swipe: handleSwipe,
+    scroll_to_element: handleScrollToElement,
+    type_text: handleTypeText,
+    press_back: handlePressBack,
+    start_log_stream: handleStartLogStream,
+    read_log_stream: handleReadLogStream,
+    stop_log_stream: handleStopLogStream,
+    classify_action_outcome: handleClassifyActionOutcome,
+    get_network_activity: handleGetNetworkActivity
+};
+export async function handleToolCall(name, args = {}) {
+    const handler = toolHandlers[name];
+    if (!handler)
+        throw new Error(`Unknown tool: ${name}`);
+    try {
+        return await handler(args);
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Error executing tool ${name}: ${error instanceof Error ? error.message : String(error)}` }]
+        };
+    }
+}