@mearl/mcp-server 2.2.0 → 2.2.2

package/README.md

@@ -12,11 +12,11 @@
 - 📴 **browser_release**: 按用户明确要求释放 debugger/CDP 控制和会话级临时效果，并保留浏览器与全部标签页
 - 🚀 **browser_launch / browser_close**: 启动或关闭独立 Profile 的托管 Chrome
 - 🌐 **browser_page_snapshot**: 首次获取页面结构和可交互元素
-- ⚡ **browser_page_click/type/hover/scroll/press/upload**: 执行页面动作，默认内置观察，返回通知、可交互控件和焦点等高置信度信号
+- ⚡ **browser_page_click/type/hover/scroll/press/upload**: 执行页面动作，默认内置观察，返回通知、可交互控件、焦点、导航或直接打开的新标签页
 
 ## 浏览器交互工作流
 
-首次进入页面时调用 `browser_page_snapshot` 建立结构基线。后续点击、输入、悬停、滚动、按键和上传直接调用 `browser_page_click/type/hover/scroll/press/upload`，它们默认内置观察，动作与异步同步在一次调用内完成；同页结果读取 `effects.notifications`、`effects.interactives` 和 `effects.focus`。新增或变化的可交互节点会尽量携带可直接用于后续动作的 `node.ref`，解析不到 ref 时回退使用 `node.selector`。导航结果读取新 URL 和就绪状态。通常仅在导航后、`fullSnapshotRecommended: true` 或需要视觉判断时重新 snapshot 或截图；滚动后若下一步需要读取新视口内容，可按需获取 viewport 快照。`browser_page_eval` 默认裸执行，仅在表达式会修改页面且需要变化信号时显式传 `observe` 对象。
+首次进入页面时调用 `browser_page_snapshot` 建立结构基线。后续点击、输入、悬停、滚动、按键和上传直接调用 `browser_page_click/type/hover/scroll/press/upload`，它们默认内置观察，动作与异步同步在一次调用内完成；同页结果读取 `effects.notifications`、`effects.interactives` 和 `effects.focus`。新增或变化的可交互节点会尽量携带可直接用于后续动作的 `node.ref`，解析不到 ref 时回退使用 `node.selector`。导航结果读取新 URL 和就绪状态；动作直接打开新标签页时，`openedTabs` 返回可继续操作的 `tabId`，无需调用 `browser_tab_list`。通常仅在导航后、`fullSnapshotRecommended: true` 或需要视觉判断时重新 snapshot 或截图；滚动后若下一步需要读取新视口内容，可按需获取 viewport 快照。`browser_page_eval` 默认裸执行，仅在表达式会修改页面且需要变化信号时显式传 `observe` 对象。
 
 长列表重新感知时优先使用 `browser_page_snapshot(mode: "viewport")`；已知 CSS 区域时使用 `rootSelector`，已有 ref 时使用 `rootRef`，只查找特定文案或角色时使用 `query`；仅需要当前视口内的控件时使用 `mode: "interactive"`，避免整页 AX Tree 占用上下文。视口内缺少 AX 控件语义时，`interactive` 会自动回退到 viewport，并返回 `fallbackMode: "viewport"`。重复文本点击可用 `scope` 限定子树，滚动子节点所在容器可用 `containerPolicy: "nearest"`。
 

package/dist/configure.d.ts

@@ -5,7 +5,17 @@
  * 使用方式：
  *   mearl-mcp-configure                              # 交互式配置（会询问是否使用自定义 Extension ID）
  *   mearl-mcp-configure --extension-id=YOUR_ID       # 直接指定自定义 Extension ID
+ *   mearl-mcp-configure --yes                        # 配置所有已检测客户端，不询问
  *   mearl-mcp-configure --skip-mcp                   # 跳过 MCP 配置
  *   mearl-mcp-configure --get                        # 查看当前配置
  */
-export {};
+export interface ConfigureArgs {
+    extensionId?: string;
+    get: boolean;
+    globalInstall: boolean;
+    skipMcp: boolean;
+    yes: boolean;
+}
+export declare function parseConfigureArgs(args?: string[]): ConfigureArgs;
+export declare function shouldUseNpx(globalInstall: boolean, detectNpxMode?: () => boolean): boolean;
+export declare function runConfigure(argv?: string[]): Promise<void>;

