vappman 2.2.1__tar.gz → 2.2.4__tar.gz

{vappman-2.2.1 → vappman-2.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: vappman
-Version: 2.2.1
+Version: 2.2.4
 Summary: A visual wrapper for appman
 Keywords: app,installer,manager,appimages
 Author-email: Joe Defen <joedef@google.com>
@@ -15,14 +15,16 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Operating System :: POSIX :: Linux
 License-File: LICENSE
-Requires-Dist: console-window == 2.1.3
+Requires-Dist: console-window ~= 3.0.0
 Requires-Dist: pytest>=7 ; extra == "dev"
 Requires-Dist: pytest-cov>=5 ; extra == "dev"
 Requires-Dist: ruff>=0.6 ; extra == "dev"
 Requires-Dist: build>=1.2 ; extra == "dev"
 Requires-Dist: twine>=7 ; extra == "dev"
 Requires-Dist: packaging>=26 ; extra == "dev"
+Requires-Dist: tomli>=2 ; extra == "dev" and ( python_version < '3.11')
 Requires-Dist: pytest>=7.0 ; extra == "test"
+Requires-Dist: tomli>=2 ; extra == "test" and ( python_version < '3.11')
 Project-URL: Bug Tracker, https://github.com/joedefen/vappman/issues
 Project-URL: Homepage, https://github.com/joedefen/vappman
 Provides-Extra: dev
@@ -196,7 +198,7 @@ Press `/` to start filtering. The filter supports two modes:
 * `i` or `ENTER` - Install the app. A prompt appears *below* the entry's rows
   (so the synopsis stays readable), followed by the install-type menu:
   ```
-      ⚠️  Install <app>?
+      🌟  Install <app>?
       *n:none s:sandbox c:icons b:both y:last ESC
   ```
   * `n` - plain install
@@ -221,7 +223,7 @@ Press `/` to start filtering. The filter supports two modes:
 * `t` - Test the app by running it in a terminal
 
 For `r`, `C`, `S` and `b`, a prompt appears below the entry's rows (synopsis and
-version/type remain visible), e.g. `⚠️  Remove <app>? Press y or ESC`; `y`
+version/type remain visible), e.g. `🌟  Remove <app>? Press y or ESC`; `y`
 confirms, `ESC` cancels, and all other keys are ignored until you answer. The
 confirmed command is run with `-y`, so `am/appman` does not ask again.
 
@@ -289,7 +291,7 @@ AppImage Compatibility Check (Ubuntu 24.04 LTS)
 ============================================================
   ✗ libfuse2: libfuse2 is not installed (required for most AppImages)
     Fix: sudo apt install libfuse2
-  ⚠ user namespaces: Unprivileged user namespaces are disabled
+  🌟 user namespaces: Unprivileged user namespaces are disabled
   ✓ /tmp noexec: OK
   ✓ AppArmor: OK
 
@@ -300,7 +302,7 @@ Detailed Information:
   libfuse2 is not installed (required for most AppImages)
   Fix: sudo apt install libfuse2
 
-⚠ user_namespaces:
+🌟 user_namespaces:
   Unprivileged user namespaces are disabled (sandboxed AppImages will fail)
   Suggestion: sudo sysctl -w kernel.unprivileged_userns_clone=1
   To make permanent: echo "kernel.unprivileged_userns_clone=1" | sudo tee /etc/sysctl.d/00-local-userns.conf

{vappman-2.2.1 → vappman-2.2.4}/README.md

@@ -165,7 +165,7 @@ Press `/` to start filtering. The filter supports two modes:
 * `i` or `ENTER` - Install the app. A prompt appears *below* the entry's rows
   (so the synopsis stays readable), followed by the install-type menu:
   ```
-      ⚠️  Install <app>?
+      🌟  Install <app>?
       *n:none s:sandbox c:icons b:both y:last ESC
   ```
   * `n` - plain install
@@ -190,7 +190,7 @@ Press `/` to start filtering. The filter supports two modes:
 * `t` - Test the app by running it in a terminal
 
 For `r`, `C`, `S` and `b`, a prompt appears below the entry's rows (synopsis and
-version/type remain visible), e.g. `⚠️  Remove <app>? Press y or ESC`; `y`
+version/type remain visible), e.g. `🌟  Remove <app>? Press y or ESC`; `y`
 confirms, `ESC` cancels, and all other keys are ignored until you answer. The
 confirmed command is run with `-y`, so `am/appman` does not ask again.
 
@@ -258,7 +258,7 @@ AppImage Compatibility Check (Ubuntu 24.04 LTS)
 ============================================================
   ✗ libfuse2: libfuse2 is not installed (required for most AppImages)
     Fix: sudo apt install libfuse2
-  ⚠ user namespaces: Unprivileged user namespaces are disabled
+  🌟 user namespaces: Unprivileged user namespaces are disabled
   ✓ /tmp noexec: OK
   ✓ AppArmor: OK
 
