cli-tools-kit 1.0.0__tar.gz → 1.1.1__tar.gz

{cli_tools_kit-1.0.0 → cli_tools_kit-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cli-tools-kit
-Version: 1.0.0
+Version: 1.1.1
 Summary: Installer protocol + helpers for self-installing Python CLI/GUI tools (desktop shortcuts, bash aliases, cron entries), plus reusable tkinter and curses installer screens
 Author: Steffen Probst
 License: MIT License
@@ -305,23 +305,52 @@ Keyword-only; every argument defaults to `None`, meaning "leave the default".
 | `notify_app` | identity's | `notify-send` application label on the `--check` path. |
 | `autostart_check_desktop_name`, `check_log_name`, `check_state_name` | identity's | Login-check artifact filenames. |
 | `hooks` | `None` | `InstallHooks(install_tool=…, remove_tool=…, install_skill=…, uninstall_skill=…)`: replace how one tool is installed, for a wrapper that builds a venv per tool. A field left `None` keeps the kit's own. |
+| `upgrade_repos` | `[]` | `(name, path)` of the tool repos an upgrade may pull. `sources.run_installer` fills it with the repos it cloned. See "Upgrades" below. |
 
 The identity is applied first and these individual names override it, so you can
 take the whole namespace from a slug and still change one thing.
 
 `run()` owns its own `argparse` and consumes `sys.argv`: `--list`, `--check`,
-`--enable-autostart-check`, `--install`, `--update-all`, `--cleanup`, `--tui`,
-`--gui`, and a screen when given none of them. A wrapper that needs its own
+`--enable-autostart-check`, `--install`, `--update-all`, `--upgrade`, `--cleanup`,
+`--tui`, `--gui`, and a screen when given none of them. A wrapper that needs its own
 subcommands should skip `run()` and call the primitives (`discover_tools`,
 `install_tool`, `remove_tool`, `cli_check`) after applying an identity with
 `_apply_identity`.
 
+### Upgrades
+
+When the window or the text screen opens, the installer checks in the
+background whether anything it runs is out of date:
+
+- the installer's own checkout (the git repo `entry_script` is in) is behind
+  its upstream;
+- a tool repo in `upgrade_repos` is behind its upstream;
+- pip would install a newer cli-tools-kit within the installer's pin. The pin is
+  the `requirements.txt` next to `entry_script` when it names the kit, else
+  anything below the next major version.
+
+If something is, a strip above the table lists it with an Upgrade button (on
+the text screen, a log line and the `u` key). Upgrade pulls the repos with `git
+pull --ff-only`, runs `pip install --upgrade` for the kit, reinstalls the
+installed tools of each pulled repo, and starts the installer again with its
+original command line so the new code is loaded. `--upgrade` does the same
+from a script, checking at once and without the restart.
+
+The network is used at most once a day: one `git fetch` per repo and one `pip
+install --dry-run`, cached under the identity's cache directory. The
+comparison with what is on disk runs on every start, so a repo pulled by hand
+stops showing at once. Git never asks for a password here; a private repo
+without stored credentials is skipped. The kit is left alone when it runs from
+a development checkout or outside a virtual environment. `--check` never runs
+any of this, so the login check stays network-free.
+
 ### The text screen
 
 Without a display (`DISPLAY`/`WAYLAND_DISPLAY` unset: SSH, WSL, a server) or
 without `python3-tk`, `run()` opens a curses screen instead of the tkinter
 window; `--tui` and `--gui` force either. Same rows, same Apply: `Space` ticks
-Install, `s` ticks Skill, `a`/`n` tick all or none, `Enter` applies, `q` quits.
+Install, `s` ticks Skill, `a`/`n` tick all or none, `Enter` applies, `u`
+upgrades when an upgrade is offered, `q` quits.
 On a host where none of the tools is installed yet every row starts ticked.
 
 A skill can go to more than one place. The default target writes
@@ -502,8 +531,8 @@ full rather than shallow (a tool that stamps its output with its commit needs th
 history), and nothing is cloned into a root that does not exist or cannot be
 written to. A clone that fails prints one line and that source is dropped, so a
 colleague without access to a private repo still gets everybody else's tools.
-`--refresh` brings the clones up to date with `git pull --ff-only`; a checkout
-given by `path` is never pulled. Cloning happens in the engine's `pre_discovery`
+`--refresh` and the upgrade (see "Upgrades") bring the clones up to date with
+`git pull --ff-only`; a checkout given by `path` is never pulled. Cloning happens in the engine's `pre_discovery`
 hook, which `--check` skips, so the login check stays network-free.
 
 An `org` entry is the only thing in this module that reaches anything but git,

{cli_tools_kit-1.0.0 → cli_tools_kit-1.1.1}/README.md

@@ -245,23 +245,52 @@ Keyword-only; every argument defaults to `None`, meaning "leave the default".
 | `notify_app` | identity's | `notify-send` application label on the `--check` path. |
 | `autostart_check_desktop_name`, `check_log_name`, `check_state_name` | identity's | Login-check artifact filenames. |
 | `hooks` | `None` | `InstallHooks(install_tool=…, remove_tool=…, install_skill=…, uninstall_skill=…)`: replace how one tool is installed, for a wrapper that builds a venv per tool. A field left `None` keeps the kit's own. |
+| `upgrade_repos` | `[]` | `(name, path)` of the tool repos an upgrade may pull. `sources.run_installer` fills it with the repos it cloned. See "Upgrades" below. |
 
 The identity is applied first and these individual names override it, so you can
 take the whole namespace from a slug and still change one thing.
 
 `run()` owns its own `argparse` and consumes `sys.argv`: `--list`, `--check`,
-`--enable-autostart-check`, `--install`, `--update-all`, `--cleanup`, `--tui`,
-`--gui`, and a screen when given none of them. A wrapper that needs its own
+`--enable-autostart-check`, `--install`, `--update-all`, `--upgrade`, `--cleanup`,
+`--tui`, `--gui`, and a screen when given none of them. A wrapper that needs its own
 subcommands should skip `run()` and call the primitives (`discover_tools`,
 `install_tool`, `remove_tool`, `cli_check`) after applying an identity with
 `_apply_identity`.
 
+### Upgrades
+
+When the window or the text screen opens, the installer checks in the
+background whether anything it runs is out of date:
+
+- the installer's own checkout (the git repo `entry_script` is in) is behind
+  its upstream;
+- a tool repo in `upgrade_repos` is behind its upstream;
+- pip would install a newer cli-tools-kit within the installer's pin. The pin is
+  the `requirements.txt` next to `entry_script` when it names the kit, else
+  anything below the next major version.
+
+If something is, a strip above the table lists it with an Upgrade button (on
+the text screen, a log line and the `u` key). Upgrade pulls the repos with `git
+pull --ff-only`, runs `pip install --upgrade` for the kit, reinstalls the
+installed tools of each pulled repo, and starts the installer again with its
+original command line so the new code is loaded. `--upgrade` does the same
+from a script, checking at once and without the restart.
+
+The network is used at most once a day: one `git fetch` per repo and one `pip
+install --dry-run`, cached under the identity's cache directory. The
+comparison with what is on disk runs on every start, so a repo pulled by hand
+stops showing at once. Git never asks for a password here; a private repo
+without stored credentials is skipped. The kit is left alone when it runs from
+a development checkout or outside a virtual environment. `--check` never runs
+any of this, so the login check stays network-free.
+
 ### The text screen
 
 Without a display (`DISPLAY`/`WAYLAND_DISPLAY` unset: SSH, WSL, a server) or
 without `python3-tk`, `run()` opens a curses screen instead of the tkinter
 window; `--tui` and `--gui` force either. Same rows, same Apply: `Space` ticks
-Install, `s` ticks Skill, `a`/`n` tick all or none, `Enter` applies, `q` quits.
+Install, `s` ticks Skill, `a`/`n` tick all or none, `Enter` applies, `u`
+upgrades when an upgrade is offered, `q` quits.
 On a host where none of the tools is installed yet every row starts ticked.
 
 A skill can go to more than one place. The default target writes
@@ -442,8 +471,8 @@ full rather than shallow (a tool that stamps its output with its commit needs th
 history), and nothing is cloned into a root that does not exist or cannot be
 written to. A clone that fails prints one line and that source is dropped, so a
 colleague without access to a private repo still gets everybody else's tools.
-`--refresh` brings the clones up to date with `git pull --ff-only`; a checkout
-given by `path` is never pulled. Cloning happens in the engine's `pre_discovery`
+`--refresh` and the upgrade (see "Upgrades") bring the clones up to date with
+`git pull --ff-only`; a checkout given by `path` is never pulled. Cloning happens in the engine's `pre_discovery`
 hook, which `--check` skips, so the login check stays network-free.
 
 An `org` entry is the only thing in this module that reaches anything but git,

{cli_tools_kit-1.0.0 → cli_tools_kit-1.1.1}/cli_tools_kit/__init__.py

@@ -56,4 +56,4 @@ __all__ = [
     "read_installed_skill",
 ]
 
-__version__ = "1.0.0"
+__version__ = "1.1.1"

{cli_tools_kit-1.0.0 → cli_tools_kit-1.1.1}/cli_tools_kit/cli.py

@@ -226,6 +226,22 @@ def cli_cleanup(dry_run: bool = False) -> int:
     return errors
 
 
+def cli_upgrade(tools: List[discovery.ToolEntry]) -> int:
+    """Check for newer versions now and upgrade what is behind. Returns 0 or 1."""
+    from . import upgrade  # noqa: PLC0415 — imports sources, only this path needs it
+    print("\nChecking for upgrades...")
+    items = upgrade.check(force=True)
+    if not items:
+        print("Everything is up to date.\n")
+        return 0
+    for item in items:
+        print(f"  {item.label()}")
+    print()
+    result = upgrade.upgrade(items, tools, lambda msg, tag="info": print(msg))
+    print(f"\nDone{', with errors' if result['errors'] else ''}.\n")
+    return 1 if result["errors"] else 0
+
+
 def cli_update_all(tools: List[discovery.ToolEntry]) -> int:
     """Sync: clean up orphans, then reinstall manager and all installed tool shortcuts.
 
@@ -439,6 +455,9 @@ def main():
                         help="Install the login update-check autostart entry")
     parser.add_argument("--disable-autostart-check", action="store_true",
                         help="Remove the login update-check autostart entry")
+    parser.add_argument("--upgrade", action="store_true",
+                        help="Check the installer's checkout, the tool repos it cloned and "
+                             "cli-tools-kit for newer versions, and upgrade them (network).")
     parser.add_argument("--refresh", action="store_true",
                         help="Before discovery, run the configured PRE_DISCOVERY hook in refresh "
                              "mode (e.g. ff-only pull every known repo checkout). No-op without a hook.")
@@ -494,6 +513,9 @@ def main():
     if args.update_all:
         sys.exit(1 if cli_update_all(tools) else 0)
 
+    if args.upgrade:
+        sys.exit(cli_upgrade(tools))
+
     if args.apply:
         from . import tui_installer
         sys.exit(tui_installer.apply_headless(tools, ",".join(args.apply), args.skill_target,
@@ -549,7 +571,8 @@ def run(*, identity: Optional[InstallerIdentity] = None,
         self_desktop_file: Optional[str] = None, self_desktop_name: Optional[str] = None,
         self_desktop_icon: Optional[str] = None,
         wm_class: Optional[str] = None, notify_app: Optional[str] = None,
-        hooks: Optional[install.InstallHooks] = None) -> None:
+        hooks: Optional[install.InstallHooks] = None,
+        upgrade_repos: Optional[List] = None) -> None:
     """Configure the engine from a thin wrapper and dispatch the standard CLI/GUI.
 
     Every argument maps to a module-level config global; ``None`` leaves the
@@ -567,6 +590,9 @@ def run(*, identity: Optional[InstallerIdentity] = None,
     ``hooks`` replaces how one tool is installed, removed or given its skill,
     for a wrapper that builds a venv per tool itself. See :class:`InstallHooks`.
 
+    ``upgrade_repos`` lists ``(name, path)`` of the tool repos the upgrade may
+    pull; ``sources.run_installer`` fills it with the repos it cloned.
+
     ``prune`` adds directory names the default wider walk never enters, on top
     of ``DISCOVERY_PRUNE``. It does nothing when a wrapper passes its own
     ``discoverer``.
@@ -629,6 +655,8 @@ def run(*, identity: Optional[InstallerIdentity] = None,
         state.NOTIFY_APP = notify_app
     if hooks is not None:
         install._apply_hooks(hooks)
+    if upgrade_repos is not None:
+        state.UPGRADE_REPOS = upgrade_repos
 
     state._load_env()                 # re-read ROOT_DIR/.env now that ROOT_DIR is final
     state._recompute_check_paths()    # re-derive login-check artifact paths from the names

{cli_tools_kit-1.0.0 → cli_tools_kit-1.1.1}/cli_tools_kit/gui_installer.py

@@ -62,6 +62,7 @@ except ImportError:  # pragma: no cover - exercised only where python3-tk is mis
 from typing import Dict, List, Optional
 
 from . import host, state, settings, discovery, install, sweep, autostart, icons, cli
+from . import upgrade
 from .autostart_gate import (
     _parse_hhmm,
     current_ssids,
@@ -98,6 +99,18 @@ RIGHT_COLS = (
     ("autostart", 85),
 )
 
+# The texts each right-hand column shows. A column is made wide enough for its
+# longest text in the current font, so "✗ Not installed" is not cut off when
+# the display scaling makes the font larger than the widths above assume.
+_COLUMN_TEXTS = {
+    "uses": ("Uses", "9999"),
+    "status": ("Status", "✓ Installed", "✗ Not installed", "⟳ Needs Update",
+               "⟳ Skill update", "⟳ Update + skill"),
+    "skill": ("Skill",),
+    "icon": ("Icon",),
+    "autostart": ("Auto-Start",),
+}
+
 _DEBUG_CELL_COLORS = {
     "uses": "#00ffff",
     "status": "#0000ff",
@@ -258,6 +271,10 @@ class InstallerApp:
         self.tk_widgets: List[tk.Widget] = []  # Other tk widgets that need bg updates
         self.usage_counts: Dict[str, int] = get_all_usage_counts()  # Tool usage statistics
 
+        # What upgrade.check() found; the strip above the table shows it and
+        # survives a theme rebuild.
+        self._upgrade_items: List[upgrade.Item] = []
+
         # Search/filter tracking
         self.search_var = tk.StringVar()
         self.category_widgets: Dict[str, tk.Widget] = {}  # category_name -> frame
@@ -272,6 +289,8 @@ class InstallerApp:
         self.orphan_desktops = sweep.find_orphan_desktop_files()
         self.orphan_aliases = sweep.find_orphan_aliases()
 
+        self._col_widths = self._column_widths()
+        self._wrap_held = False   # see _position_window
         self._setup_ui()
         self._position_window()
         self.root.deiconify()  # Show now that it's properly sized
@@ -285,6 +304,10 @@ class InstallerApp:
         # warning so the two don't fight over the log/dialog at the same tick.
         self.root.after(200, self._maybe_auto_update_on_startup)
 
+        # Newer installer, tool repos or kit: asks git and pip off the main
+        # thread, over the network at most once a day (see upgrade.check).
+        self.root.after(300, self._start_upgrade_check)
+
     # Standard freedesktop icon sizes. wm iconphoto silently fails to set
     # _NET_WM_ICON at all when handed only a source-resolution (e.g. 512x512)
     # image on some Tk/X11 combinations, so multiple smaller sizes are passed
@@ -314,6 +337,22 @@ class InstallerApp:
         except Exception:
             pass  # cosmetic only; never block startup over a bad/unsupported icon
 
+    def _column_widths(self) -> Dict[str, int]:
+        """RIGHT_COLS widths, scaled with the display and fitted to their texts.
+
+        The pixel widths in RIGHT_COLS were chosen at Tk's 96 dpi scaling.
+        They grow with the scaling and never drop below what the column's
+        longest text needs in the default font.
+        """
+        from tkinter import font as tkfont  # noqa: PLC0415 — tkinter is optional at import
+        font = tkfont.nametofont("TkDefaultFont")
+        scale = max(1.0, float(self.root.tk.call("tk", "scaling")) / (96 / 72))
+        widths = {}
+        for key, base in RIGHT_COLS:
+            text = max((font.measure(t) for t in _COLUMN_TEXTS.get(key, ())), default=0)
+            widths[key] = max(round(base * scale), text + 16)
+        return widths
+
     def _get_primary_monitor_geometry(self) -> tuple[int, int, int, int]:
         """Get primary monitor geometry (x, y, width, height). Falls back to tkinter defaults."""
         try:
@@ -338,41 +377,54 @@ class InstallerApp:
         return 0, 0, self.root.winfo_screenwidth(), self.root.winfo_screenheight()
 
     def _position_window(self):
-        """Position window: fit to content if possible, otherwise use full screen height with scrollbar."""
+        """Size the window to what every row asks for, within the monitor.
+
+        The width is the widest of the title row, the footer and the tool
+        table. The height is the fixed rows plus the table, measured after the
+        width is set, because tool descriptions wrap to the width and a wider
+        table is shorter. Both stay within 90% of the monitor, which leaves
+        room for panels and the title bar; beyond that the table scrolls. The
+        minimum size keeps the footer's buttons from being cut off.
+        """
         self.root.update_idletasks()
-
         mon_x, mon_y, mon_width, mon_height = self._get_primary_monitor_geometry()
+        avail_w, avail_h = int(mon_width * 0.9), int(mon_height * 0.9)
+
+        # The root's request covers the title, search and footer rows; the table
+        # sits in a canvas and is not part of it. The table's own request is no
+        # use either: until the window is drawn every description asks for one
+        # long line. So the table counts with its fixed columns plus room for
+        # the tool names.
+        scale = max(1.0, float(self.root.tk.call("tk", "scaling")) / (96 / 72))
+        scrollbar_w = self.scrollbar.winfo_reqwidth()
+        fixed_cols = sum(self._col_widths.values()) + len(RIGHT_COLS)
+        overhead = 40 + scrollbar_w + sum(TABLE_PADX) + fixed_cols + 70   # padding, checkbox
+        rows_w = self.root.winfo_reqwidth()
+        window_width = min(max(rows_w, overhead + round(300 * scale)), avail_w)
+
+        # Wrap the descriptions for that width before measuring the height.
+        # Their <Configure> handlers are held meanwhile: while the window is
+        # hidden they see the table's narrow first layout and wrap at 100 px.
+        # Once it is shown they set the exact wrap.
+        self._wrap_held = True
+        for label in self._desc_labels:
+            label.configure(wraplength=max(100, window_width - overhead))
+        self.root.update_idletasks()
 
-        # Get actual content dimensions
-        scrollable_height = self.scrollable_frame.winfo_reqheight()
-        content_width = self.scrollable_frame.winfo_reqwidth() + 60  # padding
-        # Add height for title (~60), footer (~60), log header (~40), status bar (~30), padding (~40)
-        non_scrollable_height = 230
-        content_height = scrollable_height + non_scrollable_height
-
-        # Clamp width to reasonable bounds (max 800 for usability)
-        window_width = max(500, min(content_width, 800, mon_width - 100))
-
-        # Use content height if it fits, otherwise use full monitor height
-        if content_height <= mon_height:
-            window_height = content_height
-            # Center vertically on primary monitor
-            y = mon_y + (mon_height - window_height) // 2
-            # Hide scrollbar initially - content fits
-            self.scrollbar.grid_forget()
-        else:
-            # Use full monitor height, align to top
-            window_height = mon_height
-            y = mon_y
-            # Show scrollbar initially - content exceeds screen
+        fixed_h = self.root.winfo_reqheight() - self.outer_frame.winfo_reqheight()
+        content_h = fixed_h + self.scrollable_frame.winfo_reqheight()
+        window_height = min(content_h, avail_h)
+        if content_h > avail_h:
             self.scrollbar.grid(row=0, column=1, sticky="ns")
+        else:
+            self.scrollbar.grid_forget()
 
-        # Center horizontally on primary monitor
         x = mon_x + (mon_width - window_width) // 2
-
+        y = mon_y + (mon_height - window_height) // 2
         self.root.geometry(f"{window_width}x{window_height}+{x}+{y}")
-        # Allow resizing in both directions
+        self.root.minsize(min(rows_w, avail_w), min(fixed_h + 150, window_height))
         self.root.resizable(True, True)
+        self._wrap_held = False
 
         # Always enable mouse wheel scrolling
         self._bind_mousewheel()
@@ -720,7 +772,7 @@ class InstallerApp:
         main_container = ttk.Frame(self.root, padding="20")
         main_container.grid(row=0, column=0, sticky="nsew")
         main_container.columnconfigure(0, weight=1)
-        main_container.rowconfigure(2, weight=1)
+        main_container.rowconfigure(3, weight=1)
 
         # Title
         title_frame = ttk.Frame(main_container)
@@ -771,9 +823,14 @@ class InstallerApp:
                              "Re-tint this theme from a base color "
                              "(re-click the theme emoji to reset)")
 
+        # Upgrade strip — only gridded while upgrade.check() has found something.
+        self.upgrade_bar = tk.Frame(main_container, bg=t["panel"], highlightthickness=1,
+                                    highlightbackground=t["accent"])
+        self._render_upgrade_bar()
+
         # Search bar
         search_frame = ttk.Frame(main_container)
-        search_frame.grid(row=1, column=0, pady=(0, 10), sticky="ew")
+        search_frame.grid(row=2, column=0, pady=(0, 10), sticky="ew")
 
         self.search_entry = tk.Entry(
             search_frame, textvariable=self.search_var,
@@ -832,7 +889,7 @@ class InstallerApp:
 
         # Scrollable Area
         self.outer_frame = ttk.Frame(main_container, relief="flat")
-        self.outer_frame.grid(row=2, column=0, sticky="nsew")
+        self.outer_frame.grid(row=3, column=0, sticky="nsew")
         self.outer_frame.columnconfigure(0, weight=1)
         self.outer_frame.rowconfigure(0, weight=1)
 
@@ -868,6 +925,7 @@ class InstallerApp:
         for group_label in sorted(tools_by_group):
             categories[group_label] = discovery.group_tools(tools_by_group[group_label])
 
+        self._desc_labels: List[ttk.Label] = []  # wrapped to the width in _position_window
         self.expand_vars: Dict[str, tk.BooleanVar] = {}  # Track expanded state
         self.children_frames: Dict[str, ttk.Frame] = {}  # Track child frames for show/hide
 
@@ -925,7 +983,15 @@ class InstallerApp:
 
         # Footer / Buttons
         footer = ttk.Frame(main_container, padding=(0, 20, 0, 0))
-        footer.grid(row=3, column=0, sticky="ew")
+        footer.grid(row=4, column=0, sticky="ew")
+
+        # Packed first: when the window is narrower than the footer, pack takes
+        # the space from the widgets packed last, so Apply stays visible.
+        self._apply_btn = ttk.Button(footer, text="Apply Changes", style="Accent.TButton", command=self._apply_changes)
+        self._apply_btn.pack(side="right", padx=5)
+        self._apply_highlighted = False
+        self._op_in_progress = False  # guards against overlapping bulk operations
+        ttk.Button(footer, text="Refresh Status", command=self._update_status_labels).pack(side="right", padx=5)
 
         ttk.Button(footer, text="Select All", command=self._select_all).pack(side="left", padx=5)
         ttk.Button(footer, text="Select None", command=self._select_none).pack(side="left", padx=5)
@@ -993,17 +1059,11 @@ class InstallerApp:
 
         ttk.Separator(footer, orient="vertical").pack(side="left", fill="y", padx=15)
 
-        self._apply_btn = ttk.Button(footer, text="Apply Changes", style="Accent.TButton", command=self._apply_changes)
-        self._apply_btn.pack(side="right", padx=5)
-        self._apply_highlighted = False
-        self._op_in_progress = False  # guards against overlapping bulk operations
-        ttk.Button(footer, text="Refresh Status", command=self._update_status_labels).pack(side="right", padx=5)
-
         # Collapsible Log Area
         self.log_expanded = tk.BooleanVar(value=False)
 
         log_container = ttk.Frame(main_container)
-        log_container.grid(row=4, column=0, sticky="nsew", pady=(15, 0))
+        log_container.grid(row=5, column=0, sticky="nsew", pady=(15, 0))
         log_container.columnconfigure(0, weight=1)
 
         # Header row (clickable to expand/collapse)
@@ -1060,7 +1120,7 @@ class InstallerApp:
         self.log_text.see("end")
 
         indicator_frame = ttk.Frame(main_container)
-        indicator_frame.grid(row=5, column=0, sticky="ew", pady=(10, 0))
+        indicator_frame.grid(row=6, column=0, sticky="ew", pady=(10, 0))
 
         self.status_bar = ttk.Label(indicator_frame, text="Ready", foreground=t["muted"], font=("", 9, "italic"))
         self.status_bar.pack(side="left")
@@ -2700,7 +2760,8 @@ class InstallerApp:
         height=24 is only a floor for the header row, whose labels are short).
         """
         cells: Dict[str, tk.Frame] = {}
-        for col_key, width in RIGHT_COLS:
+        for col_key, _ in RIGHT_COLS:
+            width = self._col_widths[col_key]
             sep = tk.Frame(container, width=1, bg=self.theme["border"],
                            highlightthickness=0)
             sep.pack(side="left", fill="y")
@@ -2840,9 +2901,11 @@ class InstallerApp:
         desc_text = self._format_desc_with_alias(tool)
         desc_label = ttk.Label(info_frame, text=desc_text, style="CardMuted.TLabel", font=("", 9))
         desc_label.pack(anchor="w", fill="x")
+        self._desc_labels.append(desc_label)
         # Dynamic wraplength based on available width
         def update_wrap(event, lbl=desc_label):
-            lbl.configure(wraplength=max(100, event.width - 10))
+            if not self._wrap_held:
+                lbl.configure(wraplength=max(100, event.width - 10))
         info_frame.bind("<Configure>", update_wrap)
 
     def _render_tool_group(self, group: discovery.ToolGroup, current_row: int) -> int:
@@ -2985,9 +3048,11 @@ class InstallerApp:
         desc_text = self._format_desc_with_alias(parent)
         desc_label = ttk.Label(info_frame, text=desc_text, style="CardMuted.TLabel", font=("", 9))
         desc_label.pack(anchor="w", fill="x")
+        self._desc_labels.append(desc_label)
         # Dynamic wraplength based on available width
         def update_wrap(event, lbl=desc_label):
-            lbl.configure(wraplength=max(100, event.width - 10))
+            if not self._wrap_held:
+                lbl.configure(wraplength=max(100, event.width - 10))
         info_frame.bind("<Configure>", update_wrap)
 
         current_row += 1
@@ -3888,6 +3953,117 @@ class InstallerApp:
         else:
             self._log("Already up to date — nothing to do.", "success")
 
+    # --- upgrades -----------------------------------------------------------------
+
+    def _start_upgrade_check(self):
+        """Run upgrade.check() on a thread and show what it finds in the strip."""
+        results: queue.Queue = queue.Queue()
+
+        def work():
+            try:
+                results.put(upgrade.check())
+            except Exception as exc:  # a failed check must not take the window down
+                results.put(exc)
+
+        threading.Thread(target=work, daemon=True).start()
+        self.root.after(200, lambda: self._poll_upgrade_check(results))
+
+    def _poll_upgrade_check(self, results):
+        try:
+            found = results.get_nowait()
+        except queue.Empty:
+            self.root.after(200, lambda: self._poll_upgrade_check(results))
+            return
+        if isinstance(found, Exception):
+            self._log(f"Upgrade check failed: {found}", "error")
+            return
+        was_shown = bool(self._upgrade_items)
+        self._upgrade_items = list(found)
+        self._render_upgrade_bar()
+        if self._upgrade_items and not was_shown:
+            # The window was sized without the strip; make room for it rather
+            # than take its height from the table.
+            self.root.update_idletasks()
+            _, _, _, mon_height = self._get_primary_monitor_geometry()
+            height = min(self.root.winfo_height() + self.upgrade_bar.winfo_reqheight() + 10,
+                         int(mon_height * 0.9))
+            self.root.geometry(f"{self.root.winfo_width()}x{height}")
+
+    def _render_upgrade_bar(self):
+        """Show the upgrade strip for what the last check found, or hide it."""
+        bar = self.upgrade_bar
+        for child in bar.winfo_children():
+            child.destroy()
+        self._upgrade_btn = None
+        if not self._upgrade_items:
+            bar.grid_remove()
+            return
+        t = self.theme
+        # The button is packed first so a narrow window squeezes the text, not it.
+        self._upgrade_btn = ttk.Button(bar, text="Upgrade", style="Accent.TButton",
+                                       command=self._upgrade_clicked)
+        self._upgrade_btn.pack(side="right", padx=8, pady=6)
+        if getattr(self, "_op_in_progress", False):
+            self._upgrade_btn.configure(state="disabled")
+        tk.Label(bar, text="Upgrade available:", bg=t["panel"], fg=t["accent"],
+                 font=("", 10, "bold")).pack(side="left", padx=(10, 6), pady=6)
+        detail = tk.Label(bar, text=" · ".join(item.label() for item in self._upgrade_items),
+                          bg=t["panel"], fg=t["fg"], font=("", 10), anchor="w",
+                          justify="left", wraplength=400)
+        detail.pack(side="left", fill="x", expand=True, pady=6)
+        detail.bind("<Configure>",
+                    lambda e: detail.configure(wraplength=max(150, e.width - 10)))
+        bar.grid(row=1, column=0, pady=(0, 10), sticky="ew")
+
+    def _upgrade_clicked(self):
+        if self._op_in_progress or not self._upgrade_items:
+            return
+        items = list(self._upgrade_items)
+        lines = "\n".join(f"  • {item.label()}" for item in items)
+        if not messagebox.askyesno(
+            "Upgrade?",
+            f"This brings these up to date:\n\n{lines}\n\n"
+            "Repos are pulled, cli-tools-kit is upgraded with pip, the installed "
+            "tools of a pulled repo are reinstalled, and the installer restarts.\n\n"
+            "This uses the network. Continue?",
+        ):
+            return
+        self._op_in_progress = True
+        self._set_action_buttons_state("disabled")
+        self._clear_hint()
+        self._toggle_log(force_expand=True)
+        events: queue.Queue = queue.Queue()
+
+        def work():
+            def log(msg, tag="info"):
+                events.put(("log", msg, tag))
+            try:
+                result = upgrade.upgrade(items, self.tools, log)
+            except Exception as exc:  # the UI must come back whatever went wrong
+                log(f"Upgrade failed: {exc}", "error")
+                result = {"changed": False, "errors": 1}
+            events.put(("done", result))
+
+        threading.Thread(target=work, daemon=True).start()
+        self.root.after(50, lambda: self._drain_op_events(events, self._finish_upgrade))
+
+    def _finish_upgrade(self, result):
+        self._op_in_progress = False
+        self._set_action_buttons_state("normal")
+        if result["changed"] and not result["errors"]:
+            self._log("Restarting the installer to load the new version...", "header")
+            self.root.after(1500, self._restart_installer)
+            return
+        if result["changed"]:
+            self._log("Some steps failed (see above). Close and reopen the installer "
+                      "to load what was upgraded.", "error")
+        self._start_upgrade_check()   # the strip then shows only what is still behind
+
+    def _restart_installer(self):
+        argv = upgrade.restart_argv()
+        self.root.destroy()
+        host.restart(argv)
+
     def _toggle_autostart_check(self):
         """Enable/disable the login update-check autostart entry."""
         if self._autostart_check_var.get():
@@ -4087,7 +4263,7 @@ class InstallerApp:
 
         Greys the ttk action buttons and the custom update badge together; the badge
         also ignores clicks while disabled (see _set_update_enabled)."""
-        for attr in ("_reinstall_btn", "_apply_btn"):
+        for attr in ("_reinstall_btn", "_apply_btn", "_upgrade_btn"):
             btn = getattr(self, attr, None)
             if btn is not None:
                 btn.configure(state=state)
@@ -4098,7 +4274,8 @@ class InstallerApp:
 # globals (gi.IDENTITY, gi.install_tool = ...). Those names now live in the
 # modules below. Reading, assigning or deleting one through gui_installer goes
 # to the module that holds it, where every screen looks it up at call time.
-_ENGINE_MODULES = (state, settings, discovery, install, sweep, autostart, icons, cli)
+_ENGINE_MODULES = (state, settings, discovery, install, sweep, autostart, icons, cli,
+                   upgrade)
 
 
 def _home_of(name: str):

{cli_tools_kit-1.0.0 → cli_tools_kit-1.1.1}/cli_tools_kit/host.py

@@ -68,6 +68,22 @@ def child_env(env: Optional[dict] = None) -> dict:
     return env
 
 
+# --- restarting -------------------------------------------------------------------
+
+def restart(argv: Iterable[str]) -> None:
+    """Replace this process with a new one running ``argv``; does not return.
+
+    After an upgrade the old code is still loaded, so the installer starts
+    again. Windows has no real exec (``os.execv`` there spawns a child and
+    leaves the console behind), so it starts the new process and exits.
+    """
+    argv = list(argv)
+    if IS_WINDOWS:
+        subprocess.Popen(argv)
+        os._exit(0)
+    os.execv(argv[0], argv)
+
+
 # --- where the shims live -----------------------------------------------------
 
 def shim_dir(identity) -> str: