preflight-ios-mcp 1.0.0

package/dist/tools/device.js

@@ -0,0 +1,130 @@
+import { z } from 'zod';
+import { execSimctl, listDevices, resolveDevice } from '../helpers/simctl.js';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+// --- list_devices ---
+export const listDevicesParams = {
+    filter: z.enum(['available', 'booted', 'all']).optional().describe('Filter devices (default: all)'),
+};
+export async function handleListDevices(args) {
+    const filter = (args.filter || 'all');
+    const devices = await listDevices(filter);
+    const lines = devices.map(d => {
+        const runtime = d.runtime
+            .replace(/^com\.apple\.CoreSimulator\.SimRuntime\./, '')
+            .replace(/-/g, ' ');
+        return `${d.name} | ${d.udid} | ${d.state} | ${runtime}`;
+    });
+    return {
+        content: [{
+                type: 'text',
+                text: devices.length === 0
+                    ? `No ${filter === 'all' ? '' : filter + ' '}devices found.`
+                    : `Found ${devices.length} device(s):\n\nName | UDID | State | Runtime\n---|---|---|---\n${lines.join('\n')}`,
+            }],
+    };
+}
+// --- boot ---
+export const bootParams = {
+    deviceId: z.string().describe('Device UDID or name to boot'),
+    waitForBoot: z.boolean().optional().describe('Wait until device is fully booted before returning (default: true)'),
+};
+export async function handleBoot(args) {
+    const devices = await listDevices();
+    const match = devices.find(d => d.name.toLowerCase() === args.deviceId.toLowerCase() ||
+        d.udid === args.deviceId);
+    if (!match) {
+        const available = devices.filter(d => d.isAvailable && d.runtime.includes('iOS'));
+        const suggestions = available.slice(0, 5).map(d => `  - ${d.name}`).join('\n');
+        throw new Error(`Device "${args.deviceId}" not found.\n\nAvailable iOS devices:\n${suggestions}`);
+    }
+    if (match.state === 'Booted') {
+        return { content: [{ type: 'text', text: `${match.name} is already booted.` }] };
+    }
+    await execSimctl(['boot', match.udid], 'tool:boot');
+    // Open Simulator.app so the window appears
+    try {
+        await execFileAsync('open', ['-a', 'Simulator']);
+    }
+    catch { /* not critical */ }
+    // Wait for boot to complete (default: true)
+    const shouldWait = args.waitForBoot !== false;
+    if (shouldWait) {
+        const maxWaitMs = 60000;
+        const startTime = Date.now();
+        let booted = false;
+        while (Date.now() - startTime < maxWaitMs) {
+            await new Promise(r => setTimeout(r, 2000));
+            const updated = await listDevices('booted');
+            if (updated.some(d => d.udid === match.udid)) {
+                booted = true;
+                break;
+            }
+        }
+        if (!booted) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Booted ${match.name} but it didn't reach Booted state within 60s. It may still be starting up.`,
+                    }],
+            };
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Booted ${match.name} (${match.udid}) — ready. Simulator.app is open.`,
+                }],
+        };
+    }
+    return {
+        content: [{
+                type: 'text',
+                text: `Booted ${match.name} (${match.udid}). Simulator.app should be opening.`,
+            }],
+    };
+}
+// --- shutdown ---
+export const shutdownParams = {
+    deviceId: z.string().optional().describe('Device UDID, name, or "booted" (default: booted)'),
+};
+export async function handleShutdown(args) {
+    const device = await resolveDevice(args.deviceId);
+    await execSimctl(['shutdown', device], 'tool:shutdown');
+    return { content: [{ type: 'text', text: `Device shut down successfully.` }] };
+}
+// --- erase ---
+export const eraseParams = {
+    deviceId: z.string().describe('Device UDID or name to erase (factory reset)'),
+};
+export async function handleErase(args) {
+    const device = await resolveDevice(args.deviceId);
+    await execSimctl(['erase', device], 'tool:erase');
+    return { content: [{ type: 'text', text: `Device erased (factory reset) successfully.` }] };
+}
+// --- open_url ---
+export const openUrlParams = {
+    url: z.string().describe('URL or deep link to open (e.g., "https://example.com" or "myapp://path")'),
+    deviceId: z.string().optional().describe('Device UDID, name, or "booted" (default: booted)'),
+};
+export async function handleOpenUrl(args) {
+    const device = await resolveDevice(args.deviceId);
+    await execSimctl(['openurl', device, args.url], 'tool:openUrl');
+    return { content: [{ type: 'text', text: `Opened URL: ${args.url}` }] };
+}
+// --- open_simulator ---
+export const openSimulatorParams = {};
+export async function handleOpenSimulator() {
+    await execFileAsync('open', ['-a', 'Simulator']);
+    return { content: [{ type: 'text', text: 'Simulator.app opened.' }] };
+}
+// --- get_booted_sim_id ---
+export const getBootedSimIdParams = {};
+export async function handleGetBootedSimId() {
+    const devices = await listDevices('booted');
+    if (devices.length === 0) {
+        return { content: [{ type: 'text', text: 'No booted simulator found.' }] };
+    }
+    const d = devices[0];
+    return { content: [{ type: 'text', text: d.udid }] };
+}

package/dist/tools/interaction.d.ts

@@ -0,0 +1,101 @@
+import { z } from 'zod';
+export declare const tapParams: {
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    duration: z.ZodOptional<z.ZodNumber>;
+    deviceId: z.ZodOptional<z.ZodString>;
+};
+export declare function handleTap(args: {
+    x: number;
+    y: number;
+    duration?: number;
+    deviceId?: string;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare const swipeParams: {
+    startX: z.ZodNumber;
+    startY: z.ZodNumber;
+    endX: z.ZodNumber;
+    endY: z.ZodNumber;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    delta: z.ZodOptional<z.ZodNumber>;
+    deviceId: z.ZodOptional<z.ZodString>;
+};
+export declare function handleSwipe(args: {
+    startX: number;
+    startY: number;
+    endX: number;
+    endY: number;
+    durationMs?: number;
+    delta?: number;
+    deviceId?: string;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare const longPressParams: {
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    deviceId: z.ZodOptional<z.ZodString>;
+};
+export declare function handleLongPress(args: {
+    x: number;
+    y: number;
+    durationMs?: number;
+    deviceId?: string;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare const describePointParams: {
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    deviceId: z.ZodOptional<z.ZodString>;
+};
+export declare function handleDescribePoint(args: {
+    x: number;
+    y: number;
+    deviceId?: string;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare const typeTextParams: {
+    text: z.ZodString;
+    deviceId: z.ZodOptional<z.ZodString>;
+};
+export declare function handleTypeText(args: {
+    text: string;
+    deviceId?: string;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare const pressKeyParams: {
+    key: z.ZodString;
+    modifiers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    deviceId: z.ZodOptional<z.ZodString>;
+};
+export declare function handlePressKey(args: {
+    key: string;
+    modifiers?: string[];
+    deviceId?: string;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/tools/interaction.js

@@ -0,0 +1,159 @@
+import { z } from 'zod';
+import { resolveDevice } from '../helpers/simctl.js';
+import { getScreenMapping, simToMac } from '../helpers/coordinate-mapper.js';
+import * as applescript from '../helpers/applescript.js';
+import * as idb from '../helpers/idb.js';
+// --- tap ---
+export const tapParams = {
+    x: z.number().describe('X coordinate in simulator screen points'),
+    y: z.number().describe('Y coordinate in simulator screen points'),
+    duration: z.number().optional().describe('Press duration in seconds (decimal allowed, e.g. 0.5). Default: normal tap'),
+    deviceId: z.string().optional().describe('Device UDID, name, or "booted" (default: booted)'),
+};
+export async function handleTap(args) {
+    const device = await resolveDevice(args.deviceId);
+    if (await idb.checkIdbAvailable()) {
+        await idb.idbTap(args.x, args.y, device, args.duration);
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Tapped at (${args.x}, ${args.y})${args.duration ? ` for ${args.duration}s` : ''} via idb [cursor-free]`,
+                }],
+        };
+    }
+    // CGEvent fallback: map sim coords → macOS screen coords
+    const mapping = await getScreenMapping(device);
+    const { macX, macY } = simToMac(args.x, args.y, mapping);
+    if (args.duration && args.duration > 0.3) {
+        await applescript.longPress(macX, macY, args.duration * 1000);
+    }
+    else {
+        await applescript.tap(macX, macY);
+    }
+    return {
+        content: [{
+                type: 'text',
+                text: `Tapped at (${args.x}, ${args.y})${args.duration ? ` for ${args.duration}s` : ''} [CGEvent fallback]`,
+            }],
+    };
+}
+// --- swipe ---
+export const swipeParams = {
+    startX: z.number().describe('Start X in simulator screen points. Use 1 to trigger iOS left-edge-swipe-back gesture (iOS recognizes edge touches within ~20pt of edge)'),
+    startY: z.number().describe('Start Y in simulator screen points'),
+    endX: z.number().describe('End X in simulator screen points'),
+    endY: z.number().describe('End Y in simulator screen points'),
+    durationMs: z.number().optional().describe('Swipe duration in milliseconds (default: 300). Use 400-600ms for edge-swipe-back'),
+    delta: z.number().optional().describe('Step size in pixels between each touch point (idb only, default: device decides)'),
+    deviceId: z.string().optional().describe('Device UDID, name, or "booted" (default: booted)'),
+};
+export async function handleSwipe(args) {
+    const device = await resolveDevice(args.deviceId);
+    const duration = args.durationMs || 300;
+    if (await idb.checkIdbAvailable()) {
+        await idb.idbSwipe(args.startX, args.startY, args.endX, args.endY, duration, device, args.delta);
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Swiped from (${args.startX},${args.startY}) to (${args.endX},${args.endY}) via idb [cursor-free]`,
+                }],
+        };
+    }
+    // CGEvent fallback
+    const mapping = await getScreenMapping(device);
+    const from = simToMac(args.startX, args.startY, mapping);
+    const to = simToMac(args.endX, args.endY, mapping);
+    await applescript.swipe(from.macX, from.macY, to.macX, to.macY, duration);
+    return {
+        content: [{
+                type: 'text',
+                text: `Swiped from (${args.startX},${args.startY}) to (${args.endX},${args.endY}) [CGEvent fallback]`,
+            }],
+    };
+}
+// --- long_press ---
+export const longPressParams = {
+    x: z.number().describe('X coordinate in simulator screen points'),
+    y: z.number().describe('Y coordinate in simulator screen points'),
+    durationMs: z.number().optional().describe('Press duration in milliseconds (default: 1000)'),
+    deviceId: z.string().optional().describe('Device UDID, name, or "booted" (default: booted)'),
+};
+export async function handleLongPress(args) {
+    const device = await resolveDevice(args.deviceId);
+    const duration = args.durationMs || 1000;
+    if (await idb.checkIdbAvailable()) {
+        await idb.idbLongPress(args.x, args.y, duration, device);
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Long pressed at (${args.x}, ${args.y}) for ${duration}ms via idb [cursor-free]`,
+                }],
+        };
+    }
+    // CGEvent fallback
+    const mapping = await getScreenMapping(device);
+    const { macX, macY } = simToMac(args.x, args.y, mapping);
+    await applescript.longPress(macX, macY, duration);
+    return {
+        content: [{
+                type: 'text',
+                text: `Long pressed at (${args.x}, ${args.y}) for ${duration}ms [CGEvent fallback]`,
+            }],
+    };
+}
+// --- describe_point ---
+export const describePointParams = {
+    x: z.number().describe('X coordinate in simulator screen points'),
+    y: z.number().describe('Y coordinate in simulator screen points'),
+    deviceId: z.string().optional().describe('Device UDID, name, or "booted" (default: booted)'),
+};
+export async function handleDescribePoint(args) {
+    const device = await resolveDevice(args.deviceId);
+    if (await idb.checkIdbAvailable()) {
+        const output = await idb.idbDescribePoint(args.x, args.y, device);
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Accessibility element at (${args.x}, ${args.y}):\n\n${output}`,
+                }],
+        };
+    }
+    return {
+        content: [{
+                type: 'text',
+                text: 'describe_point requires idb. Install: brew tap facebook/fb && brew install idb-companion && pip3 install fb-idb',
+            }],
+    };
+}
+// --- type_text ---
+export const typeTextParams = {
+    text: z.string().describe('Text to type into the currently focused field'),
+    deviceId: z.string().optional().describe('Device UDID, name, or "booted" (default: booted)'),
+};
+export async function handleTypeText(args) {
+    await resolveDevice(args.deviceId); // validate device is booted
+    await applescript.typeText(args.text);
+    return {
+        content: [{
+                type: 'text',
+                text: `Typed "${args.text.slice(0, 100)}${args.text.length > 100 ? '...' : ''}"`,
+            }],
+    };
+}
+// --- press_key ---
+export const pressKeyParams = {
+    key: z.string().describe('Key name: return, escape, delete, tab, space, up, down, left, right, home, end, pageup, pagedown, f1-f12'),
+    modifiers: z.array(z.string()).optional().describe('Modifier keys: command, shift, option, control'),
+    deviceId: z.string().optional().describe('Device UDID, name, or "booted" (default: booted)'),
+};
+export async function handlePressKey(args) {
+    await resolveDevice(args.deviceId);
+    await applescript.pressKey(args.key, args.modifiers || []);
+    const modStr = args.modifiers?.length ? `${args.modifiers.join('+')}+` : '';
+    return {
+        content: [{
+                type: 'text',
+                text: `Pressed ${modStr}${args.key}`,
+            }],
+    };
+}

package/dist/tools/playwright.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Playwright-inspired tools for iOS Simulator.
+ * Adds structured accessibility snapshots, element waiting, and element search
+ * to match the workflow patterns of Playwright MCP for web automation.
+ */
+import { z } from 'zod';
+export declare const snapshotParams: {
+    deviceId: z.ZodOptional<z.ZodString>;
+};
+export declare function handleSnapshot(args: {
+    deviceId?: string;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare const waitForElementParams: {
+    label: z.ZodOptional<z.ZodString>;
+    role: z.ZodOptional<z.ZodString>;
+    text: z.ZodOptional<z.ZodString>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    pollIntervalMs: z.ZodOptional<z.ZodNumber>;
+    deviceId: z.ZodOptional<z.ZodString>;
+};
+export declare function handleWaitForElement(args: {
+    label?: string;
+    role?: string;
+    text?: string;
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+    deviceId?: string;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: boolean;
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError?: undefined;
+}>;
+export declare const elementExistsParams: {
+    label: z.ZodOptional<z.ZodString>;
+    role: z.ZodOptional<z.ZodString>;
+    text: z.ZodOptional<z.ZodString>;
+    deviceId: z.ZodOptional<z.ZodString>;
+};
+export declare function handleElementExists(args: {
+    label?: string;
+    role?: string;
+    text?: string;
+    deviceId?: string;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: boolean;
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError?: undefined;
+}>;

package/dist/tools/playwright.js

@@ -0,0 +1,204 @@
+/**
+ * Playwright-inspired tools for iOS Simulator.
+ * Adds structured accessibility snapshots, element waiting, and element search
+ * to match the workflow patterns of Playwright MCP for web automation.
+ */
+import { z } from 'zod';
+import { resolveDevice } from '../helpers/simctl.js';
+import * as idb from '../helpers/idb.js';
+import * as logger from '../helpers/logger.js';
+// --- snapshot (like Playwright's browser_snapshot) ---
+// Returns a structured, LLM-friendly accessibility tree.
+// Preferred over screenshots for understanding page structure.
+export const snapshotParams = {
+    deviceId: z.string().optional().describe('Device (default: booted)'),
+};
+export async function handleSnapshot(args) {
+    const device = await resolveDevice(args.deviceId);
+    if (!(await idb.checkIdbAvailable())) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: 'Snapshot requires idb for the full iOS accessibility tree. Install: brew tap facebook/fb && brew install idb-companion && pip3 install fb-idb\n\nUse simulator_accessibility_audit as a fallback (AppleScript-based, less detail).',
+                }],
+        };
+    }
+    const raw = await idb.idbDescribeAll(device);
+    // Parse idb output into structured format
+    try {
+        const elements = JSON.parse(raw);
+        if (Array.isArray(elements)) {
+            const formatted = formatAccessibilityTree(elements, 0);
+            return {
+                content: [{
+                        type: 'text',
+                        text: `iOS Accessibility Snapshot (${elements.length} root elements):\n\n${formatted}\n\n---\nUse coordinates from the snapshot to interact: simulator_tap, simulator_swipe, etc.`,
+                    }],
+            };
+        }
+    }
+    catch { /* raw output isn't JSON, return as-is */ }
+    // Fallback: return raw idb output
+    const lines = raw.split('\n').filter((l) => l.trim());
+    return {
+        content: [{
+                type: 'text',
+                text: `iOS Accessibility Snapshot (${lines.length} elements):\n\n${raw}\n\n---\nUse coordinates from the snapshot to interact: simulator_tap, simulator_swipe, etc.`,
+            }],
+    };
+}
+/**
+ * Format parsed accessibility elements into a readable tree.
+ */
+function formatAccessibilityTree(elements, depth) {
+    const indent = '  '.repeat(depth);
+    const lines = [];
+    for (const el of elements) {
+        const role = el.role || el.AXRole || '?';
+        const label = el.AXLabel || el.label || el.description || '';
+        const value = el.AXValue || el.value || '';
+        const frame = el.frame || el.AXFrame;
+        let line = `${indent}${role}`;
+        if (label)
+            line += ` "${label}"`;
+        if (value && value !== label)
+            line += ` val="${value}"`;
+        if (frame) {
+            if (typeof frame === 'object') {
+                line += ` @(${Math.round(frame.x)},${Math.round(frame.y)}) ${Math.round(frame.width)}x${Math.round(frame.height)}`;
+            }
+            else if (typeof frame === 'string') {
+                line += ` ${frame}`;
+            }
+        }
+        lines.push(line);
+        // Recurse into children
+        const children = el.children || el.AXChildren;
+        if (Array.isArray(children) && children.length > 0) {
+            lines.push(formatAccessibilityTree(children, depth + 1));
+        }
+    }
+    return lines.join('\n');
+}
+// --- wait_for_element (like Playwright's browser_wait_for) ---
+// Polls the accessibility tree until an element matching the criteria appears.
+export const waitForElementParams = {
+    label: z.string().optional().describe('Wait for element with this accessibility label (case-insensitive partial match)'),
+    role: z.string().optional().describe('Wait for element with this role (e.g., "Button", "TextField", "StaticText")'),
+    text: z.string().optional().describe('Wait for element containing this text in label or value'),
+    timeoutMs: z.number().optional().describe('Max wait time in milliseconds (default: 10000)'),
+    pollIntervalMs: z.number().optional().describe('How often to check in milliseconds (default: 500)'),
+    deviceId: z.string().optional().describe('Device (default: booted)'),
+};
+export async function handleWaitForElement(args) {
+    if (!args.label && !args.role && !args.text) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: 'Provide at least one search criteria: label, role, or text.',
+                }],
+            isError: true,
+        };
+    }
+    const device = await resolveDevice(args.deviceId);
+    if (!(await idb.checkIdbAvailable())) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: 'wait_for_element requires idb. Install: brew tap facebook/fb && brew install idb-companion && pip3 install fb-idb',
+                }],
+        };
+    }
+    const timeout = args.timeoutMs || 10000;
+    const interval = args.pollIntervalMs || 500;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+        try {
+            const raw = await idb.idbDescribeAll(device);
+            const searchStr = raw.toLowerCase();
+            let found = true;
+            if (args.label && !searchStr.includes(args.label.toLowerCase()))
+                found = false;
+            if (args.role && !searchStr.includes(args.role.toLowerCase()))
+                found = false;
+            if (args.text && !searchStr.includes(args.text.toLowerCase()))
+                found = false;
+            if (found) {
+                const elapsed = Date.now() - startTime;
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Element found after ${elapsed}ms. Criteria: ${JSON.stringify({ label: args.label, role: args.role, text: args.text })}`,
+                        }],
+                };
+            }
+        }
+        catch (err) {
+            logger.debug('tool:waitForElement', `Poll error: ${err.message}`);
+        }
+        await new Promise(resolve => setTimeout(resolve, interval));
+    }
+    return {
+        content: [{
+                type: 'text',
+                text: `Timeout after ${timeout}ms. Element not found. Criteria: ${JSON.stringify({ label: args.label, role: args.role, text: args.text })}`,
+            }],
+        isError: true,
+    };
+}
+// --- element_exists ---
+// Quick boolean check: does an element matching criteria exist on screen right now?
+export const elementExistsParams = {
+    label: z.string().optional().describe('Search for element with this accessibility label (case-insensitive partial match)'),
+    role: z.string().optional().describe('Search for element with this role'),
+    text: z.string().optional().describe('Search for element containing this text'),
+    deviceId: z.string().optional().describe('Device (default: booted)'),
+};
+export async function handleElementExists(args) {
+    if (!args.label && !args.role && !args.text) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: 'Provide at least one search criteria: label, role, or text.',
+                }],
+            isError: true,
+        };
+    }
+    const device = await resolveDevice(args.deviceId);
+    if (!(await idb.checkIdbAvailable())) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: 'element_exists requires idb. Install: brew tap facebook/fb && brew install idb-companion && pip3 install fb-idb',
+                }],
+        };
+    }
+    try {
+        const raw = await idb.idbDescribeAll(device);
+        const searchStr = raw.toLowerCase();
+        let found = true;
+        if (args.label && !searchStr.includes(args.label.toLowerCase()))
+            found = false;
+        if (args.role && !searchStr.includes(args.role.toLowerCase()))
+            found = false;
+        if (args.text && !searchStr.includes(args.text.toLowerCase()))
+            found = false;
+        return {
+            content: [{
+                    type: 'text',
+                    text: found
+                        ? `true — Element exists. Criteria: ${JSON.stringify({ label: args.label, role: args.role, text: args.text })}`
+                        : `false — Element not found. Criteria: ${JSON.stringify({ label: args.label, role: args.role, text: args.text })}`,
+                }],
+        };
+    }
+    catch (err) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Error checking element: ${err.message}`,
+                }],
+            isError: true,
+        };
+    }
+}

package/dist/tools/screenshot.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+export declare const screenshotParams: {
+    deviceId: z.ZodOptional<z.ZodString>;
+    format: z.ZodOptional<z.ZodEnum<["png", "jpeg"]>>;
+    display: z.ZodOptional<z.ZodEnum<["internal", "external"]>>;
+    mask: z.ZodOptional<z.ZodEnum<["ignored", "alpha", "black"]>>;
+    savePath: z.ZodOptional<z.ZodString>;
+};
+export declare function handleScreenshot(args: {
+    deviceId?: string;
+    format?: string;
+    display?: string;
+    mask?: string;
+    savePath?: string;
+}): Promise<{
+    content: ({
+        type: "image";
+        data: string;
+        mimeType: string;
+        text?: undefined;
+    } | {
+        type: "text";
+        text: string;
+        data?: undefined;
+        mimeType?: undefined;
+    })[];
+}>;