muse-app-preview-mcp 1.3.0 → 1.5.0

package/dist/index.js

@@ -57,6 +57,58 @@ function generateId() {
 }
 // Tool definitions
 const tools = [
+    {
+        name: "create_app_previews",
+        description: "Complete workflow to create App Store preview images. Steps: 1) User selects platform (iOS/macOS/watchOS), 2) User selects language, 3) Claude generates marketing text, 4) Auto-capture screenshots, 5) Send to MUSE Preview Maker app or save to folder.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                bundleId: {
+                    type: "string",
+                    description: "Bundle ID of the app to capture",
+                },
+                appName: {
+                    type: "string",
+                    description: "Name of the app (for generating marketing text)",
+                },
+                appDescription: {
+                    type: "string",
+                    description: "Brief description of what the app does (helps Claude generate better text)",
+                },
+                platform: {
+                    type: "string",
+                    enum: ["ios", "macos", "watchos"],
+                    description: "Target platform",
+                },
+                language: {
+                    type: "string",
+                    enum: ["ko", "en", "ja", "zh", "es", "fr", "de"],
+                    description: "Language for preview text (ko=Korean, en=English, etc.)",
+                },
+                screenCount: {
+                    type: "number",
+                    description: "Number of screens to capture. Default: 3",
+                },
+                previews: {
+                    type: "array",
+                    description: "Array of preview definitions with title/subtitle. If not provided, Claude should generate these.",
+                    items: {
+                        type: "object",
+                        properties: {
+                            title: { type: "string" },
+                            subtitle: { type: "string" },
+                            paletteId: { type: "string" },
+                        },
+                    },
+                },
+                simulatorUDID: {
+                    type: "string",
+                    description: "Specific simulator UDID for iOS/watchOS. Optional.",
+                },
+            },
+            required: ["bundleId", "appName", "platform", "language"],
+        },
+    },
     {
         name: "add_preview",
         description: "Add a new preview set with screenshot, title, and subtitle. The screenshot will be used to generate an app store preview image.",
@@ -269,13 +321,13 @@ const tools = [
     },
     {
         name: "launch_and_capture",
-        description: "Launch a specific app in the simulator, wait for it to load, then capture a screenshot. This is the smart capture that ensures the app is ready before taking screenshots.",
+        description: "Launch an app and capture screenshot. Auto-detects platform (iOS simulator or macOS). For iOS, launches in simulator and captures. For macOS, launches app and captures window.",
         inputSchema: {
             type: "object",
             properties: {
                 bundleId: {
                     type: "string",
-                    description: "Bundle ID of the app to launch (e.g., 'com.example.myapp')",
+                    description: "Bundle ID of the app (e.g., 'com.example.myapp')",
                 },
                 title: {
                     type: "string",
@@ -285,25 +337,34 @@ const tools = [
                     type: "string",
                     description: "Subtitle text for the preview",
                 },
+                platform: {
+                    type: "string",
+                    enum: ["ios", "macos", "auto"],
+                    description: "Platform: 'ios' for simulator, 'macos' for Mac app, 'auto' to detect. Default: auto",
+                },
                 waitSeconds: {
                     type: "number",
                     description: "Seconds to wait after launch before capture. Default: 3",
                 },
                 simulatorUDID: {
                     type: "string",
-                    description: "Specific simulator UDID. Optional.",
+                    description: "Specific iOS simulator UDID. Optional.",
                 },
                 paletteId: {
                     type: "string",
                     description: "Color palette ID. Optional.",
                 },
+                deviceId: {
+                    type: "string",
+                    description: "Device ID for preview (iphone_6_7, mac_retina, etc.). Auto-detected if not specified.",
+                },
             },
             required: ["bundleId", "title", "subtitle"],
         },
     },
     {
         name: "capture_app_screens",
-        description: "Capture multiple screens from a running app by simulating navigation. Generates a complete set of App Store preview images.",
+        description: "Capture multiple screens from a running app. Auto-detects platform. Launches app, captures first screen, then captures additional screens with wait intervals.",
         inputSchema: {
             type: "object",
             properties: {
@@ -324,14 +385,305 @@ const tools = [
                         },
                     },
                 },
+                platform: {
+                    type: "string",
+                    enum: ["ios", "macos", "auto"],
+                    description: "Platform: 'ios', 'macos', or 'auto'. Default: auto",
+                },
                 simulatorUDID: {
                     type: "string",
-                    description: "Specific simulator UDID. Optional.",
+                    description: "Specific iOS simulator UDID. Optional.",
                 },
             },
             required: ["bundleId", "screens"],
         },
     },
