skit-cli 0.0.1__py3-none-any.whl

skit/store.py

@@ -0,0 +1,566 @@
+"""Store + Registry (Layer 0).
+
+- Each script directory scripts/<slug>/ carries its own meta.toml (self-describing, C7).
+- registry.toml is only an index; doctor_rebuild() can fully reconstruct it from the metas.
+- All writes go through atomic replace.
+- This module is fully headless and imports no CLI/TUI dependency.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import hashlib
+import os
+import shutil
+import sys
+import time
+import tomllib
+from collections.abc import Callable, Iterator
+from pathlib import Path
+from typing import Any
+
+from . import argstate, pep723
+from .atomic import atomic_write_toml
+from .i18n import gettext
+from .models import Entry, Kind, Mode, ScriptMeta, ScriptMetaError, now_iso, slugify
+from .paths import registry_path, scripts_dir
+
+# Corruption/error types every meta.toml reader must treat the same way: valid-but-unreadable file,
+# invalid TOML, or valid TOML missing a required key are all "this entry is corrupt" — never a bare
+# KeyError/OSError escaping to a caller that only handles store errors (models.py:64, store.py:210).
+_META_CORRUPTION = (OSError, tomllib.TOMLDecodeError, ScriptMetaError)
+
+# Registry read-modify-write lock (concurrency, store.py:181): a portable advisory lockfile via
+# O_CREAT|O_EXCL, with retry + a stale-lock timeout so a crashed holder can't wedge the store
+# forever. skit is a single-user CLI/TUI tool, so contention is rare and short-lived; this closes
+# the remaining race left after the filesystem-truth fix below (_fs_truth) already prevents the
+# worst case (a silent overwrite) even without a lock.
+_LOCK_STALE_SECONDS = 30
+_LOCK_POLL_SECONDS = 0.05
+
+
+class StoreError(Exception):
+    pass
+
+
+class NameConflictError(StoreError):
+    pass
+
+
+class NotFoundError(StoreError):
+    pass
+
+
+def _hash_file(path: Path) -> str:
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        for chunk in iter(lambda: f.read(65536), b""):  # pragma: no mutate
+            h.update(chunk)
+    return f"sha256:{h.hexdigest()}"
+
+
+def _read_meta(entry_dir: Path) -> ScriptMeta:
+    with open(entry_dir / "meta.toml", "rb") as f:
+        return ScriptMeta.from_toml_dict(tomllib.load(f))
+
+
+def _write_meta(entry_dir: Path, meta: ScriptMeta) -> None:
+    atomic_write_toml(entry_dir / "meta.toml", meta.to_toml_dict())
+
+
+def _load_registry() -> dict[str, dict[str, Any]]:
+    path = registry_path()
+    if not path.exists():
+        return {}
+    try:
+        with open(path, "rb") as f:
+            doc = tomllib.load(f)
+    except (OSError, tomllib.TOMLDecodeError):
+        # registry.toml is only a rebuildable index (module docstring), so degrade the same way a
+        # missing file already does: an empty registry that `doctor --rebuild` can reconstruct from
+        # the untouched scripts/<slug> metas. Preserve the bad bytes instead of discarding them
+        # outright — rename (not copy) so a corrupt file can't keep re-triggering this branch (and
+        # spawning a fresh backup) on every subsequent read before the next successful write.
+        with contextlib.suppress(OSError):
+            os.replace(path, path.with_name(f"{path.name}.corrupt"))
+        return {}
+    return doc.get("entries", {})
+
+
+def _save_registry(entries: dict[str, dict[str, Any]]) -> None:
+    atomic_write_toml(registry_path(), {"entries": entries})
+
+
+@contextlib.contextmanager
+def _registry_lock() -> Iterator[None]:
+    """Serialize the registry read-modify-write + slug allocation across processes.
+
+    A portable advisory lock (no fcntl/msvcrt split needed): an exclusive lockfile created with
+    O_CREAT|O_EXCL. A holder that never releases it (crashed mid-operation) is reclaimed once the
+    lockfile is older than _LOCK_STALE_SECONDS, so a dead process can't wedge the store forever.
+    """
+    lock_path = registry_path().with_suffix(".lock")
+    lock_path.parent.mkdir(parents=True, exist_ok=True)
+    while True:
+        try:
+            fd = os.open(lock_path, os.O_CREAT | os.O_EXCL | os.O_WRONLY)
+        except FileExistsError:
+            try:
+                age = time.time() - lock_path.stat().st_mtime
+            except OSError:
+                age = _LOCK_STALE_SECONDS + 1  # vanished mid-check; treat as reclaimable
+            if age > _LOCK_STALE_SECONDS:
+                with contextlib.suppress(OSError):
+                    lock_path.unlink()
+            else:
+                time.sleep(_LOCK_POLL_SECONDS)
+            continue
+        else:
+            os.close(fd)
+            break
+    try:
+        yield
+    finally:
+        with contextlib.suppress(OSError):
+            lock_path.unlink()
+
+
+def _unique_slug(base: str, existing: set[str]) -> str:
+    slug = base
+    i = 2
+    while slug in existing:
+        slug = f"{base}-{i}"
+        i += 1
+    return slug
+
+
+def _fs_truth(entries: dict[str, dict[str, Any]]) -> tuple[set[str], set[str]]:
+    """(taken slugs, taken names), cross-checked against the on-disk scripts/ directory.
+
+    registry.toml is only a rebuildable index (module docstring) — trusting it alone for slug
+    uniqueness / name-conflict checks means a lost or corrupt registry lets a name/slug collision
+    silently overwrite an existing stored script (store.py:187). A directory is only counted as
+    "taken" if it actually holds something (has any content): an empty leftover directory (e.g. from
+    a process that mkdir'd but crashed before writing anything) claims no slug and stays reusable.
+    """
+    slugs = set(entries)
+    names = {e["name"] for e in entries.values()}
+    root = scripts_dir()
+    if not root.is_dir():
+        return slugs, names
+    for entry_dir in root.iterdir():
+        if not entry_dir.is_dir():
+            continue
+        in_registry = entry_dir.name in entries
+        if not in_registry and not any(entry_dir.iterdir()):
+            continue  # empty, unregistered leftover — nothing to protect, safe to reuse
+        slugs.add(entry_dir.name)
+        if in_registry:
+            continue  # its name is already accounted for via the registry row
+        try:
+            names.add(_read_meta(entry_dir).name)
+        except _META_CORRUPTION:
+            continue  # unreadable; doctor --rebuild will report it, but it can't claim a name here
+    return slugs, names
+
+
+def _extract_description(script_text: str) -> str:
+    """Take the first line of the module docstring as a suggested description (empty on failure)."""
+    import ast
+
+    try:
+        doc = ast.get_docstring(ast.parse(script_text))
+    except SyntaxError:
+        return ""
+    if not doc:
+        return ""
+    return doc.strip().splitlines()[0].strip()
+
+
+def infer_kind(path: Path, force_exe: bool = False) -> str:
+    """What kind of entry a path should become — the tool can see the file type, so
+    don't demand a flag: ".py" -> "python", an executable file -> "exe", anything else
+    -> "unknown" (callers point at --exe / --cmd). Shared by the CLI and the TUI add
+    panel so the two paths can't drift apart."""
+    if force_exe:
+        return "exe"
+    if path.suffix.lower() == ".py":
+        return "python"
+    if path.is_file() and _is_executable_file(path):
+        return "exe"
+    return "unknown"
+
+
+def _is_executable_file(path: Path) -> bool:
+    """Whether `path` is a program this platform would run directly.
+
+    POSIX has an execute bit, so os.access(X_OK) is the right question there. Windows has none —
+    os.access(X_OK) is True for *every* readable file, which would misclassify a plain `notes.txt`
+    as an executable — so on Windows a file counts as executable only when its extension is one the
+    OS itself treats as runnable, i.e. a member of PATHEXT (.exe/.bat/.cmd/…)."""
+    if sys.platform == "win32":
+        # PATHEXT is a Windows env var, always ';'-delimited (independent of os.pathsep), listing
+        # the extensions the shell will execute; fall back to the conventional default when unset.
+        pathext = os.environ.get("PATHEXT") or ".COM;.EXE;.BAT;.CMD"
+        runnable = {ext.lower() for ext in pathext.split(";") if ext}
+        return path.suffix.lower() in runnable
+    return os.access(path, os.X_OK)
+
+
+def suggest_description(script_text: str) -> str:
+    """Public: the description skit would auto-derive from a script (its docstring's first line, or
+    empty). Used by the interactive `add` prompt to prefill a suggested description."""
+    return _extract_description(script_text)
+
+
+def add_python(
+    source: Path,
+    *,
+    name: str | None = None,
+    mode: Mode = "copy",
+    description: str | None = None,
+    workdir: str | None = None,
+    dependencies: list[str] | None = None,
+    requires_python: str = "",
+) -> Entry:
+    source = source.expanduser().resolve()
+    if not source.is_file():
+        raise StoreError(gettext("File not found: %(path)s") % {"path": str(source)})
+    text = source.read_text(encoding="utf-8", errors="replace")
+    final_name = name or source.stem
+    desc = description if description is not None else _extract_description(text)
+    # copy mode: dependency completion is written into the copy's PEP 723 block (comment-only, A5
+    # compliant), so the copy is portable — but only when the source is strict-UTF-8: re-encoding a
+    # lossy `errors="replace"` decode back to disk would corrupt any non-UTF-8 byte in the copy
+    # (store.py:130). A source that doesn't decode cleanly falls back to recording the deps in meta
+    # instead (same as reference mode) and leaves the copy byte-exact.
+    try:
+        strict_text: str | None = source.read_bytes().decode("utf-8")
+    except UnicodeDecodeError:
+        strict_text = None
+    # reference mode: never touch the original; record in meta, and launcher passes it via
+    # --with/--python.
+    after_copy: Callable[[Path], None] | None = None
+    deps_injected = False
+    if (
+        mode == "copy"
+        and (dependencies or requires_python)
+        and strict_text is not None
+        and not pep723.has_block(strict_text)
+    ):
+        injected_text = pep723.inject_block(strict_text, dependencies or [], requires_python)
+
+        def _write_injected(entry_dir: Path) -> None:
+            (entry_dir / "script.py").write_text(injected_text, encoding="utf-8")
+
+        after_copy = _write_injected
+        deps_injected = True
+    if mode == "reference":
+        resolved_workdir = "origin"
+    elif workdir is not None:
+        resolved_workdir = workdir
+    else:
+        # Copy mode exists specifically to decouple the entry from its original location, so its
+        # default workdir must not depend on that location either (the gap: a copy-mode script
+        # could never run again once its source directory was gone, even though the store copy was
+        # intact). "invoke" (the caller's cwd at run time) always exists and mirrors add_command's
+        # existing default for the same reason (store.py add_command); "store" (entry.dir) holds
+        # only script.py + meta.toml, with no reason to assume a script's relative file operations
+        # target it.
+        resolved_workdir = "invoke"
+    meta = ScriptMeta(
+        name=final_name,
+        kind="python",
+        mode=mode,
+        source=str(source),
+        source_hash=_hash_file(source),
+        added_at=now_iso(),
+        workdir=resolved_workdir,
+        description=desc,
+        dependencies=None if deps_injected else (dependencies or None),
+        requires_python="" if deps_injected else requires_python,
+    )
+    return _add_entry(meta, payload=source if mode == "copy" else None, after_copy=after_copy)
+
+
+def add_exe(source: Path, *, name: str | None = None, description: str = "") -> Entry:
+    source = source.expanduser().resolve()
+    if not source.exists():
+        raise StoreError(gettext("File not found: %(path)s") % {"path": str(source)})
+    meta = ScriptMeta(
+        name=name or source.stem,
+        kind="exe",
+        mode="reference",  # exe is always reference; we never copy the binary
+        source=str(source),
+        source_hash=_hash_file(source) if source.is_file() else "",
+        added_at=now_iso(),
+        description=description,
+    )
+    meta.workdir = "origin"  # pragma: no mutate — explicit default, self-describing call site
+    return _add_entry(meta, payload=None)
+
+
+def extract_placeholders(template: str) -> list[str]:
+    """Extract {name} placeholders (deduped by order of appearance; {{ }} is an escape, ignored)."""
+    import re
+
+    seen: list[str] = []
+    for m in re.finditer(r"(?<!\{)\{([a-zA-Z_][a-zA-Z0-9_]*)\}(?!\})", template):
+        if m.group(1) not in seen:
+            seen.append(m.group(1))
+    return seen
+
+
+def add_command(template: str, *, name: str, description: str = "") -> Entry:
+    if not template.strip():
+        raise StoreError(gettext("Command template must not be empty"))
+    placeholders = extract_placeholders(template)
+    meta = ScriptMeta(
+        name=name,
+        kind="command",
+        mode="reference",
+        added_at=now_iso(),
+        workdir="invoke",
+        description=description,
+        template=template,
+        params=placeholders or None,
+    )
+    meta.source = ""  # pragma: no mutate — explicit default, self-describing call site
+    return _add_entry(meta, payload=None)
+
+
+def _add_entry(
+    meta: ScriptMeta,
+    *,
+    payload: Path | None,
+    after_copy: Callable[[Path], None] | None = None,
+) -> Entry:
+    with _registry_lock():
+        entries = _load_registry()
+        existing_slugs, existing_names = _fs_truth(entries)
+        if meta.name in existing_names:
+            raise NameConflictError(
+                gettext("The name %(name)s is already taken (use --name to pick another)")
+                % {"name": meta.name}
+            )
+        slug = _unique_slug(slugify(meta.name), existing_slugs)
+        entry_dir = scripts_dir() / slug
+        if entry_dir.exists() and any(entry_dir.iterdir()):
+            # Defense in depth: _fs_truth already excludes any non-empty existing directory from
+            # the slug candidates above, so this should be unreachable — but never silently reuse
+            # (and overwrite) a directory that actually holds a stored script (store.py:187).
+            raise StoreError(
+                gettext("Refusing to reuse the existing, non-empty entry directory: %(path)s")
+                % {"path": str(entry_dir)}
+            )
+        entry_dir.mkdir(parents=True, exist_ok=True)
+        try:
+            if payload is not None:
+                # copy mode: copy the original verbatim (A5: never land a processed script)
+                shutil.copy2(payload, entry_dir / "script.py")
+            _write_meta(entry_dir, meta)
+            if after_copy is not None:
+                after_copy(entry_dir)
+        except BaseException:
+            shutil.rmtree(entry_dir, ignore_errors=True)
+            raise
+        entries[slug] = {"name": meta.name, "kind": meta.kind, "description": meta.description}
+        _save_registry(entries)
+        return Entry(slug=slug, meta=meta, dir=entry_dir)
+
+
+def list_entries() -> list[Entry]:
+    entries = _load_registry()
+    out: list[Entry] = []
+    for slug in sorted(entries):
+        entry_dir = scripts_dir() / slug
+        try:
+            meta = _read_meta(entry_dir)
+        except _META_CORRUPTION:
+            continue  # leave corrupt entries for doctor to handle
+        out.append(Entry(slug=slug, meta=meta, dir=entry_dir))
+    return out
+
+
+def resolve(name_or_slug: str) -> Entry:
+    entries = _load_registry()
+    slug = None
+    if name_or_slug in entries:
+        slug = name_or_slug
+    else:
+        matches = [s for s, e in entries.items() if e["name"] == name_or_slug]
+        if len(matches) == 1:
+            slug = matches[0]
+    if slug is None:
+        raise NotFoundError(gettext("Script not found: %(name)s") % {"name": name_or_slug})
+    entry_dir = scripts_dir() / slug
+    try:
+        meta = _read_meta(entry_dir)
+    except _META_CORRUPTION as exc:
+        raise NotFoundError(
+            gettext("%(name)s: metadata is corrupt (%(error)s); run skit doctor --rebuild")
+            % {"name": name_or_slug, "error": str(exc)}
+        ) from exc
+    return Entry(slug=slug, meta=meta, dir=entry_dir)
+
+
+def remove(name_or_slug: str) -> str:
+    entry = resolve(name_or_slug)
+    with _registry_lock():
+        entries = _load_registry()
+        entries.pop(entry.slug, None)  # pragma: no mutate — TOCTOU defense, kept deliberately
+        _save_registry(entries)
+    shutil.rmtree(entry.dir, ignore_errors=True)
+    argstate.forget(entry.slug)  # drop the last-used values too
+    return entry.meta.name
+
+
+def update_dependencies(
+    name_or_slug: str,
+    dependencies: list[str],
+    requires_python: str | None = None,
+) -> Entry:
+    """Update an entry's dependency record (meta.toml). In copy mode, also sync the copy's PEP 723
+    block; in reference mode, only touch meta (the original can't be written, A7) and pass it via
+    --with at run time."""
+    entry = resolve(name_or_slug)
+    meta = entry.meta
+    meta.dependencies = dependencies or None
+    if requires_python is not None:
+        meta.requires_python = requires_python or ""
+    _write_meta(entry.dir, meta)
+    if meta.kind == "python" and meta.mode == "copy":  # pragma: no mutate — and/or equivalent
+        from . import pep723
+
+        script = entry.dir / "script.py"
+        if script.exists():
+            text = script.read_text(encoding="utf-8", errors="replace")
+            script.write_text(
+                pep723.set_dependencies(
+                    text, dependencies, requires_python=meta.requires_python or ""
+                ),
+                encoding="utf-8",
+            )
+    return Entry(slug=entry.slug, meta=meta, dir=entry.dir)
+
+
+def rename(name_or_slug: str, new_name: str) -> Entry:
+    """Rename an entry's display name. The slug is immutable after add — it keys the
+    entry directory and the argstate values file, so keeping it means nothing moves on
+    disk and remembered values/presets survive the rename."""
+    entry = resolve(name_or_slug)
+    new_name = new_name.strip()
+    if not new_name:
+        raise StoreError(gettext("A name is required."))
+    try:
+        other = resolve(new_name)
+    except NotFoundError:
+        other = None
+    if other is not None and other.slug != entry.slug:
+        raise StoreError(gettext("The name %(name)s is already taken.") % {"name": new_name})
+    meta = entry.meta
+    meta.name = new_name
+    _write_meta(entry.dir, meta)
+    with _registry_lock():
+        entries = _load_registry()
+        row = entries.get(entry.slug)
+        if row is not None:
+            row["name"] = new_name
+            _save_registry(entries)
+    return Entry(slug=entry.slug, meta=meta, dir=entry.dir)
+
+
+def update_description(name_or_slug: str, description: str) -> Entry:
+    """Update an entry's description (meta.toml is the truth; the registry index row is
+    refreshed too so `list` doesn't need a rebuild to show it)."""
+    entry = resolve(name_or_slug)
+    meta = entry.meta
+    meta.description = description
+    _write_meta(entry.dir, meta)
+    with _registry_lock():
+        entries = _load_registry()
+        row = entries.get(entry.slug)
+        if row is not None:
+            row["description"] = description
+            _save_registry(entries)
+    return Entry(slug=entry.slug, meta=meta, dir=entry.dir)
+
+
+def doctor_rebuild() -> tuple[int, list[str]]:
+    """Rebuild the registry from each scripts/<slug>/meta.toml.
+
+    Returns (count rebuilt, problems).
+    """
+    problems: list[str] = []
+    entries: dict[str, dict[str, Any]] = {}
+    with _registry_lock():
+        root = scripts_dir()
+        if root.exists():
+            for entry_dir in sorted(p for p in root.iterdir() if p.is_dir()):
+                try:
+                    meta = _read_meta(entry_dir)
+                except FileNotFoundError:
+                    problems.append(
+                        gettext("%(slug)s: meta.toml is missing; skipped")
+                        % {"slug": entry_dir.name}
+                    )
+                    continue
+                except _META_CORRUPTION as exc:
+                    problems.append(
+                        gettext("%(slug)s: meta.toml is corrupt (%(error)s); skipped")
+                        % {"slug": entry_dir.name, "error": str(exc)}
+                    )
+                    continue
+                if meta.mode == "reference" and meta.source and not Path(meta.source).exists():
+                    problems.append(
+                        gettext("%(slug)s: the referenced source file is gone: %(path)s")
+                        % {"slug": entry_dir.name, "path": meta.source}
+                    )
+                entries[entry_dir.name] = {
+                    "name": meta.name,
+                    "kind": meta.kind,
+                    "description": meta.description,
+                }
+        _save_registry(entries)
+    return len(entries), problems
+
+
+# Type re-exports, so callers upstream only need to import store.
+def dir_size(path: Path) -> int:
+    """Total bytes of the files under a directory (0 if it doesn't exist). The library
+    disk-usage figure the health check shows — shared by `skit doctor` and the TUI."""
+    total = 0
+    if path.is_dir():
+        for p in path.rglob("*"):
+            if p.is_file():
+                total += p.stat().st_size
+    return total
+
+
+def human_size(size: int) -> str:
+    """Bytes as a compact human string (B/KB/MB/GB)."""
+    value = float(size)
+    for unit in ("B", "KB", "MB", "GB"):
+        if value < 1024 or unit == "GB":
+            return f"{value:.1f} {unit}" if unit != "B" else f"{int(value)} B"
+        value /= 1024
+    return f"{value:.1f} GB"  # pragma: no cover — loop always returns
+
+
+__all__ = [
+    "Entry",
+    "Kind",
+    "NameConflictError",
+    "NotFoundError",
+    "ScriptMeta",
+    "StoreError",
+    "add_command",
+    "add_exe",
+    "add_python",
+    "dir_size",
+    "doctor_rebuild",
+    "human_size",
+    "list_entries",
+    "remove",
+    "resolve",
+]

skit/theme.py

@@ -0,0 +1,123 @@
+"""The skit Textual theme: btop-flavored, terminal-native.
+
+Design contract:
+- The canvas stays `ansi_default` (the user's terminal background — transparency and
+  all — shows through, like btop with theme_background off), but everything skit draws
+  ON that canvas uses a controlled btop-style palette: rounded panel borders in muted
+  per-panel tints, near-white titles, a dark warm selection bar, and one warm accent
+  (terracotta) for keys and focus.
+- `ansi=True` disables Textual's ANSI→truecolor filter so default colors pass through
+  natively — BUT the ansi color system also hard-defaults links, scrollbars and table
+  headers to ANSI blue, which is unreadable noise on a dark terminal. Every one of
+  those is overridden below (variables) or in CHROME_CSS (component styles).
+"""
+
+from __future__ import annotations
+
+from textual.theme import Theme
+
+# Anthropic terracotta — the one warm accent (close kin to btop's hi_fg red).
+ACCENT = "#D97757"
+ACCENT_DIM = "#B05C3F"
+
+# Selection: btop highlights the current row with a dark tinted bar + bright text,
+# never a solid accent bar (accent-on-black text stays readable, the bar stays calm).
+SELECT_BG = "#5A2D1E"
+SELECT_FG = "#EEEEEE"
+
+# btop's signature: each panel wears its own muted border tint (cpu green, mem olive,
+# net indigo, proc maroon). skit maps them to its own surfaces.
+BOX_GREEN = "#3D7B46"  # Library list
+BOX_OLIVE = "#8A882E"  # add flow
+BOX_INDIGO = "#4B44B0"  # detail pane, settings, preferences
+BOX_MAROON = "#923535"  # run form, destructive confirms
+BOX_DIM = "#3A3A3A"  # idle input borders / dividers
+
+# Exposed to screen CSS as $skit-box-*. Apps must merge these into get_css_variables():
+# the first stylesheet parse happens BEFORE on_mount activates the skit theme, and an
+# unresolved variable is a startup crash, not a fallback.
+BOX_VARIABLES = {
+    "skit-box-green": BOX_GREEN,
+    "skit-box-olive": BOX_OLIVE,
+    "skit-box-indigo": BOX_INDIGO,
+    "skit-box-maroon": BOX_MAROON,
+}
+
+CLAUDE_THEME = Theme(
+    name="skit-claude",
+    primary=ACCENT,
+    secondary=ACCENT_DIM,
+    accent=ACCENT,
+    warning="ansi_yellow",
+    error="ansi_red",
+    success="ansi_green",
+    foreground="ansi_default",
+    background="ansi_default",
+    surface="ansi_default",
+    panel="ansi_default",
+    boost="ansi_default",
+    dark=True,
+    variables={
+        # The full variable set an ansi theme must provide (Screen's builtin CSS reads
+        # ansi-background/-foreground; the rest mirror the builtin ansi-dark theme).
+        "ansi-background": "ansi_black",
+        "ansi-foreground": "ansi_white",
+        "border-blurred": BOX_DIM,
+        # $border is what every :focus border falls back to (the ansi system would say
+        # magenta); focus always speaks accent.
+        "border": ACCENT,
+        # Selection bar: dark terracotta + bright text (btop's selected_bg pattern) —
+        # the old accent-background bar drowned the row it was meant to point at.
+        "block-cursor-foreground": SELECT_FG,
+        "block-cursor-background": SELECT_BG,
+        "block-cursor-text-style": "bold",
+        "block-cursor-blurred-foreground": "ansi_default",
+        "block-cursor-blurred-background": "#33231C",
+        "block-hover-background": "#33231C",
+        "input-cursor-background": "ansi_black",
+        "input-cursor-foreground": "ansi_bright_white",
+        "input-cursor-text-style": "none",
+        "input-selection-background": ACCENT_DIM,
+        "input-selection-foreground": "ansi_black",
+        "screen-selection-background": ACCENT_DIM,
+        "screen-selection-foreground": "ansi_black",
+        "footer-key-foreground": ACCENT,
+        # Action links (footer chips, ▾insert, modal buttons): the ansi system paints
+        # them underlined blue, which reads as a 1998 hyperlink. Textual applies link-color
+        # uniformly to the whole @click span, overriding any inline color — so an inline
+        # [$accent] on the chip's key can't win. Set link-color TO the accent: the key
+        # (which keeps its `bold`) reads as bold-terracotta, the label as plain terracotta,
+        # and the whole pill stays one clickable button. This also matches the ▾insert link,
+        # which already intends accent. Hover brightens the whole pill.
+        "link-color": ACCENT,
+        "link-style": "none",
+        "link-color-hover": "ansi_bright_white",
+        "link-background-hover": "#4A2A1D",
+        "link-style-hover": "none",
+        # Panel tints, exposed to screen CSS as $skit-box-*.
+        **BOX_VARIABLES,
+        # Scrollbars: warm dark rail instead of ansi blue.
+        "scrollbar": "#4A413C",
+        "scrollbar-hover": ACCENT_DIM,
+        "scrollbar-active": ACCENT,
+        "scrollbar-background": "ansi_default",
+        "scrollbar-background-hover": "ansi_default",
+        "scrollbar-background-active": "ansi_default",
+    },
+    ansi=True,
+)
+
+# Component chrome no theme variable reaches, shared by every skit App (the workbench
+# and the CLI's inline form). btop grammar: rounded borders, titles ON the border,
+# bold near-white table headers on the bare canvas — never a colored header bar.
+CHROME_CSS = """
+Screen { background: ansi_default; }
+/* The ansi color system pins the table header to ansi_bright_blue (unreadable and
+   loud on a dark terminal); btop headers are just bold bright text on the canvas. */
+DataTable:ansi > .datatable--header,
+DataTable > .datatable--header { background: ansi_default; color: ansi_bright_white; text-style: bold; }
+Input { border: round $border-blurred; }
+Input:focus { border: round $accent; }
+Select > SelectCurrent { border: round $border-blurred; }
+Select:focus > SelectCurrent { border: round $accent; }
+"""