auto-feedback 0.1.0

package/build/tools/get-console-logs.js

@@ -0,0 +1,55 @@
+/**
+ * MCP Tool 19: get_console_logs
+ * Retrieves browser console logs captured during a session.
+ */
+import { z } from "zod";
+import { createToolError, createToolResult } from "../utils/errors.js";
+export function registerGetConsoleLogsTool(server, sessionManager) {
+    server.tool("get_console_logs", "Get browser console logs captured during the session. Use to check for warnings, errors, or debug output from web apps.", {
+        sessionId: z.string().describe("Session ID to get logs from"),
+        level: z
+            .enum(["all", "log", "error", "warning", "info", "debug"])
+            .optional()
+            .describe("Filter by log level (default: all)"),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(1000)
+            .optional()
+            .describe("Max entries to return, most recent first (default: 100)"),
+    }, async ({ sessionId, level, limit }) => {
+        const session = sessionManager.get(sessionId);
+        if (!session) {
+            return createToolError(`Session not found: ${sessionId}`, "The session may have already been ended or never existed", "Create a session first with create_session.");
+        }
+        const collectors = sessionManager.getConsoleCollectors(sessionId);
+        if (collectors.length === 0) {
+            return createToolResult({
+                count: 0,
+                truncated: false,
+                entries: [],
+                note: "No console logs captured yet — ensure a page exists in this session",
+            });
+        }
+        // Aggregate entries from all collectors
+        let entries = collectors.flatMap((c) => [...c.getEntries()]);
+        // Filter by level if specified
+        if (level && level !== "all") {
+            entries = entries.filter((entry) => entry.level === level);
+        }
+        // Sort by timestamp descending (newest first)
+        entries.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+        // Apply limit
+        const maxEntries = limit ?? 100;
+        const truncated = entries.length > maxEntries;
+        const totalCount = entries.length;
+        entries = entries.slice(0, maxEntries);
+        return createToolResult({
+            count: entries.length,
+            totalAvailable: totalCount,
+            truncated,
+            entries,
+        });
+    });
+}

package/build/tools/get-element-state.d.ts

@@ -0,0 +1,14 @@
+/**
+ * get_element_state MCP tool
+ * Reads comprehensive UI element state in a single call: text, visibility,
+ * enabled/editable status, attributes, and bounding box.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SessionManager } from "../session-manager.js";
+/**
+ * Register the get_element_state tool with the MCP server
+ *
+ * @param server - MCP server instance
+ * @param sessionManager - Session manager for resource tracking
+ */
+export declare function registerGetElementStateTool(server: McpServer, sessionManager: SessionManager): void;

package/build/tools/get-element-state.js

