@extension.dev/mcp 3.17.0-canary.1779905934.1151df3

package/dist/module.cjs

@@ -0,0 +1,2979 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    startServer: ()=>startServer
+});
+var create_namespaceObject = {};
+__webpack_require__.r(create_namespaceObject);
+__webpack_require__.d(create_namespaceObject, {
+    handler: ()=>create_handler,
+    schema: ()=>schema
+});
+var list_templates_namespaceObject = {};
+__webpack_require__.r(list_templates_namespaceObject);
+__webpack_require__.d(list_templates_namespaceObject, {
+    handler: ()=>list_templates_handler,
+    schema: ()=>list_templates_schema
+});
+var build_namespaceObject = {};
+__webpack_require__.r(build_namespaceObject);
+__webpack_require__.d(build_namespaceObject, {
+    handler: ()=>build_handler,
+    schema: ()=>build_schema
+});
+var dev_namespaceObject = {};
+__webpack_require__.r(dev_namespaceObject);
+__webpack_require__.d(dev_namespaceObject, {
+    handler: ()=>dev_handler,
+    schema: ()=>dev_schema
+});
+var start_namespaceObject = {};
+__webpack_require__.r(start_namespaceObject);
+__webpack_require__.d(start_namespaceObject, {
+    handler: ()=>start_handler,
+    schema: ()=>start_schema
+});
+var preview_namespaceObject = {};
+__webpack_require__.r(preview_namespaceObject);
+__webpack_require__.d(preview_namespaceObject, {
+    handler: ()=>preview_handler,
+    schema: ()=>preview_schema
+});
+var get_template_source_namespaceObject = {};
+__webpack_require__.r(get_template_source_namespaceObject);
+__webpack_require__.d(get_template_source_namespaceObject, {
+    handler: ()=>get_template_source_handler,
+    schema: ()=>get_template_source_schema
+});
+var manifest_validate_namespaceObject = {};
+__webpack_require__.r(manifest_validate_namespaceObject);
+__webpack_require__.d(manifest_validate_namespaceObject, {
+    handler: ()=>manifest_validate_handler,
+    schema: ()=>manifest_validate_schema
+});
+var inspect_namespaceObject = {};
+__webpack_require__.r(inspect_namespaceObject);
+__webpack_require__.d(inspect_namespaceObject, {
+    handler: ()=>inspect_handler,
+    schema: ()=>inspect_schema
+});
+var source_inspect_namespaceObject = {};
+__webpack_require__.r(source_inspect_namespaceObject);
+__webpack_require__.d(source_inspect_namespaceObject, {
+    handler: ()=>source_inspect_handler,
+    schema: ()=>source_inspect_schema
+});
+var logs_namespaceObject = {};
+__webpack_require__.r(logs_namespaceObject);
+__webpack_require__.d(logs_namespaceObject, {
+    handler: ()=>logs_handler,
+    schema: ()=>logs_schema
+});
+var eval_namespaceObject = {};
+__webpack_require__.r(eval_namespaceObject);
+__webpack_require__.d(eval_namespaceObject, {
+    handler: ()=>eval_handler,
+    schema: ()=>eval_schema
+});
+var storage_namespaceObject = {};
+__webpack_require__.r(storage_namespaceObject);
+__webpack_require__.d(storage_namespaceObject, {
+    handler: ()=>storage_handler,
+    schema: ()=>storage_schema
+});
+var reload_namespaceObject = {};
+__webpack_require__.r(reload_namespaceObject);
+__webpack_require__.d(reload_namespaceObject, {
+    handler: ()=>reload_handler,
+    schema: ()=>reload_schema
+});
+var open_namespaceObject = {};
+__webpack_require__.r(open_namespaceObject);
+__webpack_require__.d(open_namespaceObject, {
+    handler: ()=>open_handler,
+    schema: ()=>open_schema
+});
+var dom_inspect_namespaceObject = {};
+__webpack_require__.r(dom_inspect_namespaceObject);
+__webpack_require__.d(dom_inspect_namespaceObject, {
+    handler: ()=>dom_inspect_handler,
+    schema: ()=>dom_inspect_schema
+});
+var publish_namespaceObject = {};
+__webpack_require__.r(publish_namespaceObject);
+__webpack_require__.d(publish_namespaceObject, {
+    handler: ()=>publish_handler,
+    schema: ()=>publish_schema
+});
+var wait_namespaceObject = {};
+__webpack_require__.r(wait_namespaceObject);
+__webpack_require__.d(wait_namespaceObject, {
+    handler: ()=>wait_handler,
+    schema: ()=>wait_schema
+});
+var add_feature_namespaceObject = {};
+__webpack_require__.r(add_feature_namespaceObject);
+__webpack_require__.d(add_feature_namespaceObject, {
+    handler: ()=>add_feature_handler,
+    schema: ()=>add_feature_schema
+});
+var install_browser_namespaceObject = {};
+__webpack_require__.r(install_browser_namespaceObject);
+__webpack_require__.d(install_browser_namespaceObject, {
+    handler: ()=>install_browser_handler,
+    schema: ()=>install_browser_schema
+});
+var list_browsers_namespaceObject = {};
+__webpack_require__.r(list_browsers_namespaceObject);
+__webpack_require__.d(list_browsers_namespaceObject, {
+    handler: ()=>list_browsers_handler,
+    schema: ()=>list_browsers_schema
+});
+var detect_browsers_namespaceObject = {};
+__webpack_require__.r(detect_browsers_namespaceObject);
+__webpack_require__.d(detect_browsers_namespaceObject, {
+    handler: ()=>detect_browsers_handler,
+    schema: ()=>detect_browsers_schema
+});
+const index_js_namespaceObject = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_namespaceObject = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_namespaceObject = require("@modelcontextprotocol/sdk/types.js");
+const external_extension_create_namespaceObject = require("extension-create");
+const schema = {
+    name: "extension_create",
+    description: "Create a new browser extension project from a template in the extension.dev template catalog. Use extension_list_templates to see available options.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            projectName: {
+                type: "string",
+                description: "Name of the extension project (used as directory name)"
+            },
+            template: {
+                type: "string",
+                default: "typescript",
+                description: "Template slug from the extension.dev template catalog (e.g. 'react', 'sidebar-claude', 'content-vue'). Use extension_list_templates to discover options."
+            },
+            install: {
+                type: "boolean",
+                default: true,
+                description: "Install dependencies after creation"
+            }
+        },
+        required: [
+            "projectName"
+        ]
+    }
+};
+async function create_handler(args) {
+    const start = Date.now();
+    try {
+        const result = await (0, external_extension_create_namespaceObject.extensionCreate)(args.projectName, {
+            template: args.template ?? "typescript",
+            install: args.install ?? true,
+            logger: {
+                log: ()=>{},
+                error: ()=>{}
+            }
+        });
+        return JSON.stringify({
+            projectPath: result.projectPath,
+            projectName: result.projectName,
+            template: result.template,
+            depsInstalled: result.depsInstalled,
+            duration: Date.now() - start,
+            nextSteps: [
+                `cd ${result.projectName}`,
+                "npm run dev"
+            ]
+        });
+    } catch (err) {
+        return JSON.stringify({
+            error: err instanceof Error ? err.message : String(err),
+            duration: Date.now() - start
+        });
+    }
+}
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_node_os_namespaceObject = require("node:os");
+var external_node_os_default = /*#__PURE__*/ __webpack_require__.n(external_node_os_namespaceObject);
+const CACHE_DIR = external_node_path_default().join(external_node_os_default().homedir(), ".cache", "extension-js");
+const CACHE_FILE = external_node_path_default().join(CACHE_DIR, "templates-meta.json");
+const CACHE_TTL_MS = 3600000;
+const TEMPLATES_META_URL = "https://github.com/extension-js/examples/releases/download/nightly/templates-meta.json";
+function isCacheValid() {
+    try {
+        const stat = external_node_fs_default().statSync(CACHE_FILE);
+        return Date.now() - stat.mtimeMs < CACHE_TTL_MS;
+    } catch  {
+        return false;
+    }
+}
+async function fetchTemplatesMeta() {
+    if (isCacheValid()) {
+        const cached = JSON.parse(external_node_fs_default().readFileSync(CACHE_FILE, "utf8"));
+        return cached;
+    }
+    const response = await fetch(TEMPLATES_META_URL);
+    if (!response.ok) {
+        if (external_node_fs_default().existsSync(CACHE_FILE)) return JSON.parse(external_node_fs_default().readFileSync(CACHE_FILE, "utf8"));
+        throw new Error(`Failed to fetch templates-meta.json: ${response.status}`);
+    }
+    const data = await response.json();
+    external_node_fs_default().mkdirSync(CACHE_DIR, {
+        recursive: true
+    });
+    external_node_fs_default().writeFileSync(CACHE_FILE, JSON.stringify(data, null, 2));
+    return data;
+}
+async function listTemplates(filters) {
+    const meta = await fetchTemplatesMeta();
+    let templates = meta.templates;
+    if (filters?.surface) templates = templates.filter((t)=>t.surfaces.includes(filters.surface));
+    if (filters?.framework !== void 0) templates = templates.filter((t)=>t.uiFramework === filters.framework);
+    if (filters?.tags?.length) templates = templates.filter((t)=>filters.tags.some((tag)=>t.tags?.includes(tag) || t.aiRecommendFor?.includes(tag)));
+    if (filters?.featured) templates = templates.filter((t)=>t.featured);
+    if (filters?.query) {
+        const q = filters.query.toLowerCase();
+        templates = templates.filter((t)=>t.slug.includes(q) || t.description.toLowerCase().includes(q) || t.tags?.some((tag)=>tag.includes(q)) || t.useCases?.some((uc)=>uc.toLowerCase().includes(q)) || t.aiPromptExamples?.some((ex)=>ex.toLowerCase().includes(q)));
+    }
+    return templates;
+}
+async function getTemplateBySlug(slug) {
+    const meta = await fetchTemplatesMeta();
+    return meta.templates.find((t)=>t.slug === slug);
+}
+const list_templates_schema = {
+    name: "extension_list_templates",
+    description: "List available extension templates from the extension.dev template catalog. Filter by surface, framework, or tags. Returns structured metadata from templates-meta.json.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            surface: {
+                type: "string",
+                enum: [
+                    "content",
+                    "sidebar",
+                    "action",
+                    "newtab",
+                    "devtools",
+                    "options",
+                    "background"
+                ],
+                description: "Filter by extension surface type"
+            },
+            framework: {
+                type: "string",
+                enum: [
+                    "react",
+                    "vue",
+                    "svelte",
+                    "preact",
+                    ""
+                ],
+                description: "Filter by UI framework (empty string = vanilla JS)"
+            },
+            tags: {
+                type: "array",
+                items: {
+                    type: "string"
+                },
+                description: "Filter by tags (e.g. ['ai', 'chat'])"
+            },
+            featured: {
+                type: "boolean",
+                description: "Only show featured templates"
+            },
+            query: {
+                type: "string",
+                description: "Free-text search across slug, description, tags, and useCases"
+            }
+        }
+    }
+};
+async function list_templates_handler(args) {
+    const templates = await listTemplates(args);
+    const results = templates.map((t)=>({
+            slug: t.slug,
+            description: t.description,
+            uiFramework: t.uiFramework || "vanilla",
+            surfaces: t.surfaces,
+            tags: t.tags,
+            difficulty: t.difficulty,
+            featured: t.featured,
+            useCases: t.useCases,
+            repositoryUrl: t.repositoryUrl,
+            downloads: t.downloads
+        }));
+    return JSON.stringify({
+        count: results.length,
+        templates: results
+    });
+}
+const external_extension_develop_namespaceObject = require("extension-develop");
+const build_schema = {
+    name: "extension_build",
+    description: "Build a browser extension for production. Outputs to dist/<browser>/. Optionally creates .zip for store submission.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            projectPath: {
+                type: "string",
+                description: "Path to the extension project root"
+            },
+            browser: {
+                type: "string",
+                enum: [
+                    "chrome",
+                    "edge",
+                    "firefox",
+                    "chromium-based",
+                    "gecko-based"
+                ],
+                default: "chrome",
+                description: "Target browser"
+            },
+            zip: {
+                type: "boolean",
+                default: false,
+                description: "Create a .zip file for store distribution"
+            },
+            zipSource: {
+                type: "boolean",
+                default: false,
+                description: "Include source code zip (required by some stores)"
+            }
+        },
+        required: [
+            "projectPath"
+        ]
+    }
+};
+async function build_handler(args) {
+    const start = Date.now();
+    try {
+        const summary = await (0, external_extension_develop_namespaceObject.extensionBuild)(args.projectPath, {
+            browser: args.browser ?? "chrome",
+            zip: args.zip ?? false,
+            zipSource: args.zipSource ?? false
+        });
+        return JSON.stringify({
+            success: true,
+            ...summary,
+            duration: Date.now() - start
+        });
+    } catch (err) {
+        return JSON.stringify({
+            error: err instanceof Error ? err.message : String(err),
+            duration: Date.now() - start,
+            hint: "Check that the project has a valid src/manifest.json and all dependencies are installed."
+        });
+    }
+}
+const external_node_child_process_namespaceObject = require("node:child_process");
+function runExtensionCli(args, options) {
+    return new Promise((resolve)=>{
+        const child = (0, external_node_child_process_namespaceObject.spawn)("npx", [
+            "extension",
+            ...args
+        ], {
+            cwd: options?.cwd,
+            stdio: [
+                "ignore",
+                "pipe",
+                "pipe"
+            ],
+            env: {
+                ...process.env,
+                FORCE_COLOR: "0",
+                NO_COLOR: "1"
+            },
+            shell: true,
+            timeout: options?.timeoutMs ?? 30000
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout?.on("data", (d)=>stdout += d.toString());
+        child.stderr?.on("data", (d)=>stderr += d.toString());
+        child.on("close", (code)=>resolve({
+                code,
+                stdout,
+                stderr
+            }));
+        child.on("error", (err)=>resolve({
+                code: 1,
+                stdout,
+                stderr: stderr || String(err)
+            }));
+    });
+}
+function spawnExtensionCli(args, options) {
+    const child = (0, external_node_child_process_namespaceObject.spawn)("npx", [
+        "extension",
+        ...args
+    ], {
+        cwd: options?.cwd,
+        detached: true,
+        stdio: [
+            "ignore",
+            "pipe",
+            "pipe"
+        ],
+        env: {
+            ...process.env,
+            FORCE_COLOR: "0",
+            NO_COLOR: "1"
+        },
+        shell: true
+    });
+    child.unref();
+    return child;
+}
+const sessions = new Map();
+function sessionKey(projectPath, browser) {
+    return `${projectPath}::${browser}`;
+}
+function registerSession(info) {
+    sessions.set(sessionKey(info.projectPath, info.browser), info);
+}
+const dev_schema = {
+    name: "extension_dev",
+    description: "Start the extension development server with hot module replacement. Launches a browser with the extension loaded. Returns process info for use with extension_wait and extension_source_inspect.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            projectPath: {
+                type: "string",
+                description: "Path to the extension project root"
+            },
+            browser: {
+                type: "string",
+                enum: [
+                    "chrome",
+                    "edge",
+                    "firefox",
+                    "chromium-based",
+                    "gecko-based"
+                ],
+                default: "chrome"
+            },
+            port: {
+                type: "number",
+                description: "Dev server port (0 for auto-assign)"
+            },
+            noBrowser: {
+                type: "boolean",
+                default: false,
+                description: "Start dev server without launching browser"
+            }
+        },
+        required: [
+            "projectPath"
+        ]
+    }
+};
+async function dev_handler(args) {
+    const browser = args.browser ?? "chrome";
+    const cliArgs = [
+        "dev",
+        args.projectPath,
+        "--browser",
+        browser
+    ];
+    if (void 0 !== args.port) cliArgs.push("--port", String(args.port));
+    if (args.noBrowser) cliArgs.push("--no-browser");
+    const child = spawnExtensionCli(cliArgs);
+    const pid = child.pid;
+    registerSession({
+        pid,
+        browser,
+        port: args.port,
+        projectPath: args.projectPath,
+        command: "dev"
+    });
+    let earlyOutput = "";
+    const collector = (data)=>{
+        earlyOutput += data.toString();
+    };
+    child.stdout?.on("data", collector);
+    child.stderr?.on("data", collector);
+    await new Promise((resolve)=>setTimeout(resolve, 3000));
+    child.stdout?.off("data", collector);
+    child.stderr?.off("data", collector);
+    return JSON.stringify({
+        pid,
+        browser,
+        port: args.port ?? 8080,
+        projectPath: args.projectPath,
+        status: "started",
+        hint: "Use extension_wait to check when the extension is fully loaded, then extension_source_inspect to inspect the live state.",
+        earlyOutput: earlyOutput.slice(0, 500)
+    });
+}
+const start_schema = {
+    name: "extension_start",
+    description: "Build the extension for production and immediately preview it in a browser. Combines build + preview in one step. No hot reload.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            projectPath: {
+                type: "string",
+                description: "Path to the extension project root"
+            },
+            browser: {
+                type: "string",
+                enum: [
+                    "chrome",
+                    "edge",
+                    "firefox",
+                    "chromium-based",
+                    "gecko-based"
+                ],
+                default: "chrome"
+            },
+            polyfill: {
+                type: "boolean",
+                default: true,
+                description: "Apply cross-browser polyfill"
+            }
+        },
+        required: [
+            "projectPath"
+        ]
+    }
+};
+async function start_handler(args) {
+    const browser = args.browser ?? "chrome";
+    const cliArgs = [
+        "start",
+        args.projectPath,
+        "--browser",
+        browser
+    ];
+    if (false === args.polyfill) cliArgs.push("--no-polyfill");
+    const child = spawnExtensionCli(cliArgs);
+    const pid = child.pid;
+    registerSession({
+        pid,
+        browser,
+        projectPath: args.projectPath,
+        command: "start"
+    });
+    let earlyOutput = "";
+    const collector = (data)=>{
+        earlyOutput += data.toString();
+    };
+    child.stdout?.on("data", collector);
+    child.stderr?.on("data", collector);
+    await new Promise((resolve)=>setTimeout(resolve, 5000));
+    child.stdout?.off("data", collector);
+    child.stderr?.off("data", collector);
+    return JSON.stringify({
+        pid,
+        browser,
+        projectPath: args.projectPath,
+        status: "started",
+        hint: "Use extension_wait to check when the build and browser launch are complete.",
+        earlyOutput: earlyOutput.slice(0, 500)
+    });
+}
+const preview_schema = {
+    name: "extension_preview",
+    description: "Preview a production-built extension in a browser. Uses dist/ output directly. The extension must be built first with extension_build.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            projectPath: {
+                type: "string",
+                description: "Path to the extension project root"
+            },
+            browser: {
+                type: "string",
+                enum: [
+                    "chrome",
+                    "edge",
+                    "firefox",
+                    "chromium-based",
+                    "gecko-based"
+                ],
+                default: "chrome"
+            }
+        },
+        required: [
+            "projectPath"
+        ]
+    }
+};
+async function preview_handler(args) {
+    const browser = args.browser ?? "chrome";
+    const cliArgs = [
+        "preview",
+        args.projectPath,
+        "--browser",
+        browser
+    ];
+    const child = spawnExtensionCli(cliArgs);
+    return JSON.stringify({
+        pid: child.pid,
+        browser,
+        projectPath: args.projectPath,
+        status: "launched"
+    });
+}
+const RAW_BASE = "https://raw.githubusercontent.com/extension-js/examples/main/examples";
+const get_template_source_schema = {
+    name: "extension_get_template_source",
+    description: "Read source files from a template in the extension.dev template catalog. Use this to learn implementation patterns before building something similar.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            slug: {
+                type: "string",
+                description: "Template slug (e.g. 'sidebar-claude', 'content-react')"
+            },
+            files: {
+                type: "array",
+                items: {
+                    type: "string"
+                },
+                description: "Specific files to read (e.g. ['src/manifest.json', 'src/background.ts']). If omitted, returns the file listing from templates-meta.json."
+            }
+        },
+        required: [
+            "slug"
+        ]
+    }
+};
+async function get_template_source_handler(args) {
+    const template = await getTemplateBySlug(args.slug);
+    if (!template) return JSON.stringify({
+        error: `Template '${args.slug}' not found in the catalog`,
+        hint: "Use extension_list_templates to see available templates."
+    });
+    const meta = {
+        slug: template.slug,
+        description: template.description,
+        uiFramework: template.uiFramework || "vanilla",
+        surfaces: template.surfaces,
+        permissions: template.permissions,
+        patternExplanation: template.patternExplanation,
+        keyFiles: template.keyFiles,
+        repositoryUrl: template.repositoryUrl
+    };
+    if (!args.files?.length) return JSON.stringify({
+        ...meta,
+        files: template.files,
+        hint: "Pass specific file paths in the files parameter to read their contents."
+    });
+    const fileContents = {};
+    const errors = [];
+    await Promise.all(args.files.map(async (filePath)=>{
+        const url = `${RAW_BASE}/${args.slug}/${filePath}`;
+        try {
+            const response = await fetch(url);
+            if (response.ok) fileContents[filePath] = await response.text();
+            else errors.push(`${filePath}: ${response.status}`);
+        } catch (err) {
+            errors.push(`${filePath}: ${err instanceof Error ? err.message : "fetch failed"}`);
+        }
+    }));
+    return JSON.stringify({
+        ...meta,
+        fileContents,
+        ...errors.length ? {
+            errors
+        } : {}
+    });
+}
+const manifest_validate_schema = {
+    name: "extension_manifest_validate",
+    description: "Validate a manifest.json file for correctness across browsers. Reports missing fields, invalid permissions, and cross-browser compatibility issues.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            manifestPath: {
+                type: "string",
+                description: "Path to manifest.json"
+            },
+            browsers: {
+                type: "array",
+                items: {
+                    type: "string"
+                },
+                default: [
+                    "chrome",
+                    "firefox"
+                ],
+                description: "Browsers to validate against"
+            }
+        },
+        required: [
+            "manifestPath"
+        ]
+    }
+};
+async function manifest_validate_handler(args) {
+    const browsers = args.browsers ?? [
+        "chrome",
+        "firefox"
+    ];
+    const result = {
+        valid: true,
+        errors: [],
+        warnings: [],
+        browserSupport: {},
+        similarTemplates: []
+    };
+    let manifest;
+    try {
+        const raw = external_node_fs_default().readFileSync(external_node_path_default().resolve(args.manifestPath), "utf8");
+        manifest = JSON.parse(raw);
+    } catch (err) {
+        return JSON.stringify({
+            valid: false,
+            errors: [
+                `Cannot read manifest: ${err instanceof Error ? err.message : err}`
+            ],
+            warnings: [],
+            browserSupport: {},
+            similarTemplates: []
+        });
+    }
+    if (!manifest.name) result.errors.push("Missing required field: name");
+    if (!manifest.version) result.warnings.push("Missing field: version (required for store submission)");
+    const chromiumMv = manifest["chromium:manifest_version"] ?? manifest.manifest_version;
+    manifest["firefox:manifest_version"] ?? manifest.manifest_version;
+    if (!chromiumMv && !manifest.manifest_version) result.errors.push('Missing manifest_version. Use "chromium:manifest_version": 3 and "firefox:manifest_version": 2 for cross-browser support.');
+    for (const browser of browsers){
+        const isChromium = [
+            "chrome",
+            "edge",
+            "chromium-based"
+        ].includes(browser);
+        const isFirefox = [
+            "firefox",
+            "gecko-based"
+        ].includes(browser);
+        const issues = [];
+        if (isChromium) {
+            const mv = chromiumMv;
+            if (mv && mv < 3) issues.push("Manifest V2 is deprecated on Chromium. Use chromium:manifest_version: 3.");
+            if (manifest["chromium:side_panel"] || manifest.side_panel) {
+                const perms = manifest["chromium:permissions"] ?? manifest.permissions ?? [];
+                if (!perms.includes("sidePanel")) issues.push('Side panel declared but "sidePanel" permission is missing.');
+            }
+            if (manifest["firefox:browser_action"] && !manifest["chromium:action"] && !manifest.action) issues.push('Firefox browser_action found but no chromium:action. Chromium MV3 uses "action" instead of "browser_action".');
+        }
+        if (isFirefox) {
+            const contentScripts = manifest.content_scripts;
+            if (contentScripts) {
+                for (const cs of contentScripts)if ("MAIN" === cs.world || "MAIN" === cs["world"]) issues.push('content_scripts.world: "MAIN" is Chromium-only. Use "chromium:world": "MAIN" and provide a Firefox fallback.');
+            }
+            if (manifest["chromium:side_panel"] && !manifest["firefox:sidebar_action"]) issues.push("Chromium side_panel declared but no firefox:sidebar_action. Firefox uses sidebar_action for sidebars.");
+            const bg = manifest.background;
+            if (bg) {
+                if (bg.service_worker && !bg["firefox:scripts"] && !bg.scripts) issues.push('Background service_worker declared but no firefox:scripts. Firefox uses "scripts" (array) instead of "service_worker".');
+            }
+        }
+        result.browserSupport[browser] = {
+            supported: 0 === issues.length,
+            issues
+        };
+        if (issues.length) result.valid = false;
+    }
+    const surfaces = [];
+    if (manifest.content_scripts) surfaces.push("content");
+    if (manifest["chromium:side_panel"] || manifest.side_panel) surfaces.push("sidebar");
+    if (manifest.action || manifest["chromium:action"] || manifest["firefox:browser_action"]) surfaces.push("action");
+    if (manifest.chrome_url_overrides?.newtab) surfaces.push("newtab");
+    if (manifest.background) surfaces.push("background");
+    if (surfaces.length) try {
+        const templates = await listTemplates();
+        result.similarTemplates = templates.filter((t)=>t.surfaces.some((s)=>surfaces.includes(s))).slice(0, 5).map((t)=>({
+                slug: t.slug,
+                surfaces: t.surfaces
+            }));
+    } catch  {}
+    if (0 === result.errors.length) result.valid = Object.values(result.browserSupport).every((b)=>b.supported);
+    return JSON.stringify(result);
+}
+const inspect_schema = {
+    name: "extension_inspect",
+    description: "Inspect a built extension: file sizes, entry points, permissions used, and structure analysis. The extension must be built first.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            projectPath: {
+                type: "string",
+                description: "Path to the extension project root"
+            },
+            browser: {
+                type: "string",
+                default: "chrome",
+                description: "Browser build to inspect"
+            },
+            format: {
+                type: "string",
+                enum: [
+                    "summary",
+                    "tree",
+                    "json"
+                ],
+                default: "summary"
+            }
+        },
+        required: [
+            "projectPath"
+        ]
+    }
+};
+function walkDir(dir, base = "") {
+    const entries = [];
+    try {
+        for (const entry of external_node_fs_default().readdirSync(dir, {
+            withFileTypes: true
+        })){
+            const rel = base ? `${base}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) entries.push(...walkDir(external_node_path_default().join(dir, entry.name), rel));
+            else {
+                const stat = external_node_fs_default().statSync(external_node_path_default().join(dir, entry.name));
+                const ext = external_node_path_default().extname(entry.name).toLowerCase();
+                let type = "other";
+                if ([
+                    ".js",
+                    ".mjs"
+                ].includes(ext)) type = "javascript";
+                else if ([
+                    ".css"
+                ].includes(ext)) type = "stylesheet";
+                else if ([
+                    ".html",
+                    ".htm"
+                ].includes(ext)) type = "html";
+                else if ([
+                    ".json"
+                ].includes(ext)) type = "json";
+                else if ([
+                    ".png",
+                    ".jpg",
+                    ".svg",
+                    ".gif",
+                    ".ico",
+                    ".webp"
+                ].includes(ext)) type = "image";
+                else if ([
+                    ".woff",
+                    ".woff2",
+                    ".ttf",
+                    ".otf"
+                ].includes(ext)) type = "font";
+                else if ([
+                    ".wasm"
+                ].includes(ext)) type = "wasm";
+                else if ([
+                    ".map"
+                ].includes(ext)) type = "sourcemap";
+                entries.push({
+                    path: rel,
+                    size: stat.size,
+                    type
+                });
+            }
+        }
+    } catch  {}
+    return entries;
+}
+function formatBytes(bytes) {
+    if (bytes < 1024) return `${bytes} B`;
+    if (bytes < 1048576) return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / 1048576).toFixed(1)} MB`;
+}
+async function inspect_handler(args) {
+    const browser = args.browser ?? "chrome";
+    const distPath = external_node_path_default().resolve(args.projectPath, "dist", browser);
+    if (!external_node_fs_default().existsSync(distPath)) return JSON.stringify({
+        error: `Build output not found at ${distPath}. Run extension_build first.`,
+        hint: `Use extension_build with browser: "${browser}" to build the extension.`
+    });
+    const files = walkDir(distPath);
+    const totalSize = files.reduce((sum, f)=>sum + f.size, 0);
+    let manifest = {};
+    const manifestPath = external_node_path_default().join(distPath, "manifest.json");
+    try {
+        manifest = JSON.parse(external_node_fs_default().readFileSync(manifestPath, "utf8"));
+    } catch  {}
+    const byType = {};
+    for (const f of files){
+        if (!byType[f.type]) byType[f.type] = {
+            count: 0,
+            size: 0
+        };
+        byType[f.type].count++;
+        byType[f.type].size += f.size;
+    }
+    const result = {
+        browser,
+        distPath,
+        totalSize,
+        totalSizeFormatted: formatBytes(totalSize),
+        fileCount: files.length,
+        manifest: {
+            name: manifest.name,
+            version: manifest.version,
+            manifest_version: manifest.manifest_version,
+            permissions: manifest.permissions
+        },
+        byType: Object.fromEntries(Object.entries(byType).map(([type, data])=>[
+                type,
+                {
+                    count: data.count,
+                    size: data.size,
+                    sizeFormatted: formatBytes(data.size)
+                }
+            ])),
+        ..."tree" === args.format || "json" === args.format ? {
+            files: files.map((f)=>({
+                    ...f,
+                    sizeFormatted: formatBytes(f.size)
+                }))
+        } : {
+            largestFiles: files.sort((a, b)=>b.size - a.size).slice(0, 10).map((f)=>({
+                    path: f.path,
+                    size: f.size,
+                    sizeFormatted: formatBytes(f.size)
+                }))
+        },
+        storeReadiness: {
+            hasManifest: external_node_fs_default().existsSync(manifestPath),
+            hasIcons: files.some((f)=>"image" === f.type && f.path.includes("icon")),
+            noSourceMaps: !files.some((f)=>"sourcemap" === f.type),
+            under10MB: totalSize < 10485760
+        }
+    };
+    return JSON.stringify(result);
+}
+const external_node_net_namespaceObject = require("node:net");
+var external_node_net_default = /*#__PURE__*/ __webpack_require__.n(external_node_net_namespaceObject);
+const external_ws_namespaceObject = require("ws");
+var external_ws_default = /*#__PURE__*/ __webpack_require__.n(external_ws_namespaceObject);
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const COMMAND_TIMEOUT_MS = 15000;
+class CDPClient {
+    async connect(wsUrl) {
+        return new Promise((resolve, reject)=>{
+            this.ws = new (external_ws_default())(wsUrl);
+            this.ws.on("open", ()=>resolve());
+            this.ws.on("message", (data)=>{
+                this.handleMessage(data.toString());
+            });
+            this.ws.on("error", (err)=>{
+                this.rejectAllPending(err.message);
+                reject(err);
+            });
+            this.ws.on("close", ()=>{
+                this.rejectAllPending("CDP connection closed");
+            });
+        });
+    }
+    disconnect() {
+        if (this.ws) {
+            try {
+                this.ws.close();
+            } catch  {}
+            this.ws = null;
+        }
+    }
+    handleMessage(data) {
+        try {
+            const message = JSON.parse(data);
+            if ("number" == typeof message.id) {
+                const pending = this.pendingRequests.get(message.id);
+                if (pending) {
+                    clearTimeout(pending.timeout);
+                    this.pendingRequests.delete(message.id);
+                    if (message.error) pending.reject(new Error(JSON.stringify(message.error)));
+                    else pending.resolve(message.result);
+                }
+                return;
+            }
+            if ("Log.entryAdded" === message.method) {
+                const entry = message.params?.entry;
+                if (entry) this.consoleMessages.push({
+                    level: String(entry.level ?? "info"),
+                    text: String(entry.text ?? ""),
+                    source: String(entry.source ?? "other"),
+                    timestamp: Number(entry.timestamp ?? Date.now())
+                });
+            }
+            if ("Runtime.consoleAPICalled" === message.method) {
+                const params = message.params;
+                if (params) {
+                    const args = params.args ?? [];
+                    const text = args.map((a)=>String(a.value ?? a.description ?? "")).join(" ");
+                    this.consoleMessages.push({
+                        level: String(params.type ?? "log"),
+                        text,
+                        source: "console-api",
+                        timestamp: Number(params.timestamp ?? Date.now())
+                    });
+                }
+            }
+            for (const listener of this.eventListeners)listener(message);
+        } catch  {}
+    }
+    rejectAllPending(reason) {
+        for (const [id, pending] of this.pendingRequests){
+            clearTimeout(pending.timeout);
+            pending.reject(new Error(reason));
+            this.pendingRequests.delete(id);
+        }
+    }
+    async sendCommand(method, params = {}, sessionId) {
+        return new Promise((resolve, reject)=>{
+            if (!this.ws || this.ws.readyState !== external_ws_default().OPEN) return reject(new Error("CDP WebSocket is not connected"));
+            const id = ++this.messageId;
+            const message = {
+                id,
+                method,
+                params
+            };
+            if (sessionId) message.sessionId = sessionId;
+            const timeout = setTimeout(()=>{
+                this.pendingRequests.delete(id);
+                reject(new Error(`CDP command timed out (${COMMAND_TIMEOUT_MS}ms): ${method}`));
+            }, COMMAND_TIMEOUT_MS);
+            this.pendingRequests.set(id, {
+                resolve,
+                reject,
+                timeout
+            });
+            this.ws.send(JSON.stringify(message));
+        });
+    }
+    static async discoverBrowserWsUrl(port, host = "127.0.0.1") {
+        const res = await fetch(`http://${host}:${port}/json/version`);
+        if (!res.ok) throw new Error(`CDP /json/version failed: ${res.status}`);
+        const data = await res.json();
+        if ("string" == typeof data.webSocketDebuggerUrl) return data.webSocketDebuggerUrl;
+        throw new Error("No webSocketDebuggerUrl in /json/version response");
+    }
+    static async discoverTargets(port, host = "127.0.0.1") {
+        const res = await fetch(`http://${host}:${port}/json`);
+        if (!res.ok) throw new Error(`CDP /json failed: ${res.status}`);
+        return await res.json();
+    }
+    async getTargets() {
+        const response = await this.sendCommand("Target.getTargets");
+        return response?.targetInfos ?? [];
+    }
+    async attachToTarget(targetId) {
+        const response = await this.sendCommand("Target.attachToTarget", {
+            targetId,
+            flatten: true
+        });
+        return response.sessionId ?? "";
+    }
+    async enableDomains(sessionId) {
+        await Promise.all([
+            this.sendCommand("Runtime.enable", {}, sessionId),
+            this.sendCommand("Log.enable", {}, sessionId),
+            this.sendCommand("Page.enable", {}, sessionId)
+        ]);
+    }
+    async navigate(sessionId, url) {
+        await this.sendCommand("Page.navigate", {
+            url
+        }, sessionId);
+        await new Promise((resolve)=>{
+            const timeout = setTimeout(resolve, 5000);
+            const unsubscribe = this.onEvent((msg)=>{
+                if ("Page.loadEventFired" === msg.method) {
+                    clearTimeout(timeout);
+                    unsubscribe();
+                    resolve();
+                }
+            });
+        });
+    }
+    async evaluate(sessionId, expression) {
+        const response = await this.sendCommand("Runtime.evaluate", {
+            expression,
+            returnByValue: true,
+            awaitPromise: false
+        }, sessionId);
+        return response.result?.value;
+    }
+    async getPageHTML(sessionId) {
+        const result = await this.evaluate(sessionId, `(() => {
+        try {
+          const doctype = document.doctype;
+          const dt = doctype
+            ? '<!DOCTYPE ' + doctype.name
+              + (doctype.publicId ? ' PUBLIC "' + doctype.publicId + '"' : '')
+              + (doctype.systemId ? ' "' + doctype.systemId + '"' : '')
+              + '>'
+            : '';
+          // Include shadow DOM content from extension roots
+          const roots = Array.from(document.querySelectorAll(
+            '#extension-root,[data-extension-root]:not([data-extension-root="extension-js-devtools"])'
+          ));
+          if (roots.length) {
+            const clone = document.documentElement.cloneNode(true);
+            const clonedRoots = Array.from(clone.querySelectorAll(
+              '#extension-root,[data-extension-root]:not([data-extension-root="extension-js-devtools"])'
+            ));
+            const s = new XMLSerializer();
+            for (let i = 0; i < Math.min(roots.length, clonedRoots.length); i++) {
+              const sr = roots[i].shadowRoot;
+              if (!sr) continue;
+              try {
+                const shadow = Array.from(sr.childNodes).map(n => {
+                  try { return s.serializeToString(n); } catch { return ''; }
+                }).join('');
+                if (shadow) clonedRoots[i].innerHTML = shadow;
+              } catch {}
+            }
+            return dt + '\\n' + clone.outerHTML;
+          }
+          return dt + '\\n' + document.documentElement.outerHTML;
+        } catch (e) { return ''; }
+      })()`);
+        return "string" == typeof result ? result : "";
+    }
+    async getClosedShadowRoots(sessionId, maxBytes = 65536) {
+        await this.sendCommand("DOM.enable", {}, sessionId);
+        const doc = await this.sendCommand("DOM.getDocument", {
+            depth: -1,
+            pierce: true
+        }, sessionId);
+        const found = [];
+        const walk = (node, hostName)=>{
+            if (!node || "object" != typeof node) return;
+            const name = node.localName || node.nodeName || hostName;
+            if (Array.isArray(node.shadowRoots)) for (const sr of node.shadowRoots){
+                if (sr && "closed" === sr.shadowRootType && "number" == typeof sr.nodeId) found.push({
+                    nodeId: sr.nodeId,
+                    host: String(name),
+                    type: "closed"
+                });
+                walk(sr, name);
+            }
+            if (Array.isArray(node.children)) for (const c of node.children)walk(c, name);
+            if (node.contentDocument) walk(node.contentDocument, name);
+        };
+        walk(doc.root, "html");
+        const out = [];
+        for (const f of found)try {
+            const oh = await this.sendCommand("DOM.getOuterHTML", {
+                nodeId: f.nodeId
+            }, sessionId);
+            let html = String(oh?.outerHTML ?? "");
+            let truncated = false;
+            if (maxBytes > 0 && html.length > maxBytes) {
+                html = html.slice(0, maxBytes);
+                truncated = true;
+            }
+            out.push({
+                host: f.host,
+                type: f.type,
+                html,
+                ...truncated ? {
+                    truncated
+                } : {}
+            });
+        } catch  {
+            out.push({
+                host: f.host,
+                type: f.type,
+                html: ""
+            });
+        }
+        return out;
+    }
+    async getPageMeta(sessionId) {
+        const result = await this.evaluate(sessionId, `(() => {
+        try {
+          return {
+            title: document.title,
+            url: location.href,
+            readyState: document.readyState,
+            viewport: {
+              width: window.innerWidth,
+              height: window.innerHeight,
+              devicePixelRatio: window.devicePixelRatio
+            },
+            frameCount: window.frames.length,
+            scriptCount: document.querySelectorAll('script').length,
+            styleCount: document.querySelectorAll('style,link[rel="stylesheet"]').length
+          };
+        } catch { return {}; }
+      })()`);
+        return result ?? {};
+    }
+    async probeSelectors(sessionId, selectors) {
+        const result = await this.evaluate(sessionId, `(() => {
+        const selectors = ${JSON.stringify(selectors)};
+        return selectors.map(selector => {
+          try {
+            const els = Array.from(document.querySelectorAll(selector));
+            return {
+              selector,
+              count: els.length,
+              samples: els.slice(0, 3).map(el => ({
+                tag: el.tagName.toLowerCase(),
+                id: el.id || undefined,
+                classes: Array.from(el.classList).join(' ') || undefined,
+                role: el.getAttribute('role') || undefined,
+                ariaLabel: el.getAttribute('aria-label') || undefined,
+                textLength: (el.textContent || '').length,
+                textSnippet: (el.textContent || '').trim().slice(0, 80)
+              }))
+            };
+          } catch (e) {
+            return { selector, count: 0, samples: [], error: String(e) };
+          }
+        });
+      })()`);
+        return result ?? [];
+    }
+    async getDomSnapshot(sessionId, maxNodes = 500) {
+        const result = await this.evaluate(sessionId, `(() => {
+        const maxNodes = ${maxNodes};
+        const nodes = [];
+        const walk = (node, depth) => {
+          if (nodes.length >= maxNodes || depth > 20) return;
+          if (node.nodeType !== 1) return;
+          const el = node;
+          nodes.push({
+            tag: el.tagName.toLowerCase(),
+            depth,
+            id: el.id || undefined,
+            classes: Array.from(el.classList).slice(0, 5).join(' ') || undefined,
+            role: el.getAttribute('role') || undefined,
+            ariaLabel: el.getAttribute('aria-label') || undefined,
+            childCount: el.children.length
+          });
+          for (const child of el.children) {
+            walk(child, depth + 1);
+          }
+        };
+        walk(document.documentElement, 0);
+        return nodes;
+      })()`);
+        return result ?? [];
+    }
+    async getExtensionRootMeta(sessionId) {
+        const result = await this.evaluate(sessionId, `(() => {
+        try {
+          const readGeneration = (node) => {
+            const raw = node.getAttribute && node.getAttribute('data-extjs-reinject-generation');
+            const parsed = Number(raw);
+            return Number.isFinite(parsed) ? parsed : undefined;
+          };
+          const normalize = (node) => ({
+            tag: node.tagName ? String(node.tagName).toLowerCase() : 'unknown',
+            id: node.id || undefined,
+            key: node.getAttribute ? node.getAttribute('data-extjs-reinject-key') || undefined : undefined,
+            generation: readGeneration(node),
+            status: node.getAttribute ? node.getAttribute('data-extjs-reinject-status') || undefined : undefined
+          });
+          const roots = Array.from(
+            document.querySelectorAll('#extension-root,[data-extension-root]:not([data-extension-root="extension-js-devtools"])')
+          ).slice(0, 10).map(normalize);
+          const markers = Array.from(
+            document.querySelectorAll('[data-extjs-reinject-marker="true"]')
+          ).slice(0, 10).map(normalize);
+          if (!roots.length && !markers.length) return null;
+          const generations = [...roots, ...markers]
+            .map(e => e.generation)
+            .filter(g => typeof g === 'number');
+          return {
+            rootCount: roots.length,
+            markerCount: markers.length,
+            latestGeneration: generations.length ? Math.max(...generations) : 0,
+            roots,
+            markers
+          };
+        } catch { return null; }
+      })()`);
+        return result ?? null;
+    }
+    getConsoleMessages() {
+        return [
+            ...this.consoleMessages
+        ];
+    }
+    getConsoleSummary() {
+        const counts = {};
+        const uniqueByLevel = {};
+        for (const msg of this.consoleMessages){
+            counts[msg.level] = (counts[msg.level] ?? 0) + 1;
+            if (!uniqueByLevel[msg.level]) uniqueByLevel[msg.level] = new Map();
+            const key = msg.text.slice(0, 200);
+            uniqueByLevel[msg.level].set(key, (uniqueByLevel[msg.level].get(key) ?? 0) + 1);
+        }
+        const topMessages = [];
+        for (const [level, msgs] of Object.entries(uniqueByLevel)){
+            const sorted = [
+                ...msgs.entries()
+            ].sort((a, b)=>b[1] - a[1]);
+            for (const [text, count] of sorted.slice(0, 5))topMessages.push({
+                level,
+                text,
+                count
+            });
+        }
+        return {
+            total: this.consoleMessages.length,
+            counts,
+            topMessages: topMessages.sort((a, b)=>b.count - a.count).slice(0, 10)
+        };
+    }
+    onEvent(handler) {
+        this.eventListeners.add(handler);
+        return ()=>{
+            this.eventListeners.delete(handler);
+        };
+    }
+    constructor(){
+        _define_property(this, "ws", null);
+        _define_property(this, "messageId", 0);
+        _define_property(this, "eventListeners", new Set());
+        _define_property(this, "pendingRequests", new Map());
+        _define_property(this, "consoleMessages", []);
+    }
+}
+const source_inspect_schema = {
+    name: "extension_source_inspect",
+    description: "Inspect a running extension's live state via Chrome DevTools Protocol: full HTML (with shadow DOM), DOM structure, content script injection, console messages, and CSS selector queries. Requires an active dev or start session.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            projectPath: {
+                type: "string",
+                description: "Path to the extension project root (must have an active dev session)"
+            },
+            url: {
+                type: "string",
+                description: "URL to inspect (navigates the browser tab to this URL first)"
+            },
+            probe: {
+                type: "array",
+                items: {
+                    type: "string"
+                },
+                description: "CSS selectors to query — returns element counts and samples for each"
+            },
+            include: {
+                type: "array",
+                items: {
+                    type: "string",
+                    enum: [
+                        "html",
+                        "summary",
+                        "meta",
+                        "dom_snapshot",
+                        "console",
+                        "extension_roots"
+                    ]
+                },
+                default: [
+                    "summary",
+                    "meta",
+                    "console"
+                ],
+                description: "What data to include in the response"
+            },
+            browser: {
+                type: "string",
+                default: "chrome"
+            },
+            maxBytes: {
+                type: "number",
+                default: 262144,
+                description: "Truncate HTML output at this byte count (0 = unlimited)"
+            },
+            deepDom: {
+                type: "boolean",
+                default: false,
+                description: "Pierce CLOSED shadow roots via CDP (Chromium only). The default path reads open shadow roots; closed ones need this escape hatch."
+            }
+        },
+        required: [
+            "projectPath"
+        ]
+    }
+};
+async function findCdpPort(projectPath, browser) {
+    const readyPath = external_node_path_default().resolve(projectPath, "dist", "extension-js", browser, "ready.json");
+    try {
+        const contract = JSON.parse(external_node_fs_default().readFileSync(readyPath, "utf8"));
+        if (contract.port) return contract.port;
+    } catch  {}
+    const defaultPort = 9222;
+    return new Promise((resolve)=>{
+        const socket = new (external_node_net_default()).Socket();
+        socket.setTimeout(1000);
+        socket.on("connect", ()=>{
+            socket.destroy();
+            resolve(defaultPort);
+        });
+        socket.on("error", ()=>resolve(null));
+        socket.on("timeout", ()=>{
+            socket.destroy();
+            resolve(null);
+        });
+        socket.connect(defaultPort, "127.0.0.1");
+    });
+}
+async function source_inspect_handler(args) {
+    const browser = args.browser ?? "chrome";
+    const include = new Set(args.include ?? [
+        "summary",
+        "meta",
+        "console"
+    ]);
+    const maxBytes = args.maxBytes ?? 262144;
+    const isChromium = [
+        "chrome",
+        "edge",
+        "chromium-based"
+    ].includes(browser);
+    if (!isChromium) return JSON.stringify({
+        error: `Source inspection for ${browser} uses RDP (Remote Debug Protocol). Currently only Chromium CDP is supported.`,
+        hint: "Use --browser=chrome for source inspection, or use the CLI: npx extension dev --source"
+    });
+    const cdpPort = await findCdpPort(args.projectPath, browser);
+    if (!cdpPort) return JSON.stringify({
+        error: "No active dev session found. Cannot connect to Chrome DevTools Protocol.",
+        hint: "Start a dev session first with extension_dev, then use extension_wait to confirm it is ready."
+    });
+    const cdp = new CDPClient();
+    try {
+        const allTargets = await CDPClient.discoverTargets(cdpPort);
+        const pageTargets = allTargets.filter((t)=>"page" === t.type && !t.url.startsWith("chrome://") && !t.url.startsWith("devtools://"));
+        if (0 === pageTargets.length) return JSON.stringify({
+            cdpPort,
+            browser,
+            warning: "No inspectable page targets found. The extension may not have opened a page yet.",
+            allTargets: allTargets.map((t)=>({
+                    type: t.type,
+                    url: t.url?.slice(0, 100)
+                }))
+        });
+        const target = args.url ? pageTargets.find((t)=>t.url.includes(args.url)) ?? pageTargets[0] : pageTargets[0];
+        const browserWsUrl = await CDPClient.discoverBrowserWsUrl(cdpPort);
+        await cdp.connect(browserWsUrl);
+        const sessionId = await cdp.attachToTarget(target.id);
+        await cdp.enableDomains(sessionId);
+        if (args.url && !target.url.includes(args.url)) {
+            await cdp.navigate(sessionId, args.url);
+            await new Promise((r)=>setTimeout(r, 1500));
+        } else await new Promise((r)=>setTimeout(r, 500));
+        const result = {
+            cdpPort,
+            browser,
+            target: {
+                id: target.id,
+                url: target.url,
+                title: target.title
+            },
+            targets: pageTargets.map((t)=>({
+                    id: t.id,
+                    url: t.url,
+                    title: t.title
+                }))
+        };
+        if (include.has("html")) {
+            let html = await cdp.getPageHTML(sessionId);
+            if (maxBytes > 0 && html.length > maxBytes) {
+                html = html.slice(0, maxBytes);
+                result.htmlTruncated = true;
+            }
+            result.html = html;
+        }
+        if (include.has("summary")) {
+            const summary = await cdp.evaluate(sessionId, `(() => {
+          try {
+            const roots = document.querySelectorAll('#extension-root,[data-extension-root]:not([data-extension-root="extension-js-devtools"])');
+            return {
+              htmlLength: document.documentElement.outerHTML.length,
+              scriptCount: document.querySelectorAll('script').length,
+              styleCount: document.querySelectorAll('style').length,
+              linkCount: document.querySelectorAll('link').length,
+              extensionRootCount: roots.length,
+              bodyChildCount: document.body ? document.body.children.length : 0
+            };
+          } catch { return {}; }
+        })()`);
+            result.summary = summary;
+        }
+        if (include.has("meta")) result.meta = await cdp.getPageMeta(sessionId);
+        if (include.has("dom_snapshot")) result.domSnapshot = await cdp.getDomSnapshot(sessionId);
+        if (include.has("console")) result.console = cdp.getConsoleSummary();
+        if (include.has("extension_roots")) result.extensionRoots = await cdp.getExtensionRootMeta(sessionId);
+        if (args.probe?.length) result.probes = await cdp.probeSelectors(sessionId, args.probe);
+        if (args.deepDom) {
+            const closed = await cdp.getClosedShadowRoots(sessionId, maxBytes > 0 ? maxBytes : 65536);
+            result.closedShadowRoots = closed;
+            result.deepDom = true;
+        }
+        return JSON.stringify(result);
+    } catch (err) {
+        return JSON.stringify({
+            error: `CDP inspection failed: ${err instanceof Error ? err.message : err}`,
+            cdpPort,
+            hint: "Ensure a dev session is running. The browser may have closed or the CDP port may have changed."
+        });
+    } finally{
+        cdp.disconnect();
+    }
+}
+const CONTROL_ENVELOPE_VERSION = 1;
+const CONTROL_WS_PATH = "/extjs-control";
+const DEFAULT_LIMIT = 200;
+const DEFAULT_FOLLOW_MS = 4000;
+const MIN_FOLLOW_MS = 500;
+const MAX_FOLLOW_MS = 15000;
+const logs_schema = {
+    name: "extension_logs",
+    description: "Read or stream logs from every context of a running dev session (service worker, content scripts, popup, options, sidebar, devtools, pages) in one ordered timeline. Reads the same agent-bridge plane as the `extension logs` CLI: a one-shot returns the most recent matching lines from logs.ndjson; `follow:true` collects from the live control channel for a bounded window. Requires an active `extension dev` session.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            projectPath: {
+                type: "string",
+                description: "Path to the extension project root (must have an active dev session)"
+            },
+            browser: {
+                type: "string",
+                default: "chromium",
+                description: "Which dist/extension-js/<browser>/ to read. Defaults to chromium (the default dev target)."
+            },
+            level: {
+                type: "string",
+                enum: [
+                    "off",
+                    "error",
+                    "warn",
+                    "info",
+                    "debug",
+                    "trace",
+                    "all"
+                ],
+                default: "all",
+                description: "Minimum severity to include; selecting a level includes it plus everything more severe."
+            },
+            context: {
+                type: "array",
+                items: {
+                    type: "string",
+                    enum: [
+                        "background",
+                        "content",
+                        "page",
+                        "sidebar",
+                        "popup",
+                        "options",
+                        "devtools"
+                    ]
+                },
+                description: "Restrict to these contexts. Omit for all."
+            },
+            signalsOnly: {
+                type: "boolean",
+                default: false,
+                description: "Only structured dx.signal diagnostics (which carry code/status/remediation), skipping plain console lines."
+            },
+            since: {
+                type: "number",
+                description: "Only return events with seq greater than this (cursor for polling forward)."
+            },
+            url: {
+                type: "string",
+                description: "Only events whose url/hostname matches (glob with * or plain substring), e.g. https://shop.example/*."
+            },
+            tab: {
+                type: "number",
+                description: "Only events from this tab id."
+            },
+            follow: {
+                type: "boolean",
+                default: false,
+                description: "Collect from the live control channel for a bounded window instead of reading the file. Use with followMs."
+            },
+            followMs: {
+                type: "number",
+                default: DEFAULT_FOLLOW_MS,
+                description: `How long to collect live frames when follow=true (clamped ${MIN_FOLLOW_MS}–${MAX_FOLLOW_MS}ms).`
+            },
+            limit: {
+                type: "number",
+                default: DEFAULT_LIMIT,
+                description: "Maximum number of (most recent) events to return."
+            }
+        },
+        required: [
+            "projectPath"
+        ]
+    }
+};
+const LEVEL_ORDER = [
+    "error",
+    "warn",
+    "info",
+    "debug",
+    "trace"
+];
+function levelRank(level) {
+    const l = "log" === level ? "info" : level;
+    const i = LEVEL_ORDER.indexOf(l);
+    return -1 === i ? LEVEL_ORDER.length : i;
+}
+function makeUrlMatcher(pattern) {
+    const hasGlob = pattern.includes("*");
+    let re = null;
+    if (hasGlob) {
+        const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+        re = new RegExp(escaped);
+    }
+    return (event)=>{
+        const candidates = [
+            event.url,
+            event.hostname
+        ].filter((v)=>"string" == typeof v);
+        if (0 === candidates.length) return false;
+        return candidates.some((c)=>re ? re.test(c) : c.includes(pattern));
+    };
+}
+function makeFilter(args) {
+    const minLevel = String(args.level || "all").toLowerCase();
+    const rawContexts = Array.isArray(args.context) ? args.context : "string" == typeof args.context ? args.context.split(",") : null;
+    const contexts = rawContexts && rawContexts.length ? new Set(rawContexts.map((c)=>c.trim()).filter(Boolean)) : null;
+    const sinceSeq = null != args.since ? Number(args.since) : null;
+    const urlMatches = args.url ? makeUrlMatcher(args.url) : null;
+    const tabId = null != args.tab ? Number(args.tab) : null;
+    return (event)=>{
+        if (!event || "object" != typeof event) return false;
+        if ("header" === event.type) return false;
+        if (args.signalsOnly && "dx.signal" !== event.eventType) return false;
+        if (contexts && !contexts.has(event.context)) return false;
+        if ("all" !== minLevel && "off" !== minLevel) {
+            if (levelRank(event.level) > levelRank(minLevel)) return false;
+        }
+        if (null != sinceSeq && Number.isFinite(sinceSeq) && "number" == typeof event.seq && event.seq <= sinceSeq) return false;
+        if (urlMatches && !urlMatches(event)) return false;
+        if (null != tabId && Number.isFinite(tabId) && event.tabId !== tabId) return false;
+        return true;
+    };
+}
+function logsFilePath(projectPath, browser) {
+    return external_node_path_default().resolve(projectPath, "dist", "extension-js", browser, "logs.ndjson");
+}
+function readReadyContract(projectPath, browser) {
+    const readyPath = external_node_path_default().resolve(projectPath, "dist", "extension-js", browser, "ready.json");
+    try {
+        const c = JSON.parse(external_node_fs_default().readFileSync(readyPath, "utf8"));
+        if ("number" != typeof c.controlPort || !c.instanceId) return null;
+        return {
+            controlPort: c.controlPort,
+            instanceId: String(c.instanceId),
+            runId: String(c.runId || "")
+        };
+    } catch  {
+        return null;
+    }
+}
+function capRecent(events, limit) {
+    if (events.length <= limit) return {
+        events,
+        truncated: false
+    };
+    return {
+        events: events.slice(events.length - limit),
+        truncated: true
+    };
+}
+function summarize(events, source, browser, runId, limit, dropped) {
+    const matched = events.length;
+    const { events: out, truncated } = capRecent(events, limit);
+    const lastSeq = out.length ? out.reduce((m, e)=>"number" == typeof e.seq && e.seq > m ? e.seq : m, -1) : -1;
+    return JSON.stringify({
+        ok: true,
+        source,
+        browser,
+        runId: runId || void 0,
+        matched,
+        count: out.length,
+        truncated,
+        dropped: dropped || void 0,
+        nextSince: lastSeq >= 0 ? lastSeq : void 0,
+        events: out
+    });
+}
+async function readFromFile(args, browser, limit) {
+    const file = logsFilePath(args.projectPath, browser);
+    if (!external_node_fs_default().existsSync(file)) return JSON.stringify({
+        error: `No logs found at ${file}.`,
+        hint: "Start a dev session first (extension_dev), or pass browser to match it. For live frames before any line is written, use follow:true."
+    });
+    const matches = makeFilter(args);
+    const lines = external_node_fs_default().readFileSync(file, "utf8").split("\n").filter(Boolean);
+    let runId = "";
+    const events = [];
+    for (const line of lines){
+        let event;
+        try {
+            event = JSON.parse(line);
+        } catch  {
+            continue;
+        }
+        if (event && "header" === event.type && event.runId) {
+            runId = String(event.runId);
+            continue;
+        }
+        if (matches(event)) events.push(event);
+    }
+    return summarize(events, "file", browser, runId, limit, 0);
+}
+async function readFromStream(args, browser, limit) {
+    const ready = readReadyContract(args.projectPath, browser);
+    if (!ready) return JSON.stringify({
+        error: `No active control channel found for ${browser}.`,
+        hint: `Run extension_dev (browser: ${browser}) and wait for it to be ready, then retry. For past logs without a live channel, call without follow.`
+    });
+    const followMs = Math.min(Math.max(args.followMs ?? DEFAULT_FOLLOW_MS, MIN_FOLLOW_MS), MAX_FOLLOW_MS);
+    const matches = makeFilter(args);
+    const events = [];
+    let dropped = 0;
+    let runId = ready.runId;
+    return await new Promise((resolve)=>{
+        let settled = false;
+        const url = `ws://127.0.0.1:${ready.controlPort}${CONTROL_WS_PATH}`;
+        let socket;
+        try {
+            socket = new (external_ws_default())(url);
+        } catch (err) {
+            resolve(JSON.stringify({
+                error: `Could not open control channel at ${url}: ${err instanceof Error ? err.message : String(err)}`
+            }));
+            return;
+        }
+        const finish = ()=>{
+            if (settled) return;
+            settled = true;
+            clearTimeout(timer);
+            try {
+                socket.close();
+            } catch  {}
+            resolve(summarize(events, "stream", browser, runId, limit, dropped));
+        };
+        const timer = setTimeout(finish, followMs);
+        socket.on("open", ()=>{
+            try {
+                socket.send(JSON.stringify({
+                    type: "hello",
+                    v: CONTROL_ENVELOPE_VERSION,
+                    role: "consumer",
+                    instanceId: ready.instanceId
+                }));
+            } catch  {}
+        });
+        socket.on("message", (data)=>{
+            let frame;
+            try {
+                frame = JSON.parse(data.toString());
+            } catch  {
+                return;
+            }
+            if ("ready" === frame.type && frame.runId) runId = String(frame.runId);
+            else if ("log" === frame.type && frame.event) {
+                if (matches(frame.event)) events.push(frame.event);
+            } else if ("gap" === frame.type && "number" == typeof frame.dropped) dropped += frame.dropped;
+        });
+        socket.on("error", ()=>{
+            if (settled) return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(JSON.stringify({
+                error: `Control channel error at ${url}.`,
+                hint: "The dev session may have stopped or the control port changed. Re-check with extension_wait."
+            }));
+        });
+        socket.on("close", finish);
+    });
+}
+async function logs_handler(args) {
+    const browser = args.browser ?? "chromium";
+    const limit = args.limit && args.limit > 0 ? args.limit : DEFAULT_LIMIT;
+    if (args.follow) return readFromStream(args, browser, limit);
+    return readFromFile(args, browser, limit);
+}
+async function runActVerb(args, projectPath, timeoutMs) {
+    const { code, stdout, stderr } = await runExtensionCli([
+        ...args,
+        "--output",
+        "json"
+    ], {
+        cwd: projectPath,
+        timeoutMs
+    });
+    const out = stdout.trim();
+    if (out) try {
+        JSON.parse(out);
+        return out;
+    } catch  {}
+    return JSON.stringify({
+        ok: false,
+        error: {
+            name: "CliError",
+            message: stderr.trim() || `extension exited with code ${code}`
+        }
+    });
+}
+function commonFlags(args) {
+    const flags = [];
+    if (args.context) flags.push("--context", args.context);
+    if (args.url) flags.push("--url", args.url);
+    if (null != args.tab) flags.push("--tab", String(args.tab));
+    if (args.browser) flags.push("--browser", args.browser);
+    if (null != args.timeout) flags.push("--timeout", String(args.timeout));
+    return flags;
+}
+const eval_schema = {
+    name: "extension_eval",
+    description: "Evaluate an expression in a running extension context (service worker, content script, popup, options, sidebar). Requires the dev session to be started with --allow-eval (writes a 0600 session token the CLI reads). Wraps `extension eval`.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            projectPath: {
+                type: "string",
+                description: "Path to the extension project root (must have an active dev session)"
+            },
+            expression: {
+                type: "string",
+                description: "JavaScript expression to evaluate in the target context"
+            },
+            context: {
+                type: "string",
+                enum: [
+                    "background",
+                    "popup",
+                    "options",
+                    "sidebar",
+                    "devtools",
+                    "content",
+                    "page"
+                ],
+                default: "background",
+                description: "Which extension surface to evaluate in"
+            },
+            url: {
+                type: "string",
+                description: "For content/page: document(s) to target"
+            },
+            tab: {
+                type: "number",
+                description: "For content/page: a specific tab id"
+            },
+            browser: {
+                type: "string",
+                default: "chromium"
+            },
+            timeout: {
+                type: "number",
+                description: "Command timeout in ms (default 5000)"
+            }
+        },
+        required: [
+            "projectPath",
+            "expression"
+        ]
+    }
+};
+async function eval_handler(args) {
+    return runActVerb([
+        "eval",
+        args.expression,
+        args.projectPath,
+        ...commonFlags(args)
+    ], args.projectPath, args.timeout);
+}
+const storage_schema = {
+    name: "extension_storage",
+    description: "Read or write chrome.storage in a running extension. Requires the dev session to be started with --allow-control. Wraps `extension storage get|set`.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            projectPath: {
+                type: "string",
+                description: "Path to the extension project root (must have an active dev session)"
+            },
+            action: {
+                type: "string",
+                enum: [
+                    "get",
+                    "set"
+                ],
+                description: "get reads a key (or the whole area); set writes a key"
+            },
+            area: {
+                type: "string",
+                enum: [
+                    "local",
+                    "sync",
+                    "session",
+                    "managed"
+                ],
+                default: "local"
+            },
+            key: {
+                type: "string",
+                description: "Key to get or set"
+            },
+            value: {
+                description: "Value to set (any JSON value); required for action=set"
+            },
+            context: {
+                type: "string",
+                enum: [
+                    "background",
+                    "popup",
+                    "options",
+                    "sidebar",
+                    "content"
+                ],
+                default: "background"
+            },
+            browser: {
+                type: "string",
+                default: "chromium"
+            },
+            timeout: {
+                type: "number",
+                description: "Command timeout in ms (default 5000)"
+            }
+        },
+        required: [
+            "projectPath",
+            "action"
+        ]
+    }
+};
+async function storage_handler(args) {
+    const cli = [
+        "storage",
+        args.action,
+        args.projectPath
+    ];
+    if (args.area) cli.push("--area", args.area);
+    if (args.key) cli.push("--key", args.key);
+    if ("set" === args.action) {
+        if (void 0 === args.value) return JSON.stringify({
+            ok: false,
+            error: {
+                name: "BadRequest",
+                message: "storage set requires a value"
+            }
+        });
+        cli.push("--value", JSON.stringify(args.value));
+    }
+    if (args.context) cli.push("--context", args.context);
+    if (args.browser) cli.push("--browser", args.browser);
+    if (null != args.timeout) cli.push("--timeout", String(args.timeout));
+    return runActVerb(cli, args.projectPath, args.timeout);
+}
+const reload_schema = {
+    name: "extension_reload",
+    description: "Reload a running extension (background) or a tab. Requires the dev session to be started with --allow-control. Wraps `extension reload`.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            projectPath: {
+                type: "string",
+                description: "Path to the extension project root (must have an active dev session)"
+            },
+            context: {
+                type: "string",
+                enum: [
+                    "background",
+                    "content",
+                    "page"
+                ],
+                default: "background"
+            },
+            tab: {
+                type: "number",
+                description: "For content/page: a specific tab id"
+            },
+            browser: {
+                type: "string",
+                default: "chromium"
+            },
+            timeout: {
+                type: "number",
+                description: "Command timeout in ms (default 5000)"
+            }
+        },
+        required: [
+            "projectPath"
+        ]
+    }
+};
+async function reload_handler(args) {
+    return runActVerb([
+        "reload",
+        args.projectPath,
+        ...commonFlags(args)
+    ], args.projectPath, args.timeout);
+}
+const open_schema = {
+    name: "extension_open",
+    description: "Open an extension surface — popup, options, or sidebar — in a running session. Requires the dev session to be started with --allow-control. Wraps `extension open`.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            projectPath: {
+                type: "string",
+                description: "Path to the extension project root (must have an active dev session)"
+            },
+            surface: {
+                type: "string",
+                enum: [
+                    "popup",
+                    "options",
+                    "sidebar"
+                ],
+                description: "Which surface to open"
+            },
+            browser: {
+                type: "string",
+                default: "chromium"
+            },
+            timeout: {
+                type: "number",
+                description: "Command timeout in ms (default 5000)"
+            }
+        },
+        required: [
+            "projectPath",
+            "surface"
+        ]
+    }
+};
+async function open_handler(args) {
+    const cli = [
+        "open",
+        args.surface,
+        args.projectPath
+    ];
+    if (args.browser) cli.push("--browser", args.browser);
+    if (null != args.timeout) cli.push("--timeout", String(args.timeout));
+    return runActVerb(cli, args.projectPath, args.timeout);
+}
+const dom_inspect_schema = {
+    name: "extension_dom_inspect",
+    description: "Inspect a page/content-script DOM via the agent bridge (CDP-free, localhost). Returns a structured snapshot (counts, extension roots, open shadow roots, optional capped HTML). Requires --allow-control. For closed shadow roots or deep CDP inspection use extension_source_inspect. Wraps `extension inspect`.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            projectPath: {
+                type: "string",
+                description: "Path to the extension project root (must have an active dev session)"
+            },
+            tab: {
+                type: "number",
+                description: "Tab id (required for content/page; omit for surfaces)"
+            },
+            context: {
+                type: "string",
+                enum: [
+                    "content",
+                    "page",
+                    "popup",
+                    "options",
+                    "sidebar",
+                    "devtools"
+                ],
+                default: "content",
+                description: "content/page (needs tab) or an OPEN extension surface (popup/options/sidebar/devtools)"
+            },
+            include: {
+                type: "array",
+                items: {
+                    type: "string",
+                    enum: [
+                        "summary",
+                        "html"
+                    ]
+                },
+                default: [
+                    "summary"
+                ],
+                description: "What to include; html is byte-capped"
+            },
+            maxBytes: {
+                type: "number",
+                default: 262144
+            },
+            withConsole: {
+                type: "number",
+                description: "Also include the last N console lines for the target (DOM + recent console in one call)"
+            },
+            browser: {
+                type: "string",
+                default: "chromium"
+            },
+            timeout: {
+                type: "number",
+                description: "Command timeout in ms (default 5000)"
+            }
+        },
+        required: [
+            "projectPath"
+        ]
+    }
+};
+async function dom_inspect_handler(args) {
+    const surfaces = [
+        "popup",
+        "options",
+        "sidebar",
+        "devtools"
+    ];
+    const isSurface = !!args.context && surfaces.includes(args.context);
+    if (!isSurface && null == args.tab) return JSON.stringify({
+        ok: false,
+        error: {
+            name: "BadRequest",
+            message: "content/page inspect requires a tab id"
+        }
+    });
+    const cli = [
+        "inspect",
+        args.projectPath
+    ];
+    if (null != args.tab) cli.push("--tab", String(args.tab));
+    if (args.context) cli.push("--context", args.context);
+    if (args.include?.length) cli.push("--include", args.include.join(","));
+    if (null != args.maxBytes) cli.push("--max-bytes", String(args.maxBytes));
+    if (null != args.withConsole) cli.push("--with-console", String(args.withConsole));
+    if (args.browser) cli.push("--browser", args.browser);
+    if (null != args.timeout) cli.push("--timeout", String(args.timeout));
+    return runActVerb(cli, args.projectPath, args.timeout);
+}
+const publish_schema = {
+    name: "extension_publish",
+    description: "Publish a project to extension.dev and return a shareable URL. Auth-gated: requires EXTENSION_DEV_TOKEN (a workspace/project access token) in the environment. Wraps `extension publish` (which posts to the platform's CLI publish endpoint). This is the only tool that talks to the hosted platform rather than the local browser.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            projectPath: {
+                type: "string",
+                description: "Path to the extension project root"
+            },
+            ttlHours: {
+                type: "number",
+                description: "Share-link lifetime in hours (1–168, default 24)"
+            },
+            buildSha: {
+                type: "string",
+                description: "Pin the share URL to a specific build sha"
+            },
+            api: {
+                type: "string",
+                description: "Platform base URL (defaults to https://www.extension.dev or EXTENSION_DEV_API_URL)"
+            }
+        },
+        required: [
+            "projectPath"
+        ]
+    }
+};
+async function publish_handler(args) {
+    const cli = [
+        "publish",
+        args.projectPath,
+        "--output",
+        "json"
+    ];
+    if (null != args.ttlHours) cli.push("--ttl", String(args.ttlHours));
+    if (args.buildSha) cli.push("--build-sha", args.buildSha);
+    if (args.api) cli.push("--api", args.api);
+    const { code, stdout, stderr } = await runExtensionCli(cli, {
+        cwd: args.projectPath
+    });
+    const out = stdout.trim();
+    if (out) try {
+        JSON.parse(out);
+        return out;
+    } catch  {}
+    return JSON.stringify({
+        ok: false,
+        error: {
+            name: "PublishError",
+            message: stderr.trim() || `extension publish exited with code ${code}`
+        }
+    });
+}
+const wait_schema = {
+    name: "extension_wait",
+    description: "Wait for a running dev or start session to be ready. Polls the ready.json contract file and returns structured status.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            projectPath: {
+                type: "string",
+                description: "Path to the extension project root"
+            },
+            browser: {
+                type: "string",
+                default: "chrome",
+                description: "Browser to check readiness for"
+            },
+            timeout: {
+                type: "number",
+                default: 60000,
+                description: "Timeout in milliseconds"
+            }
+        },
+        required: [
+            "projectPath"
+        ]
+    }
+};
+async function wait_handler(args) {
+    const browser = args.browser ?? "chrome";
+    const timeout = args.timeout ?? 60000;
+    const readyPath = external_node_path_default().resolve(args.projectPath, "dist", "extension-js", browser, "ready.json");
+    const start = Date.now();
+    const pollInterval = 1000;
+    while(Date.now() - start < timeout){
+        try {
+            const raw = external_node_fs_default().readFileSync(readyPath, "utf8");
+            const contract = JSON.parse(raw);
+            if ("ready" === contract.status) return JSON.stringify({
+                status: "ready",
+                command: contract.command,
+                browser: contract.browser,
+                port: contract.port,
+                pid: contract.pid,
+                distPath: contract.distPath,
+                manifestPath: contract.manifestPath,
+                compiledAt: contract.compiledAt,
+                startedAt: contract.startedAt,
+                waitDuration: Date.now() - start
+            });
+            if ("error" === contract.status) return JSON.stringify({
+                status: "error",
+                message: contract.message,
+                errors: contract.errors,
+                code: contract.code,
+                browser: contract.browser,
+                waitDuration: Date.now() - start
+            });
+        } catch  {}
+        await new Promise((resolve)=>setTimeout(resolve, pollInterval));
+    }
+    return JSON.stringify({
+        status: "timeout",
+        message: `Extension did not become ready within ${timeout}ms`,
+        readyPath,
+        hint: "The dev session may still be building. Try increasing the timeout, or check if the dev process is still running."
+    });
+}
+const add_feature_schema = {
+    name: "extension_add_feature",
+    description: "Add a new feature surface to an existing extension. Generates the required files and updates manifest.json. Sources patterns from the extension.dev template catalog.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            projectPath: {
+                type: "string",
+                description: "Path to the extension project root"
+            },
+            feature: {
+                type: "string",
+                enum: [
+                    "sidebar",
+                    "popup",
+                    "options",
+                    "content-script",
+                    "background",
+                    "newtab",
+                    "devtools"
+                ],
+                description: "Feature surface to add"
+            },
+            framework: {
+                type: "string",
+                enum: [
+                    "react",
+                    "vue",
+                    "svelte",
+                    "preact",
+                    "vanilla"
+                ],
+                default: "react"
+            }
+        },
+        required: [
+            "projectPath",
+            "feature"
+        ]
+    }
+};
+const FEATURE_TEMPLATE_MAP = {
+    sidebar: {
+        react: "sidebar-shadcn",
+        vanilla: "sidebar",
+        vue: "sidebar",
+        svelte: "sidebar",
+        preact: "sidebar"
+    },
+    "content-script": {
+        react: "content-react",
+        vue: "content-vue",
+        svelte: "content-svelte",
+        preact: "content-preact",
+        vanilla: "content"
+    },
+    popup: {
+        react: "action",
+        vanilla: "action",
+        vue: "action",
+        svelte: "action",
+        preact: "action"
+    },
+    newtab: {
+        react: "new-react",
+        vue: "new-vue",
+        svelte: "new-svelte",
+        preact: "new-preact",
+        vanilla: "new"
+    },
+    background: {
+        react: "javascript",
+        vanilla: "javascript",
+        vue: "javascript",
+        svelte: "javascript",
+        preact: "javascript"
+    },
+    options: {
+        react: "javascript",
+        vanilla: "javascript",
+        vue: "javascript",
+        svelte: "javascript",
+        preact: "javascript"
+    },
+    devtools: {
+        react: "javascript",
+        vanilla: "javascript",
+        vue: "javascript",
+        svelte: "javascript",
+        preact: "javascript"
+    }
+};
+const MANIFEST_ADDITIONS = {
+    sidebar: {
+        "chromium:side_panel": {
+            default_path: "sidebar/index.html"
+        },
+        "firefox:sidebar_action": {
+            default_panel: "sidebar/index.html"
+        },
+        "chromium:permissions": [
+            "sidePanel"
+        ]
+    },
+    popup: {
+        "chromium:action": {
+            default_popup: "action/index.html",
+            default_title: "Extension Popup"
+        },
+        "firefox:browser_action": {
+            default_popup: "action/index.html",
+            default_title: "Extension Popup"
+        }
+    },
+    "content-script": {
+        content_scripts: [
+            {
+                matches: [
+                    "<all_urls>"
+                ],
+                js: [
+                    "content/scripts.ts"
+                ],
+                css: [
+                    "content/styles.css"
+                ]
+            }
+        ]
+    },
+    newtab: {
+        chrome_url_overrides: {
+            newtab: "newtab/index.html"
+        }
+    },
+    options: {
+        options_ui: {
+            page: "options/index.html",
+            open_in_tab: true
+        }
+    },
+    background: {
+        background: {
+            "chromium:service_worker": "background.ts",
+            "firefox:scripts": [
+                "background.ts"
+            ]
+        }
+    },
+    devtools: {
+        devtools_page: "devtools/index.html"
+    }
+};
+async function add_feature_handler(args) {
+    const framework = args.framework ?? "react";
+    const projectPath = external_node_path_default().resolve(args.projectPath);
+    const srcDir = external_node_path_default().join(projectPath, "src");
+    const manifestPath = external_node_path_default().join(srcDir, "manifest.json");
+    if (!external_node_fs_default().existsSync(manifestPath)) return JSON.stringify({
+        error: `No manifest.json found at ${manifestPath}`,
+        hint: "Ensure projectPath points to an extension project root with src/manifest.json"
+    });
+    const templateSlug = FEATURE_TEMPLATE_MAP[args.feature]?.[framework];
+    if (!templateSlug) return JSON.stringify({
+        error: `No reference template for feature "${args.feature}" with framework "${framework}"`
+    });
+    const template = await getTemplateBySlug(templateSlug);
+    const referenceFiles = template?.keyFiles ?? template?.files ?? [];
+    const featureDir = "content-script" === args.feature ? "content" : args.feature;
+    const filesToCreate = [];
+    const manifestUpdates = MANIFEST_ADDITIONS[args.feature] ?? {};
+    if ([
+        "sidebar",
+        "popup",
+        "newtab",
+        "options",
+        "devtools"
+    ].includes(args.feature)) {
+        filesToCreate.push({
+            path: `src/${featureDir}/index.html`,
+            hint: "HTML entry point"
+        }, {
+            path: `src/${featureDir}/scripts.${"vanilla" === framework ? "ts" : "tsx"}`,
+            hint: "vanilla" === framework ? "Script entry point" : `${framework} mount point`
+        }, {
+            path: `src/${featureDir}/styles.css`,
+            hint: "Stylesheet"
+        });
+        if ("vanilla" !== framework) filesToCreate.push({
+            path: `src/${featureDir}/${featureDir.charAt(0).toUpperCase() + featureDir.slice(1)}App.tsx`,
+            hint: `Main ${framework} component`
+        });
+    }
+    if ("content-script" === args.feature) filesToCreate.push({
+        path: "src/content/scripts.ts",
+        hint: "Content script entry point"
+    }, {
+        path: "src/content/styles.css",
+        hint: "Content script styles"
+    });
+    if ("background" === args.feature) filesToCreate.push({
+        path: "src/background.ts",
+        hint: "Background service worker / script"
+    });
+    const conflicts = filesToCreate.filter((f)=>external_node_fs_default().existsSync(external_node_path_default().join(projectPath, f.path)));
+    return JSON.stringify({
+        feature: args.feature,
+        framework,
+        referenceTemplate: {
+            slug: templateSlug,
+            repositoryUrl: `https://github.com/extension-js/examples/tree/main/examples/${templateSlug}`,
+            referenceFiles: referenceFiles.filter((f)=>f.includes(featureDir) || f.includes("manifest"))
+        },
+        manifestUpdates,
+        filesToCreate: filesToCreate.map((f)=>({
+                ...f,
+                exists: external_node_fs_default().existsSync(external_node_path_default().join(projectPath, f.path))
+            })),
+        conflicts: conflicts.map((c)=>c.path),
+        instructions: [
+            `1. Add these fields to your src/manifest.json:\n${JSON.stringify(manifestUpdates, null, 2)}`,
+            "2. Create the following files in your project:",
+            ...filesToCreate.map((f)=>`   - ${f.path} (${f.hint})`),
+            "sidebar" === args.feature ? "3. Add background.ts to handle sidebar open: chromium uses chrome.sidePanel.setPanelBehavior, firefox uses browser.sidebarAction.open()" : "",
+            `4. Reference template source: https://github.com/extension-js/examples/tree/main/examples/${templateSlug}/src`,
+            "5. Run npm run dev to test"
+        ].filter(Boolean),
+        hint: conflicts.length ? `Warning: ${conflicts.length} file(s) already exist and would be overwritten.` : "No conflicts detected. Safe to create all files."
+    });
+}
+const external_extension_install_namespaceObject = require("extension-install");
+const install_browser_schema = {
+    name: "extension_install_browser",
+    description: "Install a managed browser binary for extension testing. Useful in CI, Docker, or fresh environments where browsers are not pre-installed.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            browser: {
+                type: "string",
+                enum: [
+                    "chrome",
+                    "chromium",
+                    "edge",
+                    "firefox"
+                ],
+                description: "Browser to install"
+            }
+        },
+        required: [
+            "browser"
+        ]
+    }
+};
+async function install_browser_handler(args) {
+    const start = Date.now();
+    try {
+        await (0, external_extension_install_namespaceObject.extensionInstall)({
+            browser: args.browser
+        });
+        return JSON.stringify({
+            status: "installed",
+            browser: args.browser,
+            duration: Date.now() - start,
+            hint: `Browser "${args.browser}" is now available. Use extension_dev or extension_start with --browser=${args.browser}.`
+        });
+    } catch (err) {
+        return JSON.stringify({
+            status: "error",
+            browser: args.browser,
+            message: err instanceof Error ? err.message : String(err),
+            duration: Date.now() - start,
+            hint: "edge" === args.browser ? "Edge installation on Linux may require elevated privileges. Try using Chrome or Chromium instead." : "Check network connectivity and disk space. You can also install browsers manually."
+        });
+    }
+}
+const list_browsers_schema = {
+    name: "extension_list_browsers",
+    description: "List managed browser binaries installed by the extension.dev platform. Shows what browsers are available in the managed cache without checking system-installed browsers.",
+    inputSchema: {
+        type: "object",
+        properties: {}
+    }
+};
+const BROWSER_NAMES = [
+    "chrome",
+    "chromium",
+    "edge",
+    "firefox"
+];
+function getDirSize(dir) {
+    let total = 0;
+    try {
+        for (const entry of external_node_fs_namespaceObject.readdirSync(dir, {
+            withFileTypes: true
+        })){
+            const full = external_node_path_namespaceObject.join(dir, entry.name);
+            if (entry.isDirectory()) total += getDirSize(full);
+            else try {
+                total += external_node_fs_namespaceObject.statSync(full).size;
+            } catch  {}
+        }
+    } catch  {}
+    return total;
+}
+function list_browsers_formatBytes(bytes) {
+    if (bytes < 1024) return `${bytes} B`;
+    if (bytes < 1048576) return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / 1048576).toFixed(1)} MB`;
+}
+async function list_browsers_handler() {
+    const cacheRoot = (0, external_extension_install_namespaceObject.getManagedBrowsersCacheRoot)();
+    const installed = [];
+    for (const browser of BROWSER_NAMES){
+        const browserDir = external_node_path_namespaceObject.join(cacheRoot, browser);
+        if (external_node_fs_namespaceObject.existsSync(browserDir)) {
+            const size = getDirSize(browserDir);
+            installed.push({
+                browser,
+                path: browserDir,
+                size,
+                sizeFormatted: list_browsers_formatBytes(size),
+                engine: "firefox" === browser ? "gecko" : "chromium"
+            });
+        }
+    }
+    return JSON.stringify({
+        cacheRoot,
+        cacheExists: external_node_fs_namespaceObject.existsSync(cacheRoot),
+        installed,
+        availableToInstall: BROWSER_NAMES.filter((b)=>!installed.some((i)=>i.browser === b)),
+        hint: 0 === installed.length ? "No managed browsers found. Use extension_install_browser to install one, or use a system-installed browser." : `${installed.length} managed browser(s) found. Use extension_detect_browsers for a full system scan.`
+    });
+}
+const external_node_util_namespaceObject = require("node:util");
+const execFileAsync = (0, external_node_util_namespaceObject.promisify)(external_node_child_process_namespaceObject.execFile);
+const detect_browsers_schema = {
+    name: "extension_detect_browsers",
+    description: "Detect which browsers are available for extension development. Checks both system-installed and managed browsers, returning paths and capabilities for each.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            browsers: {
+                type: "array",
+                items: {
+                    type: "string",
+                    enum: [
+                        "chrome",
+                        "chromium",
+                        "edge",
+                        "firefox"
+                    ]
+                },
+                description: "Browsers to check. If omitted, checks all."
+            }
+        }
+    }
+};
+const ALL_BROWSERS = [
+    "chrome",
+    "chromium",
+    "edge",
+    "firefox"
+];
+const SYSTEM_PATHS = {
+    darwin: {
+        chrome: [
+            "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+            `${process.env.HOME}/Applications/Google Chrome.app/Contents/MacOS/Google Chrome`
+        ],
+        chromium: [
+            "/Applications/Chromium.app/Contents/MacOS/Chromium",
+            `${process.env.HOME}/Applications/Chromium.app/Contents/MacOS/Chromium`
+        ],
+        edge: [
+            "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+            `${process.env.HOME}/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge`
+        ],
+        firefox: [
+            "/Applications/Firefox.app/Contents/MacOS/firefox",
+            `${process.env.HOME}/Applications/Firefox.app/Contents/MacOS/firefox`
+        ]
+    },
+    linux: {
+        chrome: [
+            "/usr/bin/google-chrome",
+            "/usr/bin/google-chrome-stable",
+            "/usr/local/bin/google-chrome"
+        ],
+        chromium: [
+            "/usr/bin/chromium",
+            "/usr/bin/chromium-browser",
+            "/snap/bin/chromium"
+        ],
+        edge: [
+            "/usr/bin/microsoft-edge",
+            "/usr/bin/microsoft-edge-stable",
+            "/opt/microsoft/msedge/msedge"
+        ],
+        firefox: [
+            "/usr/bin/firefox",
+            "/snap/bin/firefox",
+            "/usr/lib/firefox/firefox"
+        ]
+    },
+    win32: {
+        chrome: [
+            "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
+            "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe"
+        ],
+        chromium: [
+            "C:\\Program Files\\Chromium\\Application\\chrome.exe"
+        ],
+        edge: [
+            "C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe",
+            "C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe"
+        ],
+        firefox: [
+            "C:\\Program Files\\Mozilla Firefox\\firefox.exe",
+            "C:\\Program Files (x86)\\Mozilla Firefox\\firefox.exe"
+        ]
+    }
+};
+function resolveCacheRoot() {
+    const explicit = String(process.env.EXT_BROWSERS_CACHE_DIR || "").trim();
+    if (explicit) return external_node_path_default().resolve(explicit);
+    const isWin = "win32" === process.platform;
+    const isMac = "darwin" === process.platform;
+    if (isWin) {
+        const local = String(process.env.LOCALAPPDATA || "").trim();
+        if (local) return external_node_path_default().join(local, "extension.js", "browsers");
+        const userProfile = String(process.env.USERPROFILE || "").trim();
+        if (userProfile) return external_node_path_default().join(userProfile, "AppData", "Local", "extension.js", "browsers");
+        return external_node_path_default().resolve(process.cwd(), ".cache", "extension.js", "browsers");
+    }
+    if (isMac) {
+        const home = String(process.env.HOME || "").trim();
+        if (home) return external_node_path_default().join(home, "Library", "Caches", "extension.js", "browsers");
+        return external_node_path_default().resolve(process.cwd(), ".cache", "extension.js", "browsers");
+    }
+    const xdg = String(process.env.XDG_CACHE_HOME || "").trim();
+    if (xdg) return external_node_path_default().join(xdg, "extension.js", "browsers");
+    const home = String(process.env.HOME || "").trim();
+    if (home) return external_node_path_default().join(home, ".cache", "extension.js", "browsers");
+    return external_node_path_default().resolve(process.cwd(), ".cache", "extension.js", "browsers");
+}
+function findManagedBinary(browser) {
+    const browserDir = external_node_path_default().join(resolveCacheRoot(), browser);
+    if (!external_node_fs_default().existsSync(browserDir)) return null;
+    const execNames = {
+        chrome: [
+            "chrome",
+            "chrome.exe",
+            "Google Chrome for Testing"
+        ],
+        chromium: [
+            "chrome",
+            "chromium",
+            "chrome.exe",
+            "chromium.exe",
+            "Chromium.app"
+        ],
+        edge: [
+            "msedge",
+            "msedge.exe",
+            "microsoft-edge",
+            "Microsoft Edge"
+        ],
+        firefox: [
+            "firefox",
+            "firefox.exe",
+            "Firefox.app"
+        ]
+    };
+    const names = execNames[browser] ?? [];
+    function search(dir, depth) {
+        if (depth > 4) return null;
+        try {
+            for (const entry of external_node_fs_default().readdirSync(dir, {
+                withFileTypes: true
+            })){
+                const full = external_node_path_default().join(dir, entry.name);
+                if (entry.isFile() && names.includes(entry.name)) return full;
+                if (entry.isDirectory() && depth < 4) {
+                    const found = search(full, depth + 1);
+                    if (found) return found;
+                }
+            }
+        } catch  {}
+        return null;
+    }
+    return search(browserDir, 0);
+}
+function findSystemBinary(browser) {
+    const platform = process.platform;
+    const paths = SYSTEM_PATHS[platform]?.[browser] ?? [];
+    for (const p of paths)if (external_node_fs_default().existsSync(p)) return p;
+    return null;
+}
+async function getVersion(binaryPath, browser) {
+    try {
+        const flag = "firefox" === browser ? "--version" : "--version";
+        const { stdout } = await execFileAsync(binaryPath, [
+            flag
+        ], {
+            timeout: 5000,
+            env: {
+                ...process.env
+            }
+        });
+        const match = stdout.match(/[\d]+\.[\d]+[\d.]*/);
+        return match ? match[0] : stdout.trim().slice(0, 50);
+    } catch  {
+        return null;
+    }
+}
+async function detect_browsers_handler(args) {
+    const browsersToCheck = args.browsers ?? [
+        ...ALL_BROWSERS
+    ];
+    const detected = [];
+    const managed = {
+        cacheRoot: resolveCacheRoot(),
+        installed: []
+    };
+    for (const browser of ALL_BROWSERS){
+        const browserDir = external_node_path_default().join(managed.cacheRoot, browser);
+        if (external_node_fs_default().existsSync(browserDir)) managed.installed.push(browser);
+    }
+    for (const browser of browsersToCheck){
+        const isGecko = "firefox" === browser;
+        let binaryPath = findManagedBinary(browser);
+        let source = "managed";
+        if (!binaryPath) {
+            binaryPath = findSystemBinary(browser);
+            source = binaryPath ? "system" : "not_found";
+        }
+        let version = null;
+        if (binaryPath) version = await getVersion(binaryPath, browser);
+        detected.push({
+            browser,
+            binaryPath,
+            source,
+            engine: isGecko ? "gecko" : "chromium",
+            version,
+            cdpSupport: !isGecko,
+            rdpSupport: isGecko
+        });
+    }
+    const available = detected.filter((d)=>"not_found" !== d.source);
+    const missing = detected.filter((d)=>"not_found" === d.source);
+    return JSON.stringify({
+        detected,
+        managed,
+        summary: {
+            available: available.map((d)=>d.browser),
+            missing: missing.map((d)=>d.browser)
+        },
+        hint: missing.length ? `Missing browser(s): ${missing.map((d)=>d.browser).join(", ")}. Use extension_install_browser to install them.` : "All requested browsers are available."
+    });
+}
+const tools = [
+    create_namespaceObject,
+    list_templates_namespaceObject,
+    build_namespaceObject,
+    dev_namespaceObject,
+    start_namespaceObject,
+    preview_namespaceObject,
+    get_template_source_namespaceObject,
+    manifest_validate_namespaceObject,
+    inspect_namespaceObject,
+    source_inspect_namespaceObject,
+    logs_namespaceObject,
+    eval_namespaceObject,
+    storage_namespaceObject,
+    reload_namespaceObject,
+    open_namespaceObject,
+    dom_inspect_namespaceObject,
+    publish_namespaceObject,
+    wait_namespaceObject,
+    add_feature_namespaceObject,
+    install_browser_namespaceObject,
+    list_browsers_namespaceObject,
+    detect_browsers_namespaceObject
+];
+const toolMap = new Map();
+for (const tool of tools)toolMap.set(tool.schema.name, tool);
+async function startServer() {
+    const server = new index_js_namespaceObject.Server({
+        name: "extension-dev",
+        version: "3.17.0-canary.1779905934.1151df3"
+    }, {
+        capabilities: {
+            tools: {}
+        }
+    });
+    server.setRequestHandler(types_js_namespaceObject.ListToolsRequestSchema, async ()=>({
+            tools: tools.map((t)=>({
+                    name: t.schema.name,
+                    description: t.schema.description,
+                    inputSchema: t.schema.inputSchema
+                }))
+        }));
+    server.setRequestHandler(types_js_namespaceObject.CallToolRequestSchema, async (request)=>{
+        const { name, arguments: args } = request.params;
+        const tool = toolMap.get(name);
+        if (!tool) return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        error: `Unknown tool: ${name}`,
+                        availableTools: tools.map((t)=>t.schema.name)
+                    })
+                }
+            ],
+            isError: true
+        };
+        try {
+            const result = await tool.handler(args ?? {});
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: result
+                    }
+                ]
+            };
+        } catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: err instanceof Error ? err.message : String(err),
+                            tool: name
+                        })
+                    }
+                ],
+                isError: true
+            };
+        }
+    });
+    const transport = new stdio_js_namespaceObject.StdioServerTransport();
+    await server.connect(transport);
+}
+exports.startServer = __webpack_exports__.startServer;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "startServer"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});