@mearl/native-host 2.3.0 → 2.4.0

package/dist/host-updater.d.ts

@@ -0,0 +1,39 @@
+import { type CommandRunner } from '@mearl/setup/process';
+export declare const NATIVE_HOST_UPDATE_TIMEOUT_MS: number;
+export type NativeHostUpdateError = 'lock-timeout' | 'network' | 'package-unavailable' | 'setup-failed' | 'timeout' | 'verification-failed' | 'unknown';
+export interface NativeHostUpdateCommand {
+    args: string[];
+}
+type UpdateLockRunner = <T>(targetVersion: string, operation: () => Promise<T>) => Promise<T>;
+export interface RunNativeHostUpdateOptions {
+    areTargetsInstalled?: (targetReleaseLine: string, environment: NodeJS.ProcessEnv) => Promise<boolean>;
+    environment?: NodeJS.ProcessEnv;
+    nodePath?: string;
+    packageBinDirectory?: string | null;
+    packageManagerCommand?: string | null;
+    packageRunner?: string;
+    platform?: NodeJS.Platform;
+    runner?: CommandRunner;
+    timeoutMs?: number;
+    updateLockPath?: string;
+    withUpdateLock?: UpdateLockRunner;
+}
+export interface NativeHostUpdateCoordinatorOptions {
+    hostVersion: string;
+    log: (...args: unknown[]) => void;
+    requestRestart: () => void | Promise<void>;
+    runUpdate: (targetVersion: string) => Promise<void>;
+}
+export declare class NativeHostUpdateFailure extends Error {
+    readonly updateError: NativeHostUpdateError;
+    constructor(updateError: NativeHostUpdateError, message: string);
+}
+export declare function nativeHostUpdateCommand(targetVersion: string): NativeHostUpdateCommand;
+export declare function runNativeHostUpdate(targetVersion: string, options?: RunNativeHostUpdateOptions): Promise<void>;
+export declare class NativeHostUpdateCoordinator {
+    #private;
+    private readonly options;
+    constructor(options: NativeHostUpdateCoordinatorOptions);
+    evaluate(extensionVersion: unknown, checkForUpdates: unknown): void;
+}
+export {};

package/dist/index.js

@@ -10,20 +10,20 @@ var __export = (target, all) => {
 };
 
 // ../setup/dist/nativeHost.js
-import fs9 from "node:fs";
+import fs11 from "node:fs";
 import os6 from "node:os";
