@quickcall/all-configs 0.0.0-stage → 1.0.0

package/README.md

@@ -1,3 +1,16 @@
-# Temporary Holding Version
+# @quickcall/all-configs
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Run the all-configs terminal UI without installing Bun:
+
+```bash
+npx @quickcall/all-configs
+```
+
+The package selects a precompiled Bun/OpenTUI executable for the current platform. The executable contains the runtime; Bun is not required on the user's machine.
+
+Supported platforms:
+
+- macOS arm64 and x64
+- Linux arm64 and x64
+
+The package also includes the module definitions and installer scripts used by the TUI.

package/bin/all-configs.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+
+const { spawnSync } = require("node:child_process")
+const { dirname, join, resolve } = require("node:path")
+
+const platform = process.platform
+const arch = process.arch
+const key = `${platform}-${arch}`
+const packages = {
+  "darwin-arm64": "@quickcall/all-configs-darwin-arm64",
+  "darwin-x64": "@quickcall/all-configs-darwin-x64",
+  "linux-arm64": "@quickcall/all-configs-linux-arm64",
+  "linux-x64": "@quickcall/all-configs-linux-x64",
+}
+
+const platformPackage = packages[key]
+if (!platformPackage) {
+  console.error(`all-configs does not support ${platform}/${arch}`)
+  process.exit(1)
+}
+
+let packageJson
+try {
+  packageJson = require.resolve(`${platformPackage}/package.json`)
+} catch {
+  console.error(`The all-configs binary for ${platform}/${arch} is unavailable.`)
+  console.error(`Try reinstalling without omitting optional dependencies:`)
+  console.error(`  npm install -g @quickcall/all-configs`)
+  process.exit(1)
+}
+
+const binary = join(dirname(packageJson), "bin", "all-configs")
+const runtimeRoot = resolve(__dirname, "..", "runtime")
+const result = spawnSync(binary, process.argv.slice(2), {
+  stdio: "inherit",
+  env: { ...process.env, ALL_CONFIGS_ROOT: runtimeRoot },
+})
+
+if (result.error) {
+  console.error(`Failed to start all-configs: ${result.error.message}`)
+  process.exit(1)
+}
+
+process.exit(result.status ?? 1)

package/package.json

@@ -1,6 +1,22 @@
 {
   "name": "@quickcall/all-configs",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "Modular developer environment installer with an interactive OpenTUI interface",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/quickcall-dev/all-configs.git"
+  },
+  "homepage": "https://github.com/quickcall-dev/all-configs",
+  "bugs": "https://github.com/quickcall-dev/all-configs/issues",
+  "bin": {
+    "all-configs": "bin/all-configs.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": ["bin", "runtime", "README.md"],
+  "optionalDependencies": {
+    "@quickcall/all-configs-darwin-arm64": "1.0.0"
+  }
+}

package/runtime/allconfigs/__init__.py

@@ -0,0 +1 @@
+"""all-configs: module catalogue, detection, pty runner and the Textual TUI."""

package/runtime/allconfigs/__main__.py

