@mearl/client 2.15.0 → 2.15.2

package/dist/socket.js

@@ -4,7 +4,8 @@
  * 通过 Unix Domain Socket (macOS/Linux) 或 Named Pipe (Windows) 与 native host 进程通信。
  * 每次调用新建连接，收到响应后关闭，简单可靠。
  *
- * 当 Socket 文件不存在（ENOENT）时，自动尝试拉起 native host，稍后重试连接。
+ * 当 Socket 不存在，或 legacy Socket 是无人监听的残留文件时，
+ * 自动尝试拉起 native host，稍后重试连接。
  */
 import net from 'node:net';
 import fs from 'node:fs';
@@ -138,46 +139,85 @@ function selectBrowserResult(data) {
     setDefaultBrowser(match.browserId);
     return { selected: { browserId: match.browserId, name: match.browserName } };
 }
-/** Whether this process has already attempted to auto-spawn a persistent native-host. */
-let spawnAttempted = false;
+/** Deduplicates concurrent recovery attempts in long-lived clients such as the MCP server. */
+let persistentSpawnPromise = null;
 /**
  * Attempt to spawn `mearl-native-host` in the background (detached).
  * Browser discovery hosts probe the default local CDP endpoint for browser_list and only
  * persist when a real browser is available.
  * Returns true if a spawn was attempted (regardless of success).
  */