package/dist/configure.js

@@ -5,12 +5,14 @@
  * 使用方式：
  *   mearl-mcp-configure                              # 交互式配置（会询问是否使用自定义 Extension ID）
  *   mearl-mcp-configure --extension-id=YOUR_ID       # 直接指定自定义 Extension ID
+ *   mearl-mcp-configure --yes                        # 配置所有已检测客户端，不询问
  *   mearl-mcp-configure --skip-mcp                   # 跳过 MCP 配置
  *   mearl-mcp-configure --get                        # 查看当前配置
  */
 import { installNativeHost, resolveHostDir } from '@mearl/native-host';
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
-import { join, dirname } from 'path';
+import path, { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { HOST_NAME, DEFAULT_EXTENSION_ID } from './constants.js';
 import prompts from 'prompts';
 import { MCP_CLIENTS, getMCPServerConfig, isNpxMode, isClientInstalled, } from './mcp-clients.js';
@@ -19,11 +21,12 @@ const log = (...args) => {
     console.log('[Configure]', ...args);
 };
 // 解析命令行参数
-function parseArgs() {
-    const args = process.argv.slice(2);
+export function parseConfigureArgs(args = process.argv.slice(2)) {
     let extensionId;
     let skipMcp = false;
     let get = false;
+    let globalInstall = false;
+    let yes = false;
     for (const arg of args) {
         if (arg.startsWith('--extension-id=')) {
             extensionId = arg.split('=')[1];
@@ -37,8 +40,14 @@ function parseArgs() {
         else if (arg === '--get') {
             get = true;
         }
+        else if (arg === '--global-install') {
+            globalInstall = true;
+        }
+        else if (arg === '--yes' || arg === '-y' || arg === '--non-interactive') {
+            yes = true;
+        }
     }
-    return { extensionId, skipMcp, get };
+    return { extensionId, skipMcp, get, globalInstall, yes };
 }
 // 替换或追加 TOML 中的 mcp_servers.xxx 节
 function replaceTOMLSection(content, serverName, newSectionLines) {
@@ -198,10 +207,11 @@ function showCurrentConfig() {
         console.log('\n💡 运行 "mearl-mcp-configure" 重新配置\n');
     }
 }
-async function main() {
-    const parseResult = parseArgs();
-    const { skipMcp, get } = parseResult;
-    const extensionId = parseResult.extensionId;
+export function shouldUseNpx(globalInstall, detectNpxMode = isNpxMode) {
+    return !globalInstall && detectNpxMode();
+}
+export async function runConfigure(argv = process.argv.slice(2)) {
+    const { extensionId, get, globalInstall, skipMcp, yes } = parseConfigureArgs(argv);
     // 如果是查看配置，显示后退出
     if (get) {
         showCurrentConfig();
@@ -209,72 +219,101 @@ async function main() {
     }
     console.log('🔧 Mearl MCP 配置\n');
     // 检测 npx 模式
-    const useNpx = isNpxMode();
+    const useNpx = shouldUseNpx(globalInstall);
     if (useNpx) {
         log('检测到 npx 模式，将生成 npx 配置');
     }
+    else if (globalInstall) {
+        log('使用全局 mearl-mcp-server 命令生成配置');
+    }
     // 配置 Native Messaging Host
     console.log('\n📦 配置 Chrome Native Messaging Host...');
     // Install both host manifests so MCP and Skills integrations can be used at
     // the same time (they share the same Unix socket and handlers).
-    await installNativeHost({
+    const nativeHostInstalled = await installNativeHost({
         mode: 'both',
         extensionId: extensionId || process.env.MEARL_EXTENSION_ID || DEFAULT_EXTENSION_ID,
         silent: true,
     });
+    if (!nativeHostInstalled) {
+        throw new Error('Native Messaging Host 配置失败');
+    }
     console.log('✅ 配置完成\n');
     // 配置 MCP 客户端
     if (skipMcp) {
         console.log('跳过 MCP 客户端配置\n');
     }
     else {
-        const response = await prompts({
-            type: 'confirm',
-            name: 'setupMcp',
-            message: '配置 MCP 客户端？',
-            initial: true,
-        });
-        if (response.setupMcp) {
-            // 列出全部支持的客户端，已检测到安装的默认预选
-            const allClients = Object.entries(MCP_CLIENTS).map(([key, client]) => ({
-                title: isClientInstalled(key) ? `${client.name} ✓` : client.name,
+        // 列出全部支持的客户端，已检测到安装的默认预选
+        const allClients = Object.entries(MCP_CLIENTS).map(([key, client]) => {
+            const selected = isClientInstalled(key);
+            return {
+                title: selected ? `${client.name} ✓` : client.name,
                 value: key,
-                selected: isClientInstalled(key),
-            }));
-            const detectedNames = allClients.filter(c => c.selected).map(c => c.title);
-            if (detectedNames.length > 0) {
-                console.log(`\n已检测到: ${detectedNames.join(', ')}\n`);
-            }
-            else {
-                console.log('\n未检测到已安装的客户端，可手动选择\n');
+                selected,
+            };
+        });
+        const detectedClients = allClients.filter(client => client.selected);
+        const detectedNames = detectedClients.map(client => client.title);
+        let selectedClients;
+        if (yes) {
+            if (detectedClients.length === 0) {
+                throw new Error('未检测到可配置的 MCP 客户端；请交互式运行 mearl-mcp-configure 进行选择');
             }
-            const clientResponse = await prompts({
-                type: 'multiselect',
-                name: 'clients',
-                message: '选择要配置的客户端:',
-                choices: allClients,
-                instructions: false,
-                hint: '空格选择，回车确认',
+            selectedClients = detectedClients.map(client => client.value);
+            console.log(`\n将配置已检测到的客户端: ${detectedNames.join(', ')}\n`);
+        }
+        else {
+            const response = await prompts({
+                type: 'confirm',
+                name: 'setupMcp',
+                message: '配置 MCP 客户端？',
+                initial: true,
             });
-            if (clientResponse.clients && clientResponse.clients.length > 0) {
-                console.log('');
-                for (const clientKey of clientResponse.clients) {
-                    const client = MCP_CLIENTS[clientKey];
-                    if (updateMCPConfig(client.configPath, client, useNpx)) {
-                        console.log(`✅ ${client.name}`);
-                    }
-                    else {
-                        console.log(`❌ ${client.name} 配置失败`);
-                    }
+            if (response.setupMcp === undefined) {
+                throw new Error('MCP 客户端配置已取消');
+            }
+            if (response.setupMcp) {
+                if (detectedNames.length > 0) {
+                    console.log(`\n已检测到: ${detectedNames.join(', ')}\n`);
+                }
+                else {
+                    console.log('\n未检测到已安装的客户端，可手动选择\n');
+                }
+                const clientResponse = await prompts({
+                    type: 'multiselect',
+                    name: 'clients',
+                    message: '选择要配置的客户端:',
+                    choices: allClients,
+                    instructions: false,
+                    hint: '空格选择，回车确认',
+                });
+                selectedClients = clientResponse.clients;
+                if (!selectedClients || selectedClients.length === 0) {
+                    throw new Error('未选择要配置的 MCP 客户端');
                 }
-                console.log('');
             }
             else {
-                console.log('已取消\n');
+                console.log('跳过 MCP 客户端配置\n');
             }
         }
-        else {
-            console.log('跳过 MCP 客户端配置\n');
+        if (selectedClients && selectedClients.length > 0) {
+            console.log('');
+            let configured = true;
+            for (const clientKey of selectedClients) {
+                const client = MCP_CLIENTS[clientKey];
+                if (updateMCPConfig(client.configPath, client, useNpx)) {
+                    console.log(`✅ ${client.name}`);
+                }
+                else {
+                    configured = false;
+                    console.log(`❌ ${client.name} 配置失败`);
+                }
+            }
+            console.log('');
+            if (!configured) {
+                throw new Error('部分 MCP 客户端配置失败');
+            }
         }
     }
     console.log('\n✅ 全部配置完成！');
@@ -283,7 +322,13 @@ async function main() {
     console.log('   2. 打开淘宝/飞猪页面');
     console.log('   3. 在 AI 中测试: "获取最近 5 个请求"\n');
 }
-main().catch(error => {
-    console.error('Configuration failed:', error);
-    process.exit(1);
-});
+const currentFile = fileURLToPath(import.meta.url);
+if (process.argv[1] && path.resolve(process.argv[1]) === currentFile) {
+    try {
+        await runConfigure();
+    }
+    catch (error) {
+        console.error('Configuration failed:', error);
+        process.exitCode = 1;
+    }
+}

package/dist/index.js

@@ -363,7 +363,7 @@ async function main() {
         capabilities: {
             tools: {},
         },
-        instructions: '浏览器交互默认工作流：首次进入页面时使用 browser_page_snapshot 建立页面基线；后续点击、输入、悬停、滚动、按键和上传直接使用 browser_page_click/type/hover/scroll/press/upload，它们默认内置观察，动作与异步稳定判断在一次调用内完成，返回 { action, observation }；传 observe:false 可关闭观察仅执行裸动作。观察结果不替代完整页面理解：observation.mode 为 delta 时确认 scope="main-document"，再读取 effects.notifications、effects.interactives 和 effects.focus；interactives/focus 节点有 ref 时优先直接用于后续动作，没有 ref 时使用 selector；notifications 中 change=transient 表示已经消失的 Toast、状态或错误提示。为 navigation 时先检查 ready，ready=true 表示文档、相关业务请求和可见骨架状态已经稳定，可在新页面重建 snapshot。其他情况下通常仅当 fullSnapshotRecommended 为 true 时根据 snapshotReasons 回退，并选择最小范围：已有区域 ref 用 rootRef，已有 CSS 根节点用 rootSelector，只需查找特定目标时加 query，长列表用 mode="viewport"，只需当前视口内的控件用 mode="interactive"；滚动动作的 moved 只证明位置变化，下一步需要读取新视口内容时可按需获取 viewport 快照。视口内缺少 AX 控件语义时 interactive 会在同一次调用中回退到 viewport，并返回 fallbackMode。重复文本点击用 scope 限定区域，ref 指向滚动容器子节点时用 containerPolicy="nearest"。page_eval 默认裸执行且应作为结构化能力无法表达时的补充，仅在表达式修改页面并需要变化信号时显式传 observe 对象。视觉任务再使用 screenshot。不要在每次动作后固定调用 browser_page_wait、snapshot 或 screenshot。',
+        instructions: '浏览器交互默认工作流：首次进入页面时使用 browser_page_snapshot 建立页面基线；后续点击、输入、悬停、滚动、按键和上传直接使用 browser_page_click/type/hover/scroll/press/upload，它们默认内置观察，动作与异步稳定判断在一次调用内完成，返回 { action, observation }；传 observe:false 可关闭观察仅执行裸动作。观察结果不替代完整页面理解：observation.mode 为 delta 时确认 scope="main-document"，再读取 effects.notifications、effects.interactives 和 effects.focus；interactives/focus 节点有 ref 时优先直接用于后续动作，没有 ref 时使用 selector；notifications 中 change=transient 表示已经消失的 Toast、状态或错误提示。为 navigation 时先检查 ready，ready=true 表示文档、相关业务请求和可见骨架状态已经稳定，可在新页面重建 snapshot。observation.openedTabs 表示动作直接打开的关联标签页，可显式使用返回的 tabId 继续操作，无需调用 browser_tab_list。其他情况下通常仅当 fullSnapshotRecommended 为 true 时根据 snapshotReasons 回退，并选择最小范围：已有区域 ref 用 rootRef，已有 CSS 根节点用 rootSelector，只需查找特定目标时加 query，长列表用 mode="viewport"，只需当前视口内的控件用 mode="interactive"；滚动动作的 moved 只证明位置变化，下一步需要读取新视口内容时可按需获取 viewport 快照。视口内缺少 AX 控件语义时 interactive 会在同一次调用中回退到 viewport，并返回 fallbackMode。重复文本点击用 scope 限定区域，ref 指向滚动容器子节点时用 containerPolicy="nearest"。page_eval 默认裸执行且应作为结构化能力无法表达时的补充，仅在表达式修改页面并需要变化信号时显式传 observe 对象。视觉任务再使用 screenshot。不要在每次动作后固定调用 browser_page_wait、snapshot 或 screenshot。',
     });
     // 页面交互工具共享的 observe 参数 schema：默认开启内置观察，传 false 关闭
     const OBSERVE_INPUT_SCHEMA = {
@@ -609,7 +609,7 @@ async function main() {
         },
         {
             name: 'browser_send_request',
-            description: '通过浏览器发起 HTTP 代理请求，自动携带目标域名的 Cookie（使用当前浏览器登录态）。支持 GET/POST/PUT/DELETE/PATCH 等方法，适用于需要用户登录态的接口调试、数据爬取、接口测试等场景。',
+            description: '通过浏览器发起 HTTP 代理请求，自动携带目标域名的 Cookie（使用当前浏览器登录态）。支持 GET/POST/PUT/DELETE/PATCH、multipart 文本字段和本地文件上传，适用于需要用户登录态的接口调试、数据爬取、接口测试等场景。',
             inputSchema: {
                 type: 'object',
                 properties: {
@@ -636,15 +636,50 @@ async function main() {
                     body: {
                         description: '请求体。传入对象时自动序列化为 JSON 并设置 Content-Type: application/json；传入字符串时原样发送',
                     },
+                    formData: {
+                        type: 'object',
+                        description: 'multipart/form-data 文本字段。字段值支持 string、number、boolean；不能与 body 同时使用',
+                        additionalProperties: {
+                            anyOf: [{ type: 'string' }, { type: 'number' }, { type: 'boolean' }],
+                        },
+                    },
+                    files: {
+                        type: 'array',
+                        description: 'multipart 文件列表，最多 20 个且总计不超过 40 MiB。本地调用优先传绝对 filePath；远程调用可传 base64，并同时提供 filename，Base64 文件内容总计不超过 7 MiB',
+                        maxItems: 20,
+                        items: {
+                            type: 'object',
+                            properties: {
+                                fieldName: {
+                                    type: 'string',
+                                    description: 'multipart 字段名，例如 file',
+                                },
+                                filePath: {
+                                    type: 'string',
+                                    description: 'Mearl native-host 所在机器上的绝对文件路径',
+                                },
+                                base64: {
+                                    type: 'string',
+                                    description: '文件内容的 Base64；与 filePath 二选一',
+                                },
+                                filename: {
+                                    type: 'string',
+                                    description: '上传文件名；使用 base64 时必填',
+                                },
+                                contentType: {
+                                    type: 'string',
+                                    description: '文件 MIME 类型；默认根据文件名推断',
+                                },
+                            },
+                            required: ['fieldName'],
+                            oneOf: [{ required: ['filePath'] }, { required: ['base64', 'filename'] }],
+                        },
+                    },
                     withCookies: {
                         type: 'boolean',
                         description: '是否自动携带浏览器中该域名的 Cookie，默认 true',
                         default: true,
                     },
-                    cookieDomain: {
-                        type: 'string',
-                        description: '指定获取 Cookie 的域名（默认从 url 中自动提取域名）',
-                    },
                     responseType: {
                         type: 'string',
                         enum: ['json', 'text', 'auto'],
@@ -1040,6 +1075,10 @@ async function main() {
                         description: '是否激活（前台显示）新标签页。默认 false（后台打开）',
                         default: false,
                     },
+                    openerTabId: {
+                        type: 'number',
+                        description: '来源标签页 ID。侧边栏对话继续任务时传入，用于把新开或复用的标签页关联到同一对话',
+                    },
                     closeExisting: {
                         type: 'boolean',
                         description: '打开前是否先关闭 Agent 受控的已有标签页。默认 false',
@@ -1142,7 +1181,7 @@ async function main() {
         },
         {
             name: 'browser_page_click',
-            description: '点击页面元素，默认内置观察：同一次调用内等待相关 DOM、XHR/Fetch/MTop 请求或导航稳定，返回 { action, observation }；传 observe:false 仅执行裸点击。定位方式三选一：selector（CSS 或 @eN snapshot ref）、text（按可见文本匹配 accessibility name，可用 scope 限定子树）、point（视口坐标）。clickMode 默认 auto：可见页按设备模拟状态使用可信 mouse/touch，隐藏页不切换标签或还原窗口并自动使用 DOM fallback；checkbox/radio 使用带状态校验的 DOM 路径。可用 dom/mouse/touch 强制派发方式。响应返回实际 dispatchMode，可信输入还返回 pointerType。',
+            description: '点击页面元素，默认内置观察：同一次调用内等待相关 DOM、XHR/Fetch/MTop 请求或导航稳定，返回 { action, observation }；点击直接打开新标签页时 observation.openedTabs 返回可继续操作的 tabId、URL、标题和加载状态。传 observe:false 仅执行裸点击。定位方式三选一：selector（CSS 或 @eN snapshot ref）、text（按可见文本匹配 accessibility name，可用 scope 限定子树）、point（视口坐标）。clickMode 默认 auto：可见页按设备模拟状态使用可信 mouse/touch，隐藏页不切换标签或还原窗口并自动使用 DOM fallback；checkbox/radio 使用带状态校验的 DOM 路径。可用 dom/mouse/touch 强制派发方式。响应返回实际 dispatchMode，可信输入还返回 pointerType。',
             inputSchema: {
                 type: 'object',
                 properties: {
@@ -1795,10 +1834,11 @@ async function main() {
                     break;
                 }
                 case 'browser_tab_open': {
-                    const { url, active = false, closeExisting = false, reuse = 'never', match, restoreFocusOnClose = false, emulation, group, } = args;
+                    const { url, active = false, openerTabId, closeExisting = false, reuse = 'never', match, restoreFocusOnClose = false, emulation, group, } = args;
                     result = await client.tabOpen({
                         url,
                         active,
+                        openerTabId,
                         closeExisting,
                         reuse,
                         match,

package/dist/uninstall.d.ts

@@ -6,4 +6,31 @@
  *   npx @mearl/mcp-server --uninstall
  *   或 mearl-mcp-uninstall (如果全局安装)
  */
-export {};
+import { existsSync } from 'fs';
+import { MCPClientConfig } from './mcp-clients.js';
+import { uninstallNativeHost } from '@mearl/native-host';
+export type MCPConfigCleanupResult = 'removed' | 'not-found' | 'failed';
+export declare function cleanMCPConfig(configPath: string, clientConfig: MCPClientConfig): MCPConfigCleanupResult;
+export interface MCPUninstallDependencies {
+    cleanConfig?: typeof cleanMCPConfig;
+    clients?: Record<string, MCPClientConfig>;
+    exists?: typeof existsSync;
+    globalInstallationDetected?: () => boolean;
+    log?: (message: string) => void;
+    logError?: (message: string) => void;
+    prompt?: (options: {
+        type: 'multiselect';
+        name: 'clients';
+        message: string;
+        choices: Array<{
+            title: string;
+            value: string;
+        }>;
+        instructions: boolean;
+        hint: string;
+    }) => Promise<{
+        clients?: string[];
+    }>;
+    removeNativeHost?: typeof uninstallNativeHost;
+}
+export declare function runUninstall(argv?: string[], dependencies?: MCPUninstallDependencies): Promise<boolean>;

package/dist/uninstall.js

@@ -6,47 +6,53 @@
  *   npx @mearl/mcp-server --uninstall
  *   或 mearl-mcp-uninstall (如果全局安装)
  */
-import { unlinkSync, existsSync, readFileSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import { homedir, platform } from 'os';
-import { execSync } from 'child_process';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { platform } from 'os';
+import { execFileSync } from 'child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import prompts from 'prompts';
-import { HOST_NAME } from './constants.js';
 import { MCP_CLIENTS } from './mcp-clients.js';
-// 获取 Native Messaging Host 配置目录
-function getNativeHostDir() {
-    const os = platform();
-    if (os === 'darwin') {
-        return join(homedir(), 'Library/Application Support/Google/Chrome/NativeMessagingHosts');
-    }
-    else if (os === 'linux') {
-        return join(homedir(), '.config/google-chrome/NativeMessagingHosts');
-    }
-    else if (os === 'win32') {
-        throw new Error('Windows 需要手动删除注册表项，请参考 README.md');
-    }
-    else {
-        throw new Error(`不支持的平台: ${os}`);
-    }
-}
+import { uninstallNativeHost } from '@mearl/native-host';
 // 检查是否全局安装
 function isGloballyInstalled() {
     try {
         const cmd = platform() === 'win32' ? 'where' : 'which';
-        execSync(`${cmd} mearl-mcp-server`, { encoding: 'utf-8', stdio: 'pipe' });
+        execFileSync(cmd, ['mearl-mcp-server'], { encoding: 'utf-8', stdio: 'pipe' });
         return true;
     }
     catch {
         return false;
     }
 }
+function removeTomlMCPSection(content) {
+    const lines = content.split('\n');
+    const sectionStart = lines.findIndex(line => line.trim() === '[mcp_servers.mearl]');
+    if (sectionStart === -1)
+        return null;
+    let sectionEnd = lines.length;
+    for (let index = sectionStart + 1; index < lines.length; index += 1) {
+        if (lines[index].trim().startsWith('[')) {
+            sectionEnd = index;
+            break;
+        }
+    }
+    return [...lines.slice(0, sectionStart), ...lines.slice(sectionEnd)].join('\n');
+}
 // 清理 MCP 配置文件中的 mearl
-function cleanMCPConfig(configPath, clientConfig) {
+export function cleanMCPConfig(configPath, clientConfig) {
     try {
         if (!existsSync(configPath)) {
-            return false;
+            return 'not-found';
         }
         const content = readFileSync(configPath, 'utf-8');
+        if (clientConfig.useTomlFormat) {
+            const updated = removeTomlMCPSection(content);
+            if (updated === null)
+                return 'not-found';
+            writeFileSync(configPath, updated);
+            return 'removed';
+        }
         const config = JSON.parse(content);
         const useServersFormat = clientConfig.useServersFormat;
         let hasConfig = false;
@@ -65,88 +71,103 @@ function cleanMCPConfig(configPath, clientConfig) {
             }
         }
         if (!hasConfig) {
-            return false;
+            return 'not-found';
         }
         // 写回文件
         writeFileSync(configPath, JSON.stringify(config, null, 2));
-        return true;
+        return 'removed';
     }
     catch (error) {
         console.error(`   ⚠️  清理配置失败: ${error instanceof Error ? error.message : String(error)}`);
-        return false;
+        return 'failed';
     }
 }
 // 卸载主函数
-async function uninstall() {
-    console.log('🗑️  Mearl MCP 卸载\n');
+export async function runUninstall(argv = process.argv.slice(2), dependencies = {}) {
+    const log = dependencies.log ?? (message => console.log(message));
+    const logError = dependencies.logError ?? (message => console.error(message));
+    const removeNativeHost = dependencies.removeNativeHost ?? uninstallNativeHost;
+    const detectGlobalInstallation = dependencies.globalInstallationDetected ?? isGloballyInstalled;
+    const fileExists = dependencies.exists ?? existsSync;
+    const clients = dependencies.clients ?? MCP_CLIENTS;
+    const prompt = dependencies.prompt ?? prompts;
+    const cleanConfig = dependencies.cleanConfig ?? cleanMCPConfig;
+    const managedBySetup = argv.includes('--managed-by-setup');
+    const yes = argv.includes('--yes') || argv.includes('-y');
+    log('🗑️  Mearl MCP 卸载\n');
     try {
+        let completed = true;
         // 1. 清理 Native Messaging Host 配置
-        console.log('清理 Native Messaging Host...');
-        const hostDir = getNativeHostDir();
-        const manifestPath = join(hostDir, `${HOST_NAME}.json`);
-        const wrapperPath = join(hostDir, `${HOST_NAME}-launcher.sh`);
-        let hasDeleted = false;
-        if (existsSync(manifestPath)) {
-            unlinkSync(manifestPath);
-            console.log(`✅ 删除配置文件`);
-            hasDeleted = true;
-        }
-        if (existsSync(wrapperPath)) {
-            unlinkSync(wrapperPath);
-            hasDeleted = true;
-        }
-        if (!hasDeleted) {
-            console.log('未找到配置文件');
-        }
+        log('清理 Native Messaging Host...');
+        const nativeHostRemoved = await removeNativeHost({ mode: 'mcp', silent: true });
+        log(nativeHostRemoved ? '✅ Native Messaging Host 已清理' : '⚠️  Native Messaging Host 清理失败');
+        completed = nativeHostRemoved;
         // 2. 检查全局安装
-        console.log('\n检查 npm 全局安装...');
-        if (isGloballyInstalled()) {
-            console.log('⚠️  请手动卸载: npm uninstall -g @mearl/mcp-server');
-        }
-        else {
-            console.log('✅ 未检测到全局安装');
+        if (!managedBySetup) {
+            log('\n检查 npm 全局安装...');
+            if (detectGlobalInstallation()) {
+                log('⚠️  请手动卸载: npm uninstall -g @mearl/mcp-server');
+            }
+            else {
+                log('✅ 未检测到全局安装');
+            }
         }
         // 3. 清理 MCP 客户端配置
-        console.log('\n清理 MCP 客户端配置...');
+        log('\n清理 MCP 客户端配置...');
         // 检测哪些客户端有配置文件
-        const availableClients = Object.entries(MCP_CLIENTS)
-            .filter(([_, client]) => existsSync(client.configPath))
+        const availableClients = Object.entries(clients)
+            .filter(([_, client]) => fileExists(client.configPath))
             .map(([key, client]) => ({
             title: client.name,
             value: key,
         }));
         if (availableClients.length === 0) {
-            console.log('未找到 MCP 配置');
+            log('未找到 MCP 配置');
         }
         else {
-            const response = await prompts({
-                type: 'multiselect',
-                name: 'clients',
-                message: '选择要清理的客户端:',
-                choices: availableClients,
-                instructions: false,
-                hint: '空格选择，回车确认',
-            });
-            if (response.clients && response.clients.length > 0) {
-                for (const clientKey of response.clients) {
-                    const client = MCP_CLIENTS[clientKey];
-                    if (cleanMCPConfig(client.configPath, client)) {
-                        console.log(`✅ 已清理 ${client.name}`);
+            const selectedClients = yes
+                ? availableClients.map(client => client.value)
+                : (await prompt({
+                    type: 'multiselect',
+                    name: 'clients',
+                    message: '选择要清理的客户端:',
+                    choices: availableClients,
+                    instructions: false,
+                    hint: '空格选择，回车确认',
+                })).clients;
+            if (selectedClients && selectedClients.length > 0) {
+                for (const clientKey of selectedClients) {
+                    const client = clients[clientKey];
+                    const result = cleanConfig(client.configPath, client);
+                    if (result === 'removed') {
+                        log(`✅ 已清理 ${client.name}`);
+                    }
+                    else if (result === 'not-found') {
+                        log(`未找到 ${client.name} 配置`);
                     }
                     else {
-                        console.log(`未找到 ${client.name} 配置`);
+                        completed = false;
                     }
                 }
             }
             else {
-                console.log('已取消');
+                log('已取消');
             }
         }
-        console.log('\n✅ 卸载完成！');
+        if (completed) {
+            log('\n✅ 卸载完成！');
+        }
+        else {
+            logError('\n❌ 卸载未完整完成，请检查上述错误');
+        }
+        return completed;
     }
     catch (error) {
-        console.error('\n❌ 卸载失败:', error instanceof Error ? error.message : String(error));
-        process.exit(1);
+        logError(`\n❌ 卸载失败: ${error instanceof Error ? error.message : String(error)}`);
+        return false;
     }
 }
-uninstall();
+const currentFile = fileURLToPath(import.meta.url);
+if (process.argv[1] && path.resolve(process.argv[1]) === currentFile) {
+    process.exitCode = (await runUninstall()) ? 0 : 1;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mearl/mcp-server",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "description": "MCP Server for Mearl - enables AI to interact with Chrome browser requests and logs",
   "mcpName": "io.github.F-loat/mearl",
   "type": "module",
@@ -30,8 +30,8 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.4",
     "prompts": "^2.4.2",
-    "@mearl/client": "2.2.0",
-    "@mearl/native-host": "2.2.0"
+    "@mearl/client": "2.2.2",
+    "@mearl/native-host": "2.2.2"
   },
   "devDependencies": {
     "@types/node": "^24.9.1",
@@ -43,6 +43,7 @@
     "dev": "tsc --watch",
     "start": "node dist/index.js",
     "setup": "pnpm build && npm link",
+    "test": "vitest run",
     "typecheck": "tsc --noEmit"
   }
 }