+    // === Advanced Capture Tools ===
+    {
+        name: "interact_simulator",
+        description: "Interact with iOS Simulator: tap, swipe, scroll, type text. Use this to navigate to specific screens before capturing.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                action: {
+                    type: "string",
+                    enum: ["tap", "swipe", "scroll", "type", "home", "shake"],
+                    description: "Action type",
+                },
+                x: {
+                    type: "number",
+                    description: "X coordinate (for tap/swipe start)",
+                },
+                y: {
+                    type: "number",
+                    description: "Y coordinate (for tap/swipe start)",
+                },
+                toX: {
+                    type: "number",
+                    description: "End X coordinate (for swipe)",
+                },
+                toY: {
+                    type: "number",
+                    description: "End Y coordinate (for swipe)",
+                },
+                direction: {
+                    type: "string",
+                    enum: ["up", "down", "left", "right"],
+                    description: "Scroll/swipe direction (alternative to coordinates)",
+                },
+                text: {
+                    type: "string",
+                    description: "Text to type (for type action)",
+                },
+                duration: {
+                    type: "number",
+                    description: "Duration in seconds (for swipe). Default: 0.3",
+                },
+                simulatorUDID: {
+                    type: "string",
+                    description: "Target simulator UDID. Uses tracked simulator if not specified.",
+                },
+            },
+            required: ["action"],
+        },
+    },
+    {
+        name: "navigate_app",
+        description: "Navigate to a specific screen in the app using deep links (URL schemes) or by opening URLs.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                url: {
+                    type: "string",
+                    description: "Deep link URL or URL scheme (e.g., 'myapp://settings', 'https://example.com/page')",
+                },
+                bundleId: {
+                    type: "string",
+                    description: "Bundle ID of the app (required for some navigations)",
+                },
+                waitSeconds: {
+                    type: "number",
+                    description: "Seconds to wait after navigation. Default: 2",
+                },
+                simulatorUDID: {
+                    type: "string",
+                    description: "Target simulator UDID.",
+                },
+            },
+            required: ["url"],
+        },
+    },
+    {
+        name: "configure_simulator",
+        description: "Configure simulator appearance: status bar time, battery, signal, dark/light mode, etc. Makes screenshots look professional.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                statusBarTime: {
+                    type: "string",
+                    description: "Set status bar time (e.g., '9:41')",
+                },
+                batteryLevel: {
+                    type: "number",
+                    description: "Battery level 0-100",
+                },
+                batteryState: {
+                    type: "string",
+                    enum: ["charging", "charged", "discharging"],
+                    description: "Battery state",
+                },
+                cellularBars: {
+                    type: "number",
+                    description: "Cellular signal bars 0-4",
+                },
+                wifiBars: {
+                    type: "number",
+                    description: "WiFi signal bars 0-3",
+                },
+                appearance: {
+                    type: "string",
+                    enum: ["light", "dark"],
+                    description: "Light or dark mode",
+                },
+                simulatorUDID: {
+                    type: "string",
+                    description: "Target simulator UDID.",
+                },
+            },
+        },
+    },
+    {
+        name: "auto_capture_flow",
+        description: "Automatically capture a user flow with actions. Define a sequence of actions (tap, swipe, wait) and capture at each step. Perfect for capturing onboarding flows, feature tours, etc.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                bundleId: {
+                    type: "string",
+                    description: "Bundle ID of the app",
+                },
+                flow: {
+                    type: "array",
+                    description: "Sequence of actions and captures",
+                    items: {
+                        type: "object",
+                        properties: {
+                            action: {
+                                type: "string",
+                                enum: ["capture", "tap", "swipe", "scroll", "wait", "type", "navigate"],
+                                description: "Action to perform",
+                            },
+                            title: { type: "string", description: "Title for capture" },
+                            subtitle: { type: "string", description: "Subtitle for capture" },
+                            paletteId: { type: "string", description: "Palette for capture" },
+                            x: { type: "number" },
+                            y: { type: "number" },
+                            toX: { type: "number" },
+                            toY: { type: "number" },
+                            direction: { type: "string", enum: ["up", "down", "left", "right"] },
+                            text: { type: "string" },
+                            url: { type: "string", description: "URL for navigate action" },
+                            seconds: { type: "number", description: "Wait time or animation duration" },
+                        },
+                    },
+                },
+                resetFirst: {
+                    type: "boolean",
+                    description: "Reset app state before starting. Default: true",
+                },
+                simulatorUDID: {
+                    type: "string",
+                    description: "Target simulator UDID.",
+                },
+            },
+            required: ["bundleId", "flow"],
+        },
+    },
+    {
+        name: "scroll_and_capture",
+        description: "Scroll through a screen and capture at intervals. Great for capturing long lists, feeds, or scrollable content.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                bundleId: {
+                    type: "string",
+                    description: "Bundle ID of the app",
+                },
+                scrollCount: {
+                    type: "number",
+                    description: "Number of scroll actions. Default: 3",
+                },
+                direction: {
+                    type: "string",
+                    enum: ["up", "down", "left", "right"],
+                    description: "Scroll direction. Default: down",
+                },
+                captureEach: {
+                    type: "boolean",
+                    description: "Capture after each scroll. Default: true",
+                },
+                titles: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Titles for each capture",
+                },
+                subtitles: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Subtitles for each capture",
+                },
+                paletteIds: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Palette IDs for each capture",
+                },
+                waitBetween: {
+                    type: "number",
+                    description: "Seconds to wait between scrolls. Default: 1",
+                },
+                simulatorUDID: {
+                    type: "string",
+                    description: "Target simulator UDID.",
+                },
+            },
+            required: ["bundleId"],
+        },
+    },
+    {
+        name: "batch_capture_devices",
+        description: "Capture the same screen on multiple devices/simulators. Great for generating previews for all device sizes at once.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                bundleId: {
+                    type: "string",
+                    description: "Bundle ID of the app",
+                },
+                title: {
+                    type: "string",
+                    description: "Title for all captures",
+                },
+                subtitle: {
+                    type: "string",
+                    description: "Subtitle for all captures",
+                },
+                paletteId: {
+                    type: "string",
+                    description: "Palette ID for all captures",
+                },
+                devices: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "List of simulator names or UDIDs to capture",
+                },
+                bootDevices: {
+                    type: "boolean",
+                    description: "Boot specified devices if not running. Default: false",
+                },
+                waitSeconds: {
+                    type: "number",
+                    description: "Wait time after launching app. Default: 3",
+                },
+            },
+            required: ["bundleId", "title", "subtitle"],
+        },
+    },
+    {
+        name: "record_and_extract",
+        description: "Record simulator video and extract key frames as screenshots. Useful for capturing animations or transitions.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                bundleId: {
+                    type: "string",
+                    description: "Bundle ID of the app",
+                },
+                duration: {
+                    type: "number",
+                    description: "Recording duration in seconds. Default: 5",
+                },
+                frameCount: {
+                    type: "number",
+                    description: "Number of frames to extract. Default: 3",
+                },
+                titles: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Titles for each extracted frame",
+                },
+                subtitles: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Subtitles for each extracted frame",
+                },
+                simulatorUDID: {
+                    type: "string",
+                    description: "Target simulator UDID.",
+                },
+            },
+            required: ["bundleId"],
+        },
+    },
 ];
 // Tool handlers
 async function handleAddPreview(args) {
@@ -563,12 +915,16 @@ async function handleUpdateSettings(args) {
         settings: store.settings,
     });
 }