@@ -269,7 +269,7 @@ Detailed Information:
   libfuse2 is not installed (required for most AppImages)
   Fix: sudo apt install libfuse2
 
-⚠ user_namespaces:
+🌟 user_namespaces:
   Unprivileged user namespaces are disabled (sandboxed AppImages will fail)
   Suggestion: sudo sysctl -w kernel.unprivileged_userns_clone=1
   To make permanent: echo "kernel.unprivileged_userns_clone=1" | sudo tee /etc/sysctl.d/00-local-userns.conf

{vappman-2.2.1 → vappman-2.2.4}/pyproject.toml

@@ -32,7 +32,12 @@ classifiers = [
     "Operating System :: POSIX :: Linux"
 ]
 dependencies = [
-    'console-window == 2.1.3',
+    # 3.0 is the first release whose content model lives on Screen (one drawing
+    # model) and whose appearance layer is ``console_window.Appearance``.  The
+    # compatible-3.0.x spelling keeps the app on the 3.0 line: patch releases
+    # are fixes, while 3.1 may add (not break) API and would be a deliberate
+    # move.
+    'console-window ~= 3.0.0',
 ]
 
 [project.urls]
@@ -43,7 +48,13 @@ dependencies = [
 vappman = "vappman.main:main"
 
 [project.optional-dependencies]
-test = ["pytest>=7.0"]
+# `tomli` backfills `tomllib` on 3.10, where `tests/test_bless.py` and
+# `tests/inspect_dist.py` read pyproject.toml.  The vendored `bless` already
+# falls back to it, so the gate and its tests carry one requirement.
+test = [
+    "pytest>=7.0",
+    "tomli>=2; python_version < '3.11'",
+]
 # The release gate (`./bless`) runs ruff, compileall and pytest with coverage,
 # then builds, inspects, `twine check`s and smoke-installs the artifacts.  Those
 # tools must live in the interpreter that runs bless, and twine/packaging must
@@ -55,12 +66,27 @@ dev = [
     "build>=1.2",
     "twine>=7",
     "packaging>=26",
+    "tomli>=2; python_version < '3.11'",
 ]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 addopts = "-ra"
 
+[tool.coverage.run]
+source = ["vappman"]
+
+[tool.coverage.report]
+# Set just below the measured number when the shared gate was adopted.  Raise
+# it as the suite grows; never lower it to make a commit pass.
+fail_under = 35
+
+[tool.bless]
+# The default is the pair, written out here so the branch model is visible
+# where the rest of this project's identity lives.  `publish` aligns `dev`
+# with `main` before tagging, and pushes both.
+branches = ["main", "dev"]
+
 [tool.ruff]
 # Keep the lint gate identical on every machine: no global/user config can
 # change which rules the gate enforces.  The selection below is deliberately

vappman-2.2.4/vappman/Appearance.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""The appearance preferences for vappman.
+
+Colour is decoration, never information.  Every role degrades to an attribute
+(or to plain text) when the terminal has no colour, so the installed markers
+(``✔``/``🔒``), the ``S``/``U`` flags and the ``🌟`` prompts always remain
+readable on a monochrome terminal.
+
+The role ids are ``console_window.Theme``'s semantic pairs rather than literal
+colour numbers.  console-window installs those pairs at startup and re-installs
+them whenever a theme is applied, so changing the active theme recolours the
+whole UI without an edit to any draw code.
+
+The role-to-attribute mapping, the process-wide switch and the forgiving lookup
+live in :mod:`console_window` (the ``Appearance`` class, whose module is private
+from 3.0 on), and are re-exported here.  Keeping one switch matters: the
+library's theme picker paints its swatches through that layer, so a
+vappman-local copy would leave the picker in colour while the rest of the UI
+went mono.
+
+``mono`` is a real console-window theme in 3.0 (it installs the terminal-default
+background and uses the monochrome role attributes), so vappman no longer owns a
+pseudo-theme of its own.  What stays here is the preference *pair* the picker
+persists: a palette name plus the colour switch, which can be off for a named
+palette too (``--no-color``, ``NO_COLOR``).
+"""
+
+import os
+
+from console_window import (
+    MONO_ROLES, Theme, colors_enabled, semantic_attr, set_colors_enabled,
+)
+
+# Explicit re-exports: the appearance API is read from this module by vappman.
+__all__ = [
+    'MONO_ROLES', 'MONO_THEME', 'appearance_choices', 'appearance_label',
+    'colors_enabled', 'resolve_ui_prefs', 'semantic_attr',
+    'set_colors_enabled',
+]
+
+# vappman's no-colour appearance.  Since console-window 3.0 this is also a
+# library theme name, which is deliberate: the picker's rotation, the window's
+# recorded theme and a remembered preference all agree on one spelling.
+MONO_THEME = Theme.MONO
+
+
+def appearance_choices():
+    """Every appearance the picker cycles, in order.
+
+    console-window's themes come first (in ``Theme.THEMES`` order), with
+    vappman's no-colour appearance last, so one cycle always reaches ``mono``.
+    ``mono`` is a library theme in 3.0 and is already last in the registry; it
+    is moved by name rather than trusted to stay there, so a registry reorder
+    cannot put it twice or in the middle.
+    """
+    others = [name for name in Theme.list_all() if name != MONO_THEME]
+    return others + [MONO_THEME]
+
+
+def appearance_label(theme, colors):
+    """The name to show for the live appearance."""
+    if not colors:
+        return MONO_THEME
+    return theme or 'default'
+
+
+def resolve_ui_prefs(cli_theme=None, no_color=False, saved_theme='',
+                     saved_colors=True, environ=None):
+    """Starting ``(theme, colors)`` from the flag, the environment and the prefs.
+
+    Precedence, highest first: an explicit ``--theme`` / ``--no-color``, the
+    ``NO_COLOR`` convention (any non-empty value disables colour), then the
+    remembered choice.  An explicit ``--theme`` is a statement of intent, so it
+    re-enables colour even when the saved choice was ``mono`` (unless
+    ``--no-color`` says otherwise); an unknown theme name falls back to
+    console-window's ``default``.
+
+    ``theme`` is ``''`` for the library default.  The special value ``mono``
+    forces ``colors`` off and is reported as ``theme=''``: vappman remembers the
+    pair (palette, colour switch), and ``''`` + ``colors=False`` is the
+    canonical spelling of "no palette, no colour".
+    """
+    env = os.environ if environ is None else environ
+    if cli_theme:
+        if cli_theme == MONO_THEME:
+            return '', False
+        return Theme.resolve(cli_theme), not no_color
+    theme = '' if saved_theme in (None, MONO_THEME) else Theme.resolve(saved_theme)
+    colors = bool(saved_colors) and saved_theme != MONO_THEME
+    if env.get('NO_COLOR') or no_color:
+        colors = False
+    return theme, colors

{vappman-2.2.1 → vappman-2.2.4}/vappman/AppimageDoctor.py

@@ -7,6 +7,17 @@ import subprocess
 from pathlib import Path
 from typing import List, Dict, Tuple, Optional
 
+from console_window import Glyphs
+
+
+def warn_mark():
+    """The two-cell 'pay attention' badge for console output.
+
+    Asked of console-window's mark registry rather than pasted as a literal, so
+    a terminal that cannot draw the emoji gets the registered ASCII fallback.
+    """
+    return Glyphs.mark('star_glow')
+
 
 class AppImageIssue:
     """Represents a system compatibility issue for AppImages"""
@@ -243,7 +254,7 @@ def format_report(issues: List[AppImageIssue], distro_id: str, distro_name: str,
     infos = [i for i in issues if i.severity == 'info']
 
     if critical:
-        lines.append("\n⚠ CRITICAL ISSUES (AppImages will likely not work):")
+        lines.append(f"\n{warn_mark()} CRITICAL ISSUES (AppImages will likely not work):")
         for issue in critical:
             lines.append(f"\n  • {issue.description}")
             if verbose:
@@ -251,7 +262,7 @@ def format_report(issues: List[AppImageIssue], distro_id: str, distro_name: str,
                 lines.append(f"    Fix: {fix}")
 
     if warnings:
-        lines.append("\n⚠ WARNINGS (Some AppImages may fail):")
+        lines.append(f"\n{warn_mark()} WARNINGS (Some AppImages may fail):")
         for issue in warnings:
             lines.append(f"\n  • {issue.description}")
             if verbose:
@@ -298,7 +309,7 @@ def quick_check() -> Tuple[bool, List[str]]:
                 status_lines.append(f"  ✗ {check_name}: {issue.description}")
                 status_lines.append(f"    Fix: {fix_cmd}")
             elif issue.severity == 'warning':
-                status_lines.append(f"  ⚠ {check_name}: {issue.description}")
+                status_lines.append(f"  {warn_mark()} {check_name}: {issue.description}")
             else:
                 status_lines.append(f"  ℹ {check_name}: {issue.description}")
         else:
@@ -333,7 +344,7 @@ def main():
                 print(f"  Fix: {fix}")
             elif issue.severity == 'warning':
                 fix = issue.fix_commands.get(distro_id) or issue.fix_commands.get('default', 'No fix available')
-                print(f"\n⚠ {issue.name}:")
+                print(f"\n{warn_mark()} {issue.name}:")
                 print(f"  {issue.description}")
                 print(f"  Suggestion: {fix}")
     else:

{vappman-2.2.1 → vappman-2.2.4}/vappman/Prerequisites.py

@@ -13,6 +13,18 @@ import sys
 import shutil
 import subprocess
 
+from console_window import Glyphs
+
+
+def warn_mark():
+    """The two-cell 'pay attention' badge for console messages.
+
+    Asked of console-window's mark registry rather than pasted as a literal, so
+    a terminal that cannot draw the emoji gets the registered ASCII fallback.
+    """
+    return Glyphs.mark('star_glow')
+
+
 class Prerequisites:
     """ Detect / install prereqs """
     def __init__(self):
@@ -69,7 +81,7 @@ class Prerequisites:
         packages = sorted(missing)
 
         if not skip_prompt:
-            print(f'\n⚠️  Missing dependencies: {", ".join(packages)}')
+            print(f'\n{warn_mark()}  Missing dependencies: {", ".join(packages)}')
             print(f'\nDetected package manager: {pm_name}')
 
             response = input('\nInstall missing dependencies? [y/N]: ').strip().lower()
@@ -107,7 +119,7 @@ class Prerequisites:
         Returns:
             bool: True if installation succeeded or user declined, False on error
         """
-        print('\n⚠️  AM/appman is not installed.')
+        print(f'\n{warn_mark()}  AM/appman is not installed.')
         print('\nAM is a powerful AppImage package manager that allows you to:')
         print('  • Install and manage 2500+ AppImages, Soarpkgs, and AppBundles')
         print('  • Update apps with a single command')
@@ -183,7 +195,7 @@ class Prerequisites:
         has_sudo = shutil.which('sudo') is not None
         has_doas = shutil.which('doas') is not None
         if not has_sudo and not has_doas:
-            print('\n⚠️  WARNING: Neither "sudo" nor "doas" found.')
+            print(f'\n{warn_mark()}  WARNING: Neither "sudo" nor "doas" found.')
             print('    System-level operations may not work correctly.')
 
         # Check core dependencies
@@ -224,7 +236,7 @@ class Prerequisites:
             for prog in missing_optional:
                 packages_needed.add(optional_deps[prog])
 
-            print(f'\n⚠️  Optional dependencies missing: {", ".join(sorted(missing_optional))}')
+            print(f'\n{warn_mark()}  Optional dependencies missing: {", ".join(sorted(missing_optional))}')
             print('    Some features may not work without these packages.')
 
             response = input('\nInstall optional dependencies? [y/N]: ').strip().lower()
@@ -248,11 +260,12 @@ class Prerequisites:
 
             # After successful installation, exit so user can restart vappman
             print('\n✅ Installation complete!')
-            print('\n⚠️  Run "appman -h" or "am -h" and answer setup questions.')
-            print('\n⚠️  ONLY after init, restart vappman to begin using it.')
+            print(f'\n{warn_mark()}  Run "appman -h" or "am -h" and answer setup questions.')
+            print(f'\n{warn_mark()}  ONLY after init, restart vappman to begin using it.')
             sys.exit(0)
 
         if optional_install_failed:
-            print('⚠️  Core prerequisites satisfied (optional dependencies had issues).')
+            print(f'{warn_mark()}  Core prerequisites satisfied '
+                  '(optional dependencies had issues).')
         else:
             print('✅ All prerequisites satisfied.')

{vappman-2.2.1 → vappman-2.2.4}/vappman/__init__.py

@@ -1,3 +1,3 @@
 """vappman -- a visual wrapper for appman."""
 
-__version__ = "2.2.1"
+__version__ = "2.2.4"

{vappman-2.2.1 → vappman-2.2.4}/vappman/main.py

@@ -26,7 +26,7 @@ import curses as cs
 from console_window import (
     ConsoleWindow, OptionSpinner, ConsoleWindowOpts,
     Screen, ScreenStack, BasicHelpScreen, Context,
-    IncrementalSearchBar, InlineConfirmation, Theme
+    Glyphs, IncrementalSearchBar, InlineConfirmation, Theme
 )
 from . import __version__
 from .PersistentState import PersistentState
@@ -36,8 +36,8 @@ from .Prerequisites import Prerequisites
 from .VappmanListCache import AppCacheManager
 from . import AppimageDoctor
 from .Appearance import (
-    MONO_THEME, appearance_choices, appearance_label, resolve_ui_prefs,
-    semantic_attr, set_colors_enabled,
+    MONO_THEME, appearance_choices, appearance_label, colors_enabled,
+    resolve_ui_prefs, semantic_attr, set_colors_enabled,
 )
 
 # Screen constants
@@ -56,6 +56,17 @@ INSTALL_OPTIONS = (
 INSTALL_OPTION_KEYS = {ord(key): flags for key, _, flags in INSTALL_OPTIONS}
 
 
+def notice_mark():
+    """The two-cell 'pay attention' badge used on prompted rows.
+
+    Asked of console-window's mark registry rather than pasted as a literal, so
+    ASCII mode substitutes the registered fallback (``'S '``) and the prompt
+    column keeps its two cells.  Called at draw time because the glyph mode is
+    process state, decided when the first window is created.
+    """
+    return Glyphs.mark('star_glow')
+
+
 def _install_option_key(install_opts):
     """Return the menu key matching a persisted `install_opts` value."""
     flags = frozenset(x for x in (install_opts or '').split(',') if x)
@@ -140,18 +151,16 @@ class HomeScreen(VappmanScreen):
                 rv += ' ╰── ' if corner else ' │    '
             return rv
 
-        win = self.win
-
         # Skip first line (already shown on main line), add up to 'max' continuation lines
         # Continuation lines are already sized correctly from textwrap's subsequent_indent
         indent = make_indent(2+fold_offset, False)
         lines = wrapped_lines[1:1+num]
         for line in lines[:-1]:
             # Indent to fold_offset position
-            win.add_body(indent + line, context=Context("TRANSIENT"))
+            self.add_body(indent + line, context=Context("TRANSIENT"))
         indent = make_indent(2+fold_offset, True)
         if len(lines) > 0:
-            win.add_body(indent + wrapped_lines[-1], context=Context("TRANSIENT"))
+            self.add_body(indent + wrapped_lines[-1], context=Context("TRANSIENT"))
 
 
     def get_folded_synopsis(self, offset1, offset2, text):
@@ -189,14 +198,14 @@ class HomeScreen(VappmanScreen):
         pending = app.pending_action
         if label is None or pending is None:
             return ''
-        return f'    ⚠️  {label} {pending[1].appname}? Press y or ESC'
+        return f'    {notice_mark()}  {label} {pending[1].appname}? Press y or ESC'
 
 
     def draw_screen(self):
         """Draw the home screen with app list  ⮜–⮞
         """
         app = self.app
-        win = self.win
+        win = self.win  # window-only services: cols, demo mode, picked context
         all_dbs = bool(app.opts.database == 'ALL')
         # While the incremental search bar is active, suppress the selected-line
         # highlight so the pattern being typed is visually unambiguous.
@@ -209,7 +218,10 @@ class HomeScreen(VappmanScreen):
             """True when the given row should be shown as the selected line."""
             return not searching and row_idx == win.pick_pos
 
-        win.set_pick_mode(not searching)
+        # Content and the pick state live on the screen (console-window 3.0), so
+        # the writers below are Screen methods; only the demo indicator and the
+        # terminal width are the window's.
+        self.set_pick_mode(not searching)
         win.set_demo_mode(app.opts.demo_mode)
 
         title = "APPMAN"
@@ -252,7 +264,7 @@ class HomeScreen(VappmanScreen):
                 # Colour is decoration: installed rows are also marked by ✔/🔒
                 # and the S/U flags, so HOTSWAP only reinforces them.
                 attr = semantic_attr(Theme.HOTSWAP) if status == 'installed' else None
-                win.add_body(line, attr=attr, context=Context(status, info=ns))
+                self.add_body(line, attr=attr, context=Context(status, info=ns))
 
                 if picked(idx):
                     selected_key = (appname, db)
@@ -267,7 +279,7 @@ class HomeScreen(VappmanScreen):
                             # TRANSIENT (non-pickable) so the engine's auto-abut
                             # reserves the row even when the pick sits at the
                             # viewport bottom.
-                            win.add_body(
+                            self.add_body(
                                 prompt, attr=cs.A_BOLD | semantic_attr(Theme.DANGER),
                                 context=Context("TRANSIENT", pickable=False))
                 idx += 1
@@ -293,7 +305,7 @@ class HomeScreen(VappmanScreen):
                 else:
                     line += ns.synopsis
 
-                win.add_body(line, context=Context("uninstalled", info=ns))
+                self.add_body(line, context=Context("uninstalled", info=ns))
 
                 if picked(idx):
                     selected_key = (appname, db)
@@ -304,11 +316,11 @@ class HomeScreen(VappmanScreen):
                         # TRANSIENT (non-pickable) so the engine's auto-abut
                         # reserves both lines -- a DECOR row would not be
                         # counted, and the prompt could fall off-screen.
-                        win.add_body(
-                            f'    ⚠️  Install {appname}?',
+                        self.add_body(
+                            f'    {notice_mark()}  Install {appname}?',
                             attr=cs.A_BOLD | semantic_attr(Theme.DANGER),
                             context=Context("TRANSIENT", pickable=False))
-                        win.add_body(
+                        self.add_body(
                             '    ' + install_options_legend(app.opts.install_opts),
                             attr=cs.A_DIM,
                             context=Context("TRANSIENT", pickable=False))
@@ -324,7 +336,7 @@ class HomeScreen(VappmanScreen):
         #############################################
         header1 = f'{title}  {app.get_keys_line()}'
         # Use fancy header formatting to highlight keys automatically
-        win.add_fancy_header(header1, app.opts.fancy_header, line_attr=cs.A_DIM)
+        self.add_fancy_header(header1, app.opts.fancy_header, line_attr=cs.A_DIM)
 
         # Build dynamic action keys (e.g., " [r]mv [u]pd [b]kup")
         # Get base header line and combine with dynamic actions
@@ -349,7 +361,7 @@ class HomeScreen(VappmanScreen):
                 else:
                     header2 += ' [i]nstall [a]bout'
 
-        win.add_fancy_header(header2, app.opts.fancy_header, line_attr=cs.A_DIM)
+        self.add_fancy_header(header2, app.opts.fancy_header, line_attr=cs.A_DIM)
 
     def appman_on_installed(self, verb):
         """ TBD """
@@ -501,21 +513,39 @@ class VappmanHelpScreen(BasicHelpScreen):
         self.app.ss.push(THEMES_ST, self.app.win.pick_pos)
 
 
-# console-window's generic picker draws the swatches and the hint line; only
-# the cycle is overridden so vappman's 'mono' pseudo-theme is part of the
-# rotation and the process-wide colour switch follows it.  Keeping the generic
-# draw means the preview is console-window's role set, not a vappman copy.
+# Key that cycles the appearance; the picker's hint line advertises it.
+THEME_CYCLE_KEY = 't'
+
+# One dim line under the swatches.  It must not explain mono: a picker entry
+# named 'mono' with a monochrome preview explains itself, and the sentence
+# showed under every colour theme as well.
+THEME_PICKER_NOTE = 'The choice is remembered for the next run.'
+
+# console-window paints the swatches through its appearance layer, so they
+# follow the same process-wide colour switch vappman flips for 'mono': with
+# colour off the picker shows the monochrome role hierarchy instead of the
+# previous palette.  Only the cycle and the header label are vappman's.
 _ThemePickerScreen = Theme.create_picker_screen(
     VappmanScreen,
-    cycle_key='t',
-    note='The last entry, mono, uses no colour at all. '
-         'The choice is remembered for the next run.',
+    cycle_key=THEME_CYCLE_KEY,
+    note=THEME_PICKER_NOTE,
 )
 
 
 class VappmanThemeScreen(_ThemePickerScreen):
     """Theme picker over console-window's themes plus vappman's 'mono'."""
 
+    def theme_label(self, theme_name):
+        """Name 'mono' while colour is off, so header and swatches agree.
+
+        With colour on the generic label names the installed palette.  With
+        colour off the swatches are drawn from the monochrome role attributes,
+        so naming the palette left underneath would tell a different story.
+        """
+        if not colors_enabled():
+            return MONO_THEME
+        return super().theme_label(theme_name)
+
     def spin_theme_ACTION(self):
         """'t' advances to the next appearance (mono included) and persists it."""
         self.app.cycle_appearance()
@@ -592,13 +622,13 @@ class Vappman(Prerequisites):
         win_opts.dialog_abort = True
         win_opts.ctrl_c_terminates = False
         win_opts.min_cols_rows = (60, 10)
-        win_opts.theme = self.appearance_theme or 'default'
+        # 'mono' is a real theme in console-window 3.0, so the window is created
+        # on the appearance actually in effect instead of being relabelled after
+        # construction (the switch alone used to carry the choice).
+        win_opts.theme = MONO_THEME if not self.appearance_colors else (
+            self.appearance_theme or 'default')
 
         self.win = ConsoleWindow(win_opts)
-        if not self.appearance_colors:
-            # 'mono' is not a library theme; record it on the window for the
-            # picker's header while the installed palette stays at the default.
-            self.win.theme = MONO_THEME
 
         # Initialize screens and screen stack
         self.screens = {
@@ -608,10 +638,13 @@ class Vappman(Prerequisites):
         }
         self.ss = ScreenStack(self.win, None, SCREENS, self.screens)
 
-        spin = self.spin = OptionSpinner(stack=self.ss)
+        # console-window 3.0 registers ``quit`` (q, ^C) and ``escape``
+        # (ESC, ^J, ENTER) itself, before anything else, so the quit key set is
+        # a constructor argument rather than a second registration of the same
+        # name.  'x' stays an alternative quit key; ^C is delivered as a key
+        # because ctrl_c_terminates is False above.
+        spin = self.spin = OptionSpinner(stack=self.ss, quit_keys='qx\x03')
         self.opts = spin.default_obj
-        spin.add_key('quit', 'q,x - quit program (CTL-C disabled)',
-                     genre='action', keys='qx')
         spin.add_key('help', '? - enter help screen', genre='action')
         dbs = sorted(list(self.cache_mgr.dbs))
         spin.add_key('database', 'd - select app database', vals=['ALL'] + dbs)
@@ -631,11 +664,17 @@ class Vappman(Prerequisites):
         spin.add_key('update_all', 'U - update ALL installed apps', genre='action')
         spin.add_key('reinstall_all', 'R - reinstall ALL apps w updated install script', genre='action')
         spin.add_key('slash', '/ - filter apps by keywords or regex', genre='action')
-        spin.add_key('escape_filter', 'ESC - clear filter and jump to top', genre='action', keys=27)
+        # ESC is reserved by the built-in 'escape' action; claiming it on HOME
+        # only is an explicit, per-screen override, which is what clears a filter
+        # without leaving the screen.
+        spin.add_key('escape_filter', 'ESC - clear filter and jump to top',
+                     genre='action', keys=27, scope=HOME_ST)
 
         spin.add_key('install', 'i - install uninstalled app', genre='action')
+        # ENTER/^J also belong to the built-in 'escape' action, so the
+        # install/uninstall shortcut is an explicit HOME-only override.
         spin.add_key('default', 'ENTER - install/uninstall app',
-                     genre='action', keys=[cs.KEY_ENTER, 10])
+                     genre='action', keys=[cs.KEY_ENTER, 10], scope=HOME_ST)
         spin.add_key('remove', 'r - remove installed app', genre='action')
 
         spin.add_key('sandbox', 'S - Sandbox/Unsandbox app', genre='action')
@@ -745,7 +784,10 @@ class Vappman(Prerequisites):
                 result = subprocess.run(command, stdout=subprocess.PIPE,
                         stderr=subprocess.PIPE, check=False)
             except Exception as exc:
-                ConsoleWindow.stop_curses()
+                # stop_all() is the permanent teardown in every mode; the bare
+                # ConsoleWindow.stop_curses() class call only exists for
+                # singleton mode and raises when no window was ever created.
+                ConsoleWindow.stop_all()
                 if switch_to_system_mode is True:
                     self.appman.set_system_mode_cheat(False)
                 print(f'FAILED: {command}: {exc}')
@@ -813,9 +855,13 @@ class Vappman(Prerequisites):
         last_database = self.opts.database
 
         while True:
-            # Get and draw current screen
-            screen_num = self.ss.curr.num
-            self.screens[screen_num].draw_screen()
+            # The 3.0 loop: clear() adopts the screen on the window (and resets
+            # its content), draw_screen() appends the rows, render() paints them.
+            # Clearing first is what makes the screen current, so the writers in
+            # draw_screen() and the pick state read below belong to it.
+            screen = self.screens[self.ss.curr.num]
+            screen.clear()
+            screen.draw_screen()
 
             win.render()
             key = win.prompt(seconds=self.next_prompt_seconds[0])
@@ -864,8 +910,6 @@ class Vappman(Prerequisites):
                         last_database = self.opts.database
                         self.restore_selection(self.pick_identity)
 
-            win.clear()
-
     def _handle_confirmation_key(self, key):
         """Route one key to the active inline install/remove confirmation."""
         if self.confirmation.action_type == 'install':
@@ -1038,19 +1082,20 @@ class Vappman(Prerequisites):
         """Make *name* live ('mono' turns colour off) and remember it.
 
         The preference is written immediately so an early exit cannot lose it,
-        and the window is told so its own ``theme`` (which the generic picker
-        reads for the header) matches the colour table that was installed.
+        and the window is told which theme was installed.  ``mono`` is a real
+        console-window theme in 3.0, so the window is given that name: a reader
+        of ``win.theme`` sees the no-colour appearance, and ``Theme.set_active``
+        (called by ``set_theme``) turns the semantic-colour switch off with it.
+        The switch is also set here, because vappman resolves the preference
+        pair before any window exists and a host without ``set_theme`` must
+        still end up monochrome.
         """
         mono = name == MONO_THEME
         self.appearance_colors = not mono
         # '' is the library default; keep the saved file canonical.
         self.appearance_theme = '' if mono or name == 'default' else name
+        self.win.set_theme(MONO_THEME if mono else name)
         set_colors_enabled(not mono)
-        self.win.set_theme('default' if mono else name)
-        if mono:
-            # 'mono' is not a library theme: record it for the picker's header
-            # while the installed palette stays at the library default.
-            self.win.theme = MONO_THEME
         self.disk_state.theme = self.appearance_theme
         self.disk_state.colors = self.appearance_colors
         self.disk_state.save()
@@ -1191,7 +1236,8 @@ def main():
             print(line)
 
         if has_critical:
-            print("\n⚠ Critical issues found! Run 'vappman --check-appimage' for detailed fixes")
+            print(f"\n{notice_mark()} Critical issues found! "
+                  "Run 'vappman --check-appimage' for detailed fixes")
             print("Starting TUI in 3 seconds...")
             time.sleep(3)
         print()
@@ -1202,7 +1248,9 @@ def main():
     except KeyboardInterrupt:
         pass
     except Exception as exce:
-        ConsoleWindow.stop_curses()
+        # Tear down whatever exists (a failure before the window was created is
+        # common here, and stop_all() tolerates it).
+        ConsoleWindow.stop_all()
         print("exception:", str(exce))
         print(traceback.format_exc())
 

vappman-2.2.1/vappman/Appearance.py

@@ -1,119 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""Semantic colour roles and the appearance preferences for vappman.
-
-Colour is decoration, never information.  Every role degrades to an attribute
-(or to plain text) when the terminal has no colour, so the installed markers
-(``✔``/``🔒``), the ``S``/``U`` flags and the ``⚠️`` prompts always remain
-readable on a monochrome terminal.
-
-The role ids are ``console_window.Theme``'s semantic pairs rather than literal
-colour numbers.  console-window installs those pairs at startup and re-installs
-them whenever a theme is applied, so changing the active theme recolours the
-whole UI without an edit to any draw code.
-
-``mono`` is vappman's own no-colour pseudo-theme: console-window's
-``dark-mono``/``light-mono`` are still colour themes, so the true monochrome
-appearance lives here as the :data:`MONO_ROLES` mapping.  It is part of the
-picker's rotation but is not a library theme.
-"""
-
-import os
-import curses
-
-from console_window import Theme
-
-# vappman's pseudo-theme: no colour at all, only attributes.
-MONO_THEME = 'mono'
-
-# Role -> attribute used when colour is off.  The hierarchy is preserved with
-# emphasis instead of hue: destructive prompts are bold+reverse, informational
-# rows carry nothing (their ✔/🔒 and S/U markers already distinguish them).
-MONO_ROLES = {
-    Theme.DANGER: curses.A_BOLD | curses.A_REVERSE,
-    Theme.ERROR: curses.A_BOLD | curses.A_REVERSE,
-    Theme.WARNING: curses.A_BOLD,
-    Theme.SUCCESS: curses.A_BOLD,
-    Theme.EMPHASIS: curses.A_BOLD,
-    Theme.INFO: curses.A_NORMAL,
-    Theme.PROGRESS: curses.A_NORMAL,
-    Theme.OLD_SUCCESS: curses.A_NORMAL,
-    Theme.HOTSWAP: curses.A_NORMAL,
-}
-
-# Process-wide switch, seeded at startup by --no-color / NO_COLOR / mono.  One
-# terminal, so one decision.
-_COLORS_ENABLED = True
-
-
-def set_colors_enabled(enabled):
-    """Turn semantic colour on or off for the whole process."""
-    global _COLORS_ENABLED  # pylint: disable=global-statement
-    _COLORS_ENABLED = bool(enabled)
-
-
-def colors_enabled():
-    """True while semantic roles resolve to colour pairs rather than attributes."""
-    return _COLORS_ENABLED
-
-
-def semantic_attr(pair_id):
-    """Attribute for a console-window ``Theme`` role, or plain when no colour.
-
-    With colour off the role becomes an attribute from :data:`MONO_ROLES`, so
-    the UI keeps its emphasis hierarchy on a monochrome terminal.  Otherwise
-    both ``curses.has_colors()`` and ``curses.color_pair()`` can raise
-    ``curses.error`` before ``initscr()`` (and a failed lookup must never abort
-    a redraw), so any failure degrades to plain text.
-    """
-    if not _COLORS_ENABLED:
-        return MONO_ROLES.get(pair_id, curses.A_NORMAL)
-    try:
-        if not curses.has_colors():
-            return 0
-        return curses.color_pair(pair_id)
-    except curses.error:
-        return 0
-
-
-def appearance_choices():
-    """Every appearance the picker cycles, in order.
-
-    console-window's themes come first (in ``Theme.THEMES`` order), then
-    vappman's no-colour pseudo-theme, so one cycle always reaches ``mono``.
-    """
-    return list(Theme.list_all()) + [MONO_THEME]
-
-
-def appearance_label(theme, colors):
-    """The name to show for the live appearance."""
-    if not colors:
-        return MONO_THEME
-    return theme or 'default'
-
-
-def resolve_ui_prefs(cli_theme=None, no_color=False, saved_theme='',
-                     saved_colors=True, environ=None):
-    """Starting ``(theme, colors)`` from the flag, the environment and the prefs.
-
-    Precedence, highest first: an explicit ``--theme`` / ``--no-color``, the
-    ``NO_COLOR`` convention (any non-empty value disables colour), then the
-    remembered choice.  An explicit ``--theme`` is a statement of intent, so it
-    re-enables colour even when the saved choice was ``mono`` (unless
-    ``--no-color`` says otherwise); an unknown theme name falls back to
-    console-window's ``default``.
-
-    ``theme`` is ``''`` for the library default.  The special value ``mono``
-    forces ``colors`` off and is reported as ``theme=''``: there is no library
-    theme to install, because mono is the attribute mapping in this module.
-    """
-    env = os.environ if environ is None else environ
-    if cli_theme:
-        if cli_theme == MONO_THEME:
-            return '', False
-        return Theme.resolve(cli_theme), not no_color
-    theme = '' if saved_theme in (None, MONO_THEME) else Theme.resolve(saved_theme)
-    colors = bool(saved_colors) and saved_theme != MONO_THEME
-    if env.get('NO_COLOR') or no_color:
-        colors = False
-    return theme, colors