@allansantos-dev/smart-tool 0.9.45 → 0.9.46

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allansantos-dev/smart-tool",
-  "version": "0.9.45",
+  "version": "0.9.46",
   "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/projects_ui.py

@@ -1,13 +1,16 @@
 """Tela local de projetos; todas as operações passam pelos jobs do daemon."""
 import html
 import re
+import i18n
 import setup_ui
 import project_maps_ui
 import project_insights_ui
 
 
 def render_projects_page():
+    """The projects page with its token, map and insight components and the interface language script."""
     return (_PAGE.replace("__TOKEN__", html.escape(setup_ui.SETUP_TOKEN, quote=True))
+            .replace("__I18N__", i18n.page_script(setup_ui.SETUP_TOKEN))
             .replace("__MAP_STYLE__", project_maps_ui.STYLE)
             .replace("__MAP_HTML__", project_maps_ui.HTML)
             .replace("__MAP_SCRIPT__", project_maps_ui.SCRIPT)
@@ -24,13 +27,14 @@ def render_map_window():
         '__STYLE__': style.replace('__MAP_STYLE__', project_maps_ui.STYLE).replace('__INSIGHTS_STYLE__', project_insights_ui.STYLE),
         '__MAP_HTML__': project_maps_ui.HTML,
         '__MAP_SCRIPT__': project_maps_ui.SCRIPT,
+        '__I18N__': i18n.page_script(setup_ui.SETUP_TOKEN),
     }
     return re.sub('|'.join(re.escape(key) for key in values), lambda m:values[m[0]], _MAP_WINDOW)
 
 
 _MAP_WINDOW = r'''<!doctype html>
 <html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
-<meta name="setup-token" content="__TOKEN__"><title>Project maps · Smart Tool</title><style>
+<meta name="setup-token" content="__TOKEN__"><title>Project maps · Smart Tool</title>__I18N__<style>
 __STYLE__
 body.map-window{padding:0}.map-window header,.map-window main{max-width:none}.map-window header{padding:22px 28px 14px}.map-window main{padding:0 20px 30px}.map-window h1{font-size:22px}.map-window #window-root{margin:6px 0 0;font-size:12px;overflow-wrap:anywhere}.map-window .maps{margin-top:0}.map-window .maps>summary{display:none}.map-window .maps-workspace{grid-template-columns:minmax(0,1fr) 285px}.map-window #maps-svg{height:calc(100vh - 360px);min-height:430px}.map-window .maps-tools #maps-new-window{display:none}.map-window #maps-color-legend{max-height:90px}.map-window #window-message:empty{display:none}.map-window #window-message{margin-bottom:14px;overflow-wrap:anywhere}
 @media(max-width:850px){.map-window .maps-workspace{grid-template-columns:1fr}.map-window header{padding-inline:18px}.map-window main{padding-inline:12px}.map-window #maps-svg{height:450px;min-height:0}}
@@ -51,6 +55,7 @@ _PAGE = r'''<!doctype html>
 <html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
 <meta name="setup-token" content="__TOKEN__">
 <title>Projects and indexing · Smart Tool</title>