-// Helper to get booted simulators
+// Helper to get booted simulators (iOS/iPadOS only, prioritized)
 async function getBootedSimulators() {
     const { stdout } = await execAsync("xcrun simctl list devices booted -j");
     const data = JSON.parse(stdout);
     const bootedDevices = [];
     for (const [runtime, devices] of Object.entries(data.devices)) {
+        // Only include iOS/iPadOS simulators (skip watchOS, tvOS, visionOS)
+        if (!runtime.toLowerCase().includes("ios")) {
+            continue;
+        }
         const deviceList = devices;
         for (const device of deviceList) {
             if (device.state === "Booted") {
@@ -576,15 +932,30 @@ async function getBootedSimulators() {
                 const runtimeVersion = runtimeMatch
                     ? `iOS ${runtimeMatch[1].replace("-", ".")}`
                     : runtime;
+                // Priority: iPhone Pro Max > iPhone Pro > iPhone > iPad
+                let priority = 0;
+                const name = device.name.toLowerCase();
+                if (name.includes("iphone") && name.includes("pro max"))
+                    priority = 4;
+                else if (name.includes("iphone") && name.includes("pro"))
+                    priority = 3;
+                else if (name.includes("iphone"))
+                    priority = 2;
+                else if (name.includes("ipad"))
+                    priority = 1;
                 bootedDevices.push({
                     name: device.name,
                     udid: device.udid,
                     runtime: runtimeVersion,
+                    priority,
                 });
             }
         }
     }
-    return bootedDevices;
+    // Sort by priority (highest first)
+    bootedDevices.sort((a, b) => b.priority - a.priority);
+    // Remove priority field before returning
+    return bootedDevices.map(({ name, udid, runtime }) => ({ name, udid, runtime }));
 }
 // Map simulator name to deviceId
 function mapSimulatorToDeviceId(simulatorName) {
@@ -776,6 +1147,68 @@ async function isAppRunning(simulatorUDID, bundleId) {
         return false;
     }
 }
+// Helper: Detect platform for bundle ID
+async function detectPlatform(bundleId) {
+    // Check if app exists on macOS
+    try {
+        const { stdout } = await execAsync(`mdfind "kMDItemCFBundleIdentifier == '${bundleId}'" | head -1`);
+        if (stdout.trim()) {
+            return "macos";
+        }
+    }
+    catch {
+        // Not found on macOS
+    }
+    // Check if app exists on any booted iOS simulator
+    try {
+        const simulators = await getBootedSimulators();
+        for (const sim of simulators) {
+            try {
+                await execAsync(`xcrun simctl get_app_container ${sim.udid} ${bundleId}`);
+                return "ios";
+            }
+            catch {
+                // Not on this simulator
+            }
+        }
+    }
+    catch {
+        // No simulators or error
+    }
+    return null;
+}
+// Helper: Capture macOS app window
+async function captureMacOSWindow(bundleId, outputPath) {
+    try {
+        // Get window ID for the app
+        const { stdout: windowInfo } = await execAsync(`
+      osascript -e 'tell application "System Events" to get id of first window of (first process whose bundle identifier is "${bundleId}")'
+    `);
+        const windowId = windowInfo.trim();
+        if (windowId) {
+            // Capture specific window by ID
+            await execAsync(`screencapture -l ${windowId} -o "${outputPath}"`);
+            return fs.existsSync(outputPath);
+        }
+    }
+    catch {
+        // Fallback: capture by app name
+    }
+    // Fallback: use screencapture with window selection
+    try {
+        // Bring app to front and capture
+        await execAsync(`osascript -e 'tell application id "${bundleId}" to activate'`);
+        await sleep(0.5);
+        // Capture the frontmost window
+        await execAsync(`screencapture -o -w "${outputPath}"`);
+        return fs.existsSync(outputPath);
+    }
+    catch (error) {
+        return false;
+    }
+}
+// Track launched simulator for this session
+let lastLaunchedSimulator = null;
 // Handler: Complete reset
 async function handleResetAll(args) {
     if (!args.confirm) {
@@ -823,65 +1256,135 @@ async function handleResetAll(args) {
         });
     }
 }
