@kernel.chat/kbot 3.71.0 → 3.72.0

package/dist/cli.js

@@ -1962,16 +1962,22 @@ async function main() {
     });
     program
         .command('serve')
-        .description('Start HTTP server — expose all 223 tools for kernel.chat or any client')
+        .description('Start HTTP/HTTPS server — expose all tools for kernel.chat, Claude Cowork, or any client')
         .option('-p, --port <port>', 'Port to listen on', '7437')
         .option('--token <token>', 'Require auth token for all requests')
         .option('--computer-use', 'Enable computer use tools')
+        .option('--https', 'Enable HTTPS with auto-generated self-signed cert (~/.kbot/certs/)')
+        .option('--cert <path>', 'Path to TLS certificate file (implies HTTPS)')
+        .option('--key <path>', 'Path to TLS private key file (implies HTTPS)')
         .action(async (opts) => {
         const { startServe } = await import('./serve.js');
         await startServe({
             port: parseInt(opts.port, 10),
             token: opts.token,
             computerUse: opts.computerUse,
+            https: opts.https,
+            cert: opts.cert,
+            key: opts.key,
         });
     });
     program

package/dist/integrations/ableton-bridge.d.ts

@@ -11,7 +11,7 @@
  *
  * Fallback chain (used by tools):
  *   1. AbletonBridge (port 9001) — full browser API
- *   2. KBotBridge (port 9998) — kbot's own Remote Script
+ *   2. KBotBridge (port 9997) — kbot's own Remote Script
  *   3. Error with install instructions
  *
  * Follows the same singleton + newline-delimited JSON pattern as AbletonM4L.
@@ -106,7 +106,7 @@ export declare class AbletonBridgeClient {
     getEffectChain(trackIndex: number): Promise<Device[]>;
 }
 /**
- * Lightweight TCP probe for the kbot Remote Script on port 9998.
+ * Lightweight TCP probe for the kbot Remote Script on port 9997.
  * Uses the same newline-delimited JSON protocol as AbletonM4L.
  */
 export declare class KBotRemoteClient {
@@ -139,7 +139,7 @@ export declare class KBotRemoteClient {
  */
 export declare function tryAbletonBridge(): Promise<AbletonBridgeClient | null>;
 /**
- * Try to connect to KBotBridge Remote Script (port 9998).
+ * Try to connect to KBotBridge Remote Script (port 9997).
  * Returns the connected client or null if unavailable.
  */
 export declare function tryKBotRemote(): Promise<KBotRemoteClient | null>;

package/dist/integrations/ableton-bridge.js

@@ -11,7 +11,7 @@
  *
  * Fallback chain (used by tools):
  *   1. AbletonBridge (port 9001) — full browser API
- *   2. KBotBridge (port 9998) — kbot's own Remote Script
+ *   2. KBotBridge (port 9997) — kbot's own Remote Script
  *   3. Error with install instructions
  *
  * Follows the same singleton + newline-delimited JSON pattern as AbletonM4L.
@@ -268,9 +268,9 @@ export class AbletonBridgeClient {
         }));
     }
 }
