Installers / windows-x64 (push) Canceled after 0s
Installers / macos-x64 (push) Canceled after 0s
Installers / macos-arm64 (push) Canceled after 0s
Installers / linux-x64 (push) Canceled after 0s
Installers / linux-arm64 (push) Canceled after 0s
GitHub release / build (push) Canceled after 0s
GitHub release / create the release (push) Canceled after 0s
MeshTerm died building its screen on Windows with a ctypes type error, and on a double-clicked build the traceback and the window it printed to were destroyed together — which is why this needed a log file before it could be looked at. `ctypes.windll.kernel32` is a cache. Every caller in the process receives the same object and each function on it is a shared attribute, so declaring `.argtypes` is not configuration, it is a process-wide mutation where the last writer wins. The emoji-width probe declared `GetConsoleScreenBufferInfo` as taking a pointer to its own copy of the screen-buffer struct; prompt_toolkit then called that same function object with a pointer to its own copy — same layout, different class — and ctypes refused it. Nothing here reaches for `ctypes.windll` any more. Five call sites take private handles from `core/win32dll.py`, built by constructing `WinDLL` directly so each one gets its own function cache and a declaration made for one purpose cannot be seen by anything else. Each call returns a fresh handle, because two parts of MeshTerm disagreeing about a signature is the same bug in miniature. The regression test was checked against the defect rather than assumed to cover it: with the old line restored it fails, and with the fix it passes. A test that passes either way would only have recorded that somebody thought about the problem. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
680 lines
25 KiB
Python
680 lines
25 KiB
Python
"""Terminal font detection — can this terminal draw powerline path separators?
|
||
|
||
The path-line widget (:mod:`~meshterm.ui.pathline`) can render a hop sequence as
|
||
interlocking powerline segments — each hop a colour-filled chip, joined by the solid
|
||
triangle U+E0B0 whose foreground is the previous chip's fill and whose background is
|
||
the next's, the oh-my-posh look. That triangle lives in the Private Use Area, so it
|
||
only draws when the *terminal's configured font* (or the terminal itself) supplies the
|
||
glyph; a font without it shows tofu boxes. Nothing in-band can ask "do you have this
|
||
glyph?" — a missing glyph still occupies its cell, so even cursor-position probes see
|
||
nothing — which makes this an *out-of-band* detection problem: identify the terminal,
|
||
read its configuration, and match the configured face against fonts known to carry the
|
||
powerline block.
|
||
|
||
Three sources of truth, in confidence order:
|
||
|
||
* **An explicit override** — ``MESHTERM_POWERLINE`` (``1``/``full``, ``core``,
|
||
``0``/``off``) always wins, the same gate pattern as ``MESHTERM_FULL_WIDTH``. The
|
||
user knows their glass better than any probe.
|
||
* **The configured font**, resolved per terminal: Windows Terminal (``WT_SESSION`` +
|
||
``WT_PROFILE_ID`` → the profile's ``font.face`` in ``settings.json``), VS Code's
|
||
integrated terminal (``TERM_PROGRAM=vscode`` → ``terminal.integrated.fontFamily``,
|
||
workspace over user, falling back to ``editor.fontFamily``), and classic conhost
|
||
(``GetCurrentConsoleFontEx`` — trusted only when no ConPTY host is detected, because
|
||
the hidden conhost under one reports a stub face, not what's on screen). The face is
|
||
matched against :data:`RECOMMENDED_FONTS` — the list MeshTerm recommends to users —
|
||
with the alias spellings Nerd Fonts ship under (``Hack Nerd Font Mono`` / ``Hack
|
||
NFM``), plus a generic "any Nerd Font" rule, since every Nerd Font patch carries the
|
||
full powerline block.
|
||
* **The terminal's own renderer**: several terminals draw the core triangles
|
||
regardless of font — Windows Terminal falls back to its bundled Cascadia Code NF for
|
||
the symbol ranges (≥ 1.22), VS Code's terminal draws them as custom glyphs
|
||
(``terminal.integrated.customGlyphs``, default on), and kitty / WezTerm / Alacritty
|
||
ship built-in powerline glyphs. Those count as ``core`` support even when the
|
||
configured font matches nothing.
|
||
|
||
Coverage comes in two levels: ``full`` (a Nerd Font patch — triangles *and* the
|
||
extended block: rounded caps, slants) and ``core`` (just U+E0B0–U+E0B3, which many
|
||
stock coder fonts — Fira Code, JetBrains Mono, Source Code Pro — include natively).
|
||
The path widget only uses the core triangle, so ``core`` is enough to switch it on;
|
||
``full`` is headroom for fancier chrome. When nothing can be known — an ssh session
|
||
(the font lives on the far client's machine), an unrecognised terminal — the verdict
|
||
is honestly ``unknown`` and callers should keep the plain-arrow rendering.
|
||
|
||
Every probe is best-effort: unreadable settings, missing registry keys, or a failed
|
||
Win32 call degrade the verdict, never raise. The result is a *hint that picks a
|
||
default*, not a gate the user has to fight.
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import json
|
||
import os
|
||
import re
|
||
import sys
|
||
from collections.abc import Callable, Iterable, Mapping
|
||
from dataclasses import dataclass
|
||
from functools import lru_cache
|
||
from pathlib import Path
|
||
|
||
from ..core import win32dll
|
||
|
||
#: Coverage levels a verdict (or a recommended font) can carry, strongest first.
|
||
FULL = "full"
|
||
CORE = "core"
|
||
NONE = "none"
|
||
UNKNOWN = "unknown"
|
||
|
||
|
||
@dataclass(frozen=True)
|
||
class RecommendedFont:
|
||
"""One font MeshTerm recommends for powerline path rendering.
|
||
|
||
Attributes:
|
||
name: The canonical display name (what a recommendation screen shows).
|
||
aliases: Normalised name prefixes that identify the family — every spelling a
|
||
terminal config might hold, lower-case with collapsed spaces (Nerd Fonts
|
||
deliberately ship several: ``hack nerd font mono`` and ``hack nfm`` are the
|
||
same file).
|
||
coverage: :data:`FULL` when the family carries the whole powerline block
|
||
(Nerd Font patches), :data:`CORE` when it ships just the four triangles.
|
||
"""
|
||
|
||
name: str
|
||
aliases: tuple[str, ...]
|
||
coverage: str
|
||
|
||
|
||
#: The fonts MeshTerm recommends, full-coverage Nerd Fonts first — order matters, the
|
||
#: first alias hit wins, so ``JetBrainsMono Nerd Font`` must match its ``full`` entry
|
||
#: before the plain ``JetBrains Mono`` prefix could claim it as ``core``.
|
||
RECOMMENDED_FONTS: tuple[RecommendedFont, ...] = (
|
||
RecommendedFont(
|
||
"MesloLGM Nerd Font",
|
||
(
|
||
"meslolgm nerd font",
|
||
"meslolgs nerd font",
|
||
"meslolgl nerd font",
|
||
"meslolgm nf",
|
||
"meslolgs nf",
|
||
"meslolgl nf",
|
||
"meslo lgm nerd font",
|
||
"meslo lgs nerd font",
|
||
),
|
||
FULL,
|
||
),
|
||
RecommendedFont(
|
||
"Hack Nerd Font",
|
||
("hack nerd font", "hack nf", "hack nfm", "hack nfp"),
|
||
FULL,
|
||
),
|
||
RecommendedFont(
|
||
"CaskaydiaCove Nerd Font",
|
||
(
|
||
"caskaydiacove nerd font",
|
||
"caskaydiacove nf",
|
||
"caskaydiacove nfm",
|
||
"caskaydiamono nerd font",
|
||
"caskaydiamono nf",
|
||
"caskaydia cove nerd font",
|
||
),
|
||
FULL,
|
||
),
|
||
RecommendedFont(
|
||
"Cascadia Code NF",
|
||
("cascadia code nf", "cascadia mono nf"),
|
||
FULL,
|
||
),
|
||
RecommendedFont(
|
||
"FiraCode Nerd Font",
|
||
("firacode nerd font", "firacode nf", "firacode nfm", "fira code nerd font"),
|
||
FULL,
|
||
),
|
||
RecommendedFont(
|
||
"JetBrainsMono Nerd Font",
|
||
(
|
||
"jetbrainsmono nerd font",
|
||
"jetbrainsmono nf",
|
||
"jetbrainsmono nfm",
|
||
"jetbrains mono nerd font",
|
||
),
|
||
FULL,
|
||
),
|
||
RecommendedFont("Cascadia Code PL", ("cascadia code pl", "cascadia mono pl"), CORE),
|
||
RecommendedFont("Fira Code", ("fira code",), CORE),
|
||
RecommendedFont("JetBrains Mono", ("jetbrains mono",), CORE),
|
||
RecommendedFont("Source Code Pro", ("source code pro", "source code variable"), CORE),
|
||
RecommendedFont("Iosevka", ("iosevka",), CORE),
|
||
)
|
||
|
||
#: The catch-all for a patched font the explicit list doesn't spell out: any family
|
||
#: whose name carries the Nerd Font branding — the long ``… Nerd Font [Mono|Propo]``
|
||
#: or the v3 short suffixes ``NF``/``NFM``/``NFP`` — has the full powerline block.
|
||
NERD_FONT_GENERIC = RecommendedFont("Nerd Font (patched)", (), FULL)
|
||
|
||
_NERD_RE = re.compile(r"\bnerd font\b|\bnf[mp]?\b")
|
||
|
||
|
||
@dataclass(frozen=True)
|
||
class FontDetection:
|
||
"""The configured terminal font, and which terminal it was read from.
|
||
|
||
Attributes:
|
||
face: The font family name as configured (unnormalised).
|
||
source: ``"windows-terminal"``, ``"vscode"``, or ``"conhost"``.
|
||
"""
|
||
|
||
face: str
|
||
source: str
|
||
|
||
|
||
@dataclass(frozen=True)
|
||
class PowerlineSupport:
|
||
"""The verdict: how confidently this terminal can draw powerline separators.
|
||
|
||
Attributes:
|
||
level: :data:`FULL`, :data:`CORE`, :data:`NONE`, or :data:`UNKNOWN`.
|
||
source: What decided it — ``"env"`` (the override), ``"font:<terminal>"``
|
||
(a configured face matched, or definitively didn't), ``"renderer:<terminal>"``
|
||
(the terminal draws the glyphs itself), ``"ssh"`` (the font lives on the far
|
||
client, unknowable), or ``"unknown"``.
|
||
face: The configured face when one was found, for the curious.
|
||
matched: The recommended-list entry the face matched, if any.
|
||
"""
|
||
|
||
level: str
|
||
source: str
|
||
face: str | None = None
|
||
matched: RecommendedFont | None = None
|
||
|
||
@property
|
||
def capable(self) -> bool:
|
||
"""Whether the core triangle (all the path widget needs) will draw."""
|
||
return self.level in (FULL, CORE)
|
||
|
||
|
||
# --- name matching ---------------------------------------------------------------
|
||
|
||
|
||
def primary_family(value: str) -> str:
|
||
"""The first family of a CSS-style font list, unquoted.
|
||
|
||
VS Code stores ``"'Hack Nerd Font Mono', monospace"``; the first family is the
|
||
one the renderer tries first, so it is the one we judge.
|
||
|
||
Args:
|
||
value: A font-family setting value (single name or comma list).
|
||
|
||
Returns:
|
||
The first family with quotes and outer whitespace stripped.
|
||
"""
|
||
first = value.split(",")[0]
|
||
return first.strip().strip("'\"").strip()
|
||
|
||
|
||
def normalize_face(face: str) -> str:
|
||
"""Fold a face name to its matchable form: lower-case, single-spaced, unquoted.
|
||
|
||
Args:
|
||
face: A font family name as a config file spells it.
|
||
|
||
Returns:
|
||
The normalised name (may be empty).
|
||
"""
|
||
return " ".join(face.strip().strip("'\"").lower().split())
|
||
|
||
|
||
def match_recommended(face: str | None) -> RecommendedFont | None:
|
||
"""Match a configured face against the recommended-font list.
|
||
|
||
A face matches an entry when it *is* one of the entry's aliases or extends one as
|
||
a longer family name (``hack nerd font mono`` extends ``hack nerd font``); the
|
||
generic Nerd Font rule (:data:`NERD_FONT_GENERIC`) catches patched families the
|
||
explicit list doesn't spell out.
|
||
|
||
Args:
|
||
face: The configured font family (single name or comma list); ``None`` is a
|
||
polite no-op.
|
||
|
||
Returns:
|
||
The matched :class:`RecommendedFont`, or ``None`` when the face is unknown.
|
||
"""
|
||
if not face:
|
||
return None
|
||
norm = normalize_face(primary_family(face))
|
||
if not norm:
|
||
return None
|
||
for spec in RECOMMENDED_FONTS:
|
||
if any(norm == alias or norm.startswith(alias + " ") for alias in spec.aliases):
|
||
return spec
|
||
if _NERD_RE.search(norm):
|
||
return NERD_FONT_GENERIC
|
||
return None
|
||
|
||
|
||
# --- config-file reading ---------------------------------------------------------
|
||
|
||
|
||
def _strip_jsonc(text: str) -> str:
|
||
"""Strip ``//`` and ``/* */`` comments from JSON-with-comments, string-safely."""
|
||
out: list[str] = []
|
||
i, n = 0, len(text)
|
||
in_string = False
|
||
while i < n:
|
||
ch = text[i]
|
||
if in_string:
|
||
out.append(ch)
|
||
if ch == "\\" and i + 1 < n: # keep the escaped char verbatim
|
||
out.append(text[i + 1])
|
||
i += 2
|
||
continue
|
||
if ch == '"':
|
||
in_string = False
|
||
i += 1
|
||
continue
|
||
if ch == '"':
|
||
in_string = True
|
||
out.append(ch)
|
||
i += 1
|
||
continue
|
||
if ch == "/" and i + 1 < n and text[i + 1] == "/":
|
||
while i < n and text[i] != "\n":
|
||
i += 1
|
||
continue
|
||
if ch == "/" and i + 1 < n and text[i + 1] == "*":
|
||
i += 2
|
||
while i + 1 < n and not (text[i] == "*" and text[i + 1] == "/"):
|
||
i += 1
|
||
i += 2
|
||
continue
|
||
out.append(ch)
|
||
i += 1
|
||
return "".join(out)
|
||
|
||
|
||
def _read_jsonc(path: Path) -> dict | None:
|
||
"""Parse a JSONC settings file (comments, trailing commas), ``None`` on any failure.
|
||
|
||
Both Windows Terminal and VS Code write JSON-with-comments; a strict parser dies
|
||
on the first ``//``. Trailing commas are swept with a best-effort regex after the
|
||
string-aware comment strip (a *string* containing ``", }"`` could theoretically be
|
||
clipped — no font config holds one).
|
||
"""
|
||
try:
|
||
text = path.read_text(encoding="utf-8-sig")
|
||
data = json.loads(re.sub(r",\s*([}\]])", r"\1", _strip_jsonc(text)))
|
||
return data if isinstance(data, dict) else None
|
||
except Exception:
|
||
return None
|
||
|
||
|
||
def _profile_face(profile: object) -> str | None:
|
||
"""A Windows Terminal profile's configured font face.
|
||
|
||
Reads the new ``font.face`` or the legacy ``fontFace``, and answers ``None`` when
|
||
the profile leaves the choice to the defaults chain.
|
||
"""
|
||
if not isinstance(profile, dict):
|
||
return None
|
||
font = profile.get("font")
|
||
if isinstance(font, dict):
|
||
face = font.get("face")
|
||
if isinstance(face, list) and face: # defensive: an array face takes its head
|
||
face = face[0]
|
||
if isinstance(face, str) and face.strip():
|
||
return face
|
||
legacy = profile.get("fontFace")
|
||
if isinstance(legacy, str) and legacy.strip():
|
||
return legacy
|
||
return None
|
||
|
||
|
||
def _wt_settings_paths(environ: Mapping[str, str]) -> list[Path]:
|
||
"""Where Windows Terminal might keep its ``settings.json``.
|
||
|
||
The packaged, preview, and unpackaged locations — existing files only.
|
||
"""
|
||
local = environ.get("LOCALAPPDATA")
|
||
if not local:
|
||
return []
|
||
base = Path(local)
|
||
candidates: list[Path] = []
|
||
try:
|
||
packages = base / "Packages"
|
||
if packages.is_dir():
|
||
candidates.extend(
|
||
sorted(packages.glob("Microsoft.WindowsTerminal*/LocalState/settings.json"))
|
||
)
|
||
except OSError:
|
||
pass
|
||
candidates.append(base / "Microsoft" / "Windows Terminal" / "settings.json")
|
||
return [p for p in candidates if p.is_file()]
|
||
|
||
|
||
def _windows_terminal_face(environ: Mapping[str, str]) -> str:
|
||
"""The face Windows Terminal is rendering this session with.
|
||
|
||
Resolved the way the terminal itself does: the ``WT_PROFILE_ID`` profile's font,
|
||
else ``profiles.defaults``, else the built-in default ``Cascadia Mono``. An
|
||
unreadable settings file lands on the built-in default too — a pristine install
|
||
is exactly that.
|
||
"""
|
||
guid = (environ.get("WT_PROFILE_ID") or "").strip().lower()
|
||
for path in _wt_settings_paths(environ):
|
||
data = _read_jsonc(path)
|
||
if data is None:
|
||
continue
|
||
profiles = data.get("profiles")
|
||
plist: list = []
|
||
defaults: object = {}
|
||
if isinstance(profiles, dict):
|
||
plist = profiles.get("list") or []
|
||
defaults = profiles.get("defaults") or {}
|
||
elif isinstance(profiles, list): # the ancient flat-list schema
|
||
plist = profiles
|
||
profile = (
|
||
next(
|
||
(
|
||
p
|
||
for p in plist
|
||
if isinstance(p, dict) and str(p.get("guid", "")).strip().lower() == guid
|
||
),
|
||
None,
|
||
)
|
||
if guid
|
||
else None
|
||
)
|
||
face = _profile_face(profile) or _profile_face(defaults)
|
||
if face:
|
||
return face
|
||
break # a parsed settings file with no face set → the built-in default
|
||
return "Cascadia Mono"
|
||
|
||
|
||
def _vscode_settings_paths(environ: Mapping[str, str], start: Path | None) -> list[Path]:
|
||
"""VS Code's settings files, nearest first.
|
||
|
||
The closest workspace, then the user's own (stable and Insiders, in their
|
||
per-platform locations) — existing files only.
|
||
"""
|
||
paths: list[Path] = []
|
||
try:
|
||
here = (start or Path.cwd()).resolve()
|
||
for folder in (here, *here.parents):
|
||
candidate = folder / ".vscode" / "settings.json"
|
||
if candidate.is_file():
|
||
paths.append(candidate)
|
||
break
|
||
except OSError:
|
||
pass
|
||
roots: list[Path] = []
|
||
appdata = environ.get("APPDATA")
|
||
if appdata:
|
||
roots.append(Path(appdata))
|
||
home = environ.get("HOME") or environ.get("USERPROFILE")
|
||
if home:
|
||
roots.append(Path(home) / ".config")
|
||
roots.append(Path(home) / "Library" / "Application Support")
|
||
for root in roots:
|
||
for flavour in ("Code", "Code - Insiders"):
|
||
candidate = root / flavour / "User" / "settings.json"
|
||
if candidate.is_file():
|
||
paths.append(candidate)
|
||
return paths
|
||
|
||
|
||
def _vscode_default_face() -> str:
|
||
"""VS Code's per-platform default editor font family's first name."""
|
||
if sys.platform == "win32":
|
||
return "Consolas"
|
||
if sys.platform == "darwin":
|
||
return "Menlo"
|
||
return "Droid Sans Mono"
|
||
|
||
|
||
def _vscode_face(environ: Mapping[str, str], start: Path | None = None) -> str:
|
||
"""The face VS Code's integrated terminal is rendering with.
|
||
|
||
``terminal.integrated.fontFamily`` wins over ``editor.fontFamily`` (VS Code's own
|
||
fallback), and within each key the workspace file wins over the user file. The
|
||
stored value is a CSS-style comma list; the first family is judged.
|
||
"""
|
||
paths = _vscode_settings_paths(environ, start)
|
||
settings = [data for data in (_read_jsonc(p) for p in paths) if data is not None]
|
||
for key in ("terminal.integrated.fontFamily", "editor.fontFamily"):
|
||
for data in settings:
|
||
value = data.get(key)
|
||
if isinstance(value, str) and value.strip():
|
||
return primary_family(value)
|
||
return _vscode_default_face()
|
||
|
||
|
||
def _conhost_face() -> str | None:
|
||
"""The classic-console face via ``GetCurrentConsoleFontEx``, or ``None``.
|
||
|
||
Only meaningful on a *genuine* conhost — the caller gates on the absence of ConPTY
|
||
markers first, because the hidden conhost under Windows Terminal / VS Code reports
|
||
a stub face, not the glyphs on screen.
|
||
"""
|
||
if sys.platform != "win32":
|
||
return None
|
||
try:
|
||
import ctypes
|
||
import ctypes.wintypes as wintypes
|
||
|
||
kernel32 = win32dll.kernel32()
|
||
if not kernel32.GetConsoleWindow():
|
||
return None
|
||
|
||
class _COORD(ctypes.Structure):
|
||
_fields_ = [("X", wintypes.SHORT), ("Y", wintypes.SHORT)]
|
||
|
||
class _CONSOLE_FONT_INFOEX(ctypes.Structure):
|
||
_fields_ = [
|
||
("cbSize", wintypes.ULONG),
|
||
("nFont", wintypes.DWORD),
|
||
("dwFontSize", _COORD),
|
||
("FontFamily", wintypes.UINT),
|
||
("FontWeight", wintypes.UINT),
|
||
("FaceName", ctypes.c_wchar * 32),
|
||
]
|
||
|
||
info = _CONSOLE_FONT_INFOEX()
|
||
info.cbSize = ctypes.sizeof(_CONSOLE_FONT_INFOEX)
|
||
handle = kernel32.GetStdHandle(-11) # STD_OUTPUT_HANDLE
|
||
if not kernel32.GetCurrentConsoleFontEx(handle, False, ctypes.byref(info)):
|
||
return None
|
||
return info.FaceName or None
|
||
except Exception:
|
||
return None
|
||
|
||
|
||
# --- the ladder -------------------------------------------------------------------
|
||
|
||
|
||
def detect_terminal_font(
|
||
environ: Mapping[str, str] | None = None,
|
||
*,
|
||
cwd: Path | None = None,
|
||
conhost_probe: Callable[[], str | None] = _conhost_face,
|
||
) -> FontDetection | None:
|
||
"""Identify the terminal and read the font it is configured to render with.
|
||
|
||
The ladder, most to least certain: Windows Terminal (``WT_SESSION`` names the app,
|
||
``WT_PROFILE_ID`` the exact profile), VS Code (``TERM_PROGRAM=vscode``), then a
|
||
genuine classic conhost (no ConPTY markers, no ``TERM`` — a set ``TERM`` means some
|
||
other emulator is hosting the console) asked directly via Win32. Anything else —
|
||
an unrecognised terminal, an ssh session — is ``None``: the face is unknowable
|
||
from here.
|
||
|
||
Args:
|
||
environ: The environment to inspect (defaults to ``os.environ``).
|
||
cwd: Where the VS Code workspace walk starts (defaults to the process cwd).
|
||
conhost_probe: The classic-console face reader (injectable for tests).
|
||
|
||
Returns:
|
||
The configured face and its source, or ``None`` when no source applies.
|
||
"""
|
||
env = os.environ if environ is None else environ
|
||
if env.get("WT_SESSION"):
|
||
return FontDetection(_windows_terminal_face(env), "windows-terminal")
|
||
if (env.get("TERM_PROGRAM") or "").lower() == "vscode":
|
||
return FontDetection(_vscode_face(env, cwd), "vscode")
|
||
if not env.get("TERM") and not env.get("TERM_PROGRAM"):
|
||
face = conhost_probe()
|
||
if face:
|
||
return FontDetection(face, "conhost")
|
||
return None
|
||
|
||
|
||
def _renderer_backed(environ: Mapping[str, str]) -> str | None:
|
||
"""The terminal id when the terminal draws the core triangles itself.
|
||
|
||
Windows Terminal falls back to its bundled Cascadia Code NF for the powerline
|
||
symbol ranges (≥ 1.22), VS Code's terminal draws them as custom glyphs
|
||
(``terminal.integrated.customGlyphs``, default on), and kitty / WezTerm /
|
||
Alacritty ship built-in powerline glyphs — on those, the separators render
|
||
whatever the configured font holds.
|
||
"""
|
||
if environ.get("WT_SESSION"):
|
||
return "windows-terminal"
|
||
term_program = (environ.get("TERM_PROGRAM") or "").lower()
|
||
if term_program == "vscode":
|
||
return "vscode"
|
||
if term_program == "wezterm" or environ.get("WEZTERM_EXECUTABLE"):
|
||
return "wezterm"
|
||
if environ.get("KITTY_WINDOW_ID") or environ.get("TERM") == "xterm-kitty":
|
||
return "kitty"
|
||
if (
|
||
environ.get("ALACRITTY_WINDOW_ID")
|
||
or environ.get("ALACRITTY_SOCKET")
|
||
or environ.get("TERM") == "alacritty"
|
||
):
|
||
return "alacritty"
|
||
return None
|
||
|
||
|
||
def _powerline_support(
|
||
environ: Mapping[str, str] | None = None,
|
||
*,
|
||
cwd: Path | None = None,
|
||
conhost_probe: Callable[[], str | None] = _conhost_face,
|
||
) -> PowerlineSupport:
|
||
"""The uncached verdict (see :func:`powerline_support` for the ladder)."""
|
||
env = os.environ if environ is None else environ
|
||
override = (env.get("MESHTERM_POWERLINE") or "").strip().lower()
|
||
if override in {"0", "off", "no", "none", "false"}:
|
||
return PowerlineSupport(NONE, "env")
|
||
if override in {"1", "on", "yes", "true", "full"}:
|
||
return PowerlineSupport(FULL, "env")
|
||
if override == "core":
|
||
return PowerlineSupport(CORE, "env")
|
||
|
||
detected = detect_terminal_font(env, cwd=cwd, conhost_probe=conhost_probe)
|
||
matched = match_recommended(detected.face) if detected else None
|
||
if detected and matched:
|
||
return PowerlineSupport(matched.coverage, f"font:{detected.source}", detected.face, matched)
|
||
backed = _renderer_backed(env)
|
||
if backed:
|
||
return PowerlineSupport(CORE, f"renderer:{backed}", detected.face if detected else None)
|
||
if detected: # a face we could read, matching nothing, on a terminal with no fallback
|
||
return PowerlineSupport(NONE, f"font:{detected.source}", detected.face)
|
||
if env.get("SSH_CONNECTION") or env.get("SSH_TTY") or env.get("SSH_CLIENT"):
|
||
return PowerlineSupport(UNKNOWN, "ssh")
|
||
return PowerlineSupport(UNKNOWN, "unknown")
|
||
|
||
|
||
@lru_cache(maxsize=1)
|
||
def powerline_support() -> PowerlineSupport:
|
||
"""The session's powerline verdict, decided once and cached.
|
||
|
||
The ladder: the ``MESHTERM_POWERLINE`` override, then the configured font matched
|
||
against :data:`RECOMMENDED_FONTS`, then a renderer that draws the glyphs itself,
|
||
then an honest ``none`` (face read, no match, no fallback) or ``unknown`` (ssh, or
|
||
a terminal we can't identify). Cached because the environment and settings files
|
||
don't change mid-session; tests exercise :func:`_powerline_support` directly.
|
||
|
||
Returns:
|
||
The :class:`PowerlineSupport` verdict.
|
||
"""
|
||
return _powerline_support(os.environ)
|
||
|
||
|
||
def powerline_enabled() -> bool:
|
||
"""Whether path lines should default to powerline separators (see ``.capable``)."""
|
||
return powerline_support().capable
|
||
|
||
|
||
def powerline_full() -> bool:
|
||
"""Whether the *extended* block is there too — the rounded caps at U+E0B4+.
|
||
|
||
Only a Nerd Font patch carries them, so this is strictly narrower than
|
||
:func:`powerline_enabled`: a stock coder font (Fira Code, JetBrains Mono) draws
|
||
the core triangles natively and nothing beyond, and a terminal that supplies the
|
||
separators from its own renderer is only promising those four. Callers use it for
|
||
chrome that must degrade — :mod:`~meshterm.ui.pathline` rounds a path's two outer
|
||
ends when it is true and squares them off when it isn't.
|
||
"""
|
||
return powerline_support().level == FULL
|
||
|
||
|
||
# --- installed-font scan ----------------------------------------------------------
|
||
|
||
|
||
def _installed_families() -> Iterable[str]:
|
||
"""Every installed font family name this platform will admit to, best-effort."""
|
||
if sys.platform == "win32":
|
||
try:
|
||
import winreg
|
||
|
||
for root in (winreg.HKEY_LOCAL_MACHINE, winreg.HKEY_CURRENT_USER):
|
||
try:
|
||
key = winreg.OpenKey(
|
||
root, r"SOFTWARE\Microsoft\Windows NT\CurrentVersion\Fonts"
|
||
)
|
||
except OSError:
|
||
continue
|
||
with key:
|
||
for i in range(winreg.QueryInfoKey(key)[1]):
|
||
try:
|
||
name = winreg.EnumValue(key, i)[0]
|
||
except OSError:
|
||
break
|
||
# "Hack Nerd Font Mono (TrueType)" → "Hack Nerd Font Mono"
|
||
yield name.split(" (")[0]
|
||
except Exception:
|
||
return
|
||
return
|
||
try:
|
||
import subprocess
|
||
|
||
result = subprocess.run(
|
||
["fc-list", ":", "family"], capture_output=True, text=True, timeout=2
|
||
)
|
||
for line in result.stdout.splitlines():
|
||
for family in line.split(","):
|
||
if family.strip():
|
||
yield family.strip()
|
||
except Exception:
|
||
return
|
||
|
||
|
||
def installed_recommended() -> RecommendedFont | None:
|
||
"""The best recommended font *installed* on this machine, selected or not.
|
||
|
||
The weaker, always-available check that a future recommendation screen splits its
|
||
message on: "not installed — here's the list" versus "installed but not selected
|
||
in your terminal's profile" versus "active". Prefers :data:`FULL` coverage over
|
||
:data:`CORE`; returns ``None`` when nothing recommended is installed (or the
|
||
platform offers no way to ask).
|
||
"""
|
||
best: RecommendedFont | None = None
|
||
for family in _installed_families():
|
||
matched = match_recommended(family)
|
||
if matched is None:
|
||
continue
|
||
if matched.coverage == FULL:
|
||
return matched
|
||
best = best or matched
|
||
return best
|