-// Handler: Launch app and capture
+// Handler: Launch app and capture (supports iOS and macOS)
 async function handleLaunchAndCapture(args) {
     try {
         ensureScreenshotsDir();
-        // Get target simulator
-        const bootedSimulators = await getBootedSimulators();
-        if (bootedSimulators.length === 0) {
-            return JSON.stringify({
-                success: false,
-                error: "No iOS Simulator is running",
-                hint: "Please launch an iOS Simulator first",
-            });
-        }
-        let targetSimulator = args.simulatorUDID
-            ? bootedSimulators.find(s => s.udid === args.simulatorUDID)
-            : bootedSimulators[0];
-        if (!targetSimulator) {
-            return JSON.stringify({
-                success: false,
-                error: "Specified simulator not found",
-                bootedSimulators,
-            });
+        const waitTime = args.waitSeconds || 3;
+        const timestamp = Date.now();
+        const safeBundleId = args.bundleId.replace(/[^a-zA-Z0-9]/g, "_");
+        // Determine platform
+        let platform = args.platform || "auto";
+        if (platform === "auto") {
+            const detected = await detectPlatform(args.bundleId);
+            if (!detected) {
+                return JSON.stringify({
+                    success: false,
+                    error: `App not found: ${args.bundleId}`,
+                    hint: "Make sure the app is installed on macOS or iOS simulator",
+                });
+            }
+            platform = detected;
         }
-        // Terminate app first (clean state)
-        try {
-            await execAsync(`xcrun simctl terminate ${targetSimulator.udid} ${args.bundleId}`);
-            await sleep(0.5);
-        }
-        catch {
-            // App might not be running, that's ok
-        }
-        // Launch the app
-        try {
-            await execAsync(`xcrun simctl launch ${targetSimulator.udid} ${args.bundleId}`);
+        let screenshotPath;
+        let deviceId;
+        let captureInfo = {};
+        if (platform === "macos") {
+            // === macOS App Capture ===
+            screenshotPath = path.join(SCREENSHOTS_DIR, `${safeBundleId}_mac_${timestamp}.png`);
+            // Launch macOS app
+            try {
+                await execAsync(`open -b "${args.bundleId}"`);
+            }
+            catch (launchError) {
+                return JSON.stringify({
+                    success: false,
+                    error: `Failed to launch macOS app: ${launchError.message}`,
+                    bundleId: args.bundleId,
+                });
+            }
+            // Wait for app to load
+            await sleep(waitTime);
+            // Capture window
+            const captured = await captureMacOSWindow(args.bundleId, screenshotPath);
+            if (!captured) {
+                return JSON.stringify({
+                    success: false,
+                    error: "Failed to capture macOS window",
+                    hint: "Make sure the app has a visible window",
+                });
+            }
+            deviceId = args.deviceId || "mac_retina";
+            captureInfo = { platform: "macos" };
         }
-        catch (launchError) {
-            return JSON.stringify({
-                success: false,
-                error: `Failed to launch app: ${launchError.message}`,
-                hint: "Make sure the app is installed on the simulator",
+        else {
+            // === iOS Simulator Capture ===
+            const bootedSimulators = await getBootedSimulators();
+            if (bootedSimulators.length === 0) {
+                return JSON.stringify({
+                    success: false,
+                    error: "No iOS Simulator is running",
+                    hint: "Please launch an iOS Simulator first",
+                });
+            }
+            // Find target simulator
+            let targetSimulator = args.simulatorUDID
+                ? bootedSimulators.find(s => s.udid === args.simulatorUDID)
+                : null;
+            // If not specified, find simulator that has the app installed
+            if (!targetSimulator) {
+                for (const sim of bootedSimulators) {
+                    try {
+                        await execAsync(`xcrun simctl get_app_container ${sim.udid} ${args.bundleId}`);
+                        targetSimulator = sim;
+                        break;
+                    }
+                    catch {
+                        // App not on this simulator
+                    }
+                }
+            }
+            // Fallback to first simulator
+            if (!targetSimulator) {
+                targetSimulator = bootedSimulators[0];
+            }
+            screenshotPath = path.join(SCREENSHOTS_DIR, `${safeBundleId}_ios_${timestamp}.png`);
+            // Terminate app first (clean state)
+            try {
+                await execAsync(`xcrun simctl terminate ${targetSimulator.udid} ${args.bundleId}`);
+                await sleep(0.5);
+            }
+            catch {
+                // App might not be running
+            }
+            // Launch the app
+            try {
+                await execAsync(`xcrun simctl launch ${targetSimulator.udid} ${args.bundleId}`);
+            }
+            catch (launchError) {
+                return JSON.stringify({
+                    success: false,
+                    error: `Failed to launch app: ${launchError.message}`,
+                    hint: "Make sure the app is installed on the simulator",
+                    bundleId: args.bundleId,
+                    simulator: targetSimulator.name,
+                });
+            }
+            // Track this simulator
+            lastLaunchedSimulator = {
+                udid: targetSimulator.udid,
+                name: targetSimulator.name,
                 bundleId: args.bundleId,
-            });
-        }
-        // Wait for app to load
-        const waitTime = args.waitSeconds || 3;
-        await sleep(waitTime);
-        // Capture screenshot
-        const timestamp = Date.now();
-        const safeBundleId = args.bundleId.replace(/[^a-zA-Z0-9]/g, "_");
-        const screenshotPath = path.join(SCREENSHOTS_DIR, `${safeBundleId}_${timestamp}.png`);
-        await execAsync(`xcrun simctl io ${targetSimulator.udid} screenshot "${screenshotPath}"`);
-        if (!fs.existsSync(screenshotPath)) {
-            return JSON.stringify({
-                success: false,
-                error: "Screenshot capture failed",
-            });
+            };
+            // Wait for app to load
+            await sleep(waitTime);
+            // Capture screenshot from specific simulator
+            await execAsync(`xcrun simctl io ${targetSimulator.udid} screenshot "${screenshotPath}"`);
+            if (!fs.existsSync(screenshotPath)) {
+                return JSON.stringify({
+                    success: false,
+                    error: "Screenshot capture failed",
+                });
+            }
+            deviceId = args.deviceId || mapSimulatorToDeviceId(targetSimulator.name);
+            captureInfo = {
+                platform: "ios",
+                simulator: {
+                    name: targetSimulator.name,
+                    udid: targetSimulator.udid,
+                },
+            };
         }
-        // Auto-detect device ID
-        const autoDeviceId = mapSimulatorToDeviceId(targetSimulator.name);
         // Add to preview store
         const store = loadStore();
         const preview = {
@@ -889,7 +1392,7 @@ async function handleLaunchAndCapture(args) {
             screenshotPath: screenshotPath,
             title: args.title,
             subtitle: args.subtitle,
-            deviceId: autoDeviceId,
+            deviceId: deviceId,
             paletteId: args.paletteId || store.settings.defaultPaletteId,
             createdAt: new Date().toISOString(),
         };
@@ -897,11 +1400,8 @@ async function handleLaunchAndCapture(args) {
         saveStore(store);
         return JSON.stringify({
             success: true,
-            message: `App launched and captured: ${args.bundleId}`,
-            simulator: {
-                name: targetSimulator.name,
-                udid: targetSimulator.udid,
-            },
+            message: `App launched and captured (${platform}): ${args.bundleId}`,
+            ...captureInfo,
             waitedSeconds: waitTime,
             preview: preview,
             totalPreviews: store.previews.length,
@@ -1000,10 +1500,805 @@ async function handleCaptureAppScreens(args) {
         });
     }
 }
+// Handler: Complete workflow to create app previews
+async function handleCreateAppPreviews(args) {
+    try {
+        ensureScreenshotsDir();
+        const screenCount = args.screenCount || 3;
+        const palettes = ["ocean", "sunset", "forest", "lavender", "coral"];
+        // Step 1: Reset existing data
+        const dataDir = path.join(process.env.HOME || "~", ".muse-app-preview");
+        if (fs.existsSync(SCREENSHOTS_DIR)) {
+            const files = fs.readdirSync(SCREENSHOTS_DIR);
+            for (const file of files) {
+                fs.unlinkSync(path.join(SCREENSHOTS_DIR, file));
+            }
+        }
+        const store = loadStore();
+        store.previews = [];
+        saveStore(store);
+        // Step 2: Determine device ID based on platform
+        let deviceId;
+        let captureMethod;
+        switch (args.platform) {
+            case "macos":
+                deviceId = "mac_retina";
+                captureMethod = "macos";
+                break;
+            case "watchos":
+                deviceId = "watch_45mm";
+                captureMethod = "watch";
+                break;
+            default:
+                deviceId = "iphone_6_7";
+                captureMethod = "simulator";
+        }
+        // Step 3: Prepare preview definitions
+        const previewDefs = args.previews || [];
+        // If previews not provided, this will be empty and Claude should fill them
+        if (previewDefs.length === 0) {
+            return JSON.stringify({
+                success: false,
+                needsInput: true,
+                message: "Please provide preview titles and subtitles",
+                hint: `Generate ${screenCount} marketing phrases for ${args.appName} in ${args.language}`,
+                template: {
+                    previews: Array.from({ length: screenCount }, (_, i) => ({
+                        title: `[Title ${i + 1}]`,
+                        subtitle: `[Subtitle ${i + 1}]`,
+                        paletteId: palettes[i % palettes.length],
+                    })),
+                },
+                appInfo: {
+                    name: args.appName,
+                    description: args.appDescription,
+                    platform: args.platform,
+                    language: args.language,
+                },
+            });
+        }
+        // Step 4: Capture screenshots based on platform
+        const capturedPreviews = [];
+        if (captureMethod === "macos") {
+            // macOS capture
+            try {
+                await execAsync(`open -b "${args.bundleId}"`);
+            }
+            catch {
+                return JSON.stringify({
+                    success: false,
+                    error: `App not found: ${args.bundleId}`,
+                    hint: "Make sure the macOS app is installed",
+                });
+            }
+            await sleep(3);
+            for (let i = 0; i < previewDefs.length; i++) {
+                const def = previewDefs[i];
+                const timestamp = Date.now();
+                const screenshotPath = path.join(SCREENSHOTS_DIR, `mac_${i + 1}_${timestamp}.png`);
+                const captured = await captureMacOSWindow(args.bundleId, screenshotPath);
+                if (captured) {
+                    const preview = {
+                        id: generateId(),
+                        screenshotPath,
+                        title: def.title,
+                        subtitle: def.subtitle,
+                        deviceId,
+                        paletteId: def.paletteId || palettes[i % palettes.length],
+                        createdAt: new Date().toISOString(),
+                    };
+                    store.previews.push(preview);
+                    capturedPreviews.push(preview);
+                }
+                if (i < previewDefs.length - 1) {
+                    await sleep(2);
+                }
+            }
+        }
+        else {
+            // iOS/watchOS simulator capture
+            const bootedSimulators = await getBootedSimulators();
+            if (bootedSimulators.length === 0) {
+                return JSON.stringify({
+                    success: false,
+                    error: "No iOS Simulator is running",
+                    hint: "Please launch an iOS Simulator first",
+                });
+            }
+            // Find appropriate simulator
+            let targetSimulator = args.simulatorUDID
+                ? bootedSimulators.find(s => s.udid === args.simulatorUDID)
+                : null;
+            if (!targetSimulator) {
+                for (const sim of bootedSimulators) {
+                    try {
+                        await execAsync(`xcrun simctl get_app_container ${sim.udid} ${args.bundleId}`);
+                        targetSimulator = sim;
+                        break;
+                    }
+                    catch { }
+                }
+            }
+            if (!targetSimulator) {
+                targetSimulator = bootedSimulators[0];
+            }
+            // Launch app
+            try {
+                await execAsync(`xcrun simctl terminate ${targetSimulator.udid} ${args.bundleId}`);
+                await sleep(0.5);
+            }
+            catch { }
+            try {
+                await execAsync(`xcrun simctl launch ${targetSimulator.udid} ${args.bundleId}`);
+            }
+            catch (e) {
+                return JSON.stringify({
+                    success: false,
+                    error: `Failed to launch app: ${e.message}`,
+                    hint: "Make sure the app is installed on the simulator",
+                });
+            }
+            // Track simulator
+            lastLaunchedSimulator = {
+                udid: targetSimulator.udid,
+                name: targetSimulator.name,
+                bundleId: args.bundleId,
+            };
+            await sleep(3);
+            deviceId = mapSimulatorToDeviceId(targetSimulator.name);
+            for (let i = 0; i < previewDefs.length; i++) {
+                const def = previewDefs[i];
+                const timestamp = Date.now();
+                const screenshotPath = path.join(SCREENSHOTS_DIR, `ios_${i + 1}_${timestamp}.png`);
+                await execAsync(`xcrun simctl io ${targetSimulator.udid} screenshot "${screenshotPath}"`);
+                if (fs.existsSync(screenshotPath)) {
+                    const preview = {
+                        id: generateId(),
+                        screenshotPath,
+                        title: def.title,
+                        subtitle: def.subtitle,
+                        deviceId,
+                        paletteId: def.paletteId || palettes[i % palettes.length],
+                        createdAt: new Date().toISOString(),
+                    };
+                    store.previews.push(preview);
+                    capturedPreviews.push(preview);
+                }
+                if (i < previewDefs.length - 1) {
+                    await sleep(2);
+                }
+            }
+        }
+        saveStore(store);
+        // Step 5: Send to app or save to folder
+        const pendingPath = path.join(dataDir, "pending-previews.json");
+        fs.writeFileSync(pendingPath, JSON.stringify({ previews: store.previews }, null, 2));
+        let appOpened = false;
+        try {
+            await execAsync(`open -b ${APP_BUNDLE_ID}`);
+            appOpened = true;
+        }
+        catch {
+            // App not installed
+        }
+        if (appOpened) {
+            return JSON.stringify({
+                success: true,
+                message: `Created ${capturedPreviews.length} preview(s) and opened MUSE Preview Maker`,
+                platform: args.platform,
+                language: args.language,
+                previews: capturedPreviews.map(p => ({ title: p.title, subtitle: p.subtitle, paletteId: p.paletteId })),
+                appOpened: true,
+            });
+        }
+        else {
+            // Open folder instead
+            await execAsync(`open "${dataDir}"`);
+            return JSON.stringify({
+                success: true,
+                message: `Created ${capturedPreviews.length} preview(s). MUSE Preview Maker not installed.`,
+                platform: args.platform,
+                language: args.language,
+                previews: capturedPreviews.map(p => ({ title: p.title, subtitle: p.subtitle, paletteId: p.paletteId })),
+                appOpened: false,
+                dataFolder: dataDir,
+                hint: "Install MUSE Preview Maker to generate final images, or use the screenshots directly.",
+            });
+        }
+    }
+    catch (error) {
+        return JSON.stringify({
+            success: false,
+            error: `Create app previews failed: ${error.message}`,
+        });
+    }
+}
+// === Advanced Capture Handlers ===
+// Helper: Get target simulator (uses tracked or finds appropriate one)
+async function getTargetSimulator(simulatorUDID) {
+    const bootedSimulators = await getBootedSimulators();
+    if (bootedSimulators.length === 0)
+        return null;
+    if (simulatorUDID) {
+        return bootedSimulators.find(s => s.udid === simulatorUDID) || null;
+    }
+    // Use last launched simulator if available
+    if (lastLaunchedSimulator) {
+        const found = bootedSimulators.find(s => s.udid === lastLaunchedSimulator.udid);
+        if (found)
+            return found;
+    }
+    return bootedSimulators[0];
+}
+// Helper: Perform touch/gesture via AppleScript (controls Simulator.app window)
+async function simulatorInteract(udid, action, params) {
+    try {
+        // Get simulator window info
+        const { stdout: windowBounds } = await execAsync(`
+      osascript -e 'tell application "Simulator"
+        set frontmost to true
+        delay 0.2
+      end tell'
+    `);
+        // For swipe/scroll by direction, calculate coordinates
+        let startX = params.x || 200;
+        let startY = params.y || 400;
+        let endX = params.toX || startX;
+        let endY = params.toY || startY;
+        const duration = params.duration || 0.3;
+        if (params.direction) {
+            const swipeDistance = 300;
+            switch (params.direction) {
+                case "up":
+                    endY = startY - swipeDistance;
+                    break;
+                case "down":
+                    endY = startY + swipeDistance;
+                    break;
+                case "left":
+                    endX = startX - swipeDistance;
+                    break;
+                case "right":
+                    endX = startX + swipeDistance;
+                    break;
+            }
+        }
+        switch (action) {
+            case "tap":
+                // Use cliclick if available, otherwise AppleScript
+                try {
+                    await execAsync(`cliclick c:${startX},${startY}`);
+                }
+                catch {
+                    // Fallback: Use AppleScript to click
+                    await execAsync(`
+            osascript -e 'tell application "System Events"
+              tell process "Simulator"
+                click at {${startX}, ${startY}}
+              end tell
+            end tell'
+          `);
+                }
+                break;
+            case "swipe":
+            case "scroll":
+                // Use AppleScript for swipe gesture
+                await execAsync(`
+          osascript -e 'tell application "System Events"
+            tell process "Simulator"
+              set frontmost to true
+            end tell
+          end tell'
+        `);
+                // Simctl doesn't have direct swipe, but we can use privacy/UI automation
+                // For now, use key events for scrolling
+                if (action === "scroll") {
+                    const scrollKey = params.direction === "up" || params.direction === "left" ? "126" : "125";
+                    const count = 5;
+                    for (let i = 0; i < count; i++) {
+                        await execAsync(`
+              osascript -e 'tell application "System Events" to key code ${scrollKey}'
+            `);
+                        await sleep(0.1);
+                    }
+                }
+                break;
+            case "type":
+                if (params.text) {
+                    // Type text character by character
+                    await execAsync(`
+            osascript -e 'tell application "System Events"
+              tell process "Simulator"
+                set frontmost to true
+                keystroke "${params.text.replace(/"/g, '\\"')}"
+              end tell
+            end tell'
+          `);
+                }
+                break;
+            case "home":
+                await execAsync(`xcrun simctl ui ${udid} home`);
+                break;
+            case "shake":
+                // Trigger shake gesture (useful for debug menus)
+                await execAsync(`
+          osascript -e 'tell application "Simulator" to activate' -e 'tell application "System Events" to keystroke "z" using {control down, command down}'
+        `);
+                break;
+        }
+        return true;
+    }
+    catch (error) {
+        console.error("Simulator interaction failed:", error);
+        return false;
+    }
+}
+// Handler: Interact with simulator
+async function handleInteractSimulator(args) {
+    try {
+        const simulator = await getTargetSimulator(args.simulatorUDID);
+        if (!simulator) {
+            return JSON.stringify({
+                success: false,
+                error: "No iOS Simulator is running",
+            });
+        }
+        const success = await simulatorInteract(simulator.udid, args.action, {
+            x: args.x,
+            y: args.y,
+            toX: args.toX,
+            toY: args.toY,
+            direction: args.direction,
+            text: args.text,
+            duration: args.duration,
+        });
+        return JSON.stringify({
+            success,
+            message: success ? `Performed ${args.action} on simulator` : `${args.action} failed`,
+            simulator: { name: simulator.name, udid: simulator.udid },
+            action: args.action,
+            params: { x: args.x, y: args.y, direction: args.direction },
+        });
+    }
+    catch (error) {
+        return JSON.stringify({
+            success: false,
+            error: `Interact failed: ${error.message}`,
+        });
+    }
+}
+// Handler: Navigate app via deep link
+async function handleNavigateApp(args) {
+    try {
+        const simulator = await getTargetSimulator(args.simulatorUDID);
+        if (!simulator) {
+            return JSON.stringify({
+                success: false,
+                error: "No iOS Simulator is running",
+            });
+        }
+        // Open URL in simulator
+        await execAsync(`xcrun simctl openurl ${simulator.udid} "${args.url}"`);
+        // Wait for navigation
+        await sleep(args.waitSeconds || 2);
+        return JSON.stringify({
+            success: true,
+            message: `Navigated to ${args.url}`,
+            simulator: { name: simulator.name, udid: simulator.udid },
+            url: args.url,
+        });
+    }
+    catch (error) {
+        return JSON.stringify({
+            success: false,
+            error: `Navigation failed: ${error.message}`,
+        });
+    }
+}
+// Handler: Configure simulator
+async function handleConfigureSimulator(args) {
+    try {
+        const simulator = await getTargetSimulator(args.simulatorUDID);
+        if (!simulator) {
+            return JSON.stringify({
+                success: false,
+                error: "No iOS Simulator is running",
+            });
+        }
+        const changes = [];
+        // Override status bar
+        if (args.statusBarTime || args.batteryLevel !== undefined || args.cellularBars !== undefined || args.wifiBars !== undefined) {
+            let statusBarCmd = `xcrun simctl status_bar ${simulator.udid} override`;
+            if (args.statusBarTime) {
+                statusBarCmd += ` --time "${args.statusBarTime}"`;
+                changes.push(`time: ${args.statusBarTime}`);
+            }
+            if (args.batteryLevel !== undefined) {
+                statusBarCmd += ` --batteryLevel ${args.batteryLevel}`;
+                changes.push(`battery: ${args.batteryLevel}%`);
+            }
+            if (args.batteryState) {
+                statusBarCmd += ` --batteryState ${args.batteryState}`;
+                changes.push(`batteryState: ${args.batteryState}`);
+            }
+            if (args.cellularBars !== undefined) {
+                statusBarCmd += ` --cellularBars ${args.cellularBars}`;
+                changes.push(`cellular: ${args.cellularBars} bars`);
+            }
+            if (args.wifiBars !== undefined) {
+                statusBarCmd += ` --wifiBars ${args.wifiBars}`;
+                changes.push(`wifi: ${args.wifiBars} bars`);
+            }
+            await execAsync(statusBarCmd);
+        }
+        // Set appearance (dark/light mode)
+        if (args.appearance) {
+            await execAsync(`xcrun simctl ui ${simulator.udid} appearance ${args.appearance}`);
+            changes.push(`appearance: ${args.appearance}`);
+        }
+        return JSON.stringify({
+            success: true,
+            message: "Simulator configured",
+            simulator: { name: simulator.name, udid: simulator.udid },
+            changes,
+        });
+    }
+    catch (error) {
+        return JSON.stringify({
+            success: false,
+            error: `Configure failed: ${error.message}`,
+        });
+    }
+}
+// Handler: Auto capture flow
+async function handleAutoCaptureFlow(args) {
+    try {
+        ensureScreenshotsDir();
+        const simulator = await getTargetSimulator(args.simulatorUDID);
+        if (!simulator) {
+            return JSON.stringify({
+                success: false,
+                error: "No iOS Simulator is running",
+            });
+        }
+        // Reset if requested
+        if (args.resetFirst !== false) {
+            try {
+                await execAsync(`xcrun simctl terminate ${simulator.udid} ${args.bundleId}`);
+                await sleep(0.5);
+            }
+            catch { }
+        }
+        // Launch app
+        try {
+            await execAsync(`xcrun simctl launch ${simulator.udid} ${args.bundleId}`);
+            await sleep(2);
+        }
+        catch (e) {
+            return JSON.stringify({
+                success: false,
+                error: `Failed to launch app: ${e.message}`,
+            });
+        }
+        // Track this simulator
+        lastLaunchedSimulator = {
+            udid: simulator.udid,
+            name: simulator.name,
+            bundleId: args.bundleId,
+        };
+        const store = loadStore();
+        const capturedPreviews = [];
+        const palettes = ["ocean", "sunset", "forest", "lavender", "coral"];
+        const deviceId = mapSimulatorToDeviceId(simulator.name);
+        let captureIndex = 0;
+        // Execute flow
+        for (let i = 0; i < args.flow.length; i++) {
+            const step = args.flow[i];
+            switch (step.action) {
+                case "capture":
+                    const timestamp = Date.now();
+                    const screenshotPath = path.join(SCREENSHOTS_DIR, `flow_${captureIndex + 1}_${timestamp}.png`);
+                    await execAsync(`xcrun simctl io ${simulator.udid} screenshot "${screenshotPath}"`);
+                    if (fs.existsSync(screenshotPath)) {
+                        const preview = {
+                            id: generateId(),
+                            screenshotPath,
+                            title: step.title || `Screen ${captureIndex + 1}`,
+                            subtitle: step.subtitle || "",
+                            deviceId,
+                            paletteId: step.paletteId || palettes[captureIndex % palettes.length],
+                            createdAt: new Date().toISOString(),
+                        };
+                        store.previews.push(preview);
+                        capturedPreviews.push(preview);
+                        captureIndex++;
+                    }
+                    break;
+                case "tap":
+                case "swipe":
+                case "scroll":
+                case "type":
+                    await simulatorInteract(simulator.udid, step.action, {
+                        x: step.x,
+                        y: step.y,
+                        toX: step.toX,
+                        toY: step.toY,
+                        direction: step.direction,
+                        text: step.text,
+                    });
+                    await sleep(0.5);
+                    break;
+                case "wait":
+                    await sleep(step.seconds || 1);
+                    break;
+                case "navigate":
+                    if (step.url) {
+                        await execAsync(`xcrun simctl openurl ${simulator.udid} "${step.url}"`);
+                        await sleep(step.seconds || 2);
+                    }
+                    break;
+            }
+        }
+        saveStore(store);
+        return JSON.stringify({
+            success: true,
+            message: `Executed flow with ${args.flow.length} steps, captured ${capturedPreviews.length} screenshots`,
+            simulator: { name: simulator.name, udid: simulator.udid },
+            previews: capturedPreviews.map(p => ({ title: p.title, subtitle: p.subtitle })),
+            totalPreviews: store.previews.length,
+        });
+    }
+    catch (error) {
+        return JSON.stringify({
+            success: false,
+            error: `Auto capture flow failed: ${error.message}`,
+        });
+    }
+}
+// Handler: Scroll and capture
+async function handleScrollAndCapture(args) {
+    try {
+        ensureScreenshotsDir();
+        const simulator = await getTargetSimulator(args.simulatorUDID);
+        if (!simulator) {
+            return JSON.stringify({
+                success: false,
+                error: "No iOS Simulator is running",
+            });
+        }
+        const scrollCount = args.scrollCount || 3;
+        const direction = args.direction || "down";
+        const waitBetween = args.waitBetween || 1;
+        const palettes = ["ocean", "sunset", "forest", "lavender", "coral"];
+        const store = loadStore();
+        const capturedPreviews = [];
+        const deviceId = mapSimulatorToDeviceId(simulator.name);
+        // Capture initial state
+        const initialTimestamp = Date.now();
+        const initialPath = path.join(SCREENSHOTS_DIR, `scroll_0_${initialTimestamp}.png`);
+        await execAsync(`xcrun simctl io ${simulator.udid} screenshot "${initialPath}"`);
+        if (fs.existsSync(initialPath)) {
+            const preview = {
+                id: generateId(),
+                screenshotPath: initialPath,
+                title: args.titles?.[0] || "Overview",
+                subtitle: args.subtitles?.[0] || "",
+                deviceId,
+                paletteId: args.paletteIds?.[0] || palettes[0],
+                createdAt: new Date().toISOString(),
+            };
+            store.previews.push(preview);
+            capturedPreviews.push(preview);
+        }
+        // Scroll and capture
+        for (let i = 0; i < scrollCount; i++) {
+            await simulatorInteract(simulator.udid, "scroll", { direction });
+            await sleep(waitBetween);
+            if (args.captureEach !== false) {
+                const timestamp = Date.now();
+                const screenshotPath = path.join(SCREENSHOTS_DIR, `scroll_${i + 1}_${timestamp}.png`);
+                await execAsync(`xcrun simctl io ${simulator.udid} screenshot "${screenshotPath}"`);
+                if (fs.existsSync(screenshotPath)) {
+                    const preview = {
+                        id: generateId(),
+                        screenshotPath,
+                        title: args.titles?.[i + 1] || `Section ${i + 2}`,
+                        subtitle: args.subtitles?.[i + 1] || "",
+                        deviceId,
+                        paletteId: args.paletteIds?.[i + 1] || palettes[(i + 1) % palettes.length],
+                        createdAt: new Date().toISOString(),
+                    };
+                    store.previews.push(preview);
+                    capturedPreviews.push(preview);
+                }
+            }
+        }
+        saveStore(store);
+        return JSON.stringify({
+            success: true,
+            message: `Scrolled ${scrollCount} times and captured ${capturedPreviews.length} screenshots`,
+            simulator: { name: simulator.name, udid: simulator.udid },
+            previews: capturedPreviews.map(p => ({ title: p.title, subtitle: p.subtitle })),
+            totalPreviews: store.previews.length,
+        });
+    }
+    catch (error) {
+        return JSON.stringify({
+            success: false,
+            error: `Scroll and capture failed: ${error.message}`,
+        });
+    }
+}
+// Handler: Batch capture on multiple devices
+async function handleBatchCaptureDevices(args) {
+    try {
+        ensureScreenshotsDir();
+        const bootedSimulators = await getBootedSimulators();
+        if (bootedSimulators.length === 0) {
+            return JSON.stringify({
+                success: false,
+                error: "No iOS Simulators are running",
+            });
+        }
+        const waitSeconds = args.waitSeconds || 3;
+        const store = loadStore();
+        const capturedPreviews = [];
+        // If specific devices requested, filter
+        let targetSimulators = bootedSimulators;
+        if (args.devices && args.devices.length > 0) {
+            targetSimulators = bootedSimulators.filter(s => args.devices.some(d => s.name.toLowerCase().includes(d.toLowerCase()) || s.udid === d));
+        }
+        if (targetSimulators.length === 0) {
+            return JSON.stringify({
+                success: false,
+                error: "No matching simulators found",
+                availableSimulators: bootedSimulators.map(s => s.name),
+            });
+        }
+        // Capture on each device
+        for (const simulator of targetSimulators) {
+            // Launch app
+            try {
+                await execAsync(`xcrun simctl terminate ${simulator.udid} ${args.bundleId}`);
+                await sleep(0.3);
+            }
+            catch { }
+            try {
+                await execAsync(`xcrun simctl launch ${simulator.udid} ${args.bundleId}`);
+            }
+            catch (e) {
+                continue; // Skip if app not installed on this device
+            }
+            await sleep(waitSeconds);
+            // Capture
+            const timestamp = Date.now();
+            const safeName = simulator.name.replace(/[^a-zA-Z0-9]/g, "_");
+            const screenshotPath = path.join(SCREENSHOTS_DIR, `batch_${safeName}_${timestamp}.png`);
+            await execAsync(`xcrun simctl io ${simulator.udid} screenshot "${screenshotPath}"`);
+            if (fs.existsSync(screenshotPath)) {
+                const preview = {
+                    id: generateId(),
+                    screenshotPath,
+                    title: args.title,
+                    subtitle: args.subtitle,
+                    deviceId: mapSimulatorToDeviceId(simulator.name),
+                    paletteId: args.paletteId || store.settings.defaultPaletteId,
+                    createdAt: new Date().toISOString(),
+                };
+                store.previews.push(preview);
+                capturedPreviews.push(preview);
+            }
+        }
+        saveStore(store);
+        return JSON.stringify({
+            success: true,
+            message: `Captured on ${capturedPreviews.length} device(s)`,
+            previews: capturedPreviews.map(p => ({
+                title: p.title,
+                deviceId: p.deviceId,
+            })),
+            totalPreviews: store.previews.length,
+        });
+    }
+    catch (error) {
+        return JSON.stringify({
+            success: false,
+            error: `Batch capture failed: ${error.message}`,
+        });
+    }
+}
+// Handler: Record and extract frames
+async function handleRecordAndExtract(args) {
+    try {
+        ensureScreenshotsDir();
+        const simulator = await getTargetSimulator(args.simulatorUDID);
+        if (!simulator) {
+            return JSON.stringify({
+                success: false,
+                error: "No iOS Simulator is running",
+            });
+        }
+        const duration = args.duration || 5;
+        const frameCount = args.frameCount || 3;
+        const palettes = ["ocean", "sunset", "forest", "lavender", "coral"];
+        // Record video
+        const timestamp = Date.now();
+        const videoPath = path.join(SCREENSHOTS_DIR, `recording_${timestamp}.mp4`);
+        // Start recording in background
+        const recordProcess = exec(`xcrun simctl io ${simulator.udid} recordVideo --codec=h264 "${videoPath}"`);
+        // Wait for duration
+        await sleep(duration);
+        // Stop recording
+        recordProcess.kill("SIGINT");
+        await sleep(1);
+        // Check if video was created
+        if (!fs.existsSync(videoPath)) {
+            return JSON.stringify({
+                success: false,
+                error: "Failed to record video",
+            });
+        }
+        // Extract frames using ffmpeg
+        const store = loadStore();
+        const capturedPreviews = [];
+        const deviceId = mapSimulatorToDeviceId(simulator.name);
+        try {
+            // Get video duration
+            const { stdout: durationInfo } = await execAsync(`ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 "${videoPath}"`);
+            const videoDuration = parseFloat(durationInfo.trim());
+            const interval = videoDuration / (frameCount + 1);
+            for (let i = 0; i < frameCount; i++) {
+                const timeOffset = interval * (i + 1);
+                const framePath = path.join(SCREENSHOTS_DIR, `frame_${i + 1}_${timestamp}.png`);
+                await execAsync(`ffmpeg -ss ${timeOffset} -i "${videoPath}" -vframes 1 -q:v 2 "${framePath}" -y`);
+                if (fs.existsSync(framePath)) {
+                    const preview = {
+                        id: generateId(),
+                        screenshotPath: framePath,
+                        title: args.titles?.[i] || `Frame ${i + 1}`,
+                        subtitle: args.subtitles?.[i] || "",
+                        deviceId,
+                        paletteId: palettes[i % palettes.length],
+                        createdAt: new Date().toISOString(),
+                    };
+                    store.previews.push(preview);
+                    capturedPreviews.push(preview);
+                }
+            }
+        }
+        catch (ffmpegError) {
+            // ffmpeg not available, fall back to regular captures at intervals
+            return JSON.stringify({
+                success: false,
+                error: "ffmpeg not found. Install it with: brew install ffmpeg",
+                hint: "Use scroll_and_capture or auto_capture_flow as alternatives",
+            });
+        }
+        // Clean up video file
+        try {
+            fs.unlinkSync(videoPath);
+        }
+        catch { }
+        saveStore(store);
+        return JSON.stringify({
+            success: true,
+            message: `Recorded ${duration}s video and extracted ${capturedPreviews.length} frames`,
+            simulator: { name: simulator.name, udid: simulator.udid },
+            previews: capturedPreviews.map(p => ({ title: p.title, subtitle: p.subtitle })),
+            totalPreviews: store.previews.length,
+        });
+    }
+    catch (error) {
+        return JSON.stringify({
+            success: false,
+            error: `Record and extract failed: ${error.message}`,
+        });
+    }
+}
 // Main server setup
 const server = new Server({
     name: "muse-app-preview-mcp",
-    version: "1.2.0",
+    version: "1.5.0",
 }, {
     capabilities: {
         tools: {},
@@ -1060,6 +2355,31 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         case "capture_app_screens":
             result = await handleCaptureAppScreens(args);
             break;
+        case "create_app_previews":
+            result = await handleCreateAppPreviews(args);
+            break;
+        // Advanced Capture Tools
+        case "interact_simulator":
+            result = await handleInteractSimulator(args);
+            break;
+        case "navigate_app":
+            result = await handleNavigateApp(args);
+            break;
+        case "configure_simulator":
+            result = await handleConfigureSimulator(args);
+            break;
+        case "auto_capture_flow":
+            result = await handleAutoCaptureFlow(args);
+            break;
+        case "scroll_and_capture":
+            result = await handleScrollAndCapture(args);
+            break;
+        case "batch_capture_devices":
+            result = await handleBatchCaptureDevices(args);
+            break;
+        case "record_and_extract":
+            result = await handleRecordAndExtract(args);
+            break;
         default:
             result = JSON.stringify({ error: `Unknown tool: ${name}` });
     }