preflight-ios-mcp 1.0.0

package/dist/tools/app.d.ts

@@ -0,0 +1,85 @@
+import { z } from 'zod';
+export declare const listAppsParams: {
+    deviceId: z.ZodOptional<z.ZodString>;
+    includeSystem: z.ZodOptional<z.ZodBoolean>;
+};
+export declare function handleListApps(args: {
+    deviceId?: string;
+    includeSystem?: boolean;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare const appInfoParams: {
+    bundleId: z.ZodString;
+    deviceId: z.ZodOptional<z.ZodString>;
+};
+export declare function handleAppInfo(args: {
+    bundleId: string;
+    deviceId?: string;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare const launchAppParams: {
+    bundleId: z.ZodString;
+    terminateRunning: z.ZodOptional<z.ZodBoolean>;
+    args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    deviceId: z.ZodOptional<z.ZodString>;
+};
+export declare function handleLaunchApp(args: {
+    bundleId: string;
+    terminateRunning?: boolean;
+    args?: string[];
+    env?: Record<string, string>;
+    deviceId?: string;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare const terminateAppParams: {
+    bundleId: z.ZodString;
+    deviceId: z.ZodOptional<z.ZodString>;
+};
+export declare function handleTerminateApp(args: {
+    bundleId: string;
+    deviceId?: string;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare const installAppParams: {
+    path: z.ZodString;
+    deviceId: z.ZodOptional<z.ZodString>;
+};
+export declare function handleInstallApp(args: {
+    path: string;
+    deviceId?: string;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare const uninstallAppParams: {
+    bundleId: z.ZodString;
+    deviceId: z.ZodOptional<z.ZodString>;
+};
+export declare function handleUninstallApp(args: {
+    bundleId: string;
+    deviceId?: string;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/tools/app.js

@@ -0,0 +1,177 @@
+import { z } from 'zod';
+import { execSimctl, resolveDevice } from '../helpers/simctl.js';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { writeFile, unlink } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+const execFileAsync = promisify(execFile);
+// --- list_apps ---
+export const listAppsParams = {
+    deviceId: z.string().optional().describe('Device UDID, name, or "booted" (default: booted)'),
+    includeSystem: z.boolean().optional().describe('Include system apps (default: false)'),
+};
+export async function handleListApps(args) {
+    const device = await resolveDevice(args.deviceId);
+    // Use JSON output via plutil for reliable parsing
+    const { stdout } = await execSimctl(['listapps', device], 'tool:listApps');
+    let apps = [];
+    try {
+        // Write plist to temp file then convert to JSON
+        const tmpFile = join(tmpdir(), `simctl-apps-${Date.now()}.plist`);
+        await writeFile(tmpFile, stdout, 'utf-8');
+        let data;
+        try {
+            const result = await execFileAsync('plutil', ['-convert', 'json', '-o', '-', tmpFile], {
+                maxBuffer: 50 * 1024 * 1024,
+                encoding: 'utf-8',
+                timeout: 15000,
+            });
+            data = JSON.parse(result.stdout);
+        }
+        finally {
+            await unlink(tmpFile).catch(() => { });
+        }
+        for (const [bundleId, info] of Object.entries(data)) {
+            const name = info.CFBundleDisplayName || info.CFBundleName || bundleId;
+            const version = info.CFBundleShortVersionString || info.CFBundleVersion;
+            const isSystem = info.ApplicationType === 'System';
+            if (!args.includeSystem && isSystem)
+                continue;
+            apps.push({ name, bundleId, version, isSystem });
+        }
+    }
+    catch {
+        // Fallback: regex parsing
+        const bundleIdMatches = [...stdout.matchAll(/CFBundleIdentifier\s*=\s*"?([^";\n]+)"?/g)];
+        const nameMatches = [...stdout.matchAll(/(?:CFBundleDisplayName|CFBundleName)\s*=\s*"?([^";\n]+)"?/g)];
+        apps = bundleIdMatches.map((m, i) => ({
+            bundleId: m[1].trim(),
+            name: nameMatches[i]?.[1]?.trim() || m[1].trim(),
+        }));
+    }
+    apps.sort((a, b) => a.name.localeCompare(b.name));
+    const lines = apps.map(a => `${a.name} — ${a.bundleId}${a.version ? ` (v${a.version})` : ''}`);
+    return {
+        content: [{
+                type: 'text',
+                text: apps.length === 0
+                    ? 'No apps found.'
+                    : `Installed apps (${apps.length}):\n\n${lines.join('\n')}`,
+            }],
+    };
+}
+// --- app_info ---
+export const appInfoParams = {
+    bundleId: z.string().describe('App bundle identifier (e.g., "com.apple.mobilesafari")'),
+    deviceId: z.string().optional().describe('Device UDID, name, or "booted" (default: booted)'),
+};
+export async function handleAppInfo(args) {
+    const device = await resolveDevice(args.deviceId);
+    const { stdout } = await execSimctl(['appinfo', device, args.bundleId], 'tool:appInfo');
+    // Convert plist to JSON for readability
+    try {
+        const tmpFile2 = join(tmpdir(), `simctl-appinfo-${Date.now()}.plist`);
+        await writeFile(tmpFile2, stdout, 'utf-8');
+        let data;
+        try {
+            const result = await execFileAsync('plutil', ['-convert', 'json', '-o', '-', tmpFile2], {
+                maxBuffer: 10 * 1024 * 1024,
+                encoding: 'utf-8',
+                timeout: 5000,
+            });
+            data = JSON.parse(result.stdout);
+        }
+        finally {
+            await unlink(tmpFile2).catch(() => { });
+        }
+        const fields = [
+            `Bundle ID:   ${data.CFBundleIdentifier || args.bundleId}`,
+            `Name:        ${data.CFBundleDisplayName || data.CFBundleName || '—'}`,
+            `Version:     ${data.CFBundleShortVersionString || '—'} (${data.CFBundleVersion || '—'})`,
+            `Type:        ${data.ApplicationType || '—'}`,
+            `Bundle Path: ${data.Path || data.CFBundleExecutable || '—'}`,
+            `Data Path:   ${data.DataContainer || '—'}`,
+            `SDK:         ${data.DTSDKName || '—'}`,
+            `Min iOS:     ${data.MinimumOSVersion || '—'}`,
+        ];
+        return { content: [{ type: 'text', text: fields.join('\n') }] };
+    }
+    catch {
+        return { content: [{ type: 'text', text: stdout }] };
+    }
+}
+// --- launch_app ---
+export const launchAppParams = {
+    bundleId: z.string().describe('App bundle identifier to launch'),
+    terminateRunning: z.boolean().optional().describe('Terminate the app first if already running (default: false)'),
+    args: z.array(z.string()).optional().describe('Launch arguments to pass to the app'),
+    env: z.record(z.string()).optional().describe('Environment variables to set (will be prefixed with SIMCTL_CHILD_)'),
+    deviceId: z.string().optional().describe('Device UDID, name, or "booted" (default: booted)'),
+};
+export async function handleLaunchApp(args) {
+    const device = await resolveDevice(args.deviceId);
+    // Terminate first if requested
+    if (args.terminateRunning) {
+        try {
+            await execSimctl(['terminate', device, args.bundleId], 'tool:launchApp');
+        }
+        catch { /* app may not be running, ignore */ }
+    }
+    if (args.env) {
+        for (const [key, value] of Object.entries(args.env)) {
+            process.env[`SIMCTL_CHILD_${key}`] = value;
+        }
+    }
+    const cmdArgs = ['launch', device, args.bundleId, ...(args.args || [])];
+    const { stdout } = await execSimctl(cmdArgs, 'tool:launchApp');
+    if (args.env) {
+        for (const key of Object.keys(args.env)) {
+            delete process.env[`SIMCTL_CHILD_${key}`];
+        }
+    }
+    return {
+        content: [{
+                type: 'text',
+                text: `Launched ${args.bundleId}. ${stdout.trim()}`,
+            }],
+    };
+}
+// --- terminate_app ---
+export const terminateAppParams = {
+    bundleId: z.string().describe('App bundle identifier to terminate'),
+    deviceId: z.string().optional().describe('Device UDID, name, or "booted" (default: booted)'),
+};
+export async function handleTerminateApp(args) {
+    const device = await resolveDevice(args.deviceId);
+    try {
+        await execSimctl(['terminate', device, args.bundleId], 'tool:terminateApp');
+    }
+    catch (err) {
+        // Not running is not an error
+        const msg = err.message;
+        if (!msg.includes('not running') && !msg.includes('No such process'))
+            throw err;
+    }
+    return { content: [{ type: 'text', text: `Terminated ${args.bundleId}.` }] };
+}
+// --- install_app ---
+export const installAppParams = {
+    path: z.string().describe('Path to .app bundle or .ipa file to install'),
+    deviceId: z.string().optional().describe('Device UDID, name, or "booted" (default: booted)'),
+};
+export async function handleInstallApp(args) {
+    const device = await resolveDevice(args.deviceId);
+    await execSimctl(['install', device, args.path], 'tool:installApp');
+    return { content: [{ type: 'text', text: `Installed app from ${args.path}.` }] };
+}
+// --- uninstall_app ---
+export const uninstallAppParams = {
+    bundleId: z.string().describe('App bundle identifier to uninstall'),
+    deviceId: z.string().optional().describe('Device UDID, name, or "booted" (default: booted)'),
+};
+export async function handleUninstallApp(args) {
+    const device = await resolveDevice(args.deviceId);
+    await execSimctl(['uninstall', device, args.bundleId], 'tool:uninstallApp');
+    return { content: [{ type: 'text', text: `Uninstalled ${args.bundleId}.` }] };
+}

package/dist/tools/debug.d.ts

@@ -0,0 +1,140 @@
+import { z } from 'zod';
+export declare const getLogsParams: {
+    process: z.ZodOptional<z.ZodString>;
+    subsystem: z.ZodOptional<z.ZodString>;
+    category: z.ZodOptional<z.ZodString>;
+    level: z.ZodOptional<z.ZodEnum<["debug", "info", "default", "error", "fault"]>>;
+    since: z.ZodOptional<z.ZodString>;
+    messageContains: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    deviceId: z.ZodOptional<z.ZodString>;
+};
+export declare function handleGetLogs(args: {
+    process?: string;
+    subsystem?: string;
+    category?: string;
+    level?: string;
+    since?: string;
+    messageContains?: string;
+    limit?: number;
+    deviceId?: string;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare const streamLogsParams: {
+    action: z.ZodEnum<["start", "read", "stop"]>;
+    process: z.ZodOptional<z.ZodString>;
+    level: z.ZodOptional<z.ZodEnum<["debug", "info", "default", "error", "fault"]>>;
+    bufferSize: z.ZodOptional<z.ZodNumber>;
+    deviceId: z.ZodOptional<z.ZodString>;
+};
+export declare function handleStreamLogs(args: {
+    action: 'start' | 'read' | 'stop';
+    process?: string;
+    level?: string;
+    bufferSize?: number;
+    deviceId?: string;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare const getAppContainerParams: {
+    bundleId: z.ZodString;
+    containerType: z.ZodOptional<z.ZodEnum<["app", "data", "groups"]>>;
+    deviceId: z.ZodOptional<z.ZodString>;
+};
+export declare function handleGetAppContainer(args: {
+    bundleId: string;
+    containerType?: string;
+    deviceId?: string;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare const listAppFilesParams: {
+    bundleId: z.ZodString;
+    subPath: z.ZodOptional<z.ZodString>;
+    deviceId: z.ZodOptional<z.ZodString>;
+};
+export declare function handleListAppFiles(args: {
+    bundleId: string;
+    subPath?: string;
+    deviceId?: string;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare const readAppFileParams: {
+    bundleId: z.ZodString;
+    filePath: z.ZodString;
+    deviceId: z.ZodOptional<z.ZodString>;
+};
+export declare function handleReadAppFile(args: {
+    bundleId: string;
+    filePath: string;
+    deviceId?: string;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare const getCrashLogsParams: {
+    processName: z.ZodOptional<z.ZodString>;
+    since: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    deviceId: z.ZodOptional<z.ZodString>;
+};
+export declare function handleGetCrashLogs(args: {
+    processName?: string;
+    since?: string;
+    limit?: number;
+    deviceId?: string;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare const diagnoseParams: {
+    deviceId: z.ZodOptional<z.ZodString>;
+};
+export declare function handleDiagnose(args: {
+    deviceId?: string;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare const accessibilityAuditParams: {
+    deviceId: z.ZodOptional<z.ZodString>;
+};
+export declare function handleAccessibilityAudit(args: {
+    deviceId?: string;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare const getScreenInfoParams: {
+    deviceId: z.ZodOptional<z.ZodString>;
+};
+export declare function handleGetScreenInfo(args: {
+    deviceId?: string;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;