+__I18N__
 <style>
 :root{color-scheme:light dark;--bg:#f6f7f9;--surface:#fff;--border:#dde1e6;--ink:#1b2430;--muted:#5b6472;--accent:#2f6fed;--good:#18723c;--bad:#b52c2c;--warn:#805300;--selected:#eaf1ff}
 @media(prefers-color-scheme:dark){:root{--bg:#14171c;--surface:#1c2027;--border:#39414e;--ink:#e6e9ee;--muted:#a6afbb;--accent:#91baff;--good:#68dc93;--bad:#ff9696;--warn:#e0b565;--selected:#263751}}
@@ -96,7 +101,7 @@ function setAdd(open){const restore=$('add-form').contains(document.activeElemen
 function select(id){selected=id;scopeKey='';scopeDirty=false;window.SmartMaps?.reset();window.SmartInsights?.reset();history.replaceState(null,'','#'+id);render()}
 function jobsHtml(rows){return rows.map(j=>`<div class="job"><div class="job-line"><strong>${esc(kindNames[j.kind]||j.kind)}</strong><span class="state ${j.status==='error'?'bad':''}">${esc(states[j.status]||j.status)}</span></div>${j.message?`<p>${esc(j.cancel_requested?'Cancellation requested; waiting for the current call to finish.':j.message)}</p>`:''}${j.status==='pending'?`<progress aria-label="Indexing progress" ${j.total_files>0&&j.processed_files!=null?`max="${j.total_files}" value="${j.processed_files}"`:''}></progress>`:''}${j.error?`<p class="state bad">${esc(j.error)}</p>`:''}${j.warning?`<p>${esc(j.warning)}</p>`:''}<small>${esc(j.job_id)}${j.elapsed_s!=null?' · '+j.elapsed_s+' s':''}</small></div>`).join('')}
 function render(){
- $('count').textContent=projects.length+' folder'+(projects.length===1?' registered':'s registered');
+ $('count').textContent=projects.length===1?'1 folder registered':projects.length+' folders registered';
  const list=$('project-list');
  for(const node of [...list.children])if(!projects.some(p=>p.id===node.dataset.project))node.remove();
  for(const p of projects){let button=list.querySelector(`[data-project="${p.id}"]`);if(!button){button=document.createElement('button');button.className='project-item';button.dataset.project=p.id;button.append(document.createElement('strong'),document.createElement('small'));list.append(button)}button.setAttribute('aria-current',String(p.id===selected));button.firstChild.textContent=p.name;button.lastChild.textContent=(states[p.status]||p.status)+(p.watch&&!p.paused?' · Watching':'')}

package/setup_audit.py

@@ -31,6 +31,7 @@ import yaml
 
 import atomic_io
 import endpoint_sync
+import i18n
 import paths
 
 REPORT_DIR = os.path.join(paths.DATA_DIR, "setup-audit")
@@ -904,13 +905,14 @@ def notices_due():
 
 
 def toast_text(row):
-    """(title, lines) of the toast for one `notices_due` row."""
+    """(title, lines) of the toast for one `notices_due` row, in the interface language."""
     total = row["errors"] + row["warnings"]
-    title = f"Setup audit: {total} new problem{'s' if total != 1 else ''} in the agent configuration"
+    title = (i18n.t("Setup audit: 1 new problem in the agent configuration") if total == 1
+             else i18n.t("Setup audit: {count} new problems in the agent configuration", count=total))
     lines = [os.path.basename(row["project"].rstrip("\\/")) or row["project"]]
     lines += [f"{item['severity']}: {item['check']} - {item['subject']}"[:120] for item in row["items"][:3]]
     if len(row["items"]) > 3:
-        lines.append(f"and {len(row['items']) - 3} more")
+        lines.append(i18n.t("and {count} more", count=len(row["items"]) - 3))
     return title, lines
 
 

package/setup_ui.py

@@ -28,6 +28,7 @@ import config
 import daemon_launcher
 import endpoint_sync
 import gateway
+import i18n
 import model_catalog
 import model_defaults
 import model_health
@@ -101,6 +102,7 @@ def render_setup_page():
         # Único valor que entra no corpo do HTML, e não no <script>: escapado porque vem
         # de variável de ambiente, ainda que só quem já executa código possa definí-la.
         "__SETUP_ORIGIN__": html.escape(setup_origin(), quote=True),
+        "__I18N__": i18n.page_script(SETUP_TOKEN),
     }
     # Um único passe sobre o template original: .replace() encadeado re-escanearia o
     # próprio resultado e corromperia o JSON se um valor coincidisse com o outro placeholder.
@@ -419,6 +421,16 @@ def handle_providers_save(body):
             "validated_results": validated}
 
 
+def handle_language_save(body):
+    """Saves the interface language the language button picked; returns {"language": <saved>}."""
+    if not isinstance(body, dict):
+        raise SetupError("Request body must be a JSON object with 'language'.")
+    try:
+        return {"language": i18n.set_language(body.get("language"))}
+    except ValueError as exc:
+        raise SetupError(str(exc)) from exc
+
+
 def handle_autostart_get():
     return autostart.status()
 
@@ -494,6 +506,7 @@ _PAGE_TEMPLATE = """<!doctype html>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <title>Settings · Smart Tool</title>
+__I18N__
 <style>
   :root { color-scheme: light dark;
     --bg: #f6f7f9; --surface: #ffffff; --line: #dde1e6; --ink: #1b2430; --muted: #5b6472; --soft: #eef1f5;
@@ -665,7 +678,7 @@ _PAGE_TEMPLATE = """<!doctype html>
 </head>
 <body>
 <header class="top">
-  <div><h1>Smart Tool settings</h1><span class="where">__SETUP_ORIGIN__ · version <span id="app-version"></span></span></div>
+  <div><h1>Smart Tool settings</h1><span class="where">__SETUP_ORIGIN__ · <span>Version</span> <span id="app-version"></span></span></div>
   <nav><a href="/projects">Projects and indexing →</a></nav>
 </header>
 <div class="shell">
@@ -1010,7 +1023,7 @@ function renderOverview() {
     badge.hidden = !entry;
     badge.textContent = entry ? entry.count : "";
     badge.dataset.tone = entry && entry.bad ? "bad" : "warn";
-    badge.title = entry ? plural(entry.count, "item") + (entry.count === 1 ? " needs" : " need") + " attention" : "";
+    badge.title = !entry ? "" : entry.count === 1 ? "1 item needs attention" : entry.count + " items need attention";
   }
 }
 

package/smart_tool_daemon.py

@@ -4163,6 +4163,7 @@ _SETUP_SAVES = {
     "/setup/gateway": setup_ui.handle_gateway_save,
     "/setup/autostart": setup_ui.handle_autostart_action,
     "/setup/contact": setup_ui.handle_contact_save,
+    "/setup/language": setup_ui.handle_language_save,
     "/setup/audit": setup_ui.handle_audit,
 }
 

package/toast_notice.py

@@ -74,13 +74,14 @@ def action_uri(action, **params):
 
 
 def toast_xml(title, lines, buttons):
-    """`buttons` is a list of (label, uri); each one launches its protocol link and closes the toast."""
+    """`buttons` is a list of (label, uri); each one launches its protocol link and closes the toast. An empty list
+    gives a toast without an actions element."""
     text = "".join(f"<text>{escape(line)}</text>" for line in [title, *lines])
     actions = "".join(
         f'<action content={quoteattr(label)} arguments={quoteattr(uri)} activationType="protocol"/>'
         for label, uri in buttons)
     return (f'<toast><visual><binding template="ToastGeneric">{text}</binding></visual>'
-            f'<actions>{actions}</actions></toast>')
+            + (f'<actions>{actions}</actions>' if actions else '') + '</toast>')
 
 
 def show(title, lines, buttons, tag=None):

package/tray.py

@@ -22,6 +22,7 @@ sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 import autostart
 import config
 import daemon_launcher
+import i18n
 import setup_audit
 import toast_notice
 import update_check
@@ -60,14 +61,14 @@ _ICONS = {
 }
 
 _TITLES = {
-    "ok": "Smart Tool - daemon running",
-    "starting": "Smart Tool - starting the daemon...",
-    "needs_key": "Smart Tool - model gateway unavailable",
-    "needs_models": "Smart Tool - choose the models in settings",
-    "catalog_unavailable": "Smart Tool - model catalog unavailable",
-    "config_corrupt": "Smart Tool - settings file has an error",
-    "status_error": "Smart Tool - failed to read the settings",
-    "down": "Smart Tool - daemon down",
+    "ok": i18n.N_("Smart Tool - running"),
+    "starting": i18n.N_("Smart Tool - starting..."),
+    "needs_key": i18n.N_("Smart Tool - model gateway unavailable"),
+    "needs_models": i18n.N_("Smart Tool - choose the models in settings"),
+    "catalog_unavailable": i18n.N_("Smart Tool - model catalog unavailable"),
+    "config_corrupt": i18n.N_("Smart Tool - settings file has an error"),
+    "status_error": i18n.N_("Smart Tool - failed to read the settings"),
+    "down": i18n.N_("Smart Tool - stopped"),
 }
 
 
@@ -78,7 +79,30 @@ def _set_state(health, icon=None):
         _state["health"] = health
     if icon is not None:
         icon.icon = _ICONS[health]
-        icon.title = _TITLES[health]
+        icon.title = i18n.t(_TITLES[health])
+
+
+def _notify(icon, text, **values):
+    """Windows notification, translated (text is an English catalog key). A toast under Smart Tool's own app id,
+    since the tray balloon is shown as "Python"; when Windows refuses the toast, the balloon carries the text and the
+    refusal."""
+    message = i18n.t(text, **values)
+    try:
+        toast_notice.show("Smart Tool", [message], [])
+    except Exception as exc:
+        icon.notify(f"{message} ({exc})", "Smart Tool")
+
+
+def _follow_language(icon):
+    """Redraws the menu and the tooltip after the language changed here or in a settings page."""
+    try:
+        current = i18n.language()
+    except Exception:
+        return
+    if _state.get("language") != current:
+        _state["language"] = current
+        icon.title = i18n.t(_TITLES[_state["health"]])
+        icon.update_menu()
 
 
 def _configuration_state(url):
@@ -111,6 +135,7 @@ def _poll_loop(icon):
                 _set_state("status_error", icon)
         except Exception:
             _set_state("down", icon)
+        _follow_language(icon)
         time.sleep(POLL_INTERVAL_S)
 
 
@@ -121,19 +146,22 @@ def _show_notices(icon, notices):
     if offer:
         lines = [f"{role}: {change['current']} -> {change['new']}" for role, change in offer["changes"].items()]
         nonce = offer["nonce"]
-        toast_notice.show("Smart Tool has new recommended models", lines, [
-            ("Apply now", toast_notice.action_uri("models-apply", n=nonce)),
-            ("Don't show again", toast_notice.action_uri("models-decline", n=nonce)),
+        toast_notice.show(i18n.t("Smart Tool has new recommended models"), lines, [
+            (i18n.t("Apply now"), toast_notice.action_uri("models-apply", n=nonce)),
+            (i18n.t("Don't show again"), toast_notice.action_uri("models-decline", n=nonce)),
         ], tag="models-upgrade")
     for row in notices.get("failing") or []:
-        last = row.get("last_error") or "see the failure log in the settings"
+        last = row.get("last_error") or i18n.t("see the failure log in the settings")
         toast_notice.show(
-            f"{row['model']} is failing", [f"{row['errors']} of {row['calls']} calls failed in 24 h as {row['role']}.", last[:160]],
-            [("Switch model", toast_notice.action_uri("open-setup", section="models")),
-             ("Mute 7 days", toast_notice.action_uri("mute-model", model=row["model"]))], tag="model-failing:" + row["model"])
+            i18n.t("{model} is failing", model=row["model"]),
+            [i18n.t("{errors} of {calls} calls failed in 24 h as {role}.", errors=row["errors"], calls=row["calls"],
+                    role=row["role"]), last[:160]],
+            [(i18n.t("Switch model"), toast_notice.action_uri("open-setup", section="models")),
+             (i18n.t("Mute 7 days"), toast_notice.action_uri("mute-model", model=row["model"]))],
+            tag="model-failing:" + row["model"])
     for row in notices.get("audit") or []:
         title, lines = setup_audit.toast_text(row)
-        toast_notice.show(title, lines, [("Open the audit", toast_notice.action_uri("open-setup", section="audit"))],
+        toast_notice.show(title, lines, [(i18n.t("Open the audit"), toast_notice.action_uri("open-setup", section="audit"))],
                           tag="setup-audit:" + row["project"])
 
 
@@ -151,19 +179,19 @@ def _notice_loop(icon):
         except Exception as exc:
             if str(exc) != _state.get("notice_error"):
                 _state["notice_error"] = str(exc)
-                icon.notify(f"Could not show a Smart Tool notice: {exc}", "Smart Tool")
+                _notify(icon, "Could not show a Smart Tool notice: {error}", error=exc)
         time.sleep(NOTICE_INTERVAL_S)
 
 
 def _announce_start(icon):
     """Tells the user, once per start, that Smart Tool was just updated or that the last automatic update failed."""
-    updated = update_check.note_running_version()
+    updated = update_check.update_for_tray()
     if updated:
-        icon.notify(f"Smart Tool updated from {updated['from']} to {updated['to']}.", "Smart Tool")
+        _notify(icon, "Smart Tool updated from {old} to {new}.", old=updated["from"], new=updated["to"])
     failed = update_check.failed_update()
     if failed:
-        icon.notify(f"The update to {failed} failed; Smart Tool {version.VERSION} is still installed. "
-                    "It is tried again in 24 h, or now from this menu.", "Smart Tool")
+        _notify(icon, "The update to {target} failed; Smart Tool {version} is still installed. It is tried again in "
+                "24 h, or now from this menu.", target=failed, version=version.VERSION)
 
 
 def _update_loop(icon):
@@ -172,7 +200,7 @@ def _update_loop(icon):
     try:
         _announce_start(icon)
     except Exception as exc:
-        icon.notify(f"Could not read the update state: {exc}", "Smart Tool")
+        _notify(icon, "Could not read the update state: {error}", error=exc)
     while True:
         try:
             latest = update_check.newer_version()
@@ -182,7 +210,7 @@ def _update_loop(icon):
             try:
                 update_check.record_check(latest)
             except Exception as exc:
-                icon.notify(f"Could not save the update check: {exc}", "Smart Tool")
+                _notify(icon, "Could not save the update check: {error}", error=exc)
         if latest:
             known = latest == _state["update"]
             _state["update"] = latest
@@ -191,38 +219,44 @@ def _update_loop(icon):
                 automatic = update_check.automatic_enabled() and update_check.should_auto_update(latest)
             except Exception as exc:
                 automatic = False
-                icon.notify(f"Automatic update skipped: {exc}", "Smart Tool")
+                _notify(icon, "Automatic update skipped: {error}", error=exc)
             if automatic:
-                icon.notify(f"Updating Smart Tool from {version.VERSION} to {latest}...", "Smart Tool")
+                _notify(icon, "Updating Smart Tool from {old} to {new}...", old=version.VERSION, new=latest)
                 update_check.run_update(latest, automatic=True)
             elif not known:
-                icon.notify(f"Smart Tool {latest} is available: use \"Update to {latest}\" in this menu.", "Smart Tool")
+                _notify(icon, "Smart Tool {version} is available: use \"Update to {version}\" in this menu.",
+                        version=latest)
         time.sleep(UPDATE_CHECK_INTERVAL_S)
 
 
 def _update_label(item):
-    return f"Update to {_state['update']}" if _state["update"] else "Check for updates"
+    return i18n.t("Update to {version}", version=_state["update"]) if _state["update"] else i18n.t("Check for updates")
 
 
 _update_busy = threading.Lock()
 
 
 def _update_now(icon, item):
-    """Menu action: installs the known newer version, or checks npm first and says when there is none."""
+    """Menu action: installs the known newer version, or checks npm first (telling the user it is checking) and says
+    when there is none."""
     if not _update_busy.acquire(blocking=False):
         return
 
     def run():
         try:
-            latest = _state["update"] or update_check.newer_version()
+            latest = _state["update"]
             if not latest:
-                icon.notify(f"Smart Tool {version.VERSION} is the latest version.", "Smart Tool")
+                _notify(icon, "Checking for updates…")
+                latest = update_check.newer_version()
+            if not latest:
+                _notify(icon, "Smart Tool {version} is the latest version.", version=version.VERSION)
                 return
             _state["update"] = latest
             icon.update_menu()
+            _notify(icon, "Updating Smart Tool from {old} to {new}...", old=version.VERSION, new=latest)
             update_check.run_update(latest, automatic=False)
         except Exception as exc:
-            icon.notify(f"Could not update: {exc}", "Smart Tool")
+            _notify(icon, "Could not update: {error}", error=exc)
         finally:
             _update_busy.release()
     threading.Thread(target=run, daemon=True).start()
@@ -237,16 +271,34 @@ def _auto_update_checked(item):
 
 def _toggle_auto_update(icon, item):
     if update_check.env_opted_out():
-        icon.notify(f"{update_check.ENV_OPT_OUT}=off is set: automatic updates stay off until it is removed.",
-                    "Smart Tool")
+        _notify(icon, "{name}=off is set: automatic updates stay off until it is removed.", name=update_check.ENV_OPT_OUT)
         return
     try:
         config.update_config(lambda cfg: cfg.__setitem__("auto_update", not config.auto_update(cfg)))
     except Exception as exc:
-        icon.notify(f"Could not change automatic updates: {exc}", "Smart Tool")
+        _notify(icon, "Could not change automatic updates: {error}", error=exc)
     icon.update_menu()
 
 
+def _language_checked(lang):
+    def checked(item):
+        try:
+            return i18n.language() == lang
+        except Exception:
+            return False
+    return checked
+
+
+def _choose_language(lang):
+    def choose(icon, item):
+        try:
+            i18n.set_language(lang)
+        except Exception as exc:
+            _notify(icon, "Could not change the language: {error}", error=exc)
+        _follow_language(icon)
+    return choose
+
+
 def _open_setup(icon, item):
     registry = daemon_launcher.read_registry()
     webbrowser.open((registry["url"].rstrip("/") + "/setup") if registry else SETUP_URL)
@@ -258,7 +310,7 @@ def _open_projects(icon, item):
             url = daemon_launcher.ensure_daemon_running()
             webbrowser.open(url.rstrip("/") + "/projects")
         except Exception as exc:
-            icon.notify(f"Could not open the projects: {exc}", "Smart Tool")
+            _notify(icon, "Could not open the projects: {error}", error=i18n.t(str(exc)))
     threading.Thread(target=run, daemon=True).start()
 
 
@@ -268,7 +320,7 @@ def _add_project(icon, item):
             import folder_picker
             folder_picker.register_from_tray()
         except Exception as exc:
-            icon.notify(f"Could not select the folder: {exc}", "Smart Tool")
+            _notify(icon, "Could not select the folder: {error}", error=exc)
     threading.Thread(target=run, daemon=True).start()
 
 
@@ -293,12 +345,10 @@ def _toggle_autostart(icon, item):
             else:
                 result = autostart.install()
                 if result.get("method") == "startup_folder" and result.get("fallback_reason"):
-                    icon.notify(
-                        f"Scheduled Task unavailable ({result['fallback_reason']}); using the Startup folder.",
-                        "Smart Tool",
-                    )
+                    _notify(icon, "Scheduled Task unavailable ({reason}); using the Startup folder.",
+                            reason=result["fallback_reason"])
         except Exception as exc:
-            icon.notify(f"Failed to change automatic start: {exc}", "Smart Tool")
+            _notify(icon, "Failed to change automatic start: {error}", error=exc)
         finally:
             _autostart_busy.release()
             icon.update_menu()
@@ -332,18 +382,25 @@ def main():
     handle = _single_instance_handle()
     if handle is False:
         return
+    _state["language"] = i18n.language()
     icon = pystray.Icon(
         "smart-tool",
         icon=_ICONS["starting"],
-        title=_TITLES["starting"],
+        title=i18n.t(_TITLES["starting"]),
         menu=pystray.Menu(
-            pystray.MenuItem("Projects and indexing…", _open_projects, default=True),
-            pystray.MenuItem("Index a folder…", _add_project),
-            pystray.MenuItem("Open settings", _open_setup),
-            pystray.MenuItem("Start with Windows", _toggle_autostart, checked=_autostart_checked),
+            pystray.MenuItem(lambda item: i18n.t("Projects and indexing…"), _open_projects, default=True),
+            pystray.MenuItem(lambda item: i18n.t("Index a folder…"), _add_project),
+            pystray.MenuItem(lambda item: i18n.t("Open settings"), _open_setup),
+            pystray.MenuItem(lambda item: i18n.t("Start with Windows"), _toggle_autostart, checked=_autostart_checked),
             pystray.MenuItem(_update_label, _update_now),
-            pystray.MenuItem("Update automatically", _toggle_auto_update, checked=_auto_update_checked),
-            pystray.MenuItem("Quit", _quit),
+            pystray.MenuItem(lambda item: i18n.t("Update automatically"), _toggle_auto_update,
+                             checked=_auto_update_checked),
+            pystray.MenuItem("Idioma / Language", pystray.Menu(
+                pystray.MenuItem("Português (Brasil)", _choose_language("pt-BR"), checked=_language_checked("pt-BR"),
+                                 radio=True),
+                pystray.MenuItem("English", _choose_language("en"), checked=_language_checked("en"), radio=True),
+            )),
+            pystray.MenuItem(lambda item: i18n.t("Quit"), _quit),
         ),
     )
     threading.Thread(target=_poll_loop, args=(icon,), daemon=True).start()

package/update_check.py

@@ -1,5 +1,6 @@
 """Newer Smart Tool release on npm and the update itself: the tray checks npm at start and every 24 h and, when
-automatic updates are on (the default), runs the same install command a user would, in a visible console. A failed
+automatic updates are on (the default), runs the same install command a user would, behind the update screen
+(update_splash.py) and with no console window. A failed
 version is tried again after 24 h. What happened (newer version available, updated, update failed) is told to the
 user by the tray and to agent sessions by the daemon, from the state file, without contacting npm again.
 
@@ -8,12 +9,12 @@ newer-version notice still shows then, with the command to update by hand."""
 import json
 import os
 import subprocess
+import sys
 import time
 import urllib.request
 
 import atomic_io
 import config
-import node_locator
 import paths
 import version
 
@@ -102,6 +103,22 @@ def note_running_version(now=None):
     return found
 
 
+def update_for_tray(now=None):
+    """The update record (from, to, at) of the running version the first time the tray asks, whether the tray or the
+    daemon started first and recorded it; None when there is none, it is older than the updated notice, or the tray
+    already told it."""
+    note_running_version(now)
+    now = now or time.time()
+    state = _state()
+    updated = state.get("updated") or {}
+    if (updated.get("to") != version.VERSION or state.get("tray_told") == version.VERSION
+            or now - updated.get("at", 0) >= UPDATED_NOTICE_S):
+        return None
+    state["tray_told"] = version.VERSION
+    _save(state)
+    return updated
+
+
 def failed_update():
     """The version an automatic update went for and did not install (the previous version is still running), else
     None."""
@@ -136,15 +153,16 @@ 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. 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."""
+    """Starts the update screen (update_splash.py) detached from the tray, which the installer stops and restarts:
+    it runs the install command with no console window and shows each step and the result. npx is looked up by the
+    screen when it starts, not in the PATH the tray was born with."""
     if automatic:
         state = _state()
         state.update(attempted=latest, at=time.time())
         _save(state)
-    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("~"), env=node_locator.environment(prefer=node_locator.which("npx.cmd")))
+    folder = os.path.dirname(os.path.abspath(__file__))
+    pythonw = os.path.join(os.path.dirname(sys.executable), "pythonw.exe")
+    flags = getattr(subprocess, "DETACHED_PROCESS", 0) | getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0)
+    subprocess.Popen([pythonw if os.path.isfile(pythonw) else sys.executable, os.path.join(folder, "update_splash.py"),
+                      latest], creationflags=flags, close_fds=True, cwd=folder, stdin=subprocess.DEVNULL,
+                     stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)