@@ -0,0 +1,42 @@
+"""Entry point for all-configs.
+
+The interactive TUI is the OpenTUI rewrite (``experimental/opentui``); the
+original Textual TUI is archived under ``archive/textual-tui/``. This module
+locates Bun and hands off to the TypeScript app so both
+``python3 -m allconfigs`` and ``./install.sh`` keep working.
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+import sys
+from pathlib import Path
+
+
+def main() -> int:
+    if not (sys.stdin.isatty() and sys.stdout.isatty()):
+        print("all-configs TUI needs an interactive terminal; use ./install.sh <module>", file=sys.stderr)
+        return 1
+
+    root = Path(__file__).resolve().parents[1]
+    bun = shutil.which("bun")
+    if bun:
+        os.chdir(root)
+        os.execvp(bun, [bun, "run", "experimental/opentui/src/index.tsx"])
+
+    # No Bun: fall back to guidance; the platform check needs 3.11+ (tomllib).
+    from allconfigs.modules import PLATFORM
+
+    if PLATFORM == "unsupported":
+        print(f"all-configs supports macOS and Linux only (got {sys.platform})", file=sys.stderr)
+    print(
+        "The all-configs TUI needs Bun: https://bun.sh\n"
+        "Or run a module directly: ./install.sh <module>",
+        file=sys.stderr,
+    )
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/runtime/allconfigs/modules.py

@@ -0,0 +1,221 @@
+"""Module discovery and install-state detection.
+
+A module is a directory with an ``install.sh`` and a ``module.toml``::
+
+    name = "tmux"
+    description = "tmux config, TPM, vim nav, clipboard"
+    platforms = ["mac", "linux"]
+    kind = "config"                 # app | cli | config
+
+    [detect]                        # every key optional
+    commands = ["tmux"]             # any on PATH  -> tool present
+    brew = ["tmux"]                 # any brew formula/cask (macOS)
+    apps = ["Ghostty"]              # any /Applications/<name>.app (macOS)
+    paths = ["~/.tmux.conf"]        # all must exist -> config applied
+    paths_mac = [...]               # extra paths, macOS only
+    paths_linux = [...]             # extra paths, Linux only
+
+    [uninstall]                     # omit = uninstall disabled
+    brew = ["tmux"]                 # macOS: Homebrew formula/cask names
+    packages = ["tmux"]             # Linux: apt/dnf/pacman package names
+
+Status combines the two halves: tool present and config applied.
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+import tomllib
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+
+if sys.platform == "darwin":
+    PLATFORM = "mac"
+elif sys.platform.startswith("linux"):
+    PLATFORM = "linux"
+else:
+    PLATFORM = "unsupported"
+
+KINDS = ("app", "cli", "config")
+
+# Installers drop binaries here; the parent shell may not have them on PATH yet.
+EXTRA_BIN_DIRS = (
+    "~/.local/bin",
+    "~/.bun/bin",
+    "~/.cargo/bin",
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+    "/home/linuxbrew/.linuxbrew/bin",
+)
+
+APP_DIRS = (Path("/Applications"), Path("~/Applications").expanduser())
+
+
+class Status(str, Enum):
+    CHECKING = "checking"
+    INSTALLED = "installed"
+    PARTIAL = "partial"
+    MISSING = "missing"
+    UNKNOWN = "unknown"
+
+
+class ModuleError(ValueError):
+    """A module.toml that cannot be used."""
+
+
+@dataclass
+class Module:
+    name: str
+    description: str
+    platforms: tuple[str, ...]
+    kind: str
+    path: Path
+    commands: tuple[str, ...] = ()
+    brew: tuple[str, ...] = ()
+    apps: tuple[str, ...] = ()
+    paths: tuple[str, ...] = ()
+    uninstall_packages: tuple[str, ...] = ()
+    status: Status = Status.CHECKING
+    last_run_failed: bool = field(default=False, compare=False)
+
+    @property
+    def install_script(self) -> Path:
+        return self.path / "install.sh"
+
+    @property
+    def can_uninstall(self) -> bool:
+        # Config modules only configure a tool; removing them must never
+        # remove the tool itself, so uninstall is disabled for them.
+        return self.kind != "config" and bool(self.uninstall_packages)
+
+
+def _str_list(table: dict, key: str, where: str) -> tuple[str, ...]:
+    value = table.get(key, [])
+    if not isinstance(value, list) or not all(isinstance(v, str) for v in value):
+        raise ModuleError(f"{where}: '{key}' must be a list of strings")
+    return tuple(value)
+
+
+def parse_module(toml_path: Path, platform: str = PLATFORM) -> Module | None:
+    """Parse one module.toml. Returns None when the module targets another platform."""
+    where = str(toml_path)
+    try:
+        data = tomllib.loads(toml_path.read_text())
+    except (OSError, tomllib.TOMLDecodeError) as exc:
+        raise ModuleError(f"{where}: {exc}") from exc
+
+    directory = toml_path.parent
+    name = data.get("name", directory.name)
+    if name != directory.name:
+        raise ModuleError(f"{where}: name '{name}' must match directory '{directory.name}'")
+    platforms = _str_list(data, "platforms", where) or ("mac", "linux")
+    if platform not in platforms:
+        return None
+    kind = data.get("kind", "config")
+    if kind not in KINDS:
+        raise ModuleError(f"{where}: kind must be one of {', '.join(KINDS)}")
+    if not (directory / "install.sh").is_file():
+        raise ModuleError(f"{where}: missing install.sh")
+
+    detect = data.get("detect", {})
+    uninstall = data.get("uninstall", {})
+    paths = _str_list(detect, "paths", where) + _str_list(detect, f"paths_{platform}", where)
+    packages = _str_list(uninstall, "brew" if platform == "mac" else "packages", where)
+
+    return Module(
+        name=name,
+        description=str(data.get("description", "")),
+        platforms=platforms,
+        kind=kind,
+        path=directory,
+        commands=_str_list(detect, "commands", where),
+        brew=_str_list(detect, "brew", where),
+        apps=_str_list(detect, "apps", where),
+        paths=paths,
+        uninstall_packages=packages,
+    )
+
+
+def load_modules(root: Path, platform: str = PLATFORM) -> tuple[list[Module], list[str]]:
+    """Discover modules under ``root/modules``. Bad module.toml files are reported, not fatal."""
+    modules: list[Module] = []
+    errors: list[str] = []
+    for toml_path in sorted((root / "modules").glob("*/module.toml")):
+        try:
+            module = parse_module(toml_path, platform)
+        except ModuleError as exc:
+            errors.append(str(exc))
+            continue
+        if module is not None:
+            modules.append(module)
+    return modules, errors
+
+
+@dataclass(frozen=True)
+class Environment:
+    """Facts about the machine shared by every module's detection."""
+
+    path: str
+    brew_packages: frozenset[str] = frozenset()
+    platform: str = PLATFORM
+
+
+def search_path() -> str:
+    dirs = os.environ.get("PATH", "").split(os.pathsep)
+    dirs += [os.path.expanduser(d) for d in EXTRA_BIN_DIRS]
+    return os.pathsep.join(dict.fromkeys(d for d in dirs if d))
+
+
+def probe_environment() -> Environment:
+    """Collect PATH and Homebrew package lists (two `brew list` calls, run in parallel)."""
+    path = search_path()
+    brew = shutil.which("brew", path=path)
+    if PLATFORM != "mac" or not brew:
+        return Environment(path=path)
+    procs = [
+        subprocess.Popen(
+            [brew, "list", flag, "-1"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+            text=True,
+        )
+        for flag in ("--formula", "--cask")
+    ]
+    names: set[str] = set()
+    for proc in procs:
+        try:
+            out, _ = proc.communicate(timeout=60)
+        except subprocess.TimeoutExpired:
+            proc.kill()
+            continue
+        if proc.returncode == 0:
+            names.update(line.strip() for line in out.splitlines() if line.strip())
+    return Environment(path=path, brew_packages=frozenset(names))
+
+
+def detect(module: Module, env: Environment) -> Status:
+    tool_checks: list[bool] = []
+    if module.commands:
+        tool_checks.append(any(shutil.which(c, path=env.path) is not None for c in module.commands))
+    if module.brew and env.platform == "mac" and env.brew_packages:
+        tool_checks.append(any(b in env.brew_packages for b in module.brew))
+    if module.apps and env.platform == "mac":
+        tool_checks.append(any((d / f"{a}.app").is_dir() for d in APP_DIRS for a in module.apps))
+
+    results: list[bool] = []
+    if tool_checks:
+        results.append(any(tool_checks))
+    if module.paths:
+        results.append(all(Path(p).expanduser().exists() for p in module.paths))
+
+    if not results:
+        return Status.UNKNOWN
+    if all(results):
+        return Status.INSTALLED
+    if any(results):
+        return Status.PARTIAL
+    return Status.MISSING

package/runtime/allconfigs/probe.py

@@ -0,0 +1,60 @@
+"""NDJSON probe for external TUIs (e.g. the OpenTUI experiment).
+
+Reuses the same discovery and detection logic as the Textual TUI and prints
+one JSON object per line so a parent process can stream results:
+
+    {"type": "env", "platform": "mac", "root": "/path/to/repo"}
+    {"type": "error", "message": "modules/foo/module.toml: ..."}
+    {"type": "module", "module": {"name": "tmux", "status": "installed", ...}}
+
+Usage::
+
+    python3 -m allconfigs.probe [repo-root]   # run from the repo root
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+from allconfigs.modules import detect, load_modules, probe_environment
+
+
+def main() -> int:
+    root = Path(sys.argv[1]).resolve() if len(sys.argv) > 1 else Path(__file__).resolve().parents[1]
+
+    def emit(payload: dict) -> None:
+        try:
+            print(json.dumps(payload), flush=True)
+        except BrokenPipeError:
+            # The consumer went away; nothing useful left to do.
+            raise SystemExit(0)
+
+    env = probe_environment()
+    emit({"type": "env", "platform": env.platform, "root": str(root)})
+
+    modules, errors = load_modules(root, env.platform)
+    for error in errors:
+        emit({"type": "error", "message": error})
+    for module in modules:
+        module.status = detect(module, env)
+        emit(
+            {
+                "type": "module",
+                "module": {
+                    "name": module.name,
+                    "description": module.description,
+                    "kind": module.kind,
+                    "platforms": list(module.platforms),
+                    "status": module.status.value,
+                    "can_uninstall": module.can_uninstall,
+                    "uninstall_packages": list(module.uninstall_packages),
+                },
+            }
+        )
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/runtime/install.sh

@@ -0,0 +1,74 @@
+#!/usr/bin/env bash
+# all-configs entry point (macOS and Linux only).
+#
+#   ./install.sh               interactive TUI
+#   ./install.sh tmux nvim     install the named modules directly, no TUI
+#   ./install.sh --list        list modules available on this platform
+set -e
+
+trap 'echo ""; fail "Interrupted"; exit 130' INT
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+MODULES_DIR="$ROOT_DIR/modules"
+# common.sh exits on anything other than Darwin/Linux
+source "$ROOT_DIR/lib/common.sh" || { echo "Error: lib/common.sh not found" >&2; exit 1; }
+
+PYTHON_VERSION="3.12"
+
+ensure_uv() {
+    # uv may already be installed but not on PATH in this shell
+    export PATH="$HOME/.local/bin:$HOME/.cargo/bin:$PATH"
+    command -v uv &>/dev/null && return 0
+
+    [[ -f "$MODULES_DIR/uv/install.sh" ]] || { fail "uv not found and modules/uv/install.sh missing"; exit 1; }
+    step "uv not found — installing"
+    bash "$MODULES_DIR/uv/install.sh"
+    command -v uv &>/dev/null || { fail "uv install finished but uv is not on PATH"; exit 1; }
+    ok "uv installed ${D}$(command -v uv)${R}"
+}
+
+list_modules() {
+    local toml name platforms
+    for toml in "$MODULES_DIR"/*/module.toml; do
+        name="$(basename "$(dirname "$toml")")"
+        platforms="$(grep -E '^platforms' "$toml" || true)"
+        if [[ "$platforms" == *"\"$PLATFORM\""* ]]; then echo "$name"; fi
+    done
+}
+
+case "${1:-}" in
+    -h|--help)
+        sed -n '2,6p' "$0" | sed 's/^# \{0,1\}//'
+        exit 0
+        ;;
+    -l|--list)
+        list_modules
+        exit 0
+        ;;
+esac
+
+# Direct install mode: ./install.sh tmux nvim
+if [[ $# -gt 0 ]]; then
+    for mod in "$@"; do
+        # module names are plain directory names; reject paths like ../x
+        if [[ ! "$mod" =~ ^[a-z0-9][a-z0-9_-]*$ ]] || [[ ! -f "$MODULES_DIR/$mod/install.sh" ]]; then
+            fail "Unknown module: $mod (see ./install.sh --list)"
+            exit 1
+        fi
+    done
+    for mod in "$@"; do
+        bash "$MODULES_DIR/$mod/install.sh"
+    done
+    exit 0
+fi
+
+# Interactive TUI mode needs a real terminal
+if [[ ! -t 0 || ! -t 1 ]]; then
+    fail "The TUI needs an interactive terminal. Use ./install.sh <module>... instead."
+    exit 1
+fi
+
+ensure_uv
+cd "$ROOT_DIR"
+# The OpenTUI TUI runs on Bun; __main__ locates it and hands off.
+exec uv run --quiet --no-project --python "$PYTHON_VERSION" python3 -m allconfigs

package/runtime/lib/common.sh

@@ -0,0 +1,147 @@
+#!/usr/bin/env bash
+# Shared helpers for all installers
+
+R='\033[0m' B='\033[1m' D='\033[2m'
+GRN='\033[32m' YLW='\033[33m' RED='\033[31m'
+CYN='\033[36m' BLU='\033[34m' MAG='\033[35m'
+
+ok()   { printf "  ${GRN}${B}✓${R} %b\n" "$1"; }
+warn() { printf "  ${YLW}${B}!${R} %b\n" "$1"; }
+fail() { printf "  ${RED}${B}✗${R} %b\n" "$1"; }
+step() { printf "\n  ${CYN}${B}→${R} %b\n" "$1"; }
+
+OS="$(uname -s)"
+case "$OS" in
+    Darwin) PLATFORM="mac" ;;
+    Linux)  PLATFORM="linux" ;;
+    *)      fail "Unsupported OS: $OS"; exit 1 ;;
+esac
+
+pkg_install() {
+    local pkg="$1"
+    if [[ "$PLATFORM" == "mac" ]]; then
+        command -v brew &>/dev/null || { fail "Homebrew not found: https://brew.sh"; return 1; }
+        yes | NONINTERACTIVE=1 CI=1 brew install "$pkg"
+    else
+        if command -v apt-get &>/dev/null; then
+            sudo apt-get update -qq && sudo apt-get install -y -qq "$pkg"
+        elif command -v dnf &>/dev/null; then
+            sudo dnf install -y "$pkg"
+        elif command -v pacman &>/dev/null; then
+            sudo pacman -S --noconfirm "$pkg"
+        else
+            fail "No supported package manager found"; return 1
+        fi
+    fi
+}
+
+pkg_check() {
+    local pkg="$1"
+    if [[ "$PLATFORM" == "mac" ]]; then
+        if command -v brew &>/dev/null; then
+            brew list --cask "$pkg" &>/dev/null && return 0
+            brew list "$pkg" &>/dev/null && return 0
+        fi
+    fi
+    command -v "$pkg" &>/dev/null && return 0
+    if command -v dpkg &>/dev/null && dpkg -l "$pkg" &>/dev/null 2>&1; then
+        return 0
+    fi
+    if command -v rpm &>/dev/null && rpm -q "$pkg" &>/dev/null 2>&1; then
+        return 0
+    fi
+    if command -v pacman &>/dev/null && pacman -Q "$pkg" &>/dev/null 2>&1; then
+        return 0
+    fi
+    return 1
+}
+
+pkg_uninstall() {
+    local pkg="$1"
+    if [[ "$PLATFORM" == "mac" ]]; then
+        # macOS: only Homebrew-managed packages can be removed here; never
+        # fall through to Linux package managers.
+        command -v brew &>/dev/null || { fail "Homebrew not found"; return 1; }
+        if brew_cask_installed "$pkg"; then
+            NONINTERACTIVE=1 CI=1 brew uninstall --cask "$pkg"
+        elif brew_formula_installed "$pkg"; then
+            NONINTERACTIVE=1 CI=1 brew uninstall "$pkg"
+        else
+            warn "$pkg is not managed by Homebrew — remove it manually"
+            return 1
+        fi
+        return
+    fi
+    if command -v apt-get &>/dev/null; then
+        dpkg -s "$pkg" &>/dev/null || { warn "$pkg is not installed (dpkg)"; return 1; }
+        sudo apt-get remove -y -qq "$pkg"
+    elif command -v dnf &>/dev/null; then
+        rpm -q "$pkg" &>/dev/null || { warn "$pkg is not installed (rpm)"; return 1; }
+        sudo dnf remove -y "$pkg"
+    elif command -v pacman &>/dev/null; then
+        pacman -Q "$pkg" &>/dev/null || { warn "$pkg is not installed (pacman)"; return 1; }
+        sudo pacman -R --noconfirm "$pkg"
+    else
+        fail "No supported package manager for uninstall"; return 1
+    fi
+}
+
+ensure_cmd() {
+    local cmd="$1" pkg="${2:-$1}"
+    if command -v "$cmd" &>/dev/null; then
+        ok "$cmd ${D}$(command -v "$cmd")${R}"
+        return 0
+    else
+        warn "$cmd not found — installing"
+        pkg_install "$pkg"
+        if command -v "$cmd" &>/dev/null; then
+            ok "$cmd installed"
+        else
+            fail "$cmd installation failed"
+            return 1
+        fi
+    fi
+}
+
+brew_cask_installed() {
+    local name="$1"
+    command -v brew &>/dev/null && brew list --cask "$name" &>/dev/null 2>&1
+}
+
+brew_formula_installed() {
+    local name="$1"
+    command -v brew &>/dev/null && brew list "$name" &>/dev/null 2>&1
+}
+
+brew_install_cask() {
+    local name="$1"
+    if brew_cask_installed "$name"; then
+        ok "$name already installed"
+        return 0
+    fi
+    step "Installing $name"
+    # no `yes |` pipe: under `set -o pipefail` yes exits 141 (SIGPIPE) and
+    # fails the whole pipeline even when brew succeeds
+    NONINTERACTIVE=1 CI=1 brew install --cask "$name"
+    ok "$name installed"
+}
+
+brew_install_formula() {
+    local name="$1"
+    if brew_formula_installed "$name"; then
+        ok "$name already installed"
+        return 0
+    fi
+    step "Installing $name"
+    NONINTERACTIVE=1 CI=1 brew install "$name"
+    ok "$name installed"
+}
+
+backup_file() {
+    local file="$1"
+    if [[ -f "$file" ]] && [[ ! -L "$file" ]]; then
+        local bak="${file}.backup.$(date +%Y%m%d_%H%M%S)"
+        cp "$file" "$bak"
+        ok "backed up ${D}→ $bak${R}"
+    fi
+}