@allansantos-dev/smart-tool 0.9.43 → 0.9.46

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)

package/update_splash.py

@@ -0,0 +1,197 @@
+"""Update screen: a small window with no buttons that runs the update with no console window and shows each step in
+the interface language, then the result. Started by the tray (update_check.run_update) as `pythonw update_splash.py
+<version>`; it outlives the tray, which the installer stops and starts again.
+
+The install command runs with CREATE_NO_WINDOW, so it and every console program it starts (node, the installer,
+pip, PowerShell, schtasks) share one hidden console. Its output goes to UPDATE_LOG; a failure shows the last line,
+the log path and a Windows notification, and the installer has already restored the previous version."""
+import os
+import queue
+import subprocess
+import sys
+import threading
+import time
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import i18n
+import node_locator
+import paths
+import toast_notice
+import update_check
+import version
+
+UPDATE_LOG = os.path.join(paths.DATA_DIR, "update.log")
+TIMEOUT_S = 20 * 60
+SUCCESS_CLOSE_MS = 4000
+FAILURE_CLOSE_MS = 15000
+MUTEX_NAME = "Local\\SmartToolUpdate"
+NO_WINDOW = getattr(subprocess, "CREATE_NO_WINDOW", 0)
+STEPS = (
+    ("Downloading uv", i18n.N_("Downloading components…")),
+    ("Preparing Python", i18n.N_("Preparing Python…")),
+    ("TLS inspection", i18n.N_("Preparing Python…")),
+    ("Older Smart Tool installation found", i18n.N_("Removing an older installation…")),
+    ("Updating Smart Tool at", i18n.N_("Copying the new files…")),
+    ("Installing Smart Tool at", i18n.N_("Copying the new files…")),
+    ("Files changed:", i18n.N_("Installing dependencies…")),
+    ("Browser control", i18n.N_("Checking browser control…")),
+    ("Failed:", i18n.N_("Restoring the previous version…")),
+)
+
+
+def step_for(line):
+    """English catalog key of the step an installer output line starts, or None."""
+    for marker, step in STEPS:
+        if marker in line:
+            return step
+    return None
+
+
+def install_command():
+    """argv of the update: the same npx command a user types, through cmd.exe because npx is a .cmd script."""
+    npx = node_locator.which("npx.cmd")
+    if not npx:
+        raise RuntimeError(i18n.t("Node.js (npx) was not found; install Node.js and try again."))
+    return ["cmd.exe", "/d", "/c", npx, "--yes", f"{update_check.PACKAGE}@latest", "install"], npx
+
+
+def run_install(lines):
+    """Runs the install command hidden, puts each output line on `lines`, writes them to UPDATE_LOG and returns
+    (exit code, last non-empty line). Kills the whole process tree after TIMEOUT_S."""
+    command, npx = install_command()
+    os.makedirs(os.path.dirname(UPDATE_LOG), exist_ok=True)
+    last = ""
+    with open(UPDATE_LOG, "w", encoding="utf-8") as log:
+        log.write(f"{time.strftime('%Y-%m-%d %H:%M:%S')} {' '.join(command)}\n")
+        with subprocess.Popen(command, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+                              text=True, encoding="utf-8", errors="replace", creationflags=NO_WINDOW,
+                              cwd=os.path.expanduser("~"), env=node_locator.environment(prefer=npx)) as proc:
+            timer = threading.Timer(TIMEOUT_S, lambda: subprocess.run(
+                ["taskkill", "/PID", str(proc.pid), "/T", "/F"], capture_output=True, creationflags=NO_WINDOW))
+            timer.start()
+            try:
+                for line in proc.stdout:
+                    log.write(line)
+                    log.flush()
+                    if line.strip():
+                        last = line.strip()
+                        lines.put(last)
+                code = proc.wait()
+            finally:
+                timer.cancel()
+        log.write(f"{time.strftime('%Y-%m-%d %H:%M:%S')} exit {code}\n")
+    return code, last
+
+
+def _single_instance():
+    """True when no other update screen is running (a named mutex held for the life of this process)."""
+    if sys.platform != "win32":
+        return True
+    import ctypes
+    kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
+    kernel32.CreateMutexW.restype = ctypes.c_void_p
+    handle = kernel32.CreateMutexW(None, False, MUTEX_NAME)
+    return bool(handle) and ctypes.get_last_error() != 183
+
+
+class Splash:
+    """The window: product name, the version change, the current step, a moving bar; no buttons and no close box."""
+
+    def __init__(self, target):
+        import tkinter as tk
+        from tkinter import ttk
+        self.tk = tk
+        self.root = root = tk.Tk()
+        root.withdraw()
+        root.title("Smart Tool")
+        root.overrideredirect(True)
+        root.attributes("-topmost", True)
+        root.protocol("WM_DELETE_WINDOW", lambda: None)
+        width, height = 500, 236
+        root.geometry(f"{width}x{height}+{(root.winfo_screenwidth() - width) // 2}+{(root.winfo_screenheight() - height) // 3}")
+        frame = tk.Frame(root, bg="#ffffff", highlightthickness=1, highlightbackground="#c9d2df")
+        frame.pack(fill="both", expand=True)
+        tk.Frame(frame, bg="#2f6fed", height=6).pack(fill="x")
+        body = tk.Frame(frame, bg="#ffffff", padx=28, pady=18)
+        body.pack(fill="both", expand=True)
+        tk.Label(body, text="Smart Tool", bg="#ffffff", fg="#2f6fed", font=("Segoe UI Semibold", 11)).pack(anchor="w")
+        self.title = tk.Label(body, text=i18n.t("Updating Smart Tool"), bg="#ffffff", fg="#1b2430",
+                              font=("Segoe UI Semibold", 17))
+        self.title.pack(anchor="w", pady=(2, 0))
+        tk.Label(body, text=i18n.t("Version {old} → {new}", old=version.VERSION, new=target), bg="#ffffff",
+                 fg="#5b6472", font=("Segoe UI", 10)).pack(anchor="w")
+        style = ttk.Style(root)
+        style.theme_use("clam")
+        style.configure("Smart.Horizontal.TProgressbar", troughcolor="#e8edf5", background="#2f6fed",
+                        bordercolor="#e8edf5", lightcolor="#2f6fed", darkcolor="#2f6fed")
+        self.bar = ttk.Progressbar(body, mode="indeterminate", style="Smart.Horizontal.TProgressbar", length=444)
+        self.bar.pack(anchor="w", pady=(16, 8))
+        self.bar.start(12)
+        self.step = tk.Label(body, text=i18n.t("Downloading version {version}…", version=target), bg="#ffffff",
+                             fg="#1b2430", font=("Segoe UI", 10), anchor="w", justify="left", wraplength=444)
+        self.step.pack(anchor="w", fill="x")
+        self.note = tk.Label(body, text=i18n.t("This can take a few minutes. You do not need to do anything."),
+                             bg="#ffffff", fg="#5b6472", font=("Segoe UI", 9), anchor="w", justify="left",
+                             wraplength=444)
+        self.note.pack(anchor="w", fill="x", pady=(6, 0))
+        root.deiconify()
+
+    def show_step(self, key):
+        self.step.config(text=i18n.t(key))
+
+    def finish(self, ok, title, detail, note):
+        self.bar.stop()
+        self.bar.config(mode="determinate", maximum=100, value=100 if ok else 0)
+        self.title.config(text=title, fg="#18723c" if ok else "#b52c2c")
+        self.step.config(text=detail)
+        self.note.config(text=note)
+        self.root.after(SUCCESS_CLOSE_MS if ok else FAILURE_CLOSE_MS, self.root.destroy)
+
+
+def main(argv):
+    """Shows the screen, runs the update and reports the outcome; returns the installer's exit code."""
+    target = argv[1] if len(argv) > 1 else "latest"
+    if not _single_instance():
+        return 0
+    splash = Splash(target)
+    lines, outcome = queue.Queue(), {}
+
+    def work():
+        try:
+            outcome["code"], outcome["last"] = run_install(lines)
+        except Exception as exc:
+            outcome["code"], outcome["last"] = 1, f"{type(exc).__name__}: {exc}"
+
+    worker = threading.Thread(target=work, daemon=True)
+    worker.start()
+
+    def pump():
+        while not lines.empty():
+            step = step_for(lines.get_nowait())
+            if step:
+                splash.show_step(step)
+        if worker.is_alive():
+            splash.root.after(200, pump)
+            return
+        if outcome["code"] == 0:
+            splash.finish(True, i18n.t("Smart Tool updated"),
+                          i18n.t("Version {version} is installed and running.", version=target),
+                          i18n.t("This window closes by itself."))
+            return
+        detail = i18n.t("The update did not finish; version {version} is still installed.", version=version.VERSION)
+        splash.finish(False, i18n.t("Update not finished"), f"{detail}\n{outcome['last'][:180]}",
+                      i18n.t("Details in {path}", path=UPDATE_LOG))
+        try:
+            toast_notice.show(i18n.t("Smart Tool update not finished"), [detail, i18n.t("Details in {path}", path=UPDATE_LOG)],
+                              [], tag="update-failed")
+        except Exception as exc:
+            splash.note.config(text=f"{splash.note.cget('text')}\n{exc}")
+
+    splash.root.after(200, pump)
+    splash.root.mainloop()
+    worker.join(timeout=1)
+    return outcome.get("code", 1)
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))

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.43"
+VERSION = "0.9.46"
 _CONTACT_RE = re.compile(r"^(?:[^\s@()<>;]+@[^\s@()<>;]+\.[^\s@()<>;]+|https?://[^\s()<>;]+)$")
 
 

package/web_search_health.py

@@ -24,14 +24,17 @@ _LOCK = threading.Lock()
 OUTCOMES = ("ok", "failed", "rate_limited", "captcha", "paused")
 
 
-def record(tier_name, success, outcome=None):
+def record(tier_name, success, outcome=None, requester=None):
     """One tier call: outcome tells a provider 429 (rate_limited), a captcha and a self-imposed quota pause (paused,
-    left out of success rates) apart from an ordinary failure, so quota pressure can be read from the log."""
+    left out of success rates) apart from an ordinary failure, so quota pressure can be read from the log. requester
+    (requester.claim) says which session asked, never what."""
     outcome = outcome or ("ok" if success else "failed")
     if outcome not in OUTCOMES:
         raise ValueError(f"Unknown web search outcome: {outcome}")
     os.makedirs(os.path.dirname(HEALTH_PATH), exist_ok=True)
     entry = {"ts": time.time(), "tier": tier_name, "success": bool(success), "outcome": outcome}
+    if requester:
+        entry["requester"] = requester
     with _LOCK:
         with open(HEALTH_PATH, "a", encoding="utf-8") as f:
             f.write(json.dumps(entry, ensure_ascii=False) + "\n")