@allansantos-dev/smart-tool 0.9.27 → 0.9.28

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.9.28 - beta
+
+- Node, npx and npm are looked up when they are needed, never remembered. A process keeps the PATH it was born with:
+  the tray started at logon never saw a Node installed, moved or removed afterwards, so the automatic update
+  (`npx --yes ... install`, run from the tray) stopped working once Node changed place, and everything the update then
+  started (installer, restarted tray) inherited the same stale PATH. New `node_locator.py`: the process PATH, then the
+  machine and user PATH stored in the registry, then the usual install folders (Program Files, nvm, Volta, fnm, Scoop,
+  Chocolatey); the Node inside Smart Tool (`web_adapters/node/.node-runtime`) is used only when the machine has none.
+  - The updater launches the install with that fresh PATH and the folder of the `npx` it found first in it.
+  - The web runtime installer takes the machine's Node from the PATH first (it preferred the one inside Smart Tool).
+  - Search adapters and the code analyzers resolve Node at each launch, so a Node changed while the daemon runs is
+    followed without a restart.
+  - The Playwright MCP registration writes the absolute Node path into the client's configuration; the daemon now
+    registers it again at start when that executable no longer exists (`browser_control.heal`).
+- Tests: `tests/test_node_locator.py` (Node in an unusual folder, only in the registry PATH, only in a known folder,
+  nothing found, the updater without npx in the tray PATH, a registration whose Node is gone).
+
 ## 0.9.27 - beta
 
 - No folder is read before it is classified, and a tool's hidden folder (`.crowd`, `.tokenguard`, `.vscode`, any name

package/README.md

@@ -15,7 +15,7 @@ registered as the `playwright` server where this machine lets a browser be drive
 An optional hook routes the agent's native Grep/Glob/Read/Bash/WebSearch/WebFetch calls to these tools when they
 are cheaper, or just tells the agent what Smart Tool would do.
 
-**Status:** 0.9.27 beta. Windows only. What changed in each version: [CHANGELOG.md](CHANGELOG.md).
+**Status:** 0.9.28 beta. Windows only. What changed in each version: [CHANGELOG.md](CHANGELOG.md).
 
 ## How it works
 

package/browser_control.py

@@ -26,6 +26,7 @@ import tomllib
 import atomic_io
 import endpoint_sync
 import install_runtime
+import node_locator
 import paths
 
 SERVER = "playwright"
@@ -157,6 +158,34 @@ def registered():
     return found
 
 
+def registered_command(client):
+    """Executable the client's `playwright` server is registered with, or None when it is not registered."""
+    try:
+        if client == "claude":
+            with open(endpoint_sync.claude_json(), encoding="utf-8") as stream:
+                entry = (json.load(stream).get("mcpServers") or {}).get(SERVER)
+        else:
+            with open(_codex_config(), encoding="utf-8") as stream:
+                entry = (tomllib.loads(stream.read()).get("mcp_servers") or {}).get(SERVER)
+    except (OSError, ValueError, AttributeError):
+        return None
+    command = entry.get("command") if isinstance(entry, dict) else None
+    return command if isinstance(command, str) else None
+
+
+def heal(log=None):
+    """Registers again, through ensure, each registration of ours whose executable no longer exists: the Node path is
+    written into the client's configuration, which a moved or reinstalled Node leaves pointing nowhere. Returns
+    {client: ensure's outcome} for the clients refreshed."""
+    refreshed = {}
+    for client in ("claude", "codex"):
+        command = registered_command(client)
+        ours = status().get(client, {}).get("state") in ("registered", "undenied")
+        if ours and command and not node_locator.exists(command):
+            refreshed[client] = ensure(client, log)
+    return refreshed
+
+
 def _codex_config():
     """Codex keeps config.toml in CODEX_HOME when set, else ~/.codex."""
     return os.path.join(endpoint_sync.codex_dir(), "config.toml")