-// ── KBotBridge fallback (port 9998) ────────────────────────────────────
+// ── KBotBridge fallback (port 9997) ────────────────────────────────────
 /**
- * Lightweight TCP probe for the kbot Remote Script on port 9998.
+ * Lightweight TCP probe for the kbot Remote Script on port 9997.
  * Uses the same newline-delimited JSON protocol as AbletonM4L.
  */
 export class KBotRemoteClient {
@@ -280,7 +280,7 @@ export class KBotRemoteClient {
     pending = new Map();
     nextId = 1;
     buffer = '';
-    static PORT = 9998;
+    static PORT = 9997;
     static HOST = '127.0.0.1';
     static TIMEOUT = 10_000;
     static CONNECT_TIMEOUT = 3_000;
@@ -431,7 +431,7 @@ export async function tryAbletonBridge() {
     return ok ? client : null;
 }
 /**
- * Try to connect to KBotBridge Remote Script (port 9998).
+ * Try to connect to KBotBridge Remote Script (port 9997).
  * Returns the connected client or null if unavailable.
  */
 export async function tryKBotRemote() {
@@ -478,7 +478,7 @@ export function formatBridgeError() {
         '  kbot\'s own Remote Script. Install:',
         '  1. Run `kbot ableton install` or copy KBotBridge to Remote Scripts',
         '  2. Enable in Ableton: Preferences → Link/Tempo/MIDI → Control Surface → KBotBridge',
-        '  3. Verify: TCP server starts on localhost:9998',
+        '  3. Verify: TCP server starts on localhost:9997',
         '',
         'Both require Ableton Live to be running.',
     ].join('\n');

package/dist/integrations/ableton-m4l.d.ts

@@ -124,7 +124,7 @@ export interface BrowserCategory {
     child_count: number;
 }
 /**
- * Client for the KBotBridge Remote Script (TCP 9998).
+ * Client for the KBotBridge Remote Script (TCP 9997).
  *
  * This is separate from the M4L bridge (9999) because the Browser API
  * (browser.load_item) is ONLY available from Python Remote Scripts,
@@ -146,7 +146,7 @@ export declare class AbletonBrowserBridge {
     private constructor();
     static getInstance(): AbletonBrowserBridge;
     /**
-     * Connect to the KBotBridge Remote Script on port 9998.
+     * Connect to the KBotBridge Remote Script on port 9997.
      * Returns true if connected and the bridge responds to ping.
      */
     connect(): Promise<boolean>;
@@ -195,12 +195,12 @@ export declare class AbletonBrowserBridge {
  */
 export declare function ensureM4L(): Promise<AbletonM4L>;
 /**
- * Get a connected Browser bridge instance (KBotBridge Remote Script on port 9998).
+ * Get a connected Browser bridge instance (KBotBridge Remote Script on port 9997).
  * Throws if not available.
  */
 export declare function ensureBrowserBridge(): Promise<AbletonBrowserBridge>;
 /**
- * Connect to both M4L bridge (9999) and Browser bridge (9998).
+ * Connect to both M4L bridge (9999) and Browser bridge (9997).
  * Returns whichever connections succeed. At least one must connect.
  */
 export declare function connectBrowser(): Promise<{

package/dist/integrations/ableton-m4l.js

@@ -302,7 +302,7 @@ export class AbletonM4L {
     }
 }
 /**
- * Client for the KBotBridge Remote Script (TCP 9998).
+ * Client for the KBotBridge Remote Script (TCP 9997).
  *
  * This is separate from the M4L bridge (9999) because the Browser API
  * (browser.load_item) is ONLY available from Python Remote Scripts,
@@ -318,7 +318,7 @@ export class AbletonBrowserBridge {
     pending = new Map();
     nextId = 1;
     buffer = '';
-    static PORT = 9998;
+    static PORT = 9997;
     static HOST = '127.0.0.1';
     static TIMEOUT = 15_000; // Browser operations can be slow
     constructor() { }
@@ -329,7 +329,7 @@ export class AbletonBrowserBridge {
         return AbletonBrowserBridge.instance;
     }
     /**
-     * Connect to the KBotBridge Remote Script on port 9998.
+     * Connect to the KBotBridge Remote Script on port 9997.
      * Returns true if connected and the bridge responds to ping.
      */
     async connect() {
@@ -518,7 +518,7 @@ export async function ensureM4L() {
     return m4l;
 }
 /**
- * Get a connected Browser bridge instance (KBotBridge Remote Script on port 9998).
+ * Get a connected Browser bridge instance (KBotBridge Remote Script on port 9997).
  * Throws if not available.
  */
 export async function ensureBrowserBridge() {
@@ -531,13 +531,13 @@ export async function ensureBrowserBridge() {
             'Make sure:\n' +
             '1. Ableton Live is running\n' +
             '2. KBotBridge is selected as a Control Surface in Preferences > Link, Tempo & MIDI\n' +
-            '3. Ableton status bar shows "KBotBridge: Listening on port 9998"\n\n' +
+            '3. Ableton status bar shows "KBotBridge: Listening on port 9997"\n\n' +
             'To install: kbot ableton install-bridge\n');
     }
     return bridge;
 }
 /**
- * Connect to both M4L bridge (9999) and Browser bridge (9998).
+ * Connect to both M4L bridge (9999) and Browser bridge (9997).
  * Returns whichever connections succeed. At least one must connect.
  */
 export async function connectBrowser() {
@@ -582,7 +582,7 @@ export function formatBrowserBridgeError() {
         '5. Close Preferences',
         '',
         'This runs alongside the M4L bridge — they use different ports:',
-        '- KBotBridge: TCP 9998 (Browser API, device loading)',
+        '- KBotBridge: TCP 9997 (Browser API, device loading)',
         '- M4L Bridge: TCP 9999 (LOM access, clips, mixing)',
     ].join('\n');
 }

package/dist/integrations/install-remote-script.d.ts

@@ -2,7 +2,7 @@
  * install-remote-script.ts — Install KBotBridge Remote Script into Ableton Live
  *
  * Copies the KBotBridge Python Remote Script to Ableton's User Library,
- * enabling the Browser API bridge on TCP port 9998.
+ * enabling the Browser API bridge on TCP port 9997.
  *
  * The Remote Script exposes Ableton's browser.load_item() API, which is
  * ONLY available from Python Remote Scripts (not from Max for Live).

package/dist/integrations/install-remote-script.js

@@ -2,7 +2,7 @@
  * install-remote-script.ts — Install KBotBridge Remote Script into Ableton Live
  *
  * Copies the KBotBridge Python Remote Script to Ableton's User Library,
- * enabling the Browser API bridge on TCP port 9998.
+ * enabling the Browser API bridge on TCP port 9997.
  *
  * The Remote Script exposes Ableton's browser.load_item() API, which is
  * ONLY available from Python Remote Scripts (not from Max for Live).
@@ -84,11 +84,11 @@ export async function installKBotBridge() {
     log('  5. Close Preferences');
     log('');
     log('Verify:');
-    log('  - Ableton status bar shows "KBotBridge: Listening on port 9998"');
-    log('  - Run: echo \'{"id":1,"action":"ping"}\\n\' | nc localhost 9998');
+    log('  - Ableton status bar shows "KBotBridge: Listening on port 9997"');
+    log('  - Run: echo \'{"id":1,"action":"ping"}\\n\' | nc localhost 9997');
     log('');
     log('KBotBridge runs alongside AbletonOSC — they use different ports:');
-    log('  - KBotBridge: TCP 9998 (Browser API, device loading)');
+    log('  - KBotBridge: TCP 9997 (Browser API, device loading)');
     log('  - M4L Bridge: TCP 9999 (LOM access, clips, mixing)');
     log('  - AbletonOSC: UDP 11000/11001 (OSC, legacy)');
     return lines.join('\n');

package/dist/integrations/mobile-mcp-client.d.ts

@@ -0,0 +1,111 @@
+/**
+ * mobile-mcp-client.ts — kbot <-> mobile-mcp integration
+ *
+ * Singleton client that manages the mobile-mcp server process lifecycle.
+ * Communicates via MCP protocol over stdio transport.
+ * Auto-installs @mobilenext/mobile-mcp via npm if not present.
+ *
+ * mobile-mcp provides native accessibility-tree-based automation for
+ * iOS and Android devices connected via USB or WiFi.
+ *
+ * @see https://github.com/mobile-next/mobile-mcp
+ */
+export interface MobileDevice {
+    id: string;
+    name: string;
+    platform: 'ios' | 'android';
+    type: 'real' | 'simulator' | 'emulator';
+    version: string;
+    state: 'online' | 'offline';
+}
+export interface MobileElement {
+    type: string;
+    text?: string;
+    label?: string;
+    name?: string;
+    value?: string;
+    identifier?: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface MobileScreenSize {
+    width: number;
+    height: number;
+}
+export declare class MobileMCPClient {
+    private static instance;
+    private process;
+    private messageId;
+    private pending;
+    private buffer;
+    private initialized;
+    private activeDeviceId;
+    static getInstance(): MobileMCPClient;
+    /** Whether the MCP server process is running and initialized */
+    get isConnected(): boolean;
+    /** The device ID currently being controlled */
+    get currentDeviceId(): string | null;
+    /** Start the mobile-mcp server process and perform MCP handshake */
+    start(): Promise<void>;
+    /** Stop the mobile-mcp server process */
+    stop(): void;
+    private parseMessages;
+    private sendRequest;
+    private sendNotification;
+    /** Call a tool on the mobile-mcp server */
+    callTool(toolName: string, args: Record<string, unknown>): Promise<unknown>;
+    /** Extract text content from an MCP tool result */
+    extractText(result: unknown): string;
+    /** Extract image content (base64) from an MCP tool result */
+    extractImage(result: unknown): {
+        data: string;
+        mimeType: string;
+    } | null;
+    /** List all available devices */
+    listDevices(): Promise<MobileDevice[]>;
+    /** Set the active device for subsequent operations */
+    setActiveDevice(deviceId: string): void;
+    /** Get the active device ID, throwing if none set */
+    private requireDevice;
+    /** List apps on the active device */
+    listApps(deviceId?: string): Promise<string>;
+    /** Launch an app by bundle ID */
+    launchApp(packageName: string, deviceId?: string): Promise<string>;
+    /** Take a screenshot, returns base64 image data */
+    takeScreenshot(deviceId?: string): Promise<{
+        data: string;
+        mimeType: string;
+    } | string>;
+    /** Save screenshot to a file */
+    saveScreenshot(saveTo: string, deviceId?: string): Promise<string>;
+    /** List UI elements on screen via accessibility tree */
+    listElements(deviceId?: string): Promise<string>;
+    /** Tap at coordinates */
+    tap(x: number, y: number, deviceId?: string): Promise<string>;
+    /** Swipe on screen */
+    swipe(direction: 'up' | 'down' | 'left' | 'right', opts?: {
+        x?: number;
+        y?: number;
+        distance?: number;
+        deviceId?: string;
+    }): Promise<string>;
+    /** Type text */
+    typeText(text: string, submit?: boolean, deviceId?: string): Promise<string>;
+    /** Press a device button */
+    pressButton(button: 'HOME' | 'BACK' | 'VOLUME_UP' | 'VOLUME_DOWN' | 'ENTER', deviceId?: string): Promise<string>;
+    /** Get screen size */
+    getScreenSize(deviceId?: string): Promise<string>;
+    /** Open a URL in the device browser */
+    openUrl(url: string, deviceId?: string): Promise<string>;
+    /** Get device orientation */
+    getOrientation(deviceId?: string): Promise<string>;
+    /** Terminate an app */
+    terminateApp(packageName: string, deviceId?: string): Promise<string>;
+    /** Double tap at coordinates */
+    doubleTap(x: number, y: number, deviceId?: string): Promise<string>;
+    /** Long press at coordinates */
+    longPress(x: number, y: number, duration?: number, deviceId?: string): Promise<string>;
+}
+//# sourceMappingURL=mobile-mcp-client.d.ts.map

package/dist/integrations/mobile-mcp-client.js

@@ -0,0 +1,343 @@
+/**
+ * mobile-mcp-client.ts — kbot <-> mobile-mcp integration
+ *
+ * Singleton client that manages the mobile-mcp server process lifecycle.
+ * Communicates via MCP protocol over stdio transport.
+ * Auto-installs @mobilenext/mobile-mcp via npm if not present.
+ *
+ * mobile-mcp provides native accessibility-tree-based automation for
+ * iOS and Android devices connected via USB or WiFi.
+ *
+ * @see https://github.com/mobile-next/mobile-mcp
+ */
+import { spawn, execSync } from 'node:child_process';
+import { Buffer } from 'node:buffer';
+function encodeJsonRpc(msg) {
+    const body = JSON.stringify(msg);
+    return `Content-Length: ${Buffer.byteLength(body)}\r\n\r\n${body}`;
+}
+// ── MobileMCPClient ────────────────────────────────────────────────────
+export class MobileMCPClient {
+    static instance = null;
+    process = null;
+    messageId = 0;
+    pending = new Map();
+    buffer = '';
+    initialized = false;
+    activeDeviceId = null;
+    static getInstance() {
+        if (!MobileMCPClient.instance) {
+            MobileMCPClient.instance = new MobileMCPClient();
+        }
+        return MobileMCPClient.instance;
+    }
+    /** Whether the MCP server process is running and initialized */
+    get isConnected() {
+        return this.initialized && this.process !== null && !this.process.killed;
+    }
+    /** The device ID currently being controlled */
+    get currentDeviceId() {
+        return this.activeDeviceId;
+    }
+    // ── Process lifecycle ──────────────────────────────────────────────
+    /** Start the mobile-mcp server process and perform MCP handshake */
+    async start() {
+        if (this.isConnected)
+            return;
+        // Ensure npx is available
+        try {
+            execSync('which npx', { stdio: 'pipe' });
+        }
+        catch {
+            throw new Error('npx not found. Ensure Node.js >= 22 is installed.');
+        }
+        // Spawn the mobile-mcp server via npx (auto-installs if needed)
+        this.process = spawn('npx', ['-y', '@mobilenext/mobile-mcp@latest'], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: { ...process.env },
+        });
+        this.buffer = '';
+        this.messageId = 0;
+        this.pending.clear();
+        this.process.stdout?.on('data', (chunk) => {
+            this.buffer += chunk.toString();
+            this.parseMessages();
+        });
+        // Log stderr for debugging but don't crash
+        this.process.stderr?.on('data', (chunk) => {
+            const msg = chunk.toString().trim();
+            if (msg && process.env.KBOT_DEBUG) {
+                console.error(`[mobile-mcp stderr] ${msg}`);
+            }
+        });
+        this.process.on('error', (err) => {
+            this.initialized = false;
+            this.process = null;
+            if (process.env.KBOT_DEBUG) {
+                console.error(`[mobile-mcp] Process error: ${err.message}`);
+            }
+        });
+        this.process.on('exit', (code) => {
+            this.initialized = false;
+            this.process = null;
+            // Reject any pending requests
+            const pendingEntries = Array.from(this.pending.entries());
+            for (const [id, { reject }] of pendingEntries) {
+                reject(new Error(`mobile-mcp process exited with code ${code}`));
+                this.pending.delete(id);
+            }
+        });
+        // MCP initialize handshake
+        try {
+            await this.sendRequest('initialize', {
+                protocolVersion: '2024-11-05',
+                capabilities: {},
+                clientInfo: { name: 'kbot', version: '3.61.0' },
+            });
+            this.sendNotification('initialized', {});
+            this.initialized = true;
+        }
+        catch (err) {
+            this.stop();
+            throw new Error(`mobile-mcp handshake failed: ${err instanceof Error ? err.message : String(err)}\n` +
+                'Ensure @mobilenext/mobile-mcp is installed: npm install -g @mobilenext/mobile-mcp');
+        }
+    }
+    /** Stop the mobile-mcp server process */
+    stop() {
+        if (this.process) {
+            try {
+                // Graceful shutdown
+                this.sendNotification('exit', null);
+            }
+            catch { /* best effort */ }
+            this.process.kill();
+            this.process = null;
+        }
+        this.initialized = false;
+        this.activeDeviceId = null;
+        this.buffer = '';
+        this.pending.clear();
+    }
+    // ── MCP protocol ───────────────────────────────────────────────────
+    parseMessages() {
+        while (true) {
+            const headerEnd = this.buffer.indexOf('\r\n\r\n');
+            if (headerEnd === -1)
+                break;
+            const header = this.buffer.slice(0, headerEnd);
+            const lengthMatch = header.match(/Content-Length:\s*(\d+)/i);
+            if (!lengthMatch) {
+                this.buffer = this.buffer.slice(headerEnd + 4);
+                continue;
+            }
+            const contentLength = parseInt(lengthMatch[1], 10);
+            const bodyStart = headerEnd + 4;
+            if (this.buffer.length < bodyStart + contentLength)
+                break;
+            const body = this.buffer.slice(bodyStart, bodyStart + contentLength);
+            this.buffer = this.buffer.slice(bodyStart + contentLength);
+            try {
+                const msg = JSON.parse(body);
+                if (msg.id !== undefined && this.pending.has(msg.id)) {
+                    const { resolve, reject } = this.pending.get(msg.id);
+                    this.pending.delete(msg.id);
+                    if (msg.error) {
+                        reject(new Error(msg.error.message));
+                    }
+                    else {
+                        resolve(msg.result);
+                    }
+                }
+            }
+            catch {
+                // Skip malformed messages
+            }
+        }
+    }
+    sendRequest(method, params, timeout = 30_000) {
+        return new Promise((resolve, reject) => {
+            if (!this.process?.stdin?.writable) {
+                reject(new Error('mobile-mcp process is not running. Call mobile_connect first.'));
+                return;
+            }
+            const id = ++this.messageId;
+            this.pending.set(id, { resolve, reject });
+            const msg = { jsonrpc: '2.0', id, method, params };
+            this.process.stdin.write(encodeJsonRpc(msg));
+            setTimeout(() => {
+                if (this.pending.has(id)) {
+                    this.pending.delete(id);
+                    reject(new Error(`mobile-mcp request timeout after ${timeout / 1000}s: ${method}`));
+                }
+            }, timeout);
+        });
+    }
+    sendNotification(method, params) {
+        if (!this.process?.stdin?.writable)
+            return;
+        const msg = { jsonrpc: '2.0', method, params };
+        this.process.stdin.write(encodeJsonRpc(msg));
+    }
+    /** Call a tool on the mobile-mcp server */
+    async callTool(toolName, args) {
+        if (!this.isConnected) {
+            throw new Error('Not connected to mobile-mcp. Call mobile_connect first.');
+        }
+        const result = await this.sendRequest('tools/call', {
+            name: toolName,
+            arguments: args,
+        }, 60_000);
+        return result;
+    }
+    /** Extract text content from an MCP tool result */
+    extractText(result) {
+        const r = result;
+        if (r?.content) {
+            return r.content
+                .filter(c => c.type === 'text' && c.text)
+                .map(c => c.text)
+                .join('\n');
+        }
+        return JSON.stringify(result, null, 2);
+    }
+    /** Extract image content (base64) from an MCP tool result */
+    extractImage(result) {
+        const r = result;
+        if (r?.content) {
+            const img = r.content.find(c => c.type === 'image' && c.data);
+            if (img)
+                return { data: img.data, mimeType: img.mimeType || 'image/png' };
+        }
+        return null;
+    }
+    // ── High-level device operations ───────────────────────────────────
+    /** List all available devices */
+    async listDevices() {
+        const result = await this.callTool('mobile_list_available_devices', {});
+        const text = this.extractText(result);
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            // Try to parse from structured output
+            return [];
+        }
+    }
+    /** Set the active device for subsequent operations */
+    setActiveDevice(deviceId) {
+        this.activeDeviceId = deviceId;
+    }
+    /** Get the active device ID, throwing if none set */
+    requireDevice(deviceId) {
+        const id = deviceId || this.activeDeviceId;
+        if (!id) {
+            throw new Error('No device selected. Use mobile_connect to connect to a device, or pass a device ID.');
+        }
+        return id;
+    }
+    /** List apps on the active device */
+    async listApps(deviceId) {
+        const device = this.requireDevice(deviceId);
+        const result = await this.callTool('mobile_list_apps', { device });
+        return this.extractText(result);
+    }
+    /** Launch an app by bundle ID */
+    async launchApp(packageName, deviceId) {
+        const device = this.requireDevice(deviceId);
+        const result = await this.callTool('mobile_launch_app', { device, packageName });
+        return this.extractText(result);
+    }
+    /** Take a screenshot, returns base64 image data */
+    async takeScreenshot(deviceId) {
+        const device = this.requireDevice(deviceId);
+        const result = await this.callTool('mobile_take_screenshot', { device });
+        const img = this.extractImage(result);
+        if (img)
+            return img;
+        return this.extractText(result);
+    }
+    /** Save screenshot to a file */
+    async saveScreenshot(saveTo, deviceId) {
+        const device = this.requireDevice(deviceId);
+        const result = await this.callTool('mobile_save_screenshot', { device, saveTo });
+        return this.extractText(result);
+    }
+    /** List UI elements on screen via accessibility tree */
+    async listElements(deviceId) {
+        const device = this.requireDevice(deviceId);
+        const result = await this.callTool('mobile_list_elements_on_screen', { device });
+        return this.extractText(result);
+    }
+    /** Tap at coordinates */
+    async tap(x, y, deviceId) {
+        const device = this.requireDevice(deviceId);
+        const result = await this.callTool('mobile_click_on_screen_at_coordinates', { device, x, y });
+        return this.extractText(result);
+    }
+    /** Swipe on screen */
+    async swipe(direction, opts) {
+        const device = this.requireDevice(opts?.deviceId);
+        const args = { device, direction };
+        if (opts?.x !== undefined)
+            args.x = opts.x;
+        if (opts?.y !== undefined)
+            args.y = opts.y;
+        if (opts?.distance !== undefined)
+            args.distance = opts.distance;
+        const result = await this.callTool('mobile_swipe_on_screen', args);
+        return this.extractText(result);
+    }
+    /** Type text */
+    async typeText(text, submit = false, deviceId) {
+        const device = this.requireDevice(deviceId);
+        const result = await this.callTool('mobile_type_keys', { device, text, submit });
+        return this.extractText(result);
+    }
+    /** Press a device button */
+    async pressButton(button, deviceId) {
+        const device = this.requireDevice(deviceId);
+        const result = await this.callTool('mobile_press_button', { device, button });
+        return this.extractText(result);
+    }
+    /** Get screen size */
+    async getScreenSize(deviceId) {
+        const device = this.requireDevice(deviceId);
+        const result = await this.callTool('mobile_get_screen_size', { device });
+        return this.extractText(result);
+    }
+    /** Open a URL in the device browser */
+    async openUrl(url, deviceId) {
+        const device = this.requireDevice(deviceId);
+        const result = await this.callTool('mobile_open_url', { device, url });
+        return this.extractText(result);
+    }
+    /** Get device orientation */
+    async getOrientation(deviceId) {
+        const device = this.requireDevice(deviceId);
+        const result = await this.callTool('mobile_get_orientation', { device });
+        return this.extractText(result);
+    }
+    /** Terminate an app */
+    async terminateApp(packageName, deviceId) {
+        const device = this.requireDevice(deviceId);
+        const result = await this.callTool('mobile_terminate_app', { device, packageName });
+        return this.extractText(result);
+    }
+    /** Double tap at coordinates */
+    async doubleTap(x, y, deviceId) {
+        const device = this.requireDevice(deviceId);
+        const result = await this.callTool('mobile_double_tap_on_screen', { device, x, y });
+        return this.extractText(result);
+    }
+    /** Long press at coordinates */
+    async longPress(x, y, duration, deviceId) {
+        const device = this.requireDevice(deviceId);
+        const args = { device, x, y };
+        if (duration !== undefined)
+            args.duration = duration;
+        const result = await this.callTool('mobile_long_press_on_screen_at_coordinates', args);
+        return this.extractText(result);
+    }
+}
+//# sourceMappingURL=mobile-mcp-client.js.map