-async function trySpawnNativeHost(mode = 'control', retryPreviousAttempt = false) {
+async function trySpawnNativeHost(mode = 'control') {
     const persistent = mode === 'control';
-    if (persistent && spawnAttempted && !retryPreviousAttempt)
-        return false;
-    if (persistent)
-        spawnAttempted = true;
-    try {
-        const { spawn } = await import('node:child_process');
-        return await new Promise(resolve => {
-            const args = persistent ? ['--daemon'] : ['--daemon', '--discover-cdp'];
-            const child = spawn('mearl-native-host', args, {
-                detached: true,
-                stdio: 'ignore',
-                windowsHide: true,
-            });
-            let settled = false;
-            const finish = (ok) => {
-                if (settled)
-                    return;
-                settled = true;
-                resolve(ok);
-            };
-            // `spawn ENOENT` 等错误会通过事件异步抛出；必须显式监听避免进程崩溃。
-            child.once('error', () => finish(false));
-            child.once('spawn', () => {
-                child.unref();
-                finish(true);
+    if (persistent && persistentSpawnPromise)
+        return persistentSpawnPromise;
+    const spawnPromise = (async () => {
+        try {
+            const { spawn } = await import('node:child_process');
+            return await new Promise(resolve => {
+                const args = persistent ? ['--daemon'] : ['--daemon', '--discover-cdp'];
+                const child = spawn('mearl-native-host', args, {
+                    detached: true,
+                    stdio: 'ignore',
+                    windowsHide: true,
+                });
+                let settled = false;
+                const finish = (ok) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    resolve(ok);
+                };
+                // `spawn ENOENT` 等错误会通过事件异步抛出；必须显式监听避免进程崩溃。
+                child.once('error', () => finish(false));
+                child.once('spawn', () => {
+                    child.unref();
+                    finish(true);
+                });
             });
-        });
+        }
+        catch {
+            return false;
+        }
+    })();
+    if (!persistent)
+        return spawnPromise;
+    persistentSpawnPromise = spawnPromise;
+    try {
+        return await spawnPromise;
+    }
+    finally {
+        if (persistentSpawnPromise === spawnPromise)
+            persistentSpawnPromise = null;
+    }
+}
+function readOwnedLegacySocketIdentity() {
+    if (process.platform === 'win32')
+        return null;
+    try {
+        const stat = fs.lstatSync(SOCKET_PATH);
+        if (!stat.isSocket())
+            return null;
+        if (process.getuid && stat.uid !== process.getuid())
+            return null;
+        return { dev: stat.dev, ino: stat.ino };
     }
     catch {
-        return false;
+        return null;
+    }
+}
+/** Remove only the same-user socket inode whose failed connection proved it stale. */
+function removeStaleLegacySocket(identity) {
+    if (!identity)
+        return;
+    try {
+        const current = fs.lstatSync(SOCKET_PATH);
+        if (!current.isSocket() || current.dev !== identity.dev || current.ino !== identity.ino)
+            return;
+        fs.unlinkSync(SOCKET_PATH);
+    }
+    catch {
+        // Spawning and the final retry provide the authoritative recovery result.
     }
 }
 /**
@@ -185,7 +225,7 @@ async function trySpawnNativeHost(mode = 'control', retryPreviousAttempt = false
  *
  * 目标解析优先级：显式 options.browser → setDefaultBrowser → 环境变量
  * MEARL_BROWSER → 自动（注册表中最近聚焦的浏览器）。注册表为空时回退到
- * legacy well-known socket，并在 socket 不存在（ENOENT）时自动拉起 native host。
+ * legacy well-known socket，并在 socket 不存在或已残留时自动拉起 native host。
  */
 export function invoke(action, data = {}, options = {}) {
     if (action === 'browser_select_browser') {
@@ -284,16 +324,19 @@ async function dispatchInvoke(action, data, timeoutSec, transport, selector, con
     }
     return invokeViaLegacy(action, data, timeoutSec, transport, controlSource, /* isRetry */ false);
 }
-/** Legacy well-known socket, auto-spawning a native-host on ENOENT and retrying once. */
+/** Legacy well-known socket, repairing a missing or stale endpoint and retrying once. */
 async function invokeViaLegacy(action, data, timeoutSec, transport, controlSource, isRetry) {
+    const legacySocketIdentity = readOwnedLegacySocketIdentity();
     try {
         return await invokeOnce(action, data, timeoutSec, transport, SOCKET_PATH, controlSource);
     }
     catch (error) {
         const err = error;
-        const shouldAttemptSpawn = err.code === 'ENOENT' || (action === 'browser_release' && err.code === 'ECONNREFUSED');
+        const shouldAttemptSpawn = err.code === 'ENOENT' || err.code === 'ECONNREFUSED';
         if (shouldAttemptSpawn && !isRetry) {
-            const spawned = await trySpawnNativeHost(action === 'browser_list' ? 'discovery' : 'control', action === 'browser_release');
+            if (err.code === 'ECONNREFUSED')
+                removeStaleLegacySocket(legacySocketIdentity);
+            const spawned = await trySpawnNativeHost(action === 'browser_list' ? 'discovery' : 'control');
             if (spawned) {
                 // Wait for the native host to start listening. Discovery retries the legacy socket directly
                 // so the spawned host receives the probe even if another browser registers in the meantime.
@@ -425,7 +468,7 @@ function formatConnectError(error, socketPath) {
     if (error.code === 'ECONNREFUSED') {
         return [
             `Socket 连接被拒绝: ${socketPath}`,
-            'native host 可能已退出。',
+            'native host 自动恢复失败。',
             '请确认 Chrome 浏览器正在运行，可尝试在 chrome://extensions 重新加载插件。',
             '',
             installHint,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mearl/client",
-  "version": "2.15.0",
+  "version": "2.15.2",
   "description": "Unified Mearl SDK & CLI for local and remote browsers",
   "type": "module",
   "main": "dist/index.js",
@@ -59,8 +59,8 @@
     "commander": "^15.0.0",
     "fastest-levenshtein": "^1.0.16",
     "ws": "^8.18.0",
-    "@mearl/cloud-types": "2.15.0",
-    "@mearl/provider": "2.15.0"
+    "@mearl/cloud-types": "2.15.2",
+    "@mearl/provider": "2.15.2"
   },
   "devDependencies": {
     "@types/node": "^24.9.1",

package/dist/buc.d.ts

@@ -1,65 +0,0 @@
-interface ProgramResult {
-    stdout: string;
-    stderr: string;
-}
-export interface BucIdentity {
-    agentId?: string;
-    empId: string;
-    name?: string;
-}
-export interface BucProfile extends BucIdentity {
-    bucUserId?: string;
-    gid?: string;
-    empType?: string;
-    photoPath?: string;
-    displayName?: string;
-    nickName?: string;
-    deptId?: string;
-    admin?: boolean;
-    buName?: string;
-    buNo?: string;
-    deptDesc?: string;
-    lang?: string;
-    cid?: string;
-    jobDesc?: string;
-    loginWorkNo?: string;
-}
-export type BucRequestFormValue = string | number | boolean;
-export type BucRequestAuth = 'id-token' | 'ticket-header' | 'ticket-query';
-export interface BucRequestParams {
-    app: string;
-    url: string;
-    auth?: BucRequestAuth;
-    method?: string;
-    headers?: Record<string, string>;
-    params?: Record<string, string | number | boolean | null | undefined>;
-    body?: unknown;
-    formData?: Record<string, BucRequestFormValue>;
-    responseType?: 'json' | 'text' | 'auto';
-    timeoutMs?: number;
-}
-export interface BucRequestResult {
-    status: number;
-    statusText: string;
-    headers: Record<string, string>;
-    body: unknown;
-}
-export interface BucApi {
-    request(params: BucRequestParams): Promise<BucRequestResult>;
-    whoami(): Promise<BucIdentity>;
-    profile(): Promise<BucProfile>;
-}
-export type BucCommandRunner = (args: string[]) => Promise<ProgramResult>;
-export interface BucDependencies {
-    fetch?: typeof fetch;
-    installBuc?: () => Promise<void>;
-    runBuc?: BucCommandRunner;
-}
-export declare const runBucCommand: BucCommandRunner;
-export declare function installBucCli(): Promise<void>;
-export declare function bucWhoami(dependencies?: BucDependencies): Promise<BucIdentity>;
-export declare function bucProfile(dependencies?: BucDependencies): Promise<BucProfile>;
-/** Executes one internal request with a fresh credential in the selected BUC authentication mode. */
-export declare function bucRequest(input: BucRequestParams, dependencies?: BucDependencies): Promise<BucRequestResult>;
-export declare const buc: BucApi;
-export {};