package/code_graph.py

@@ -242,7 +242,7 @@ def _run_analyzer(script, payload, failure):
     needed more than the former fixed 512 MB). The run is killed after `ANALYZER_TIMEOUT_S` seconds (a context
     variable: the edit hook lowers it so a slow file cannot hold its worker)."""
     for heap in NODE_HEAP_MB:
-        process=subprocess.run([web_search_adapters.NODE_EXECUTABLE,f'--max-old-space-size={heap}',str(Path(__file__).with_name(script))],
+        process=subprocess.run([web_search_adapters.executable_path(web_search_adapters.NODE_EXECUTABLE),f'--max-old-space-size={heap}',str(Path(__file__).with_name(script))],
             input=payload,capture_output=True,text=True,encoding='utf-8',timeout=ANALYZER_TIMEOUT_S.get(),
             creationflags=getattr(subprocess,'CREATE_NO_WINDOW',0))
         if process.returncode==0:

package/install_runtime.py

@@ -21,6 +21,8 @@ import venv
 import zipfile
 from pathlib import Path
 
+import node_locator
+
 
 ROOT = Path(__file__).resolve().parent
 NODE_DIR = ROOT / "web_adapters" / "node"
@@ -32,7 +34,7 @@ JAVA_PARSER = NODE_DIR / 'node_modules' / 'java-parser' / 'src' / 'index.js'
 ANGULAR_PARSER = NODE_DIR / 'node_modules' / '@angular' / 'compiler' / 'fesm2022' / 'compiler.mjs'
 # Browser control for agents (browser_control.py): Microsoft's Playwright MCP over the Chromium installed below.
 PLAYWRIGHT_MCP_CLI = NODE_DIR / "node_modules" / "@playwright" / "mcp" / "cli.js"
-NODE_RUNTIME = NODE_DIR / ".node-runtime"
+NODE_RUNTIME = Path(node_locator.LOCAL_RUNTIME)
 # Moli renders the JavaScript pages web_fetch cannot read over HTTP; Chromium (Crawl4AI) stays as its fallback.
 # Measured on 2026-10-10 over 21 such pages: 1.6 s and 90 MB peak (median) against 4.2 s and 581 MB for Chromium.
 MOLI_VERSION = "1.1.15"
@@ -58,14 +60,16 @@ def _node_supported(node):
 
 
 def _node_commands():
+    """(node, npm) of the Node to use: the machine's, found through the PATH first, else the one inside Smart Tool;
+    (None, None) when neither is a supported version."""
+    node = node_locator.which("node")
+    npm = node_locator.which("npm.cmd") or node_locator.which("npm")
+    if node and npm and _node_supported(node):
+        return node, npm
     local_node, local_npm = NODE_RUNTIME / "node.exe", NODE_RUNTIME / "npm.cmd"
-    if NODE_RUNTIME.exists():
-        if local_node.is_file() and local_npm.is_file() and _node_supported(local_node):
-            return str(local_node), str(local_npm)
-        return None, None
-    node = shutil.which("node")
-    npm = shutil.which("npm.cmd") or shutil.which("npm")
-    return (node, npm) if node and npm and _node_supported(node) else (None, None)
+    if local_node.is_file() and local_npm.is_file() and _node_supported(local_node):
+        return str(local_node), str(local_npm)
+    return None, None
 
 
 def _download_verified(url, expected_sha256, path):
@@ -169,10 +173,9 @@ def _install_moli():
 def _run(args, *, cwd=None, label="Web dependency", idle_s=600, stream=False, attempts=1):
     """Runs a step with UTF-8 output and closed stdin (a prompt fails at once instead of hanging); it is stopped only
     after idle_s without any output, and stream shows the output live."""
-    env = os.environ.copy()
+    node, _npm = _node_commands()
+    env = node_locator.environment(prefer=node)
     env.update(PYTHONUTF8="1", PYTHONIOENCODING="utf-8")
-    if NODE_RUNTIME.is_dir():
-        env["PATH"] = str(NODE_RUNTIME) + os.pathsep + env.get("PATH", "")
     flags = (subprocess.CREATE_NEW_PROCESS_GROUP | subprocess.CREATE_NO_WINDOW) if os.name == "nt" else 0
     for attempt in range(1, attempts + 1):
         print(f"{label}: starting{f' (attempt {attempt} of {attempts})' if attempt > 1 else ''}...", flush=True)

package/node_locator.py

@@ -0,0 +1,103 @@
+"""Where Node.js (and npx/npm) is on this machine, looked up when it is needed and never remembered.
+
+A process keeps the PATH it was born with: the tray started at logon never sees a Node installed, moved or removed
+afterwards, and everything it launches (the updater, the installer, the daemon) inherits that stale PATH. The lookup is
+therefore: the process PATH, then the PATH Windows stores for the machine and the user (what a new process would get),
+then the usual install folders. The Node that Smart Tool downloads into web_adapters/node/.node-runtime is the last
+resort of `node()`, used only when the machine has none.
+"""
+import os
+import shutil
+
+LOCAL_RUNTIME = os.path.join(os.path.dirname(os.path.abspath(__file__)), "web_adapters", "node", ".node-runtime")
+_MACHINE_ENVIRONMENT = r"SYSTEM\CurrentControlSet\Control\Session Manager\Environment"
+
+
+def _registry_path():
+    """Entries of the machine and user PATH as stored in the registry, variables expanded."""
+    if os.name != "nt":
+        return []
+    import winreg
+    entries = []
+    for hive, subkey in ((winreg.HKEY_LOCAL_MACHINE, _MACHINE_ENVIRONMENT), (winreg.HKEY_CURRENT_USER, "Environment")):
+        try:
+            with winreg.OpenKey(hive, subkey) as key:
+                entries += os.path.expandvars(winreg.QueryValueEx(key, "Path")[0]).split(os.pathsep)
+        except FileNotFoundError:
+            continue
+    return entries
+
+
+def _unique(entries):
+    seen, kept = set(), []
+    for entry in entries:
+        entry = entry.strip().strip('"')
+        if entry and os.path.normcase(entry) not in seen:
+            seen.add(os.path.normcase(entry))
+            kept.append(entry)
+    return kept
+
+
+def search_path():
+    """The process PATH followed by the registry PATH entries it does not have."""
+    return _unique(os.environ.get("PATH", "").split(os.pathsep) + _registry_path())
+
+
+def known_folders():
+    """Where Node installers and version managers put node.exe, for a machine whose PATH does not list it."""
+    program_files = [os.environ.get(name) for name in ("ProgramFiles", "ProgramW6432", "ProgramFiles(x86)")]
+    local = os.environ.get("LOCALAPPDATA")
+    home = os.path.expanduser("~")
+    candidates = [os.path.join(base, "nodejs") for base in program_files if base]
+    candidates += [os.environ.get("NVM_SYMLINK"), os.environ.get("FNM_MULTISHELL_PATH"),
+                   os.path.join(os.environ["VOLTA_HOME"], "bin") if os.environ.get("VOLTA_HOME") else None,
+                   os.path.join(local, "Programs", "nodejs") if local else None,
+                   os.path.join(home, "scoop", "apps", "nodejs", "current"),
+                   os.path.join(home, "scoop", "apps", "nodejs-lts", "current"),
+                   os.path.join(os.environ["ChocolateyInstall"], "bin") if os.environ.get("ChocolateyInstall") else None]
+    return _unique(path for path in candidates if path)
+
+
+_FOUND = {}
+
+
+def which(name):
+    """Full path of an executable (`node`, `npx.cmd`...): the PATH first, the known install folders only when the PATH
+    does not have it; None when neither does. A path found is remembered per PATH value and used again only while the
+    file is still there, so a lookup costs a stat, not a scan of every folder, and a moved Node is searched again."""
+    key = (name, os.environ.get("PATH", ""))
+    found = _FOUND.get(key)
+    if found and os.path.isfile(found):
+        return found
+    found = (shutil.which(name, path=os.pathsep.join(search_path()))
+             or shutil.which(name, path=os.pathsep.join(known_folders())))
+    if found:
+        _FOUND[key] = found
+    return found
+
+
+def local_node():
+    """The Node downloaded into Smart Tool, or None."""
+    path = os.path.join(LOCAL_RUNTIME, "node.exe")
+    return path if os.path.isfile(path) else None
+
+
+def node():
+    """node.exe of the machine (PATH first), else the Node inside Smart Tool, else None."""
+    return which("node") or local_node()
+
+
+def environment(prefer=None):
+    """A copy of the environment with the current PATH (see search_path), the folder of `prefer` (an executable)
+    first: what a process launched now should inherit."""
+    env = {key: value for key, value in os.environ.items() if key.upper() != "PATH"}
+    entries = search_path()
+    if prefer:
+        entries.insert(0, os.path.dirname(prefer))
+    env["PATH"] = os.pathsep.join(_unique(entries))
+    return env
+
+
+def exists(command):
+    """Whether a registered executable (a full path, or a bare name resolved through the PATH) is still there."""
+    return os.path.isfile(command) or bool(which(command))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allansantos-dev/smart-tool",
-  "version": "0.9.27",
+  "version": "0.9.28",
   "description": "Local MCP server that gives coding agents (Claude Code, Codex) cheaper, sharper tools than their built-in search. Windows.",
   "license": "Apache-2.0",
   "author": "Allan Santos",

package/smart_tool_daemon.py

@@ -40,6 +40,7 @@ import capabilities
 import client_hooks
 import install_runtime
 import integration_metrics
+import node_locator
 import config
 import freshness
 import model_client
@@ -2078,9 +2079,9 @@ def _run_search_script(executable, script_path, args, timeout_s):
         if _IS_WINDOWS else {"start_new_session": True}
     )
     proc = subprocess.Popen(
-        [executable, script_path, *args],
+        [web_search_adapters.executable_path(executable), script_path, *args],
         stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, encoding="utf-8", errors="replace",
-        env={**os.environ, "SMART_TOOL_USER_AGENT": version.user_agent(config.load_config().get("contact"))},
+        env={**node_locator.environment(), "SMART_TOOL_USER_AGENT": version.user_agent(config.load_config().get("contact"))},
         **popen_kwargs,
     )
     try:
@@ -4183,6 +4184,14 @@ def _probe_capabilities():
         _log(f"capabilities probe failed: {type(exc).__name__}: {exc}")
 
 
+def _heal_browser_control():
+    """Re-registers the Playwright MCP server when the Node it was registered with is gone (Node moved or reinstalled)."""
+    try:
+        browser_control.heal(_log)
+    except Exception as exc:
+        _log(f"browser control not refreshed: {type(exc).__name__}: {exc}")
+
+
 def main():
     global _PROJECT_MONITOR
     # O bind vem antes de qualquer I/O de rede: enquanto a porta não abre, o
@@ -4206,6 +4215,7 @@ def main():
     except (OSError, ValueError) as exc:
         _log(f"clients not pointed to port {_BOUND_PORT}: {type(exc).__name__}: {exc}")
     atexit.register(BROWSER_SERVICE.close)
+    threading.Thread(target=_heal_browser_control, daemon=True).start()
     try:
         recovered = project_store.recover_interrupted()
         project_store.import_known_legacy(indexer.INDEX_DIR)

package/update_check.py

@@ -13,6 +13,7 @@ import urllib.request
 
 import atomic_io
 import config
+import node_locator
 import paths
 import version
 
@@ -136,7 +137,9 @@ def notices(now=None):
 
 def run_update(latest, automatic):
     """Starts the install command in its own visible console, detached from the tray (the installer stops and restarts
-    the tray). The console closes on success and stays open with the error on failure."""
+    the tray). The console closes on success and stays open with the error on failure. npx is looked up now, not in the
+    PATH the tray was born with: a Node installed or moved since the last logon still runs the update, and the folder
+    found is put first in the PATH the installer (and the tray it restarts) inherits."""
     if automatic:
         state = _state()
         state.update(attempted=latest, at=time.time())