-import path10 from "node:path";
+import path12 from "node:path";
 import { execFileSync } from "node:child_process";
 function resolveNativeHostDirectory(options = {}) {
   const env = options.env ?? process.env;
   const home = (options.homedir ?? os6.homedir)();
   switch (options.platform ?? process.platform) {
     case "darwin":
-      return path10.join(home, "Library/Application Support/Google/Chrome/NativeMessagingHosts");
+      return path12.join(home, "Library/Application Support/Google/Chrome/NativeMessagingHosts");
     case "linux":
-      return path10.join(home, ".config/google-chrome/NativeMessagingHosts");
+      return path12.join(home, ".config/google-chrome/NativeMessagingHosts");
     case "win32":
-      return path10.join(env.PROGRAMDATA || "C:\\ProgramData", "Google\\Chrome\\NativeMessagingHosts");
+      return path12.join(env.PROGRAMDATA || "C:\\ProgramData", "Google\\Chrome\\NativeMessagingHosts");
     default:
       throw new Error(`Unsupported platform: ${String(options.platform ?? process.platform)}`);
   }
@@ -46,20 +46,20 @@ function uninstallNativeHostArtifacts(options = {}, dependencies = {}) {
       writeLine(line);
   };
   try {
-    const existsSync4 = dependencies.existsSync ?? fs9.existsSync;
+    const existsSync4 = dependencies.existsSync ?? fs11.existsSync;
     const platform = dependencies.platform ?? process.platform;
     const hostDir = dependencies.hostDir ?? resolveNativeHostDirectory({
       env: dependencies.env,
       homedir: dependencies.homedir,
       platform
     });
-    const unlinkSync = dependencies.unlinkSync ?? fs9.unlinkSync;
+    const unlinkSync = dependencies.unlinkSync ?? fs11.unlinkSync;
     const unregister = dependencies.unregisterWindowsNativeHost ?? unregisterWindowsNativeHost;
     const hostName = MEARL_NATIVE_HOST_NAMES[mode];
     const launcherExtension = platform === "win32" ? "cmd" : "sh";
     const artifacts = [
-      path10.join(hostDir, `${hostName}.json`),
-      path10.join(hostDir, `${hostName}-launcher.${launcherExtension}`)
+      path12.join(hostDir, `${hostName}.json`),
+      path12.join(hostDir, `${hostName}-launcher.${launcherExtension}`)
     ];
     for (const artifact of artifacts) {
       if (!existsSync4(artifact))
@@ -94,17 +94,17 @@ __export(install_exports, {
   runCli: () => runCli,
   uninstallNativeHost: () => uninstallNativeHost
 });
-import fs10 from "node:fs";
-import path11 from "node:path";
+import fs12 from "node:fs";
+import path13 from "node:path";
 import { execFileSync as execFileSync2 } from "node:child_process";
 import { createRequire } from "node:module";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 function resolveHostDir() {
   return resolveNativeHostDirectory();
 }
 function resolveNativeHostPath() {
-  const siblingPath = path11.join(__dirname, "index.js");
-  if (fs10.existsSync(siblingPath)) {
+  const siblingPath = path13.join(__dirname, "index.js");
+  if (fs12.existsSync(siblingPath)) {
     return siblingPath;
   }
   try {
@@ -123,16 +123,16 @@ function registerWindowsNativeHost(hostName, manifestPath) {
   });
 }
 function createLauncherScript(hostDir, hostPath, hostName) {
-  const nodePath = path11.resolve(process.execPath);
+  const nodePath = path13.resolve(process.execPath);
   if (process.platform === "win32") {
-    const launcherPath2 = path11.join(hostDir, `${hostName}-launcher.cmd`);
+    const launcherPath2 = path13.join(hostDir, `${hostName}-launcher.cmd`);
     const content2 = `@echo off\r
 "${nodePath}" "${hostPath}" %*\r
 `;
-    fs10.writeFileSync(launcherPath2, content2, "utf-8");
+    fs12.writeFileSync(launcherPath2, content2, "utf-8");
     return launcherPath2;
   }
-  const launcherPath = path11.join(hostDir, `${hostName}-launcher.sh`);
+  const launcherPath = path13.join(hostDir, `${hostName}-launcher.sh`);
   const content = [
     "#!/bin/sh",
     `NODE_BIN=${JSON.stringify(nodePath)}`,
@@ -140,8 +140,8 @@ function createLauncherScript(hostDir, hostPath, hostName) {
     'exec "$NODE_BIN" "$HOST_SCRIPT" "$@"',
     ""
   ].join("\n");
-  fs10.writeFileSync(launcherPath, content, "utf-8");
-  fs10.chmodSync(launcherPath, 493);
+  fs12.writeFileSync(launcherPath, content, "utf-8");
+  fs12.chmodSync(launcherPath, 493);
   return launcherPath;
 }
 async function installNativeHost(options = {}) {
@@ -167,14 +167,14 @@ async function installNativeHost(options = {}) {
   try {
     const hostDir = resolveHostDir();
     if (skipIfExists) {
-      const manifestPath2 = path11.join(hostDir, `${hostName}.json`);
-      if (fs10.existsSync(manifestPath2)) {
+      const manifestPath2 = path13.join(hostDir, `${hostName}.json`);
+      if (fs12.existsSync(manifestPath2)) {
         log2(`✅ Already installed: ${manifestPath2}`);
         return true;
       }
     }
-    if (!fs10.existsSync(hostDir)) {
-      fs10.mkdirSync(hostDir, { recursive: true });
+    if (!fs12.existsSync(hostDir)) {
+      fs12.mkdirSync(hostDir, { recursive: true });
       log2(`✅ Created directory: ${hostDir}`);
     }
     const resolvedHostPath = resolveNativeHostPath();
@@ -188,13 +188,13 @@ async function installNativeHost(options = {}) {
       type: "stdio",
       allowed_origins: [`chrome-extension://${extensionId}/`]
     };
-    const manifestPath = path11.join(hostDir, `${hostName}.json`);
-    fs10.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+    const manifestPath = path13.join(hostDir, `${hostName}.json`);
+    fs12.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
     if (process.platform === "win32") {
       registerWindowsNativeHost(hostName, manifestPath);
       log2(`✅ Windows registry key created for: ${hostName}`);
     } else {
-      fs10.chmodSync(manifestPath, 420);
+      fs12.chmodSync(manifestPath, 420);
     }
     log2(`✅ Manifest installed: ${manifestPath}`);
     log2(`✅ Extension ID: ${extensionId}`);
@@ -306,19 +306,19 @@ var init_install = __esm({
     "use strict";
     init_nativeHost();
     DEFAULT_EXTENSION_ID = "aoehhjnofngknnjefamjbplchbolghkm";
-    __filename = fileURLToPath(import.meta.url);
-    __dirname = path11.dirname(__filename);
+    __filename = fileURLToPath2(import.meta.url);
+    __dirname = path13.dirname(__filename);
     ALL_MODES = ["skills", "mcp"];
   }
 });
 
 // src/index.ts
 import net from "node:net";
-import fs11 from "node:fs";
+import fs13 from "node:fs";
 import http5 from "node:http";
 import os7 from "node:os";
-import path12 from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import path14 from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // src/cdp-backend/cdp-session.ts
 import http3 from "node:http";
@@ -1166,13 +1166,13 @@ function queryTrackingEvents(buffer, options = {}) {
 }
 
 // ../browser-core/dist/requestSerializer.js
-function parsePath(path13) {
-  if (path13.length > 1e3)
+function parsePath(path15) {
+  if (path15.length > 1e3)
     throw new Error("Path too long: maximum 1000 characters allowed");
   const keys = [];
   let current = "";
-  for (let i = 0; i < path13.length; i++) {
-    const char = path13[i];
+  for (let i = 0; i < path15.length; i++) {
+    const char = path15[i];
     if (char === ".") {
       if (current) {
         keys.push(current);
@@ -1184,10 +1184,10 @@ function parsePath(path13) {
         current = "";
       }
       let j = i + 1;
-      while (j < path13.length && path13[j] !== "]")
+      while (j < path15.length && path15[j] !== "]")
         j++;
-      if (j < path13.length) {
-        const index = parseInt(path13.substring(i + 1, j), 10);
+      if (j < path15.length) {
+        const index = parseInt(path15.substring(i + 1, j), 10);
         if (!isNaN(index)) {
           if (index < 0 || index > 1e5)
             throw new Error(`Array index out of safe range: ${index}`);
@@ -1205,8 +1205,8 @@ function parsePath(path13) {
     throw new Error("Path too deep: maximum 50 levels allowed");
   return keys;
 }
-function getValueByPath(obj, path13) {
-  const keys = parsePath(path13);
+function getValueByPath(obj, path15) {
+  const keys = parsePath(path15);
   let current = obj;
   for (const key of keys) {
     if (current === null || current === void 0)
@@ -1215,8 +1215,8 @@ function getValueByPath(obj, path13) {
   }
   return current;
 }
-function setValueByPath(obj, path13, value) {
-  const keys = parsePath(path13);
+function setValueByPath(obj, path15, value) {
+  const keys = parsePath(path15);
   let current = obj;
   for (let i = 0; i < keys.length - 1; i++) {
     const key = keys[i];
@@ -2752,19 +2752,19 @@ function installPageObserverInPage(maxBatches = 50) {
         }
       }
     }
-    const path13 = [];
+    const path15 = [];
     let current = input;
-    while (current && current !== document.documentElement && path13.length < 6) {
+    while (current && current !== document.documentElement && path15.length < 6) {
       const parent = current.parentElement;
       const currentTag = current.tagName.toLowerCase();
       if (!parent) {
-        path13.unshift(currentTag);
+        path15.unshift(currentTag);
         break;
       }
       const siblings = Array.from(parent.children).filter((item) => item.tagName === current.tagName);
       const position = siblings.indexOf(current) + 1;
-      path13.unshift(siblings.length > 1 ? `${currentTag}:nth-of-type(${position})` : currentTag);
-      const candidate = path13.join(" > ");
+      path15.unshift(siblings.length > 1 ? `${currentTag}:nth-of-type(${position})` : currentTag);
+      const candidate = path15.join(" > ");
       if (input.isConnected) {
         try {
           if (document.querySelectorAll(candidate).length === 1)
@@ -2774,7 +2774,7 @@ function installPageObserverInPage(maxBatches = 50) {
       }
       current = parent;
     }
-    return path13.join(" > ") || void 0;
+    return path15.join(" > ") || void 0;
   };
   const inferredRole = (element) => {
     const explicit = element.getAttribute("role");
@@ -4409,12 +4409,12 @@ function resolveGetCookieTarget(currentUrl, input) {
   const url2 = parseCurrentUrl(currentUrl, action);
   const name = validateCookieName(input?.name, action);
   const domain2 = resolveExplicitDomain(url2, input?.domain, action);
-  const path13 = validateCookiePath(input?.path, action);
+  const path15 = validateCookiePath(input?.path, action);
   return {
     cookieName: name,
-    cookieUrl: `${url2.protocol}//${url2.hostname}${(path13 ?? url2.pathname) || "/"}`,
+    cookieUrl: `${url2.protocol}//${url2.hostname}${(path15 ?? url2.pathname) || "/"}`,
     ...domain2 ? { domain: domain2 } : {},
-    ...path13 ? { path: path13 } : {}
+    ...path15 ? { path: path15 } : {}
   };
 }
 function resolveSetCookieTarget(currentUrl, input) {
@@ -4422,7 +4422,7 @@ function resolveSetCookieTarget(currentUrl, input) {
   const url2 = parseCurrentUrl(currentUrl, action);
   const name = validateCookieName(input?.name, action);
   const value = validateCookieValue(input?.value);
-  const path13 = validateCookiePath(input?.path, action) ?? "/";
+  const path15 = validateCookiePath(input?.path, action) ?? "/";
   if (input.reload !== void 0 && typeof input.reload !== "boolean") {
     throw new Error('set_cookie: "reload" must be a boolean');
   }
@@ -4432,9 +4432,9 @@ function resolveSetCookieTarget(currentUrl, input) {
     cookieName: name,
     cookieValue: value,
     ...explicitDomain ? { cookieDomain: explicitDomain.includes(".") ? `.${explicitDomain}` : explicitDomain } : {},
-    cookieUrl: `${url2.protocol}//${url2.hostname.toLowerCase()}${path13}`,
+    cookieUrl: `${url2.protocol}//${url2.hostname.toLowerCase()}${path15}`,
     domain: domain2,
-    path: path13,
+    path: path15,
     reload: input.reload === true
   };
 }
@@ -7612,8 +7612,8 @@ registerActions([
 ]);
 
 // src/cdp-backend/tdbank-handlers.ts
-async function cdpFetchTdbank(session, path13, options = {}) {
-  const url2 = new URL(`https://tdbank.alibaba-inc.com${path13}`);
+async function cdpFetchTdbank(session, path15, options = {}) {
+  const url2 = new URL(`https://tdbank.alibaba-inc.com${path15}`);
   for (const [key, value] of Object.entries(options.params ?? {})) {
     if (value !== void 0 && value !== null) {
       url2.searchParams.set(key, String(value));
@@ -9752,7 +9752,7 @@ import os2 from "node:os";
 import { randomUUID as randomUUID4 } from "node:crypto";
 
 // src/version.ts
-var NATIVE_HOST_VERSION = true ? "2.3.0" : "unknown";
+var NATIVE_HOST_VERSION = true ? "2.4.0" : "unknown";
 
 // src/analytics.ts
 var MEASUREMENT_ID = "G-W84LJDZ6PH";
@@ -10625,6 +10625,7 @@ import path7 from "node:path";
 import fs5 from "node:fs";
 import path6 from "node:path";
 import { spawn as spawn4 } from "node:child_process";
+var MAX_CAPTURE_LENGTH = 1e6;
 function isExecutable(filePath, platform = process.platform) {
   try {
     fs5.accessSync(filePath, platform === "win32" ? fs5.constants.F_OK : fs5.constants.X_OK);
@@ -10669,12 +10670,12 @@ function resolveSpawnCommand(executable, args, platform = process.platform, comm
 function prependCommandPath(command, env = process.env) {
   if (!path6.isAbsolute(command))
     return env;
-  return prependPath(path6.dirname(command), env);
+  return prependPathDirectory(path6.dirname(command), env);
 }
 function prependNodePath(env = process.env, nodeExecutable = process.execPath) {
-  return prependPath(path6.dirname(nodeExecutable), env);
+  return prependPathDirectory(path6.dirname(nodeExecutable), env);
 }
-function prependPath(directory, env) {
+function prependPathDirectory(directory, env = process.env) {
   const pathKey = Object.keys(env).find((key) => key.toLowerCase() === "path") || "PATH";
   const inherited = env[pathKey] || "";
   const entries = inherited.split(path6.delimiter).filter(Boolean);
@@ -10682,6 +10683,59 @@ function prependPath(directory, env) {
     return env;
   return { ...env, [pathKey]: [directory, ...entries].join(path6.delimiter) };
 }
+function findExecutable(name, options = {}) {
+  const env = options.env ?? process.env;
+  const platform = options.platform ?? process.platform;
+  const existsSync4 = options.existsSync ?? ((candidate) => isExecutable(candidate, platform));
+  const pathKey = Object.keys(env).find((key) => key.toLowerCase() === "path") || "PATH";
+  const directories = [
+    ...options.extraDirectories ?? [],
+    ...(env[pathKey] ?? "").split(path6.delimiter).filter(Boolean)
+  ];
+  for (const directory of directories) {
+    for (const executableName of executableNames(name, platform)) {
+      const candidate = path6.join(directory, executableName);
+      if (existsSync4(candidate))
+        return candidate;
+    }
+  }
+  return null;
+}
+var runCommand = (command, args, options = {}) => new Promise((resolve, reject) => {
+  const capture = options.capture === true;
+  const launch = resolveSpawnCommand(command, args);
+  const child = spawn4(launch.command, launch.args, {
+    cwd: options.cwd,
+    env: options.env,
+    stdio: capture ? ["ignore", "pipe", "pipe"] : "inherit",
+    windowsHide: true
+  });
+  let stdout = "";
+  let stderr = "";
+  let settled = false;
+  const append = (current, chunk) => current.length >= MAX_CAPTURE_LENGTH ? current : (current + chunk.toString("utf8")).slice(0, MAX_CAPTURE_LENGTH);
+  const finish = (error48, code = 1) => {
+    if (settled)
+      return;
+    settled = true;
+    if (timer)
+      clearTimeout(timer);
+    if (error48)
+      reject(error48);
+    else
+      resolve({ code, stdout, stderr });
+  };
+  const timer = options.timeoutMs === void 0 ? void 0 : setTimeout(() => {
+    child.kill("SIGTERM");
+    finish(new Error(`Command timed out after ${options.timeoutMs}ms`));
+  }, options.timeoutMs);
+  if (capture) {
+    child.stdout?.on("data", (chunk) => stdout = append(stdout, chunk));
+    child.stderr?.on("data", (chunk) => stderr = append(stderr, chunk));
+  }
+  child.once("error", (error48) => finish(error48));
+  child.once("close", (code) => finish(void 0, code ?? 1));
+});
 
 // src/agent/executable-resolver.ts
 function agentExecutableCandidatePaths({
@@ -12163,10 +12217,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path13) {
-  if (!path13)
+function getElementAtPath(obj, path15) {
+  if (!path15)
     return obj;
-  return path13.reduce((acc, key) => acc?.[key], obj);
+  return path15.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -12549,11 +12603,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path13, issues) {
+function prefixIssues(path15, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path13);
+    iss.path.unshift(path15);
     return iss;
   });
 }
@@ -12736,7 +12790,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path13 = []) => {
+  const processError = (error49, path15 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -12746,7 +12800,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path13, ...issue2.path];
+        const fullpath = [...path15, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -12778,8 +12832,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path13 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path13) {
+  const path15 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path15) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -24756,13 +24810,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path13 = ref.slice(1).split("/").filter(Boolean);
-  if (path13.length === 0) {
+  const path15 = ref.slice(1).split("/").filter(Boolean);
+  if (path15.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path13[0] === defsKey) {
-    const key = path13[1];
+  if (path15[0] === defsKey) {
+    const key = path15[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -29769,6 +29823,409 @@ function createExtensionRequestMessage(id, action, data, trustedInternal = false
   };
 }
 
+// src/host-updater.ts
+import fs10 from "node:fs";
+import path11 from "node:path";
+import { fileURLToPath } from "node:url";
+
+// ../setup/dist/packageManager.js
+import fs9 from "node:fs";
+import path10 from "node:path";
+function normalizePath(filePath) {
+  return filePath.replaceAll("\\", "/").replace(/\/+$/, "");
+}
+function firstExisting(candidates, existsSync4) {
+  return candidates.find((candidate) => existsSync4(candidate));
+}
+function fallbackCommand(name, platform) {
+  if (platform !== "win32")
+    return name;
+  if (name === "bun" || name === "volta")
+    return `${name}.exe`;
+  return `${name}.cmd`;
+}
+function resolvePackageManagerInstallation(packageRoot, packageName, options = {}) {
+  const env = options.env ?? process.env;
+  const platform = options.platform ?? process.platform;
+  const existsSync4 = options.existsSync ?? ((candidate) => isExecutable(candidate, platform));
+  const processExecPath = options.processExecPath ?? process.execPath;
+  const normalizedRoot = normalizePath(path10.resolve(packageRoot));
+  const lowerRoot = normalizedRoot.toLowerCase();
+  const lowerPackageName = packageName.toLowerCase();
+  const pnpmGlobalRoot = /\/global\/\d+\/(?:\.pnpm\/.*\/)?node_modules\//.exec(lowerRoot);
+  if (pnpmGlobalRoot && lowerRoot.endsWith(`/node_modules/${lowerPackageName}`)) {
+    const pnpmHome = normalizedRoot.slice(0, pnpmGlobalRoot.index);
+    const command = firstExisting([
+      ...executableNames("pnpm", platform).map((name) => path10.join(pnpmHome, name)),
+      ...executableNames("pnpm", platform).map((name) => path10.join(path10.dirname(processExecPath), name))
+    ], existsSync4) ?? fallbackCommand("pnpm", platform);
+    return { manager: "pnpm", command, binDirectory: pnpmHome };
+  }
+  const bunMarker = `/.bun/install/global/node_modules/${lowerPackageName}`;
+  if (lowerRoot.endsWith(bunMarker)) {
+    const bunHome = normalizedRoot.slice(0, lowerRoot.indexOf("/.bun/"));
+    const command = firstExisting(executableNames("bun", platform).map((name) => path10.join(bunHome, ".bun", "bin", name)), existsSync4) ?? fallbackCommand("bun", platform);
+    return {
+      manager: "bun",
+      command,
+      binDirectory: path10.join(bunHome, ".bun", "bin")
+    };
+  }
+  if ((lowerRoot.includes("/.config/yarn/global/node_modules/") || lowerRoot.includes("/.yarn/global/node_modules/") || lowerRoot.includes("/yarn/global/node_modules/") || lowerRoot.includes("/yarn/data/global/node_modules/")) && lowerRoot.endsWith(`/node_modules/${lowerPackageName}`)) {
+    const layout = [
+      { marker: "/.config/yarn/global/", binSegments: [".yarn", "bin"] },
+      { marker: "/.yarn/global/", binSegments: [".yarn", "bin"] },
+      { marker: "/yarn/data/global/", binSegments: ["yarn", "bin"] },
+      { marker: "/yarn/global/", binSegments: ["yarn", "bin"] }
+    ].find((candidate) => lowerRoot.includes(candidate.marker));
+    const prefix = normalizedRoot.slice(0, lowerRoot.indexOf(layout.marker));
+    const binDirectory = path10.join(prefix, ...layout.binSegments);
+    const command = firstExisting([
+      ...executableNames("yarn", platform).map((name) => path10.join(binDirectory, name)),
+      ...executableNames("yarn", platform).map((name) => path10.join(path10.dirname(processExecPath), name))
+    ], existsSync4) ?? findExecutable("yarn", { env, existsSync: existsSync4, platform }) ?? fallbackCommand("yarn", platform);
+    return { manager: "yarn", command, binDirectory };
+  }
+  if (lowerRoot.includes("/.volta/tools/image/packages/") && lowerRoot.endsWith(`/lib/node_modules/${lowerPackageName}`)) {
+    const voltaHome = normalizedRoot.slice(0, lowerRoot.indexOf("/.volta/"));
+    const command = firstExisting(executableNames("volta", platform).map((name) => path10.join(voltaHome, ".volta", "bin", name)), existsSync4) ?? fallbackCommand("volta", platform);
+    return {
+      manager: "volta",
+      command,
+      binDirectory: path10.join(voltaHome, ".volta", "bin")
+    };
+  }
+  const npmMarker = `/lib/node_modules/${lowerPackageName}`;
+  if (lowerRoot.endsWith(npmMarker)) {
+    const prefix = normalizedRoot.slice(0, lowerRoot.length - npmMarker.length);
+    const command = firstExisting([
+      ...executableNames("npm", platform).map((name) => path10.join(prefix, "bin", name)),
+      ...executableNames("npm", platform).map((name) => path10.join(path10.dirname(processExecPath), name))
+    ], existsSync4) ?? fallbackCommand("npm", platform);
+    return { manager: "npm", command, binDirectory: path10.join(prefix, "bin") };
+  }
+  if (platform === "win32" && env.APPDATA) {
+    const npmRoot = normalizePath(path10.join(env.APPDATA, "npm", "node_modules", packageName));
+    if (lowerRoot === npmRoot.toLowerCase()) {
+      const binDirectory = path10.join(env.APPDATA, "npm");
+      const command = firstExisting([
+        ...executableNames("npm", platform).map((name) => path10.join(binDirectory, name)),
+        ...executableNames("npm", platform).map((name) => path10.join(path10.dirname(processExecPath), name))
+      ], existsSync4) ?? fallbackCommand("npm", platform);
+      return { manager: "npm", command, binDirectory };
+    }
+  }
+  return null;
+}
+
+// ../setup/dist/version.js
+var MEARL_RELEASE_VERSION_MAX_LENGTH = 64;
+var RELEASE_VERSION_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-beta\.(0|[1-9]\d*))?$/;
+var RELEASE_LINE_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.x$/;
+var RELEASE_COMPONENT_MAXIMUM = 65535;
+function parseComponent(value) {
+  const component = Number(value);
+  return Number.isSafeInteger(component) && component <= RELEASE_COMPONENT_MAXIMUM ? component : null;
+}
+function parseMearlReleaseVersion(value) {
+  if (typeof value !== "string" || value.length > MEARL_RELEASE_VERSION_MAX_LENGTH)
+    return null;
+  const match = RELEASE_VERSION_PATTERN.exec(value);
+  if (!match)
+    return null;
+  const major = parseComponent(match[1]);
+  const minor = parseComponent(match[2]);
+  const patch = parseComponent(match[3]);
+  const beta = match[4] === void 0 ? void 0 : parseComponent(match[4]);
+  if (major === null || minor === null || patch === null || beta === null)
+    return null;
+  return {
+    raw: value,
+    major,
+    minor,
+    patch,
+    channel: beta === void 0 ? "stable" : "beta",
+    ...beta === void 0 ? {} : { beta }
+  };
+}
+function isMearlReleaseVersion(value) {
+  return parseMearlReleaseVersion(value) !== null;
+}
+function parseMearlReleaseLine(value) {
+  if (typeof value !== "string" || value.length > MEARL_RELEASE_VERSION_MAX_LENGTH)
+    return null;
+  const match = RELEASE_LINE_PATTERN.exec(value);
+  if (!match)
+    return null;
+  const major = parseComponent(match[1]);
+  const minor = parseComponent(match[2]);
+  if (major === null || minor === null)
+    return null;
+  return { raw: value, major, minor };
+}
+function mearlReleaseLineForVersion(version2) {
+  const parsed = parseMearlReleaseVersion(version2);
+  if (!parsed)
+    throw new Error("A valid Mearl release version is required");
+  return `${parsed.major}.${parsed.minor}.x`;
+}
+function isMearlReleaseVersionInLine(version2, releaseLine) {
+  const parsedVersion = parseMearlReleaseVersion(version2);
+  const parsedLine = parseMearlReleaseLine(releaseLine);
+  return parsedVersion !== null && parsedLine !== null && parsedVersion.major === parsedLine.major && parsedVersion.minor === parsedLine.minor;
+}
+function compareMearlReleaseLines(leftVersion, rightVersion) {
+  const left = parseMearlReleaseVersion(leftVersion);
+  const right = parseMearlReleaseVersion(rightVersion);
+  if (!left || !right) {
+    throw new Error("Mearl release-line comparison requires valid release versions");
+  }
+  for (const key of ["major", "minor"]) {
+    if (left[key] < right[key])
+      return -1;
+    if (left[key] > right[key])
+      return 1;
+  }
+  return 0;
+}
+
+// src/host-updater.ts
+var NATIVE_HOST_UPDATE_TIMEOUT_MS = 5 * 6e4;
+var UPDATE_LOCK_PATH = path11.join(DAEMON_HOME, "native-host-update.lock");
+var UPDATE_LOCK_POLL_MS = 500;
+var INVALID_UPDATE_LOCK_GRACE_MS = 1e4;
+var NativeHostUpdateFailure = class extends Error {
+  constructor(updateError, message) {
+    super(message);
+    this.updateError = updateError;
+    this.name = "NativeHostUpdateFailure";
+  }
+};
+function wait(delayMs) {
+  return new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+function readLockState(lockPath) {
+  try {
+    const stat2 = fs10.lstatSync(lockPath);
+    if (!stat2.isFile() || stat2.isSymbolicLink() || stat2.size > 4096) {
+      return { modifiedAt: stat2.mtimeMs, owner: null };
+    }
+    try {
+      const value = JSON.parse(fs10.readFileSync(lockPath, "utf8"));
+      const owner = Number.isInteger(value.pid) && value.pid > 0 && typeof value.startedAt === "number" && Number.isFinite(value.startedAt) && value.startedAt > 0 ? { pid: value.pid, startedAt: value.startedAt } : null;
+      return { modifiedAt: stat2.mtimeMs, owner };
+    } catch {
+      return { modifiedAt: stat2.mtimeMs, owner: null };
+    }
+  } catch {
+    return null;
+  }
+}
+async function withNativeHostUpdateLock(lockPath, targetVersion, operation) {
+  fs10.mkdirSync(path11.dirname(lockPath), { recursive: true, mode: 448 });
+  const startedAt = Date.now();
+  const owner = `${JSON.stringify({ pid: process.pid, startedAt, targetVersion })}
+`;
+  while (true) {
+    try {
+      const handle = fs10.openSync(lockPath, "wx", 384);
+      try {
+        fs10.writeFileSync(handle, owner, "utf8");
+      } finally {
+        fs10.closeSync(handle);
+      }
+      break;
+    } catch (error48) {
+      if (!(error48 instanceof Error) || !("code" in error48) || error48.code !== "EEXIST") throw error48;
+      const existing = readLockState(lockPath);
+      const staleAfter = existing?.owner ? NATIVE_HOST_UPDATE_TIMEOUT_MS : INVALID_UPDATE_LOCK_GRACE_MS;
+      const referenceTime = existing?.owner?.startedAt ?? existing?.modifiedAt;
+      const expired = referenceTime !== void 0 && Date.now() - referenceTime > staleAfter;
+      const ownerAlive = existing?.owner ? isAlive(existing.owner.pid) : false;
+      if (expired && !ownerAlive) {
+        try {
+          fs10.unlinkSync(lockPath);
+          continue;
+        } catch {
+        }
+      }
+      if (Date.now() - startedAt > NATIVE_HOST_UPDATE_TIMEOUT_MS + 1e4) {
+        throw new NativeHostUpdateFailure(
+          "lock-timeout",
+          "Another Mearl Native Host update did not finish in time"
+        );
+      }
+      await wait(UPDATE_LOCK_POLL_MS);
+    }
+  }
+  try {
+    return await operation();
+  } finally {
+    try {
+      if (fs10.readFileSync(lockPath, "utf8") === owner) fs10.unlinkSync(lockPath);
+    } catch {
+    }
+  }
+}
+function classifyUpdateFailure(output) {
+  if (/\b(?:E404|ETARGET)\b|no matching version found|404\s+not found|package.+not found/i.test(
+    output
+  )) {
+    return "package-unavailable";
+  }
+  if (/\b(?:EAI_AGAIN|ECONNREFUSED|ECONNRESET|ENETUNREACH|ENOTFOUND|ERR_SOCKET_TIMEOUT)\b|fetch failed|network request/i.test(
+    output
+  )) {
+    return "network";
+  }
+  return "setup-failed";
+}
+function nativeHostUpdateCommand(targetVersion) {
+  if (!isMearlReleaseVersion(targetVersion)) {
+    throw new Error("The Native Host update target must be a valid Mearl release");
+  }
+  const releaseLine = mearlReleaseLineForVersion(targetVersion);
+  const packageSpec = `@mearl/setup@${releaseLine}`;
+  const args = [
+    "--yes",
+    packageSpec,
+    "update",
+    "--local",
+    "--yes",
+    "--target-line",
+    releaseLine,
+    "--skip-skill"
+  ];
+  return {
+    args
+  };
+}
+function currentNativeHostPackageRoot(entryPath) {
+  let current = path11.dirname(entryPath);
+  for (let depth = 0; depth < 12; depth += 1) {
+    try {
+      const manifest = JSON.parse(fs10.readFileSync(path11.join(current, "package.json"), "utf8"));
+      if (manifest.name === "@mearl/native-host") return current;
+    } catch {
+    }
+    const parent = path11.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return null;
+}
+function currentPackageManagerInstallation(environment, nodePath, platform) {
+  const packageRoot = currentNativeHostPackageRoot(fileURLToPath(import.meta.url));
+  if (!packageRoot) return null;
+  return resolvePackageManagerInstallation(packageRoot, "@mearl/native-host", {
+    env: environment,
+    platform,
+    processExecPath: nodePath
+  });
+}
+async function installedLocalPackagesMatch(targetReleaseLine, environment, runner) {
+  const installedVersions = [];
+  for (const executableName of ["mearl-native-host", "mearl"]) {
+    const executable = findExecutable(executableName, { env: environment });
+    if (!executable) return false;
+    try {
+      const result = await runner(executable, ["--version"], {
+        capture: true,
+        env: environment,
+        timeoutMs: 5e3
+      });
+      const installedVersion = result.stdout.trim();
+      if (result.code !== 0 || !isMearlReleaseVersionInLine(installedVersion, targetReleaseLine)) {
+        return false;
+      }
+      installedVersions.push(installedVersion);
+    } catch {
+      return false;
+    }
+  }
+  return new Set(installedVersions).size === 1;
+}
+async function runNativeHostUpdate(targetVersion, options = {}) {
+  const command = nativeHostUpdateCommand(targetVersion);
+  const targetReleaseLine = mearlReleaseLineForVersion(targetVersion);
+  const environment = options.environment ?? process.env;
+  const platform = options.platform ?? process.platform;
+  const nodePath = options.nodePath ?? process.execPath;
+  const currentInstallation = currentPackageManagerInstallation(environment, nodePath, platform);
+  const managerCommand = options.packageManagerCommand === void 0 ? currentInstallation?.command ?? null : options.packageManagerCommand;
+  const packageBinDirectory = options.packageBinDirectory === void 0 ? currentInstallation?.binDirectory ?? null : options.packageBinDirectory;
+  let childEnvironment = prependNodePath(environment, nodePath);
+  if (managerCommand) childEnvironment = prependCommandPath(managerCommand, childEnvironment);
+  if (packageBinDirectory) {
+    childEnvironment = prependPathDirectory(packageBinDirectory, childEnvironment);
+  }
+  const packageRunner = options.packageRunner ?? findExecutable("npx", {
+    env: childEnvironment,
+    extraDirectories: [path11.dirname(nodePath)],
+    platform
+  });
+  if (!packageRunner) {
+    throw new NativeHostUpdateFailure("package-unavailable", "The package runner is unavailable");
+  }
+  const runner = options.runner ?? runCommand;
+  const areTargetsInstalled = options.areTargetsInstalled ?? ((version2, env) => installedLocalPackagesMatch(version2, env, runner));
+  const withUpdateLock = options.withUpdateLock ?? ((version2, operation) => withNativeHostUpdateLock(options.updateLockPath ?? UPDATE_LOCK_PATH, version2, operation));
+  await withUpdateLock(targetVersion, async () => {
+    let result;
+    try {
+      result = await runner(packageRunner, command.args, {
+        capture: true,
+        env: childEnvironment,
+        timeoutMs: options.timeoutMs ?? NATIVE_HOST_UPDATE_TIMEOUT_MS
+      });
+    } catch (error48) {
+      const message = error48 instanceof Error ? error48.message : String(error48);
+      const classified = classifyUpdateFailure(message);
+      throw new NativeHostUpdateFailure(
+        /timed out/i.test(message) ? "timeout" : classified === "setup-failed" ? "unknown" : classified,
+        "The Native Host update process did not complete"
+      );
+    }
+    if (result.code !== 0) {
+      throw new NativeHostUpdateFailure(
+        classifyUpdateFailure(`${result.stderr.slice(0, 8192)}
+${result.stdout.slice(0, 8192)}`),
+        "The Mearl setup release line did not complete successfully"
+      );
+    }
+    if (!await areTargetsInstalled(targetReleaseLine, childEnvironment)) {
+      throw new NativeHostUpdateFailure(
+        "verification-failed",
+        "The installed Native Host and client do not match the Extension release line"
+      );
+    }
+  });
+}
+var NativeHostUpdateCoordinator = class {
+  constructor(options) {
+    this.options = options;
+  }
+  #automaticAttempted = false;
+  #operation = null;
+  evaluate(extensionVersion2, checkForUpdates) {
+    if (checkForUpdates !== true || this.#automaticAttempted || this.#operation) return;
+    if (!isMearlReleaseVersion(extensionVersion2) || !isMearlReleaseVersion(this.options.hostVersion)) {
+      this.options.log("Skipped Native Host update check because a release version was invalid");
+      return;
+    }
+    const targetVersion = extensionVersion2;
+    if (compareMearlReleaseLines(this.options.hostVersion, targetVersion) >= 0) return;
+    this.#automaticAttempted = true;
+    const operation = this.options.runUpdate(targetVersion).then(() => this.options.requestRestart()).catch((error48) => {
+      const category = error48 instanceof NativeHostUpdateFailure ? error48.updateError : "unknown";
+      this.options.log(`Native Host automatic update failed (${category})`);
+    }).finally(() => {
+      if (this.#operation === operation) this.#operation = null;
+    });
+    this.#operation = operation;
+  }
+};
+
 // src/index.ts
 var cliArgs = process.argv.slice(2);
 var cliArg = cliArgs[0];
@@ -29835,11 +30292,11 @@ Examples:
   process.exit(0);
 }
 function socketPathFor(suffix) {
-  return process.platform === "win32" ? `\\\\.\\pipe\\mearl-agent${suffix}` : path12.join(os7.tmpdir(), `mearl-agent${suffix}.sock`);
+  return process.platform === "win32" ? `\\\\.\\pipe\\mearl-agent${suffix}` : path14.join(os7.tmpdir(), `mearl-agent${suffix}.sock`);
 }
 var LEGACY_SOCKET_PATH = socketPathFor("");
 var INSTANCE_SOCKET_PATH = socketPathFor(`-${process.pid}`);
-var LOG_FILE = path12.join(os7.tmpdir(), "mearl-native-host.log");
+var LOG_FILE = path14.join(os7.tmpdir(), "mearl-native-host.log");
 var DEFAULT_TIMEOUT_MS = 15e3;
 var INVENTORY_IDLE_EXIT_MS = 1e3;
 var MAX_SOCKET_BUFFER_SIZE = 64 * 1024 * 1024;
@@ -29938,7 +30395,7 @@ function log(...args) {
   const msg = `[${(/* @__PURE__ */ new Date()).toISOString()}] [NativeHost] ${args.join(" ")}
 `;
   try {
-    fs11.appendFileSync(LOG_FILE, msg);
+    fs13.appendFileSync(LOG_FILE, msg);
   } catch {
   }
 }
@@ -29950,6 +30407,14 @@ function sendToExtension(message) {
   process.stdout.write(header);
   process.stdout.write(json2);
 }
+var nativeHostUpdateCoordinator = new NativeHostUpdateCoordinator({
+  hostVersion: NATIVE_HOST_VERSION,
+  log,
+  runUpdate: (targetVersion) => runNativeHostUpdate(targetVersion),
+  requestRestart: () => {
+    restartAfterUpdate();
+  }
+});
 var agentChatManager = null;
 var agentSkillManager = new AgentSkillManager();
 function getAgentChatManager() {
@@ -30060,6 +30525,7 @@ function handleExtensionMessage(message) {
       extensionVersion: extensionVersion ?? void 0
     });
     sendToExtension({ type: "pong", timestamp: Date.now(), version: NATIVE_HOST_VERSION });
+    nativeHostUpdateCoordinator.evaluate(message.version, message.checkForUpdates);
     return;
   }
   if (message && message.type === "browser_focus") {
@@ -30343,7 +30809,7 @@ async function handleSocketLine(socket, line) {
         return result2.cookies ?? [];
       } : (domains) => cdpExportCookies(getCdpSession(), domains);
       const result = await launchManagedBrowser(data, {
-        nativeHostScript: fileURLToPath2(import.meta.url),
+        nativeHostScript: fileURLToPath3(import.meta.url),
         prepareTdbankSso,
         exportCookies,
         log
@@ -30472,7 +30938,7 @@ function onSocketConnection(socket) {
 }
 function isPathAlive(socketPath) {
   return new Promise((resolve) => {
-    if (process.platform !== "win32" && !fs11.existsSync(socketPath)) {
+    if (process.platform !== "win32" && !fs13.existsSync(socketPath)) {
       resolve(false);
       return;
     }
@@ -30495,9 +30961,9 @@ function isPathAlive(socketPath) {
 }
 function listenOn(socketPath) {
   return new Promise((resolve, reject) => {
-    if (process.platform !== "win32" && fs11.existsSync(socketPath)) {
+    if (process.platform !== "win32" && fs13.existsSync(socketPath)) {
       try {
-        fs11.unlinkSync(socketPath);
+        fs13.unlinkSync(socketPath);
       } catch {
       }
     }
@@ -30506,11 +30972,11 @@ function listenOn(socketPath) {
     server.listen(socketPath, () => {
       if (process.platform !== "win32") {
         try {
-          fs11.chmodSync(socketPath, 384);
+          fs13.chmodSync(socketPath, 384);
         } catch (error48) {
           server.close();
           try {
-            fs11.unlinkSync(socketPath);
+            fs13.unlinkSync(socketPath);
           } catch {
           }
           reject(error48);
@@ -30546,7 +31012,7 @@ function releaseLegacySocket() {
   }
   if (process.platform !== "win32") {
     try {
-      if (fs11.existsSync(LEGACY_SOCKET_PATH)) fs11.unlinkSync(LEGACY_SOCKET_PATH);
+      if (fs13.existsSync(LEGACY_SOCKET_PATH)) fs13.unlinkSync(LEGACY_SOCKET_PATH);
     } catch {
     }
   }
@@ -30558,8 +31024,8 @@ async function startSocketServer() {
 function cleanupInstanceSocketFile() {
   if (process.platform === "win32") return;
   try {
-    if (fs11.existsSync(INSTANCE_SOCKET_PATH)) {
-      fs11.unlinkSync(INSTANCE_SOCKET_PATH);
+    if (fs13.existsSync(INSTANCE_SOCKET_PATH)) {
+      fs13.unlinkSync(INSTANCE_SOCKET_PATH);
     }
   } catch (error48) {
     log("cleanup socket file failed:", String(error48));
@@ -30586,6 +31052,11 @@ function cleanupAndExit(code) {
   }
   finish();
 }
+function restartAfterUpdate() {
+  const forcedExit = setTimeout(() => process.exit(0), 2e3);
+  forcedExit.unref();
+  cleanupAndExit(0);
+}
 async function main() {
   initBrowserRegistry({ log });
   pruneDeadBrowsers();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mearl/native-host",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "Native Messaging Host for Mearl — bridges Chrome Extension and local socket server",
   "type": "module",
   "main": "dist/install.js",
@@ -32,9 +32,9 @@
     "@types/node": "^24.9.1",
     "esbuild": "^0.25.2",
     "typescript": "^5.8.3",
-    "@mearl/daemon-core": "2.3.0",
-    "@mearl/browser-core": "2.3.0",
-    "@mearl/setup": "2.3.0"
+    "@mearl/browser-core": "2.4.0",
+    "@mearl/daemon-core": "2.4.0",
+    "@mearl/setup": "2.4.0"
   },
   "scripts": {
     "build": "rm -rf dist/ && node build.mjs",