@@ -0,0 +1,116 @@
+/**
+ * get_element_state MCP tool
+ * Reads comprehensive UI element state in a single call: text, visibility,
+ * enabled/editable status, attributes, and bounding box.
+ */
+import { z } from "zod";
+import { createToolError, createToolResult } from "../utils/errors.js";
+import { resolveSelector, getActivePage } from "../interaction/selectors.js";
+/**
+ * Register the get_element_state tool with the MCP server
+ *
+ * @param server - MCP server instance
+ * @param sessionManager - Session manager for resource tracking
+ */
+export function registerGetElementStateTool(server, sessionManager) {
+    server.tool("get_element_state", "Read element state: text, visibility, enabled, attributes. Use to verify UI state without taking a screenshot.", {
+        sessionId: z
+            .string()
+            .describe("Session ID from create_session"),
+        selector: z
+            .string()
+            .describe("Element selector. CSS: #id, .class, div > span. Text: text=Click me. Role: role=button[name='Submit']. Test ID: testid=my-btn"),
+        pageIdentifier: z
+            .string()
+            .optional()
+            .describe("URL or 'electron' to target a specific page. Omit if session has only one page."),
+        attributes: z
+            .array(z.string())
+            .optional()
+            .describe("Attribute names to read (e.g., ['href', 'class', 'aria-label']). Omit to skip attribute reading."),
+        timeout: z
+            .number()
+            .int()
+            .min(0)
+            .optional()
+            .describe("Max wait time in ms (default: 30000)"),
+    }, async ({ sessionId, selector, pageIdentifier, attributes, timeout }) => {
+        try {
+            // Validate session exists
+            const session = sessionManager.get(sessionId);
+            if (!session) {
+                const availableSessions = sessionManager.list();
+                return createToolError(`Session not found: ${sessionId}`, "The session may have already been ended", availableSessions.length > 0
+                    ? `Available sessions: ${availableSessions.join(", ")}`
+                    : "Create a session first with create_session.");
+            }
+            // Find the active page
+            const pageResult = getActivePage(sessionManager, sessionId, pageIdentifier);
+            if (!pageResult.success) {
+                return createToolError(pageResult.error, `Session: ${sessionId}`, pageResult.availablePages
+                    ? `Available pages: ${pageResult.availablePages.join(", ")}`
+                    : undefined);
+            }
+            const { page } = pageResult;
+            const effectiveTimeout = timeout ?? 30000;
+            // Resolve selector to Playwright Locator
+            const locator = resolveSelector(page, selector);
+            // Auto-wait gate: ensure element is in DOM before reading state
+            await locator.waitFor({
+                state: "attached",
+                timeout: effectiveTimeout,
+            });
+            // Read core state properties in parallel
+            const [text, innerTextVal, visible, enabled, editable] = await Promise.all([
+                locator.textContent({ timeout: effectiveTimeout }),
+                locator.innerText({ timeout: effectiveTimeout }),
+                locator.isVisible(),
+                locator.isEnabled({ timeout: effectiveTimeout }),
+                locator.isEditable({ timeout: effectiveTimeout }).catch(() => false),
+            ]);
+            // Read optional properties (return null for non-applicable elements)
+            const [inputVal, checked] = await Promise.all([
+                locator.inputValue({ timeout: effectiveTimeout }).catch(() => null),
+                locator.isChecked({ timeout: effectiveTimeout }).catch(() => null),
+            ]);
+            // Read bounding box (null if element not visible)
+            const box = await locator.boundingBox();
+            // Read requested attributes
+            const attrs = {};
+            if (attributes) {
+                for (const name of attributes) {
+                    attrs[name] = await locator.getAttribute(name, {
+                        timeout: effectiveTimeout,
+                    });
+                }
+            }
+            // Return structured state (text-only, no screenshot)
+            return createToolResult({
+                selector,
+                visible,
+                enabled,
+                editable,
+                checked,
+                textContent: text,
+                innerText: innerTextVal,
+                inputValue: inputVal,
+                attributes: attrs,
+                boundingBox: box,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            // Strict mode violation: selector matched multiple elements
+            if (message.includes("strict mode violation")) {
+                return createToolError("Selector matched multiple elements", `Selector "${selector}" matched more than one element (strict mode violation)`, "Use a more specific selector or add :nth-child(), :first-of-type, or similar to target a single element.");
+            }
+            // Timeout: element not found or not attached within timeout
+            if (message.includes("Timeout") ||
+                message.includes("timeout")) {
+                return createToolError("Element not found within timeout", `Selector "${selector}" did not match any element within ${timeout ?? 30000}ms`, "Check the selector is correct, the element exists in the DOM, or increase the timeout. Take a screenshot first to verify the page state.");
+            }
+            // Default error
+            return createToolError("Failed to read element state", `Selector: "${selector}" — ${message}`, "Take a screenshot to verify the element exists and is visible on the page.");
+        }
+    });
+}

package/build/tools/get-errors.d.ts

@@ -0,0 +1,7 @@
+/**
+ * MCP Tool 20: get_errors
+ * Retrieves runtime errors and page crashes captured during a session.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SessionManager } from "../session-manager.js";
+export declare function registerGetErrorsTool(server: McpServer, sessionManager: SessionManager): void;

package/build/tools/get-errors.js

@@ -0,0 +1,40 @@
+/**
+ * MCP Tool 20: get_errors
+ * Retrieves runtime errors and page crashes captured during a session.
+ */
+import { z } from "zod";
+import { createToolError, createToolResult } from "../utils/errors.js";
+export function registerGetErrorsTool(server, sessionManager) {
+    server.tool("get_errors", "Get runtime errors and page crashes captured during the session. Use to diagnose uncaught exceptions or page crashes in web apps.", {
+        sessionId: z.string().describe("Session ID to get errors from"),
+        type: z
+            .enum(["all", "uncaught-exception", "page-crash"])
+            .optional()
+            .describe("Filter by error type (default: all)"),
+    }, async ({ sessionId, type }) => {
+        const session = sessionManager.get(sessionId);
+        if (!session) {
+            return createToolError(`Session not found: ${sessionId}`, "The session may have already been ended or never existed", "Create a session first with create_session.");
+        }
+        const collectors = sessionManager.getErrorCollectors(sessionId);
+        if (collectors.length === 0) {
+            return createToolResult({
+                count: 0,
+                entries: [],
+                note: "No errors captured yet — ensure a page exists in this session",
+            });
+        }
+        // Aggregate entries from all collectors
+        let entries = collectors.flatMap((c) => [...c.getEntries()]);
+        // Filter by type if specified
+        if (type && type !== "all") {
+            entries = entries.filter((entry) => entry.type === type);
+        }
+        // Sort by timestamp descending (newest first)
+        entries.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+        return createToolResult({
+            count: entries.length,
+            entries,
+        });
+    });
+}

package/build/tools/get-network-logs.d.ts

@@ -0,0 +1,7 @@
+/**
+ * MCP Tool 21: get_network_logs
+ * Retrieves HTTP request/response logs captured during a session.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SessionManager } from "../session-manager.js";
+export declare function registerGetNetworkLogsTool(server: McpServer, sessionManager: SessionManager): void;

package/build/tools/get-network-logs.js

@@ -0,0 +1,58 @@
+/**
+ * MCP Tool 21: get_network_logs
+ * Retrieves HTTP request/response logs captured during a session.
+ */
+import { z } from "zod";
+import { createToolError, createToolResult } from "../utils/errors.js";
+export function registerGetNetworkLogsTool(server, sessionManager) {
+    server.tool("get_network_logs", "Get HTTP request/response logs captured during the session. Use to inspect API calls, failed requests, or slow responses in web apps.", {
+        sessionId: z.string().describe("Session ID to get network logs from"),
+        filter: z
+            .enum(["all", "failed", "errors"])
+            .optional()
+            .describe("Filter: 'failed' = status 0 (network errors), 'errors' = status >= 400 or 0 (default: all)"),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(500)
+            .optional()
+            .describe("Max entries to return, most recent first (default: 100)"),
+    }, async ({ sessionId, filter, limit }) => {
+        const session = sessionManager.get(sessionId);
+        if (!session) {
+            return createToolError(`Session not found: ${sessionId}`, "The session may have already been ended or never existed", "Create a session first with create_session.");
+        }
+        const collectors = sessionManager.getNetworkCollectors(sessionId);
+        if (collectors.length === 0) {
+            return createToolResult({
+                count: 0,
+                truncated: false,
+                entries: [],
+                note: "No network logs captured yet — ensure a page exists in this session",
+            });
+        }
+        // Aggregate entries from all collectors
+        let entries = collectors.flatMap((c) => [...c.getEntries()]);
+        // Apply filter
+        if (filter === "failed") {
+            entries = entries.filter((entry) => entry.status === 0);
+        }
+        else if (filter === "errors") {
+            entries = entries.filter((entry) => entry.status === 0 || entry.status >= 400);
+        }
+        // Sort by timestamp descending (newest first)
+        entries.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+        // Apply limit
+        const maxEntries = limit ?? 100;
+        const truncated = entries.length > maxEntries;
+        const totalCount = entries.length;
+        entries = entries.slice(0, maxEntries);
+        return createToolResult({
+            count: entries.length,
+            totalAvailable: totalCount,
+            truncated,
+            entries,
+        });
+    });
+}

package/build/tools/get-process-output.d.ts

@@ -0,0 +1,7 @@
+/**
+ * MCP Tool 22: get_process_output
+ * Retrieves stdout/stderr output from spawned processes in a session.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SessionManager } from "../session-manager.js";
+export declare function registerGetProcessOutputTool(server: McpServer, sessionManager: SessionManager): void;

package/build/tools/get-process-output.js

@@ -0,0 +1,55 @@
+/**
+ * MCP Tool 22: get_process_output
+ * Retrieves stdout/stderr output from spawned processes in a session.
+ */
+import { z } from "zod";
+import { createToolError, createToolResult } from "../utils/errors.js";
+export function registerGetProcessOutputTool(server, sessionManager) {
+    server.tool("get_process_output", "Get stdout/stderr output from spawned processes in the session. Use to check dev server logs, build errors, or runtime output.", {
+        sessionId: z.string().describe("Session ID to get output from"),
+        stream: z
+            .enum(["all", "stdout", "stderr"])
+            .optional()
+            .describe("Filter by output stream (default: all)"),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(5000)
+            .optional()
+            .describe("Max lines to return, most recent first (default: 200)"),
+    }, async ({ sessionId, stream, limit }) => {
+        const session = sessionManager.get(sessionId);
+        if (!session) {
+            return createToolError(`Session not found: ${sessionId}`, "The session may have already been ended or never existed", "Create a session first with create_session.");
+        }
+        const collectors = sessionManager.getProcessCollectors(sessionId);
+        if (collectors.length === 0) {
+            return createToolResult({
+                count: 0,
+                truncated: false,
+                entries: [],
+                note: "No process output captured yet — ensure a process exists in this session",
+            });
+        }
+        // Aggregate entries from all collectors
+        let entries = collectors.flatMap((c) => [...c.getEntries()]);
+        // Filter by stream if specified
+        if (stream && stream !== "all") {
+            entries = entries.filter((entry) => entry.stream === stream);
+        }
+        // Sort by timestamp descending (newest first)
+        entries.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+        // Apply limit
+        const maxEntries = limit ?? 200;
+        const truncated = entries.length > maxEntries;
+        const totalCount = entries.length;
+        entries = entries.slice(0, maxEntries);
+        return createToolResult({
+            count: entries.length,
+            totalAvailable: totalCount,
+            truncated,
+            entries,
+        });
+    });
+}

package/build/tools/get-screenshot.d.ts

@@ -0,0 +1,7 @@
+/**
+ * get_screenshot MCP tool
+ * Retrieves the most recent auto-captured screenshot for a session
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SessionManager } from "../session-manager.js";
+export declare function registerGetScreenshotTool(server: McpServer, sessionManager: SessionManager): void;

package/build/tools/get-screenshot.js

@@ -0,0 +1,32 @@
+/**
+ * get_screenshot MCP tool
+ * Retrieves the most recent auto-captured screenshot for a session
+ */
+import { z } from "zod";
+import { createToolError, createScreenshotResult } from "../utils/errors.js";
+export function registerGetScreenshotTool(server, sessionManager) {
+    server.tool("get_screenshot", "Get the most recent auto-captured screenshot for a session. Use to check current visual state without triggering a new capture.", {
+        sessionId: z.string().describe("Session ID to get the screenshot for"),
+    }, async ({ sessionId }) => {
+        try {
+            const session = sessionManager.get(sessionId);
+            if (!session) {
+                return createToolError(`Session not found: ${sessionId}`, "The session may have already been ended", "Create a session first with create_session.");
+            }
+            const autoCapture = sessionManager.getAutoCapture(sessionId);
+            if (!autoCapture) {
+                return createToolError("No auto-captured screenshot available", `Session ${sessionId} has no auto-capture yet. Auto-captures are taken after page navigations in web and Electron apps.`, "Use screenshot_web, screenshot_electron, or screenshot_desktop for an on-demand capture. Or navigate the app to trigger an auto-capture.");
+            }
+            return createScreenshotResult({
+                sessionId,
+                source: "auto-capture",
+                url: autoCapture.url,
+                capturedAt: autoCapture.capturedAt.toISOString(),
+            }, autoCapture.imageBase64, autoCapture.mimeType);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return createToolError("Failed to retrieve screenshot", message, "Check the session ID is valid.");
+        }
+    });
+}

package/build/tools/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * MCP tool registration
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SessionManager } from "../session-manager.js";
+/**
+ * Register all MCP tools with the server
+ */
+export declare function registerTools(server: McpServer, sessionManager: SessionManager): void;

package/build/tools/index.js

@@ -0,0 +1,117 @@
+/**
+ * MCP tool registration
+ */
+import { z } from "zod";
+import { createToolError, createToolResult } from "../utils/errors.js";
+import { registerCheckPortTool } from "./check-port.js";
+import { registerLaunchWebServerTool } from "./launch-web-server.js";
+import { registerLaunchElectronTool } from "./launch-electron.js";
+import { registerLaunchWindowsExeTool } from "./launch-windows-exe.js";
+import { registerStopProcessTool } from "./stop-process.js";
+import { registerScreenshotWebTool } from "./screenshot-web.js";
+import { registerScreenshotElectronTool } from "./screenshot-electron.js";
+import { registerScreenshotDesktopTool } from "./screenshot-desktop.js";
+import { registerGetScreenshotTool } from "./get-screenshot.js";
+import { registerClickElementTool } from "./click-element.js";
+import { registerTypeTextTool } from "./type-text.js";
+import { registerNavigateTool } from "./navigate.js";
+import { registerGetElementStateTool } from "./get-element-state.js";
+import { registerWaitForElementTool } from "./wait-for-element.js";
+import { registerGetConsoleLogsTool } from "./get-console-logs.js";
+import { registerGetErrorsTool } from "./get-errors.js";
+import { registerGetNetworkLogsTool } from "./get-network-logs.js";
+import { registerGetProcessOutputTool } from "./get-process-output.js";
+import { registerRunWorkflowTool } from "./run-workflow.js";
+/**
+ * Register all MCP tools with the server
+ */
+export function registerTools(server, sessionManager) {
+    // Tool 1: get_version
+    server.tool("get_version", "Get server version and capabilities. Use to verify the server is running and responsive.", {}, async () => {
+        return createToolResult({
+            name: "feedback",
+            version: "0.1.0",
+            status: "ready",
+            capabilities: [
+                "process_lifecycle",
+                "screenshots",
+                "interactions",
+                "error_capture",
+                "workflows",
+                "assertions",
+            ],
+        });
+    });
+    // Tool 2: create_session
+    server.tool("create_session", "Create a new session for tracking app resources. Returns a unique session ID used by other tools.", {}, async () => {
+        const sessionId = sessionManager.create();
+        return createToolResult({
+            sessionId,
+            created: true,
+        });
+    });
+    // Tool 3: list_sessions
+    server.tool("list_sessions", "List all active session IDs. Use to find existing sessions or check server state.", {}, async () => {
+        const sessions = sessionManager.list();
+        return createToolResult({
+            sessions,
+            count: sessions.length,
+        });
+    });
+    // Tool 4: end_session
+    server.tool("end_session", "End a session and clean up all its resources. Use when done testing an application.", {
+        sessionId: z.string().describe("The session ID to end"),
+    }, async ({ sessionId }) => {
+        const session = sessionManager.get(sessionId);
+        if (!session) {
+            const availableSessions = sessionManager.list();
+            return createToolError(`Session not found: ${sessionId}`, "The session may have already been ended or never existed", availableSessions.length > 0
+                ? `Available sessions: ${availableSessions.join(", ")}`
+                : "No active sessions. Create one with create_session first.");
+        }
+        await sessionManager.destroy(sessionId);
+        return createToolResult({
+            sessionId,
+            ended: true,
+        });
+    });
+    // Tool 5: check_port
+    registerCheckPortTool(server, sessionManager);
+    // Tool 6: launch_web_server
+    registerLaunchWebServerTool(server, sessionManager);
+    // Tool 7: launch_electron
+    registerLaunchElectronTool(server, sessionManager);
+    // Tool 8: launch_windows_exe
+    registerLaunchWindowsExeTool(server, sessionManager);
+    // Tool 9: stop_process
+    registerStopProcessTool(server, sessionManager);
+    // Tool 10: screenshot_web
+    registerScreenshotWebTool(server, sessionManager);
+    // Tool 11: screenshot_electron
+    registerScreenshotElectronTool(server, sessionManager);
+    // Tool 12: screenshot_desktop
+    registerScreenshotDesktopTool(server, sessionManager);
+    // Tool 13: get_screenshot
+    registerGetScreenshotTool(server, sessionManager);
+    // Tool 14: click_element
+    registerClickElementTool(server, sessionManager);
+    // Tool 15: type_text
+    registerTypeTextTool(server, sessionManager);
+    // Tool 16: navigate
+    registerNavigateTool(server, sessionManager);
+    // Tool 17: get_element_state
+    registerGetElementStateTool(server, sessionManager);
+    // Tool 18: wait_for_element
+    registerWaitForElementTool(server, sessionManager);
+    // Tool 19: get_console_logs
+    registerGetConsoleLogsTool(server, sessionManager);
+    // Tool 20: get_errors
+    registerGetErrorsTool(server, sessionManager);
+    // Tool 21: get_network_logs
+    registerGetNetworkLogsTool(server, sessionManager);
+    // Tool 22: get_process_output
+    registerGetProcessOutputTool(server, sessionManager);
+    // Tool 23: run_workflow
+    registerRunWorkflowTool(server, sessionManager);
+    console.error("Registered 23 MCP tools");
+}

package/build/tools/launch-electron.d.ts

@@ -0,0 +1,13 @@
+/**
+ * launch_electron MCP tool (PROC-02)
+ * Launches an Electron app via Playwright for automation
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SessionManager } from "../session-manager.js";
+/**
+ * Register the launch_electron tool with the MCP server
+ *
+ * @param server - MCP server instance
+ * @param sessionManager - Session manager for resource tracking
+ */
+export declare function registerLaunchElectronTool(server: McpServer, sessionManager: SessionManager): void;

package/build/tools/launch-electron.js

@@ -0,0 +1,97 @@
+/**
+ * launch_electron MCP tool (PROC-02)
+ * Launches an Electron app via Playwright for automation
+ */
+import path from "path";
+import { z } from "zod";
+import { _electron as electron } from "playwright";
+import { createToolError, createToolResult } from "../utils/errors.js";
+import { setupAutoCapture } from "../screenshot/auto-capture.js";
+import { attachConsoleCollector } from "../capture/console-collector.js";
+import { attachErrorCollector } from "../capture/error-collector.js";
+import { attachNetworkCollector } from "../capture/network-collector.js";
+/**
+ * Register the launch_electron tool with the MCP server
+ *
+ * @param server - MCP server instance
+ * @param sessionManager - Session manager for resource tracking
+ */
+export function registerLaunchElectronTool(server, sessionManager) {
+    server.tool("launch_electron", "Launch an Electron app via Playwright for automation. Use to start and instrument Electron desktop applications.", {
+        sessionId: z.string().describe("Session ID to track this app"),
+        entryPath: z
+            .string()
+            .describe("Path to Electron main entry file (e.g., main.js, index.js)"),
+        cwd: z
+            .string()
+            .optional()
+            .describe("Working directory (defaults to entry file directory)"),
+        timeoutMs: z
+            .number()
+            .int()
+            .min(1000)
+            .max(120000)
+            .optional()
+            .describe("Launch timeout in ms (default: 30000)"),
+    }, async ({ sessionId, entryPath, cwd, timeoutMs }) => {
+        try {
+            // Validate session exists
+            const session = sessionManager.get(sessionId);
+            if (!session) {
+                return createToolError(`Session not found: ${sessionId}`, "The session may have already been ended or never existed", "Create a session first with create_session.");
+            }
+            console.error(`[launch_electron] Launching Electron: ${entryPath}`);
+            // Resolve paths
+            const resolvedEntryPath = path.resolve(entryPath);
+            const resolvedCwd = cwd
+                ? path.resolve(cwd)
+                : path.dirname(resolvedEntryPath);
+            // Launch Electron via Playwright
+            const electronApp = await electron.launch({
+                args: [resolvedEntryPath],
+                cwd: resolvedCwd,
+                timeout: timeoutMs ?? 30000,
+            });
+            // Wait for the first window to appear
+            const window = await electronApp.firstWindow();
+            console.error(`[launch_electron] Window detected, app ready`);
+            // Store page reference for screenshot access
+            sessionManager.setPageRef(sessionId, "electron", {
+                type: "electron",
+                page: window,
+                electronApp,
+            });
+            // Attach auto-capture on navigation events
+            const removeAutoCapture = setupAutoCapture(window, sessionId, sessionManager);
+            // Attach diagnostic collectors
+            const consoleCollector = attachConsoleCollector(window);
+            const errorCollector = attachErrorCollector(window);
+            const networkCollector = attachNetworkCollector(window);
+            sessionManager.setConsoleCollector(sessionId, "electron", consoleCollector);
+            sessionManager.setErrorCollector(sessionId, "electron", errorCollector);
+            sessionManager.setNetworkCollector(sessionId, "electron", networkCollector);
+            // Create a resource that cleans up the Electron app
+            const resource = {
+                cleanup: async () => {
+                    console.error(`[launch_electron] Closing Electron app`);
+                    removeAutoCapture();
+                    sessionManager.removePageRef(sessionId, "electron");
+                    await electronApp.close();
+                    console.error(`[launch_electron] Electron app closed`);
+                },
+            };
+            sessionManager.addResource(sessionId, resource);
+            return createToolResult({
+                sessionId,
+                type: "electron",
+                status: "ready",
+                entryPath: resolvedEntryPath,
+                windowTitle: await window.title(),
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return createToolError("Failed to launch Electron app", message, "Check the entry path points to a valid Electron main file. Ensure Electron is installed in the target project.");
+        }
+    });
+}