@@ -144,4 +147,4 @@ def run_update(latest, automatic):
     flags = getattr(subprocess, "CREATE_NEW_CONSOLE", 0) | getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0)
     command = f'title Smart Tool update to {latest} && {UPDATE_COMMAND} || pause'
     subprocess.Popen(["cmd.exe", "/c", command], creationflags=flags, close_fds=True,
-                     cwd=os.path.expanduser("~"))
+                     cwd=os.path.expanduser("~"), env=node_locator.environment(prefer=node_locator.which("npx.cmd")))

package/version.py

@@ -1,7 +1,7 @@
 """Single source of the Smart Tool version and of the User-Agent sent to public APIs."""
 import re
 
-VERSION = "0.9.27"
+VERSION = "0.9.28"
 _CONTACT_RE = re.compile(r"^(?:[^\s@()<>;]+@[^\s@()<>;]+\.[^\s@()<>;]+|https?://[^\s()<>;]+)$")
 
 

package/web_search_adapters.py

@@ -31,11 +31,14 @@ Bing entra pelo tier yahoo.
 import os
 import sys
 
+import node_locator
+
 PACKAGE_DIR = os.path.dirname(os.path.abspath(__file__))
 NODE_ADAPTER_DIR = os.path.join(PACKAGE_DIR, "web_adapters", "node")
 BROWSER_ADAPTER_DIR = os.path.join(PACKAGE_DIR, "web_adapters", "browser")
-LOCAL_NODE_EXECUTABLE = os.path.join(NODE_ADAPTER_DIR, ".node-runtime", "node.exe")
-NODE_EXECUTABLE = LOCAL_NODE_EXECUTABLE if os.path.isfile(LOCAL_NODE_EXECUTABLE) else "node"
+# Adapters name Node, not a path: `executable_path` finds it when the adapter is launched (node_locator), so a Node
+# installed, moved or removed while the daemon runs is followed without a restart.
+NODE_EXECUTABLE = "node"
 CAMOUFOX_VENV_PYTHON = os.path.join(BROWSER_ADAPTER_DIR, ".venv", "Scripts", "python.exe")
 BROWSER_SERVICE_SCRIPT = os.path.join(BROWSER_ADAPTER_DIR, "browser_service.py")
 DDG_SEARCH_SCRIPT = os.path.join(NODE_ADAPTER_DIR, "ddg-search.mjs")
@@ -44,6 +47,13 @@ WIKIPEDIA_SEARCH_SCRIPT = os.path.join(NODE_ADAPTER_DIR, "wikipedia-search.mjs")
 EXTERNAL_SEARCH_SCRIPT = os.path.join(PACKAGE_DIR, "web_search_external.py")
 DDGS_SEARCH_SCRIPT = os.path.join(PACKAGE_DIR, "web_search_ddgs.py")
 
+
+def executable_path(executable):
+    """The program to launch for an adapter's `executable`: Node is looked up now (PATH first, then the Node inside
+    Smart Tool); any other executable is returned unchanged. A Node that is nowhere stays `node`, so the launch fails
+    with the system's own "not found"."""
+    return (node_locator.node() or NODE_EXECUTABLE) if executable == NODE_EXECUTABLE else executable
+
 FETCH_TIMEOUT_S = 15
 OPEN_WEBSEARCH_TIMEOUT_S = 30
 WIKIPEDIA_TIMEOUT_S = 15