+ With no command, xfetch renders the fetch. Global options may appear before or
+ after the subcommand. Unsupported flag combinations fail with exit code 2.
+
+
+
+ The renderer reads the config, applies the theme and config providers, collects
+ only the required probes, and prints the selected layout.
+
+
+
+ Command addons expose extra CLI commands. They are installed and updated like
+ the other addon families, but they run on demand:
+
+
+
+ The command receives positional arguments and returns plain text, one field
+ per line. The core prints the text as-is by default; --render
+ passes the lines through the configured layout and logo. --json
+ wraps the output as
+ {schema_version, command, args, lines}.
+
+
+
+ Backups are JSON text (optionally compressed/encrypted) and may contain
+ sensitive configuration values. On Unix the backup file is written with mode
+ 0600. Store encrypted backups and passphrase files securely.
+
+
+
+ Images use the Kitty graphics protocol when available, iTerm inline images in
+ compatible terminals, and half blocks otherwise. Text colors are controlled by
+ --color; images are not affected by --no-color.
+
+
+
+ This table is a summary. The complete reference, including output modes, JSON
+ schemas, runtime overrides and exit codes, is in
+ CLI.md.
+
+
diff --git a/docs/EXTENSIONS.md b/docs/EXTENSIONS.md
index 604a791..c04276a 100644
--- a/docs/EXTENSIONS.md
+++ b/docs/EXTENSIONS.md
@@ -21,6 +21,17 @@
diff --git a/docs/INSTALLATION.md b/docs/INSTALLATION.md
index d499e3e..9d949de 100644
--- a/docs/INSTALLATION.md
+++ b/docs/INSTALLATION.md
@@ -91,6 +91,19 @@
@@ -265,6 +278,36 @@ makepkg -si
+Windows (winget)
+
+
+ xfetch is available from the Windows Package Manager.
+ No Rust toolchain or compilation is needed:
+
+
+winget install xfetch
+
+
+ To update to a newer release:
+
+
+winget upgrade xfetch
+
+
+ To uninstall:
+
+
+winget uninstall xfetch
+
+
+ Note: xfetch detects winget-managed installs and delegates
+ xfetch update to
+ winget upgrade --id Xfetch-cli.Xfetch --exact. winget may lag
+ behind the GitHub release while its manifest is reviewed.
+
+
+
+
Verifying Installation
@@ -313,7 +356,7 @@ makepkg -si
and gh):
-VERSION=1.0.2
+VERSION=1.0.3
ASSET="xfetch-${VERSION}-x86_64-unknown-linux-gnu.tar.gz"
BASE="https://github.com/xfetch-cli/xfetch/releases/download/v${VERSION}"
@@ -395,11 +438,13 @@ xfetch update --yes # skip the confirmation prompt
-
- Prebuilt installs (
install-prebuilt.sh,
- typically ~/.local/bin): the matching release asset is
- downloaded, verified against the published SHA256SUMS,
- extracted and moved over the current executable with an atomic rename. A
- single xfetch.bak keeps the previous binary and is
+ Prebuilt installs (install-prebuilt.sh on
+ Unix, install-prebuilt.ps1 on Windows): the matching release
+ asset is downloaded, verified against the published
+ SHA256SUMS, extracted and moved over the current executable.
+ Unix uses an atomic rename; Windows uses a self-replace helper because a
+ running .exe cannot be deleted. A single xfetch.bak
+ (or xfetch.exe.bak) keeps the previous binary and is
overwritten on the next update.
-
@@ -407,16 +452,38 @@ xfetch update --yes # skip the confirmation prompt
cargo install xfetch-cli --force --locked.
-
- Package-manager installs and local builds: never replaced;
- the command prints the right command instead.
+ Source builds (
install.ps1 or
+ cargo install --path): rebuilt from the source checkout when
+ it still exists; otherwise the command prints the rebuild command. They
+ are never replaced with the crates.io release.
+
+ -
+ winget installs (Windows): delegated to
+
winget upgrade --id Xfetch-cli.Xfetch --exact. xfetch never
+ overwrites a winget-managed file itself. winget may lag behind the GitHub
+ release while its manifest is reviewed; in that case the command reports
+ the pending manifest instead of pretending the update succeeded.
+
+ -
+ Manual copies and local builds: never replaced
+ automatically; the command prints the right command or the release URL.
+
+ The PowerShell installers write
+ %LOCALAPPDATA%\xfetch\install.json to record whether the binary
+ is a prebuilt install or a source build. This is what distinguishes a
+ script-installed binary from a manual copy in the same directory. Existing
+ installs without a receipt are treated conservatively as unknown.
+
+
xfetch update --prebuilt --bin-dir <dir> forces the
- in-place update of <dir>/xfetch (Unix only). On Windows
- the prebuilt path is not available yet; use
- cargo install xfetch-cli --force or your installer of choice.
+ in-place update of <dir>/xfetch (or
+ <dir>\xfetch.exe on Windows). It refuses to touch
+ binaries owned by cargo or winget. This is also the escape hatch for a
+ manually downloaded binary.
@@ -431,7 +498,12 @@ xfetch update --yes # skip the confirmation prompt
See the Uninstallation Guide for detailed instructions.
-Quick uninstall:
+Quick uninstall from the CLI:
+
+xfetch self-uninstall
+xfetch self-uninstall --purge --yes
+
+Quick uninstall script:
curl -fsSL https://raw.githubusercontent.com/xfetch-cli/xfetch/main/uninstall.sh | bash
@@ -446,6 +518,29 @@ rm -rf ~/.config/xfetch
+Shell Integration
+
+
+ Generate completions for your shell and install the man page:
+
+
+# Bash
+xfetch completions bash > ~/.local/share/bash-completion/completions/xfetch
+
+# Zsh
+xfetch completions zsh > ~/.zfunc/_xfetch
+
+# Fish
+xfetch completions fish > ~/.config/fish/completions/xfetch.fish
+
+# Man page
+xfetch man --output ~/.local/share/man/man1/xfetch.1
+
+
+ See CLI.md for the complete command reference, JSON
+ output and exit codes.
+
+
Next Steps
diff --git a/docs/LAYOUTS.md b/docs/LAYOUTS.md
index f998eac..8db37e7 100644
--- a/docs/LAYOUTS.md
+++ b/docs/LAYOUTS.md
@@ -297,6 +297,21 @@ memory: 16 GiB / 32 GiB (50%)
"layout": "bottom"
}
+16. Right Layout
+
+
+ Mirrors the classic layout: the info column is on the left and the logo,
+ ASCII or image, is on the right.
+
+
+Configuration:
+
+
{
+ "layout": "right",
+ "logo_path": "~/.config/xfetch/logo.png",
+ "logo_width": 24
+}
+
Module Grouping
diff --git a/docs/PLUGINS.md b/docs/PLUGINS.md
index 0110aa8..5877030 100644
--- a/docs/PLUGINS.md
+++ b/docs/PLUGINS.md
@@ -26,11 +26,14 @@
End users should install official plugins by name from the remote repository:
-xfetch plugin install animate-logo
+xfetch plugin install animate-logo
+xfetch plugin install --all
The core downloads the plugin source from the official remote, builds it, and installs
- the resulting binary into the xfetch plugin directory.
+ the resulting binary into the xfetch plugin directory. install --all
+ installs every plugin advertised by the catalog and skips plugins that are already
+ installed; add --force to reinstall them.
@@ -48,11 +51,29 @@ XFETCH_PLUGIN_REPO=https://github.com/user/plugins.git xfetch plugin install my-
an extra development directory to that search path.
+
+ Every successful install writes an .install.json receipt next to
+ the plugin. It records the version, source, repository and artifact hash used
+ by update. Updates rebuild native plugins from the recorded
+ source and keep the previous binary as .bak for
+ rollback.
+
+
+
+ The same actions are available through the unified form
+ xfetch addon plugin <action>. See
+ CLI.md for the complete command and JSON reference.
+
+
Manage installed plugins
xfetch plugin list
xfetch plugin list --verbose
xfetch plugin info <name>
+xfetch plugin update <name>
+xfetch plugin update --all
+xfetch plugin update --all --check
+xfetch plugin rollback <name>
xfetch plugin search <query>
xfetch plugin available
xfetch plugin remove <name>
diff --git a/docs/THEMES.md b/docs/THEMES.md
index cbcaf9f..6f8566b 100644
--- a/docs/THEMES.md
+++ b/docs/THEMES.md
@@ -136,8 +136,32 @@ xfetch theme remove nord
# Export current visual config as a reusable theme file
xfetch theme export my-theme
+
+# Apply a theme to one run without editing the config
+xfetch --theme nord
+
+# Machine-readable theme list
+xfetch --json theme list
+
+# Remote registry: search, inspect, install and update
+xfetch theme search dark
+xfetch theme info nord
+xfetch theme install nord
+xfetch theme update --all --check
+xfetch theme update nord
+
+ All theme commands accept the global --json flag. Remote commands
+ use the registry at
+ https://raw.githubusercontent.com/xfetch-cli/themes/main/index.json
+ (override with XFETCH_THEME_INDEX) and are blocked by
+ --offline. Installed themes keep a
+ .<name>.xfetch-meta.json sidecar with version and source.
+ theme update --check exits 1 when an update is available. See
+ CLI.md for the JSON shapes and exit codes.
+
+
Export Behavior
diff --git a/docs/UNINSTALLATION.md b/docs/UNINSTALLATION.md
index a64057f..81bbb00 100644
--- a/docs/UNINSTALLATION.md
+++ b/docs/UNINSTALLATION.md
@@ -60,3 +60,9 @@ export PATH="$HOME/.local/bin:$PATH"
irm https://raw.githubusercontent.com/xfetch-cli/xfetch/main/uninstall.ps1 | iex -Args "-Purge"
+
+
+ If you installed with winget, uninstall through winget instead:
+
+
+winget uninstall xfetch
diff --git a/docs/WASM.md b/docs/WASM.md
index 535ccd7..500d02f 100644
--- a/docs/WASM.md
+++ b/docs/WASM.md
@@ -1,8 +1,8 @@
WebAssembly Guests
- Plugins, effects and extensions can be WebAssembly artifacts instead of native
- executables. The core detects them by their binary header, runs them inside a
+ Plugins, effects, extensions and command addons can be WebAssembly artifacts
+ instead of native executables. The core detects them by their binary header, runs them inside a
sandboxed wasmtime runtime and keeps the same JSON protocol version 1, so the
rest of the system (config, timeouts, list/remove commands) is unchanged.
@@ -23,13 +23,13 @@
| Core module |
wasm32-wasip1 |
- JSON request on stdin, JSON response on stdout, host calls through the xfetch.host_call import |
+ JSON request on stdin, JSON or plain-text response on stdout, host calls through the xfetch.host_call import |
Rust, C, Zig, Go, AssemblyScript, ... |
| Component |
Component model (wasm32) |
- Export run from the WIT world, typed host imports |
+ Export run from the plugin/effect/extension/command WIT world, typed host imports |
Python (componentize-py), JavaScript (componentize-js), Rust (wit-bindgen), ... |
@@ -62,6 +62,11 @@ xfetch plugin install https://example.com/releases/plugin.wasm --sha256 <64-h
xfetch effects install ./effects/wasm-matrix
xfetch extension install ./extensions/wasm-night-mode
+
+ The complete wasm command reference, including JSON output and
+ exit codes, is in CLI.md.
+
+
wasm inspect prints a human-readable report or the same data as
JSON with --json. wasm run accepts the request
diff --git a/install-prebuilt.ps1 b/install-prebuilt.ps1
index 7cc44f0..e00d093 100644
--- a/install-prebuilt.ps1
+++ b/install-prebuilt.ps1
@@ -5,7 +5,7 @@
#
# Usage:
# irm https://raw.githubusercontent.com/xfetch-cli/xfetch/main/install-prebuilt.ps1 | iex
-# .\install-prebuilt.ps1 -Version 1.0.2 -BinDir C:\tools\bin
+# .\install-prebuilt.ps1 -Version 1.0.3 -BinDir C:\tools\bin
# .\install-prebuilt.ps1 -NoChecksum -NoPath
param(
@@ -29,6 +29,33 @@ function Fail($Message) {
exit 1
}
+# Records how this copy was installed. The updater reads it before falling
+# back to path heuristics, so a prebuilt install and a manually copied build
+# in the same directory are not confused.
+function Write-InstallReceipt($Method, $Path, $Version, $Source, $SourcePath, $Repo, $Commit) {
+ if (-not $env:LOCALAPPDATA) { return }
+ try {
+ $receiptDir = Join-Path $env:LOCALAPPDATA "xfetch"
+ New-Item -ItemType Directory -Path $receiptDir -Force | Out-Null
+ $receipt = [ordered]@{
+ schema_version = 1
+ method = $Method
+ path = $Path
+ installed_at = (Get-Date).ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ")
+ }
+ if ($Version) { $receipt.version = $Version }
+ if ($Source) { $receipt.source = $Source }
+ if ($SourcePath) { $receipt.source_path = $SourcePath }
+ if ($Repo) { $receipt.repo = $Repo }
+ if ($Commit) { $receipt.commit = $Commit }
+ $json = $receipt | ConvertTo-Json -Compress
+ $utf8 = New-Object System.Text.UTF8Encoding -ArgumentList $false
+ [System.IO.File]::WriteAllText((Join-Path $receiptDir "install.json"), $json, $utf8)
+ } catch {
+ Write-Warn "Could not write install receipt: $($_.Exception.Message)"
+ }
+}
+
# Windows PowerShell 5.1 defaults to older TLS versions; GitHub needs 1.2.
if ($PSVersionTable.PSVersion.Major -lt 6) {
[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
@@ -128,6 +155,7 @@ try {
Fail "Could not install the binary: $($_.Exception.Message)"
}
Write-Ok "Installed binary: $installPath"
+ Write-InstallReceipt -Method "prebuilt" -Path $installPath -Version $Version -Source "install-prebuilt.ps1"
if (-not $NoPath -and $env:OS -eq "Windows_NT") {
$userPath = [Environment]::GetEnvironmentVariable("Path", "User")
diff --git a/install-prebuilt.sh b/install-prebuilt.sh
index 40cb54a..3fed8bf 100755
--- a/install-prebuilt.sh
+++ b/install-prebuilt.sh
@@ -3,7 +3,7 @@
# Prebuilt installer — downloads a precompiled binary from GitHub Releases.
# Fast: no Rust toolchain, no compilation. Requires only curl (and tar/unzip).
# Usage: curl -fsSL https://raw.githubusercontent.com/xfetch-cli/xfetch/main/install-prebuilt.sh | bash
-# bash install-prebuilt.sh --version 1.0.2
+# bash install-prebuilt.sh --version 1.0.3
# bash install-prebuilt.sh --prefix /usr/local --yes
set -euo pipefail
@@ -174,7 +174,7 @@ Options:
-y, --yes Automatic yes to all prompts
-s, --skip-config Skip generating the default config
-q, --quiet Quiet mode (minimal output)
- --version Install a specific version (e.g. 1.0.2); default: latest release
+ --version Install a specific version (e.g. 1.0.3); default: latest release
--require-signature Abort when cosign is unavailable or the signature bundle is missing
--allow-unsigned Accept a signed release that is missing SHA256SUMS.bundle
(SHA-256 only; not recommended)
@@ -200,7 +200,7 @@ Examples:
curl -fsSL ${REPO_RAW}/install-prebuilt.sh | bash
# Install a specific version
- curl -fsSL ${REPO_RAW}/install-prebuilt.sh | bash -s -- --version 1.0.2
+ curl -fsSL ${REPO_RAW}/install-prebuilt.sh | bash -s -- --version 1.0.3
# Non-interactive install
bash install-prebuilt.sh --yes
@@ -255,7 +255,7 @@ parse_args() {
# ──────────────────────────────────────────────
# A release version must be a dotted numeric version, optionally with a
-# prerelease suffix (1.0.2, 1.0.2-rc1, 1.0.2-rc.2). Anything else is rejected
+# prerelease suffix (1.0.3, 1.0.3-rc1, 1.0.3-rc.2). Anything else is rejected
# instead of being silently coerced.
validate_version() {
printf '%s\n' "${1:-}" \
@@ -268,7 +268,7 @@ resolve_asset_url() {
release_url="${REPO_API}/releases/latest"
else
validate_version "${VERSION}" \
- || die "Invalid --version '${VERSION}': expected a dotted numeric release such as 1.0.2."
+ || die "Invalid --version '${VERSION}': expected a dotted numeric release such as 1.0.3."
release_url="${REPO_API}/releases/tags/v${VERSION}"
fi
diff --git a/install.ps1 b/install.ps1
index 66e2efc..7f164ee 100644
--- a/install.ps1
+++ b/install.ps1
@@ -8,6 +8,32 @@ param(
Write-Host "Installing xfetch..." -ForegroundColor Cyan
+# Records that this binary came from a source checkout. The updater uses it
+# to distinguish a path install from `cargo install xfetch-cli`.
+function Write-InstallReceipt($Method, $Path, $Version, $Source, $SourcePath, $Repo, $Commit) {
+ if (-not $env:LOCALAPPDATA) { return }
+ try {
+ $receiptDir = Join-Path $env:LOCALAPPDATA "xfetch"
+ New-Item -ItemType Directory -Path $receiptDir -Force | Out-Null
+ $receipt = [ordered]@{
+ schema_version = 1
+ method = $Method
+ path = $Path
+ installed_at = (Get-Date).ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ")
+ }
+ if ($Version) { $receipt.version = $Version }
+ if ($Source) { $receipt.source = $Source }
+ if ($SourcePath) { $receipt.source_path = $SourcePath }
+ if ($Repo) { $receipt.repo = $Repo }
+ if ($Commit) { $receipt.commit = $Commit }
+ $json = $receipt | ConvertTo-Json -Compress
+ $utf8 = New-Object System.Text.UTF8Encoding -ArgumentList $false
+ [System.IO.File]::WriteAllText((Join-Path $receiptDir "install.json"), $json, $utf8)
+ } catch {
+ Write-Host "Could not write install receipt: $($_.Exception.Message)" -ForegroundColor Yellow
+ }
+}
+
# Check for Rust/Cargo
if (-not (Get-Command cargo -ErrorAction SilentlyContinue)) {
if ($Yes -or [Console]::IsInputRedirected) {
@@ -78,6 +104,17 @@ if ($UserPath -notlike "*$CargoBin*") {
Write-Host "Added $CargoBin to user PATH." -ForegroundColor Green
}
+# Record the source build before the temporary clone is removed.
+$InstalledVersion = ""
+try {
+ $InstalledVersion = ((& xfetch --version 2>$null) -replace '^xfetch(?:-cli)?\s+', '').Trim()
+} catch {}
+$Commit = ""
+try {
+ $Commit = (git -C $TempDir rev-parse HEAD 2>$null).Trim()
+} catch {}
+Write-InstallReceipt -Method "source" -Path (Join-Path $CargoBin "xfetch.exe") -Version $InstalledVersion -Source "install.ps1" -Repo $RepoUrl -Commit $Commit
+
# Setup Config
$ConfigDir = Join-Path $env:APPDATA "xfetch"
Write-Host "Setting up default config..." -ForegroundColor Cyan
diff --git a/scripts/test-cli-sandbox.sh b/scripts/test-cli-sandbox.sh
new file mode 100755
index 0000000..30dd64c
--- /dev/null
+++ b/scripts/test-cli-sandbox.sh
@@ -0,0 +1,473 @@
+#!/usr/bin/env bash
+# End-to-end CLI sandbox test. Usage: scripts/test-cli-sandbox.sh [xfetch-binary]
+set -uo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+BIN="${1:-$SCRIPT_DIR/../target/release/xfetch}"
+if [ ! -x "$BIN" ]; then
+ echo "xfetch binary not found at $BIN"
+ echo "Run: cargo build --release --locked"
+ exit 1
+fi
+SB="$(mktemp -d /tmp/xfetch-cli-sandbox.XXXXXX)"
+export HOME="$SB/home"
+export XDG_CONFIG_HOME="$SB/config"
+export XDG_CACHE_HOME="$SB/cache"
+export XDG_STATE_HOME="$SB/state"
+OUT="$SB/out.txt"
+ERR="$SB/err.txt"
+mkdir -p "$HOME" "$XDG_CONFIG_HOME/xfetch" "$XDG_CACHE_HOME" "$XDG_STATE_HOME"
+
+pass=0
+fail_count=0
+fail() { echo "FAIL: $*"; fail_count=$((fail_count + 1)); }
+ok() { pass=$((pass + 1)); }
+run() { "$@" >"$OUT" 2>"$ERR" || { fail "command failed: $*"; cat "$OUT" "$ERR"; }; }
+expect() {
+ local want=$1; shift
+ "$@" >"$OUT" 2>"$ERR"
+ local got=$?
+ if [ "$got" -ne "$want" ]; then
+ fail "expected exit $want, got $got: $*"
+ cat "$OUT" "$ERR"
+ else
+ ok
+ fi
+}
+contains() { grep -q -- "$1" "$OUT" || fail "missing '$1' in output of $2"; }
+json_check() { python3 -c "$1" <"$OUT" || fail "json check failed: $1"; }
+
+# Basic info and discovery.
+run "$BIN" --version
+contains "xfetch 1.0.3" 1
+run "$BIN" --help
+contains "--backup" help
+contains "--restore" help
+run "$BIN" --list-layouts
+contains "right" layouts
+run "$BIN" --json --list-layouts
+json_check 'import json,sys; v=json.load(sys.stdin); assert "right" in v'
+run "$BIN" --list-modules
+contains "packages:" modules
+run "$BIN" modules
+contains "packages:" modules
+run "$BIN" --json modules
+json_check 'import json,sys; v=json.load(sys.stdin); assert any(x["key"]=="os" for x in v)'
+run "$BIN" --json --list-modules
+json_check 'import json,sys; v=json.load(sys.stdin); assert any(x["key"]=="os" for x in v)'
+
+# Output modes.
+run "$BIN" --json
+json_check 'import json,sys; v=json.load(sys.stdin); assert v["schema_version"]==1 and v["name"]=="xfetch"'
+run "$BIN" --json --benchmark
+json_check 'import json,sys; v=json.load(sys.stdin); assert "benchmark" in v'
+run "$BIN" --get os
+[ -n "$(cat "$OUT")" ] || fail "--get os returned no value"
+run "$BIN" --get os,cpu
+contains "os=" get-os-cpu
+contains "cpu=" get-os-cpu
+run "$BIN" --json --get os,cpu
+json_check 'import json,sys; v=json.load(sys.stdin); assert v["schema_version"]==1 and "values" in v and "os" in v["values"]'
+run "$BIN" --format 'os={{os}} name={{name}} version={{version}} missing={{nope}}'
+contains "os=" format
+contains "name=xfetch" format
+contains "version=1.0.3" format
+printf 'kernel={{kernel}}\n' >"$SB/template.txt"
+run "$BIN" --template "$SB/template.txt"
+contains "kernel=" template
+
+# Runtime overrides.
+run "$BIN" --layout right --json
+json_check 'import json,sys; v=json.load(sys.stdin); assert v["schema_version"]==1'
+run "$BIN" --modules os,kernel --json
+json_check 'import json,sys; v=json.load(sys.stdin); assert v["schema_version"]==1'
+run "$BIN" --color never --modules os,kernel
+[ ! -s "$OUT" ] || ! grep -q $'\x1b' "$OUT" || fail "ANSI found with --color never"
+run "$BIN" --color always --modules os,kernel
+grep -q $'\x1b' "$OUT" || fail "no ANSI with --color always"
+run "$BIN" --no-cache --json
+run "$BIN" --offline --json
+run "$BIN" --quiet --json
+run "$BIN" --verbose --get os
+grep -q "config:" "$ERR" || fail "verbose diagnostics missing"
+
+# Conflicts and stable errors.
+expect 2 "$BIN" --json --format '{{os}}'
+expect 2 "$BIN" --get os --format '{{os}}'
+expect 2 "$BIN" --layout nope --get os
+expect 3 "$BIN" --theme nope --get os
+expect 7 "$BIN" --get nope
+expect 4 "$BIN" --offline plugin search logo
+expect 6 "$BIN" --offline update --check
+
+# Configuration commands and simple backup/restore.
+CONFIG="$XDG_CONFIG_HOME/xfetch/config.jsonc"
+printf '{\n // keep me\n "layout": "section",\n "modules": ["os", "kernel"]\n}\n' >"$CONFIG"
+run "$BIN" config validate
+contains "Config OK" validate
+run "$BIN" --json config validate
+json_check 'import json,sys; v=json.load(sys.stdin); assert v["valid"] is True'
+run "$BIN" config print --raw
+contains "// keep me" print-raw
+run "$BIN" config print
+contains '"layout"' print
+run "$BIN" --json config print
+json_check 'import json,sys; v=json.load(sys.stdin); assert "layout" in v'
+run "$BIN" config get layout
+contains "section" get-layout
+run "$BIN" --json config get modules
+json_check 'import json,sys; v=json.load(sys.stdin); assert isinstance(v,list) and "os" in v'
+run "$BIN" --quiet config set layout right
+[ -s "$OUT" ] && fail "quiet config set printed output"
+grep -q '"layout": "right"' "$CONFIG" || fail "config set did not write layout right"
+[ "$(grep -c '// keep me' "$CONFIG")" -eq 1 ] || fail "comment lost"
+run "$BIN" --json config set colors.cpu red
+json_check 'import json,sys; v=json.load(sys.stdin); assert v["key"]=="colors.cpu"'
+
+# Backup/restore: simple config.
+run "$BIN" --json --backup
+json_check 'import json,sys; v=json.load(sys.stdin); assert v["schema_version"]==1 and v["path"].endswith(".json")'
+BACKUP_SIMPLE=$(python3 -c 'import json,sys; print(json.load(open("/dev/stdin"))["path"])' <"$OUT")
+printf '{ "layout": "minimal" }\n' >"$CONFIG"
+run "$BIN" --json --restore
+json_check 'import json,sys; v=json.load(sys.stdin); assert v["restored"]'
+grep -q '"layout": "right"' "$CONFIG" || fail "restore did not restore layout right"
+run "$BIN" config backup --output "$SB/backups"
+mkdir -p "$SB/backups" 2>/dev/null || true
+[ -f "$BACKUP_SIMPLE" ] || fail "simple backup file missing"
+printf '{ "layout": "tree" }\n' >"$CONFIG"
+LATEST_DIR="$XDG_CONFIG_HOME/xfetch/backups"
+run "$BIN" config restore --from "$LATEST_DIR"
+grep -q '"layout": "right"' "$CONFIG" || fail "restore from dir did not restore layout right"
+printf '{ "layout": "tree" }\n' >"$CONFIG"
+run "$BIN" config restore --dry-run
+contains "Would restore" dry-run
+grep -q '"layout": "tree"' "$CONFIG" || fail "dry-run wrote to the config"
+
+# Themes.
+THEMES="$XDG_CONFIG_HOME/xfetch/themes"
+mkdir -p "$THEMES"
+printf '{ "layout": "compact", "colors": { "os": "Cyan" } }\n' >"$THEMES/nord.jsonc"
+run "$BIN" --json theme list
+json_check 'import json,sys; v=json.load(sys.stdin); assert any(t["name"]=="nord" for t in v["themes"])'
+run "$BIN" --json theme set nord
+json_check 'import json,sys; v=json.load(sys.stdin); assert v["status"]=="set"'
+run "$BIN" --theme nord --json
+json_check 'import json,sys; v=json.load(sys.stdin); assert v["schema_version"]==1'
+run "$BIN" --theme nord --json config print
+json_check 'import json,sys; v=json.load(sys.stdin); assert v["layout"]=="compact"'
+run "$BIN" --layout right --json config print
+json_check 'import json,sys; v=json.load(sys.stdin); assert v["layout"]=="right"'
+run "$BIN" --json theme export exported
+json_check 'import json,sys; v=json.load(sys.stdin); assert v["status"]=="exported"'
+run "$BIN" --json theme remove exported
+json_check 'import json,sys; v=json.load(sys.stdin); assert v["status"]=="removed"'
+
+# Doctor.
+run "$BIN" doctor
+contains "checks:" doctor
+run "$BIN" --json doctor
+json_check 'import json,sys; v=json.load(sys.stdin); assert v["schema_version"]==1 and v["checks"]'
+run "$BIN" --quiet doctor
+! grep -q "\[environment\]" "$OUT" || fail "quiet doctor printed OK checks"
+
+
+# Diagnostics commands and structured logging.
+run "$BIN" paths
+contains "config" paths
+run "$BIN" --json paths
+json_check 'import json,sys; v=json.load(sys.stdin); assert v["config"] and v["config_dir"]'
+run "$BIN" env
+contains "platform" env
+run "$BIN" --json env
+json_check 'import json,sys; v=json.load(sys.stdin); assert v["build"] and v["settings"]'
+run "$BIN" build-info
+contains "wasm support" build-info
+run "$BIN" --json build-info
+json_check 'import json,sys; v=json.load(sys.stdin); assert v["features"]["encryption"] is True'
+run "$BIN" --json doctor --bench
+json_check 'import json,sys; v=json.load(sys.stdin); assert "benchmark" in v'
+run "$BIN" doctor --image
+run "$BIN" --log-json --log-level debug --verbose --get os
+python3 - "$ERR" <<'PY'
+import json, sys
+lines=[line for line in open(sys.argv[1]) if line.strip()]
+assert lines, "no structured logs"
+for line in lines:
+ data=json.loads(line)
+ assert data["level"] == "debug"
+ assert data["target"] == "xfetch"
+PY
+[ $? -eq 0 ] || fail "structured log validation failed"
+run "$BIN" --log-level off --verbose --get os
+[ ! -s "$ERR" ] || fail "log level off still wrote logs"
+run "$BIN" help plugin install
+contains "Install an addon" help-plugin-install
+
+# Shell integration.
+for shell in bash zsh fish elvish powershell; do
+ run "$BIN" completions "$shell"
+ [ -s "$OUT" ] || fail "empty completions for $shell"
+done
+run "$BIN" man
+contains ".TH xfetch" man
+run "$BIN" man --output "$SB/xfetch.1"
+[ -s "$SB/xfetch.1" ] || fail "man output file missing"
+
+# Wasm tooling (no-op/error paths).
+run "$BIN" wasm wit
+contains "xfetch:runtime" wasm-wit
+printf 'not wasm\n' >"$SB/not-wasm.bin"
+expect 5 "$BIN" wasm inspect "$SB/not-wasm.bin"
+expect 5 "$BIN" wasm run "$SB/not-wasm.bin"
+
+# Addon commands.
+run "$BIN" --json addon plugin list
+json_check 'import json,sys; v=json.load(sys.stdin); assert v["schema_version"]==1 and isinstance(v["addons"],list)'
+run "$BIN" --json plugin list
+json_check 'import json,sys; v=json.load(sys.stdin); assert isinstance(v["addons"],list)'
+expect 4 "$BIN" --offline addon plugin search logo
+expect 4 "$BIN" --offline --json addon plugin install --all
+expect 5 "$BIN" --json addon plugin rollback x
+expect 5 "$BIN" --json addon plugin remove x
+
+# JSON addon rollback/remove against a fake installed native artifact.
+PLUGINS="$XDG_CONFIG_HOME/xfetch/plugins"
+mkdir -p "$PLUGINS"
+printf 'new' >"$PLUGINS/xfetch-plugin-test"
+printf 'old' >"$PLUGINS/xfetch-plugin-test.bak"
+run "$BIN" --json addon plugin rollback test
+json_check 'import json,sys; v=json.load(sys.stdin); assert v["status"]=="rolled-back"'
+[ "$(cat "$PLUGINS/xfetch-plugin-test")" = "old" ] || fail "rollback did not restore the backup"
+run "$BIN" --json addon plugin remove test
+json_check 'import json,sys; v=json.load(sys.stdin); assert v["status"]=="removed"'
+[ ! -e "$PLUGINS/xfetch-plugin-test" ] || fail "remove did not delete the artifact"
+
+# Daemon/cache no-op paths.
+run "$BIN" --json --daemon-stop
+json_check 'import json,sys; v=json.load(sys.stdin); assert "stopped" in v'
+run "$BIN" --json --daemon-live-stop
+json_check 'import json,sys; v=json.load(sys.stdin); assert "stopped" in v'
+run "$BIN" --json --clean-cache
+json_check 'import json,sys; v=json.load(sys.stdin); assert v["cleaned"] is True'
+
+# Config-roulette: routes + theme + fake extension.
+ROULETTE="$XDG_CONFIG_HOME/xfetch/roulette"
+mkdir -p "$ROULETTE/a" "$ROULETTE/b"
+printf '{ "layout": "compact", "colors": { "os": "Cyan" } }\n' >"$THEMES/theme.jsonc"
+printf '{ "layout": "compact", "theme": "theme", "modules": ["os"] }\n' >"$ROULETTE/a/config.jsonc"
+printf '{ "layout": "tree", "modules": ["kernel"] }\n' >"$ROULETTE/b/config.jsonc"
+printf '[{"_name":"a","path":"%s/a/config.jsonc"},{"_name":"b","path":"%s/b/config.jsonc"}]\n' "$ROULETTE" "$ROULETTE" >"$ROULETTE/routes.json"
+printf '{\n "config_providers": [\n { "extension": "config-roulette", "args": { "routes": "%s/routes.json" } }\n ]\n}\n' "$ROULETTE" >"$XDG_CONFIG_HOME/xfetch/config.jsonc"
+EXT="$XDG_CONFIG_HOME/xfetch/extensions"
+mkdir -p "$EXT"
+cat >"$EXT/xfetch-extension-config-roulette" <<'PY'
+#!/usr/bin/env python3
+import json, os, sys
+request = json.load(sys.stdin)
+args = request.get("args") or {}
+routes = os.path.expanduser(args.get("routes", "~/.config/xfetch/routes.json"))
+with open(routes, encoding="utf-8") as handle:
+ routes_data = json.load(handle)
+choice = routes_data[0]
+path = os.path.expanduser(choice["path"])
+if not os.path.isabs(path):
+ path = os.path.join(os.path.dirname(routes), path)
+with open(path, encoding="utf-8") as handle:
+ config = json.load(handle)
+json.dump({"config": config}, sys.stdout)
+PY
+chmod +x "$EXT/xfetch-extension-config-roulette"
+run "$BIN" --json config print
+json_check 'import json,sys; v=json.load(sys.stdin); assert v["layout"]=="compact"'
+run "$BIN" config backup --output "$SB/roulette-backup.json"
+python3 - "$SB/roulette-backup.json" <<'PY' >"$SB/roulette-roles.txt"
+import json, sys
+b=json.load(open(sys.argv[1]))
+roles=[f["role"] for f in b["files"]]
+print(",".join(roles))
+assert "config" in roles
+assert "routes" in roles
+assert "theme" in roles
+assert roles.count("route-config") == 2
+print("ROULETTE_OK")
+PY
+grep -q "ROULETTE_OK" "$SB/roulette-roles.txt" || fail "roulette backup roles check failed"
+# Restore the roulette bundle after deleting its files.
+rm -f "$XDG_CONFIG_HOME/xfetch/config.jsonc" "$ROULETTE/routes.json" "$ROULETTE/a/config.jsonc" "$ROULETTE/b/config.jsonc" "$THEMES/theme.jsonc"
+run "$BIN" config restore --from "$SB/roulette-backup.json"
+[ -f "$XDG_CONFIG_HOME/xfetch/config.jsonc" ] || fail "roulette config not restored"
+[ -f "$ROULETTE/routes.json" ] || fail "roulette routes not restored"
+[ -f "$ROULETTE/a/config.jsonc" ] || fail "route a not restored"
+[ -f "$ROULETTE/b/config.jsonc" ] || fail "route b not restored"
+[ -f "$THEMES/theme.jsonc" ] || fail "theme not restored"
+
+
+# Template conditionals and loops.
+run "$BIN" --format '{{#if kernel}}kernel-ok{{else}}no-kernel{{/if}} {{#unless nope}}unless-ok{{/unless}} {{#each gpu}}[{{this}}]{{else}}none{{/each}}'
+contains "kernel-ok" template-if
+contains "unless-ok" template-unless
+
+# Config editing: array set, unset, edit and reset.
+EDIT_CFG="$SB/edit-config.jsonc"
+printf '{ "layout": "section" }\n' >"$EDIT_CFG"
+run "$BIN" --config "$EDIT_CFG" config set modules.0 os
+run "$BIN" --config "$EDIT_CFG" config set modules.1 kernel
+grep -q '"kernel"' "$EDIT_CFG" || fail "config set modules.1 failed"
+run "$BIN" --config "$EDIT_CFG" config unset modules.1
+! grep -q '"kernel"' "$EDIT_CFG" || fail "config unset modules.1 failed"
+cat >"$SB/editor.sh" <<'SH'
+#!/bin/sh
+printf '{ "layout": "minimal" }\n' > "$1"
+SH
+chmod +x "$SB/editor.sh"
+env EDITOR="$SB/editor.sh" "$BIN" --config "$EDIT_CFG" config edit >"$OUT" 2>"$ERR" || fail "config edit failed"
+grep -q '"minimal"' "$EDIT_CFG" || fail "config edit did not apply the editor output"
+run "$BIN" --config "$EDIT_CFG" config reset --yes
+grep -q 'xfetch configuration' "$EDIT_CFG" || fail "config reset did not write defaults"
+run "$BIN" --json config backups
+json_check 'import json,sys; v=json.load(sys.stdin); assert v["backups"]'
+run "$BIN" --json --backup
+run "$BIN" --json config prune --keep 0
+json_check 'import json,sys; v=json.load(sys.stdin); assert v["deleted"]'
+
+# Backup compression, encryption, addon assets and root remapping.
+ROOT_CFG="$SB/root/xfetch/config.jsonc"
+mkdir -p "$SB/root/xfetch/themes" "$SB/compressed"
+printf '{ "layout": "compact" }\n' >"$SB/root/xfetch/themes/nord.jsonc"
+printf '{ "theme": "%s/root/xfetch/themes/nord.jsonc" }\n' "$SB" >"$ROOT_CFG"
+run "$BIN" --config "$ROOT_CFG" config backup --output "$SB/compressed" --compress
+ls "$SB/compressed"/*.json.gz >/dev/null 2>&1 || fail "compressed backup missing"
+printf 'secret' >"$SB/pass.txt"
+run "$BIN" --config "$ROOT_CFG" config backup --output "$SB/encrypted.enc" --encrypt --passphrase-file "$SB/pass.txt"
+[ -s "$SB/encrypted.enc" ] || fail "encrypted backup missing"
+printf '{ "layout": "tree" }\n' >"$ROOT_CFG"
+rm -f "$SB/root/xfetch/themes/nord.jsonc"
+run "$BIN" --config "$ROOT_CFG" config restore --from "$SB/encrypted.enc" --passphrase-file "$SB/pass.txt"
+grep -q 'theme' "$ROOT_CFG" || fail "encrypted restore did not restore the config"
+grep -q 'compact' "$SB/root/xfetch/themes/nord.jsonc" || fail "encrypted restore did not restore the theme"
+PLUGIN_ARTIFACT="$XDG_CONFIG_HOME/xfetch/plugins/xfetch-plugin-json-test"
+printf 'artifact' >"$PLUGIN_ARTIFACT"
+run "$BIN" --config "$ROOT_CFG" config backup --output "$SB/with-addons.json" --with-addons
+python3 - "$SB/with-addons.json" <<'PY'
+import json, sys
+b=json.load(open(sys.argv[1]))
+roles=[f["role"] for f in b["files"]]
+assert "addon-artifact" in roles, roles
+print("ADDON_ASSET_OK")
+PY
+run "$BIN" --config "$ROOT_CFG" config backup --output "$SB/root-backup.json"
+rm -rf "$SB/root"
+run "$BIN" config restore --from "$SB/root-backup.json" --root "$SB/root-restored"
+[ -f "$SB/root-restored/config.jsonc" ] || fail "root remapped config missing"
+[ -f "$SB/root-restored/themes/nord.jsonc" ] || fail "root remapped theme missing"
+
+# Doctor --fix generates a missing config.
+FIX_XDG="$SB/fix-config"
+env XDG_CONFIG_HOME="$FIX_XDG" HOME="$SB/fix-home" XDG_CACHE_HOME="$SB/fix-cache" "$BIN" --json doctor --fix >"$OUT" 2>"$ERR" || fail "doctor --fix failed"
+json_check 'import json,sys; v=json.load(sys.stdin); assert v["fixes"]'
+[ -f "$FIX_XDG/xfetch/config.jsonc" ] || fail "doctor --fix did not generate a config"
+
+# Schema output.
+run "$BIN" --json schema fetch
+json_check 'import json,sys; v=json.load(sys.stdin); assert v["title"]=="xfetch fetch output"'
+
+# Core binary rollback.
+RB="$SB/rollback-bin"
+mkdir -p "$RB"
+printf 'new' >"$RB/xfetch"
+printf 'old' >"$RB/xfetch.bak"
+run "$BIN" --json update --rollback --bin-dir "$RB"
+json_check 'import json,sys; v=json.load(sys.stdin); assert v["status"]=="rolled-back"'
+[ "$(cat "$RB/xfetch")" = "old" ] || fail "update rollback failed"
+
+# Remote theme and logo catalogs via a local HTTP server.
+REPO_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+if [ -d "$REPO_ROOT/../logos" ] && [ -d "$REPO_ROOT/../themes" ]; then
+ HTTP_ROOT="$SB/http-root"
+ mkdir -p "$HTTP_ROOT"
+ ln -s "$REPO_ROOT/../logos" "$HTTP_ROOT/logos"
+ ln -s "$REPO_ROOT/../themes" "$HTTP_ROOT/themes"
+ python3 - "$HTTP_ROOT/themes/index.json" "$HTTP_ROOT/themes/index.local.json" <<'PY'
+import json, sys
+src, dst = sys.argv[1], sys.argv[2]
+data = json.load(open(src))
+base = "http://127.0.0.1:8765/themes"
+for entry in data.get("themes", []):
+ entry["source"] = entry["source"].replace("https://raw.githubusercontent.com/xfetch-cli/themes/main", base)
+json.dump(data, open(dst, "w"))
+PY
+ python3 -m http.server 8765 --directory "$HTTP_ROOT" >"$SB/http.log" 2>&1 &
+ HTTP_PID=$!
+ trap 'kill "$HTTP_PID" 2>/dev/null || true' EXIT
+ export XFETCH_LOGOS_URL="http://127.0.0.1:8765/logos"
+ export XFETCH_THEME_INDEX="http://127.0.0.1:8765/themes/index.local.json"
+ sleep 1
+ run "$BIN" --json logo list
+ json_check 'import json,sys; v=json.load(sys.stdin); assert v["logos"]'
+ run "$BIN" logo preview arch
+ [ -s "$OUT" ] || fail "logo preview was empty"
+ expect 4 "$BIN" --offline logo list
+ run "$BIN" --json theme search nord
+ json_check 'import json,sys; v=json.load(sys.stdin); assert any(t["name"]=="nord" for t in v["themes"])'
+ run "$BIN" --json theme install nord --force
+ json_check 'import json,sys; v=json.load(sys.stdin); assert v["status"]=="installed"'
+ run "$BIN" --json theme info nord
+ json_check 'import json,sys; v=json.load(sys.stdin); assert v["theme"]["name"]=="nord"'
+ run "$BIN" --json theme update --all --check
+ json_check 'import json,sys; v=json.load(sys.stdin); assert "themes" in v'
+ run "$BIN" --json theme remove nord
+ json_check 'import json,sys; v=json.load(sys.stdin); assert v["status"]=="removed"'
+ expect 4 "$BIN" --offline theme search nord
+fi
+
+
+# Command addons.
+CMDS_REPO="$(cd "$SCRIPT_DIR/.." && pwd)/../commands"
+if [ -d "$CMDS_REPO/commands/github" ]; then
+ run "$BIN" command install "$CMDS_REPO/commands/github"
+ contains "Installed wasm command 'github'" command-install
+ run "$BIN" --json command list
+ json_check 'import json,sys; v=json.load(sys.stdin); assert any(a["name"]=="github" for a in v["addons"])'
+ run "$BIN" command info github
+ contains "github" command-info
+fi
+
+# Fake native command for the runner path.
+CMDS_DIR="$XDG_CONFIG_HOME/xfetch/commands"
+mkdir -p "$CMDS_DIR"
+cat >"$CMDS_DIR/xfetch-command-echo" <<'SH'
+#!/bin/sh
+printf 'repo: %s\nauthor: test\n' "$1"
+SH
+chmod +x "$CMDS_DIR/xfetch-command-echo"
+run "$BIN" --json command list
+json_check 'import json,sys; v=json.load(sys.stdin); assert any(a["name"]=="echo" for a in v["addons"])'
+run "$BIN" run echo -- owner/repo
+contains "repo: owner/repo" command-run
+run "$BIN" --json run echo -- owner/repo
+json_check 'import json,sys; v=json.load(sys.stdin); assert v["command"]=="echo" and v["lines"]'
+expect 5 "$BIN" run missing -- value
+run "$BIN" command remove echo
+
+# Conflicts.
+expect 2 "$BIN" --backup --restore
+expect 2 "$BIN" --backup modules
+
+# Self-uninstall a copied binary.
+UNINSTALL_BIN="$SB/uninstall-bin"
+mkdir -p "$UNINSTALL_BIN"
+cp "$BIN" "$UNINSTALL_BIN/xfetch"
+env XDG_CONFIG_HOME="$SB/uninstall-config" HOME="$SB/uninstall-home" XDG_CACHE_HOME="$SB/uninstall-cache" \
+ "$UNINSTALL_BIN/xfetch" --json self-uninstall --purge --yes >"$OUT" 2>"$ERR" || fail "self-uninstall failed"
+json_check 'import json,sys; v=json.load(sys.stdin); assert v["status"]=="uninstalled"'
+[ ! -e "$UNINSTALL_BIN/xfetch" ] || fail "self-uninstall did not remove the binary"
+
+# Conflicts.
+expect 2 "$BIN" --backup --restore
+expect 2 "$BIN" --backup modules
+
+echo
+echo "SANDBOX=$SB"
+echo "PASS=$pass FAIL=$fail_count"
+[ "$fail_count" -eq 0 ]
diff --git a/src/addons/catalog.rs b/src/addons/catalog.rs
index 513a2a6..dd4ba54 100644
--- a/src/addons/catalog.rs
+++ b/src/addons/catalog.rs
@@ -18,6 +18,8 @@ const PLUGIN_CATALOG: &str = "https://raw.githubusercontent.com/xfetch-cli/plugi
const EFFECT_CATALOG: &str = "https://raw.githubusercontent.com/xfetch-cli/effects/main/index.json";
const EXTENSION_CATALOG: &str =
"https://raw.githubusercontent.com/xfetch-cli/extensions/main/index.json";
+const COMMAND_CATALOG: &str =
+ "https://raw.githubusercontent.com/xfetch-cli/commands/main/index.json";
/// One addon advertised by a repository catalog.
#[derive(Debug, Clone, Serialize, Deserialize)]
@@ -39,10 +41,22 @@ pub struct CatalogEntry {
pub guest_runtime: Option,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub capabilities: Option,
+ /// Repository URL override; the installer falls back to its family default.
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub repo: Option,
+ /// Optional tag, branch or commit to build from.
+ #[serde(rename = "ref", default, skip_serializing_if = "Option::is_none")]
+ pub reference: Option,
+ /// SDK version used by the addon, for diagnostics and receipts.
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub sdk_version: Option,
+ /// Minimum xfetch core version required by the addon.
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub min_xfetch_version: Option,
}
impl CatalogEntry {
- fn install_name(&self) -> &str {
+ pub fn install_name(&self) -> &str {
self.install.as_deref().unwrap_or(&self.name)
}
@@ -88,6 +102,19 @@ pub fn search(kind: AddonKind, query: &str) -> Result, String>
.collect())
}
+/// Returns every entry in the catalog for `kind`.
+pub fn all(kind: AddonKind) -> Result, String> {
+ Ok(load(kind)?.entries)
+}
+
+/// Finds one catalog entry by its package name or install name.
+pub fn find(kind: AddonKind, name: &str) -> Result, String> {
+ Ok(load(kind)?
+ .entries
+ .into_iter()
+ .find(|entry| entry.name == name || entry.install_name() == name))
+}
+
/// Prints search results as a readable list or JSON.
pub fn print_search(kind: AddonKind, query: Option<&str>, json: bool) -> Result<(), String> {
let query = query.unwrap_or("");
@@ -134,6 +161,7 @@ fn install_command(kind: AddonKind, name: &str) -> String {
AddonKind::Plugin => format!("xfetch plugin install {}", name),
AddonKind::Effect => format!("xfetch effects install {}", name),
AddonKind::Extension => format!("xfetch extension install {}", name),
+ AddonKind::Command => format!("xfetch command install {}", name),
}
}
@@ -160,11 +188,15 @@ fn catalog_source(kind: AddonKind) -> String {
AddonKind::Plugin => ("XFETCH_PLUGIN_INDEX", PLUGIN_CATALOG),
AddonKind::Effect => ("XFETCH_EFFECT_INDEX", EFFECT_CATALOG),
AddonKind::Extension => ("XFETCH_EXTENSION_INDEX", EXTENSION_CATALOG),
+ AddonKind::Command => ("XFETCH_COMMAND_INDEX", COMMAND_CATALOG),
};
std::env::var(env_name).unwrap_or_else(|_| default.to_string())
}
fn fetch_remote(source: &str) -> Result {
+ if crate::runtime::offline() {
+ return Err("network access is disabled by --offline".to_string());
+ }
let mut response = ureq::get(source)
.config()
.timeout_global(Some(Duration::from_secs(15)))
@@ -214,7 +246,11 @@ mod tests {
"version": "0.2.0",
"kind": "info_provider",
"runtime": "native",
- "path": "plugins/weather"
+ "path": "plugins/weather",
+ "repo": "https://github.com/xfetch-cli/plugins.git",
+ "ref": "v0.2.0",
+ "sdk_version": "0.3.0",
+ "min_xfetch_version": "1.0.3"
}
]
}
@@ -228,6 +264,16 @@ mod tests {
assert!(catalog.entries[0].matches("WASM"));
assert!(!catalog.entries[0].matches("weather"));
assert_eq!(catalog.entries[1].install_name(), "weather");
+ assert_eq!(
+ catalog.entries[1].repo.as_deref(),
+ Some("https://github.com/xfetch-cli/plugins.git")
+ );
+ assert_eq!(catalog.entries[1].reference.as_deref(), Some("v0.2.0"));
+ assert_eq!(catalog.entries[1].sdk_version.as_deref(), Some("0.3.0"));
+ assert_eq!(
+ catalog.entries[1].min_xfetch_version.as_deref(),
+ Some("1.0.3")
+ );
}
#[test]
diff --git a/src/addons/mod.rs b/src/addons/mod.rs
index f02a3ba..4bcdabd 100644
--- a/src/addons/mod.rs
+++ b/src/addons/mod.rs
@@ -8,4 +8,6 @@
pub mod catalog;
pub mod install;
pub mod model;
+pub mod receipt;
pub mod report;
+pub mod update;
diff --git a/src/addons/model.rs b/src/addons/model.rs
index 0b3c8b3..0b3a77a 100644
--- a/src/addons/model.rs
+++ b/src/addons/model.rs
@@ -14,12 +14,13 @@ use crate::wasm::detect::is_wasm_file;
use crate::wasm::manifest::{self, Manifest, ManifestSource};
use std::path::{Path, PathBuf};
-/// The three installable addon families supported by the core.
+/// The four installable addon families supported by the core.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AddonKind {
Plugin,
Effect,
Extension,
+ Command,
}
impl AddonKind {
@@ -29,6 +30,7 @@ impl AddonKind {
Self::Plugin => "plugin",
Self::Effect => "effect",
Self::Extension => "extension",
+ Self::Command => "command",
}
}
@@ -38,6 +40,7 @@ impl AddonKind {
Self::Plugin => "plugins",
Self::Effect => "effects",
Self::Extension => "extensions",
+ Self::Command => "commands",
}
}
@@ -47,6 +50,7 @@ impl AddonKind {
Self::Plugin => "xfetch-plugin-",
Self::Effect => "xfetch-effect-",
Self::Extension => "xfetch-extension-",
+ Self::Command => "xfetch-command-",
}
}
@@ -56,6 +60,7 @@ impl AddonKind {
Self::Plugin => default_plugin_dir(),
Self::Effect => default_effect_dir(),
Self::Extension => default_extension_dir(),
+ Self::Command => crate::commands::default_command_dir(),
}
}
@@ -65,6 +70,7 @@ impl AddonKind {
Self::Plugin => plugin_binary_name(name),
Self::Effect => effect_binary_name(name),
Self::Extension => extension_binary_name(name),
+ Self::Command => crate::commands::command_binary_name(name),
}
}
@@ -74,6 +80,7 @@ impl AddonKind {
Self::Plugin => plugin_wasm_name(name),
Self::Effect => effect_wasm_name(name),
Self::Extension => extension_wasm_name(name),
+ Self::Command => crate::commands::command_wasm_name(name),
}
}
@@ -83,9 +90,29 @@ impl AddonKind {
Self::Plugin => plugin_manifest_name(name),
Self::Effect => effect_manifest_name(name),
Self::Extension => extension_manifest_name(name),
+ Self::Command => crate::commands::command_manifest_name(name),
}
}
+ /// Install receipt name for `name`.
+ pub fn receipt_name(self, name: &str) -> String {
+ format!("{}{}.install.json", self.prefix(), name)
+ }
+
+ /// Install receipt path for `name`.
+ pub fn receipt_path(self, name: &str) -> PathBuf {
+ self.directory().join(self.receipt_name(name))
+ }
+
+ /// Backup path used by update/rollback for an installed artifact.
+ pub fn backup_path(self, path: &Path) -> PathBuf {
+ let file_name = path
+ .file_name()
+ .and_then(|name| name.to_str())
+ .unwrap_or("addon");
+ path.with_file_name(format!("{}.bak", file_name))
+ }
+
/// Finds the installed native or wasm artifact in the default directory.
pub fn installed_path(self, name: &str) -> Option {
let directory = self.directory();
@@ -123,6 +150,7 @@ pub struct AddonEntry {
pub runtime: AddonRuntime,
pub manifest: Option,
pub manifest_source: Option,
+ pub receipt: Option,
pub enabled: bool,
}
@@ -147,6 +175,7 @@ impl AddonEntry {
_ => Some(loaded.manifest.clone()),
});
let manifest_source = loaded.map(|loaded| loaded.source.as_str().to_string());
+ let receipt = crate::addons::receipt::InstallReceipt::load(kind, name);
Self {
kind,
name: name.to_string(),
@@ -154,6 +183,7 @@ impl AddonEntry {
runtime,
manifest,
manifest_source,
+ receipt,
enabled: is_enabled(kind, name, config),
}
}
@@ -170,6 +200,11 @@ impl AddonEntry {
self.manifest
.as_ref()
.and_then(|manifest| manifest.version.as_deref())
+ .or_else(|| {
+ self.receipt
+ .as_ref()
+ .and_then(|receipt| receipt.version.as_deref())
+ })
}
pub fn description(&self) -> Option<&str> {
@@ -250,6 +285,9 @@ pub fn config_snippet(kind: AddonKind, name: &str, manifest_kind: Option<&str>)
format!(" {{ \"extension\": \"{name}\" }}"),
"]".to_string(),
],
+ AddonKind::Command => vec![format!(
+ "No config needed; run it with: xfetch run {name} -- "
+ )],
}
}
@@ -288,6 +326,7 @@ fn fallback_kind(kind: AddonKind) -> &'static str {
AddonKind::Plugin => "plugin",
AddonKind::Effect => "effect",
AddonKind::Extension => "config_provider",
+ AddonKind::Command => "command",
}
}
@@ -344,6 +383,7 @@ fn is_enabled(kind: AddonKind, name: &str, config: &Config) -> bool {
.config_providers
.iter()
.any(|provider| provider.extension == name),
+ AddonKind::Command => true,
}
}
diff --git a/src/addons/receipt.rs b/src/addons/receipt.rs
new file mode 100644
index 0000000..b7ed5f2
--- /dev/null
+++ b/src/addons/receipt.rs
@@ -0,0 +1,241 @@
+//! Installed-addon metadata used by `plugin/effects/extension update`.
+//!
+//! Native addons are built from source and have no embedded version, so the
+//! installer records how they were installed in a sidecar receipt. The updater
+//! uses that receipt to decide where to rebuild from and which version is
+//! currently installed.
+
+use crate::addons::catalog::CatalogEntry;
+use crate::addons::model::AddonKind;
+use crate::hash::sha256_hex;
+use serde::{Deserialize, Serialize};
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+/// Receipt schema accepted by this version.
+pub const SCHEMA_VERSION: u32 = 1;
+
+/// Metadata written after a successful addon install.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct InstallReceipt {
+ pub schema_version: u32,
+ pub kind: String,
+ pub name: String,
+ pub runtime: String,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub version: Option,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub sdk_version: Option,
+ pub source: String,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub repo: Option,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub path: Option,
+ #[serde(rename = "ref", default, skip_serializing_if = "Option::is_none")]
+ pub reference: Option,
+ #[serde(default)]
+ pub installed_at: u64,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub sha256: Option,
+}
+
+impl InstallReceipt {
+ /// Location of the receipt for an installed addon.
+ pub fn path(kind: AddonKind, name: &str) -> PathBuf {
+ kind.receipt_path(name)
+ }
+
+ /// Loads the receipt for `name`, if present and valid.
+ pub fn load(kind: AddonKind, name: &str) -> Option {
+ Self::load_from(&Self::path(kind, name))
+ }
+
+ /// Loads and validates a receipt from an explicit path.
+ pub fn load_from(path: &Path) -> Option {
+ let text = fs::read_to_string(path).ok()?;
+ let receipt: Self = serde_json::from_str(&text).ok()?;
+ (receipt.schema_version == SCHEMA_VERSION).then_some(receipt)
+ }
+
+ /// Writes the receipt atomically.
+ pub fn write(&self, kind: AddonKind, name: &str) -> Result<(), String> {
+ self.write_to(&Self::path(kind, name))
+ }
+
+ /// Writes the receipt atomically to an explicit path.
+ pub fn write_to(&self, path: &Path) -> Result<(), String> {
+ let bytes = serde_json::to_vec_pretty(self)
+ .map_err(|err| format!("Failed to serialize install receipt: {}", err))?;
+ if let Some(parent) = path.parent() {
+ fs::create_dir_all(parent)
+ .map_err(|err| format!("Failed to create '{}': {}", parent.display(), err))?;
+ }
+ crate::atomic_fs::write_atomic(path, &bytes)
+ .map_err(|err| format!("Failed to write '{}': {}", path.display(), err))
+ }
+}
+
+/// Records the source and installed version after a successful install.
+///
+/// `source` is `catalog`, `local`, `repo`, `url` or `manual`. `source_path`
+/// stores a local directory or URL; `repo` is the repository URL. A catalog
+/// entry, when available, supplies the version, SDK and reference.
+pub fn record(
+ kind: AddonKind,
+ name: &str,
+ source: &str,
+ repo: Option<&str>,
+ source_path: Option<&str>,
+ catalog: Option<&CatalogEntry>,
+) -> Result<(), String> {
+ let path = kind.installed_path(name).ok_or_else(|| {
+ format!(
+ "Cannot write install receipt: {} '{}' is not installed",
+ kind.label(),
+ name
+ )
+ })?;
+ let runtime = if crate::wasm::is_wasm_file(&path) {
+ "wasm"
+ } else {
+ "native"
+ };
+
+ let previous = InstallReceipt::load(kind, name);
+ let wasm_version = if runtime == "wasm" {
+ crate::wasm::manifest::load(&path)
+ .ok()
+ .and_then(|loaded| loaded.manifest.version)
+ } else {
+ None
+ };
+ let version = catalog
+ .and_then(|entry| entry.version.clone())
+ .or(wasm_version)
+ .or_else(|| {
+ previous
+ .as_ref()
+ .and_then(|receipt| receipt.version.clone())
+ });
+ let sdk_version = catalog
+ .and_then(|entry| entry.sdk_version.clone())
+ .or_else(|| {
+ previous
+ .as_ref()
+ .and_then(|receipt| receipt.sdk_version.clone())
+ });
+ let reference = catalog
+ .and_then(|entry| entry.reference.clone())
+ .or_else(|| {
+ previous
+ .as_ref()
+ .and_then(|receipt| receipt.reference.clone())
+ });
+ let repo = repo
+ .map(str::to_string)
+ .or_else(|| catalog.and_then(|entry| entry.repo.clone()))
+ .or_else(|| previous.as_ref().and_then(|receipt| receipt.repo.clone()));
+ let stored_path = if matches!(source, "local" | "url" | "repo") {
+ source_path
+ .map(str::to_string)
+ .or_else(|| previous.as_ref().and_then(|receipt| receipt.path.clone()))
+ .or_else(|| catalog.and_then(|entry| entry.path.clone()))
+ } else {
+ catalog
+ .and_then(|entry| entry.path.clone())
+ .or_else(|| source_path.map(str::to_string))
+ .or_else(|| previous.as_ref().and_then(|receipt| receipt.path.clone()))
+ };
+ let sha256 = fs::read(&path).ok().map(|bytes| sha256_hex(&bytes));
+
+ let receipt = InstallReceipt {
+ schema_version: SCHEMA_VERSION,
+ kind: kind.label().to_string(),
+ name: name.to_string(),
+ runtime: runtime.to_string(),
+ version,
+ sdk_version,
+ source: source.to_string(),
+ repo,
+ path: stored_path,
+ reference,
+ installed_at: SystemTime::now()
+ .duration_since(UNIX_EPOCH)
+ .map(|duration| duration.as_secs())
+ .unwrap_or(0),
+ sha256,
+ };
+ receipt.write(kind, name)
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ fn scratch(tag: &str) -> PathBuf {
+ let dir =
+ std::env::temp_dir().join(format!("xfetch-receipt-{}-{}", tag, std::process::id()));
+ let _ = fs::remove_dir_all(&dir);
+ fs::create_dir_all(&dir).expect("create scratch");
+ dir
+ }
+
+ #[test]
+ fn parses_optional_fields() {
+ let text = r#"{
+ "schema_version": 1,
+ "kind": "plugin",
+ "name": "weather",
+ "runtime": "native",
+ "source": "catalog",
+ "repo": "https://github.com/xfetch-cli/plugins.git",
+ "path": "plugins/weather",
+ "ref": "v0.2.0",
+ "version": "0.2.0",
+ "sdk_version": "0.3.0",
+ "installed_at": 100,
+ "sha256": "abc"
+ }"#;
+ let receipt: InstallReceipt = serde_json::from_str(text).expect("parse");
+ assert_eq!(receipt.name, "weather");
+ assert_eq!(receipt.reference.as_deref(), Some("v0.2.0"));
+ assert_eq!(receipt.sdk_version.as_deref(), Some("0.3.0"));
+ }
+
+ #[test]
+ fn writes_and_reads_a_receipt() {
+ let dir = scratch("roundtrip");
+ let path = dir.join("install.json");
+ let receipt = InstallReceipt {
+ schema_version: SCHEMA_VERSION,
+ kind: "effect".to_string(),
+ name: "decrypt".to_string(),
+ runtime: "native".to_string(),
+ version: Some("0.2.0".to_string()),
+ sdk_version: None,
+ source: "local".to_string(),
+ repo: None,
+ path: Some("/tmp/effects/decrypt".to_string()),
+ reference: None,
+ installed_at: 1,
+ sha256: None,
+ };
+ receipt.write_to(&path).expect("write");
+ assert_eq!(InstallReceipt::load_from(&path), Some(receipt));
+ let _ = fs::remove_dir_all(&dir);
+ }
+
+ #[test]
+ fn rejects_other_schema_versions() {
+ let dir = scratch("schema");
+ let path = dir.join("install.json");
+ fs::write(
+ &path,
+ r#"{"schema_version":2,"kind":"plugin","name":"x","runtime":"native","source":"local"}"#,
+ )
+ .expect("write");
+ assert!(InstallReceipt::load_from(&path).is_none());
+ let _ = fs::remove_dir_all(&dir);
+ }
+}
diff --git a/src/addons/report.rs b/src/addons/report.rs
index be7a373..41e0055 100644
--- a/src/addons/report.rs
+++ b/src/addons/report.rs
@@ -2,6 +2,7 @@
use crate::addons::model::{AddonEntry, AddonKind};
use crate::config::Config;
+use crate::runtime;
/// Prints the installed addon list. The default layout is unchanged for
/// scripts; `verbose` adds kind, runtime, version, capabilities and state.
@@ -65,6 +66,15 @@ pub fn print_info(entry: &AddonEntry) {
if let Some(source) = &entry.manifest_source {
println!("Manifest: {}", source);
}
+ if let Some(receipt) = &entry.receipt {
+ println!("Install source: {} ({})", receipt.source, receipt.runtime);
+ if let Some(repo) = &receipt.repo {
+ println!("Repository: {}", repo);
+ }
+ if let Some(reference) = &receipt.reference {
+ println!("Reference: {}", reference);
+ }
+ }
println!("Enabled: {}", if entry.enabled { "yes" } else { "no" });
println!("Capabilities:");
@@ -84,6 +94,9 @@ pub fn print_info(entry: &AddonEntry) {
/// Prints the config snippet and declared capabilities after a successful
/// install. The installer has already printed the artifact path.
pub fn print_install_guidance(kind: AddonKind, name: &str) {
+ if runtime::quiet() {
+ return;
+ }
let path = kind
.installed_path(name)
.unwrap_or_else(|| kind.directory().join(kind.wasm_name(name)));
@@ -112,5 +125,6 @@ fn title(kind: AddonKind) -> &'static str {
AddonKind::Plugin => "Plugin",
AddonKind::Effect => "Effect",
AddonKind::Extension => "Extension",
+ AddonKind::Command => "Command",
}
}
diff --git a/src/addons/update.rs b/src/addons/update.rs
new file mode 100644
index 0000000..689a07f
--- /dev/null
+++ b/src/addons/update.rs
@@ -0,0 +1,511 @@
+//! Shared install-all, update and rollback flow for the three addon families.
+//!
+//! Native addons are still built from source. Update reads the install receipt
+//! written by the installer, compares the recorded version with the catalog and
+//! rebuilds from the original source. The previous artifact is copied to
+//! `.bak` before replacement; a failed build leaves it untouched.
+
+use crate::addons::catalog::{self, CatalogEntry};
+use crate::addons::model::AddonKind;
+use crate::addons::receipt::{self, InstallReceipt};
+use crate::runtime;
+use semver::Version;
+use serde::Serialize;
+use std::fs;
+use std::path::{Path, PathBuf};
+
+/// Options for `plugin/effects/extension update`.
+#[derive(Debug, Default)]
+pub struct UpdateOptions {
+ /// Update every installed addon of this family.
+ pub all: bool,
+ /// Report only; do not install.
+ pub check: bool,
+ /// Reinstall even when the catalog version is not newer.
+ pub force: bool,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct UpdateCheck {
+ pub name: String,
+ pub installed: Option,
+ pub available: Option,
+ pub update_available: bool,
+ pub compatible: bool,
+ pub min_xfetch_version: Option,
+}
+
+/// Machine-readable update check used by `--json`.
+pub fn check(kind: AddonKind, name: Option<&str>, all: bool) -> Result, String> {
+ if all && name.is_some() {
+ return Err("Use either an addon name or --all, not both.".to_string());
+ }
+ if !all && name.is_none() {
+ return Err(format!("Specify a {} name or use --all.", kind.label()));
+ }
+
+ let targets = if all {
+ installed_names(kind)?
+ } else {
+ vec![name.expect("validated above").to_string()]
+ };
+ let entries = catalog::all(kind)?;
+ let mut checks = Vec::new();
+
+ for target in targets {
+ let entry = entries
+ .iter()
+ .find(|entry| entry.name == target || entry.install_name() == target)
+ .cloned();
+ let receipt = InstallReceipt::load(kind, &target);
+ let installed = receipt
+ .as_ref()
+ .and_then(|receipt| receipt.version.clone())
+ .or_else(|| installed_manifest_version(kind, &target));
+ let available = entry.as_ref().and_then(|entry| entry.version.clone());
+ let compatible = entry.as_ref().map(meets_min_core).unwrap_or(true);
+ let update_available = compatible && is_newer(installed.as_deref(), available.as_deref());
+ checks.push(UpdateCheck {
+ name: target,
+ installed,
+ available,
+ update_available,
+ compatible,
+ min_xfetch_version: entry.and_then(|entry| entry.min_xfetch_version),
+ });
+ }
+
+ Ok(checks)
+}
+
+/// Installs every addon advertised by the catalog, skipping installed ones
+/// unless `force` is set. Returns the names that were installed.
+pub fn install_all(kind: AddonKind, force: bool, json: bool) -> Result, String> {
+ let entries = catalog::all(kind)?;
+ if entries.is_empty() {
+ if !json {
+ runtime::info(format!(
+ "No {} available in the catalog.",
+ kind.plural_label()
+ ));
+ }
+ return Ok(Vec::new());
+ }
+
+ let mut installed = 0usize;
+ let mut skipped = 0usize;
+ let mut installed_names = Vec::new();
+ for entry in entries {
+ let name = entry.install_name().to_string();
+ if !force && kind.installed_path(&name).is_some() {
+ if !json {
+ runtime::info(format!(
+ "Skipping {} '{}' (already installed).",
+ kind.label(),
+ name
+ ));
+ }
+ skipped += 1;
+ continue;
+ }
+
+ install_one(kind, &name, entry.repo.as_deref(), None)?;
+ receipt::record(
+ kind,
+ &name,
+ "catalog",
+ entry.repo.as_deref(),
+ entry.path.as_deref(),
+ Some(&entry),
+ )?;
+ if !json {
+ runtime::info(format!("Installed {} '{}'.", kind.label(), name));
+ }
+ installed += 1;
+ installed_names.push(name);
+ }
+
+ if !json {
+ runtime::info(format!(
+ "Installed {} {}; skipped {} already installed.",
+ installed,
+ kind.plural_label(),
+ skipped
+ ));
+ }
+ Ok(installed_names)
+}
+
+/// Updates one addon, or every installed addon when `--all` is set.
+///
+/// Returns `true` when at least one update was available (used by `--check`).
+pub fn run(kind: AddonKind, name: Option<&str>, options: &UpdateOptions) -> Result {
+ if options.all && name.is_some() {
+ return Err("Use either an addon name or --all, not both.".to_string());
+ }
+ if !options.all && name.is_none() {
+ return Err(format!("Specify a {} name or use --all.", kind.label()));
+ }
+
+ let targets = if options.all {
+ installed_names(kind)?
+ } else {
+ vec![name.expect("validated above").to_string()]
+ };
+ if targets.is_empty() {
+ runtime::info(format!("No {} installed.", kind.plural_label()));
+ return Ok(false);
+ }
+
+ let entries = catalog::all(kind)?;
+ let mut any = false;
+
+ for target in targets {
+ let entry = entries
+ .iter()
+ .find(|entry| entry.name == target || entry.install_name() == target)
+ .cloned();
+ let receipt = InstallReceipt::load(kind, &target);
+ let installed_version = receipt
+ .as_ref()
+ .and_then(|receipt| receipt.version.clone())
+ .or_else(|| installed_manifest_version(kind, &target));
+
+ let available_version = entry.as_ref().and_then(|entry| entry.version.as_deref());
+ if !options.force && !is_newer(installed_version.as_deref(), available_version) {
+ runtime::info(format!(
+ "{} '{}' is up to date ({}).",
+ title(kind),
+ target,
+ installed_version.as_deref().unwrap_or("unknown")
+ ));
+ continue;
+ }
+
+ if let Some(entry) = &entry
+ && !meets_min_core(entry)
+ {
+ runtime::info(format!(
+ "{} '{}' requires xfetch {}, skipping.",
+ title(kind),
+ target,
+ entry.min_xfetch_version.as_deref().unwrap_or("?")
+ ));
+ continue;
+ }
+
+ any = true;
+ let from = installed_version.as_deref().unwrap_or("unknown");
+ let to = available_version.unwrap_or("unknown");
+ if options.check {
+ runtime::info(format!("{} '{}': {} -> {}", title(kind), target, from, to));
+ continue;
+ }
+
+ if receipt.is_none() && !options.force {
+ eprintln!(
+ "{} '{}' has no install receipt; re-run with --force to rebuild it.",
+ title(kind),
+ target
+ );
+ continue;
+ }
+
+ let source = match resolve_source(kind, &target, receipt.as_ref(), entry.as_ref()) {
+ Ok(source) => source,
+ Err(err) => {
+ eprintln!("{} '{}' skipped: {}", title(kind), target, err);
+ continue;
+ }
+ };
+
+ backup_installed(kind, &target)?;
+ if let Err(err) = source.install(kind, &target) {
+ eprintln!(
+ "{} '{}' update failed: {}. Keeping the previous installation.",
+ title(kind),
+ target,
+ err
+ );
+ continue;
+ }
+
+ receipt::record(
+ kind,
+ &target,
+ source.label(),
+ source.repo(),
+ source.path(),
+ entry.as_ref(),
+ )?;
+ runtime::info(format!(
+ "Updated {} '{}' ({} -> {}).",
+ kind.label(),
+ target,
+ from,
+ to
+ ));
+ }
+
+ Ok(any)
+}
+
+/// Restores the previous artifact saved by the last update.
+pub fn rollback(kind: AddonKind, name: &str) -> Result<(), String> {
+ let path = kind
+ .installed_path(name)
+ .ok_or_else(|| format!("{} '{}' is not installed.", title(kind), name))?;
+ let backup = backup_path(&path);
+ if !backup.is_file() {
+ return Err(format!(
+ "No previous version for {} '{}' (expected '{}').",
+ kind.label(),
+ name,
+ backup.display()
+ ));
+ }
+ crate::atomic_fs::copy_atomic(&backup, &path)
+ .map_err(|err| format!("Failed to restore '{}': {}", path.display(), err))?;
+
+ if crate::wasm::is_wasm_file(&path) {
+ restore_if_present(kind, &kind.directory().join(kind.manifest_name(name)))?;
+ }
+ restore_if_present(kind, &kind.receipt_path(name))?;
+
+ Ok(())
+}
+
+fn restore_if_present(kind: AddonKind, path: &Path) -> Result<(), String> {
+ let backup = kind.backup_path(path);
+ if backup.is_file() {
+ crate::atomic_fs::copy_atomic(&backup, path)
+ .map_err(|err| format!("Failed to restore '{}': {}", path.display(), err))?;
+ }
+ Ok(())
+}
+
+fn installed_names(kind: AddonKind) -> Result, String> {
+ let entries = match kind {
+ AddonKind::Plugin => crate::plugins::list_plugins()
+ .map(|entries| entries.into_iter().map(|(name, _)| name).collect())?,
+ AddonKind::Effect => crate::effects::list_effects()
+ .map(|entries| entries.into_iter().map(|(name, _)| name).collect())?,
+ AddonKind::Extension => crate::extensions::list_extensions()
+ .map(|entries| entries.into_iter().map(|(name, _)| name).collect())?,
+ AddonKind::Command => crate::commands::list_commands()
+ .map(|entries| entries.into_iter().map(|(name, _)| name).collect())?,
+ };
+ Ok(entries)
+}
+
+fn installed_manifest_version(kind: AddonKind, name: &str) -> Option {
+ let path = kind.installed_path(name)?;
+ if !crate::wasm::is_wasm_file(&path) {
+ return None;
+ }
+ crate::wasm::manifest::load(&path)
+ .ok()
+ .and_then(|loaded| loaded.manifest.version)
+}
+
+fn is_newer(installed: Option<&str>, available: Option<&str>) -> bool {
+ let Some(available) = available else {
+ return false;
+ };
+ let Some(installed) = installed else {
+ return true;
+ };
+ match (
+ Version::parse(installed.trim_start_matches('v')),
+ Version::parse(available.trim_start_matches('v')),
+ ) {
+ (Ok(installed), Ok(available)) => available > installed,
+ _ => installed != available,
+ }
+}
+
+fn meets_min_core(entry: &CatalogEntry) -> bool {
+ let Some(minimum) = entry.min_xfetch_version.as_deref() else {
+ return true;
+ };
+ let (Ok(current), Ok(minimum)) = (
+ Version::parse(env!("CARGO_PKG_VERSION")),
+ Version::parse(minimum.trim_start_matches('v')),
+ ) else {
+ return true;
+ };
+ current >= minimum
+}
+
+fn install_one(
+ kind: AddonKind,
+ source: &str,
+ repo: Option<&str>,
+ sha256: Option<&str>,
+) -> Result<(), String> {
+ match kind {
+ AddonKind::Plugin => crate::plugins::install_plugin(source, repo, sha256),
+ AddonKind::Effect => crate::effects::install_effect(source, repo, sha256),
+ AddonKind::Extension => crate::extensions::install_extension(source, repo, sha256),
+ AddonKind::Command => crate::commands::install_command(source, repo, sha256),
+ }
+}
+
+/// Where the next version should be built from.
+enum UpdateSource {
+ Catalog(Box),
+ Local(String),
+ Url(String),
+ Repo { name: String, repo: Option },
+}
+
+impl UpdateSource {
+ fn install(&self, kind: AddonKind, name: &str) -> Result<(), String> {
+ match self {
+ Self::Catalog(entry) => {
+ install_one(kind, entry.install_name(), entry.repo.as_deref(), None)
+ }
+ Self::Local(path) => install_one(kind, path, None, None),
+ Self::Url(url) => install_one(kind, url, None, None),
+ Self::Repo {
+ name: source_name,
+ repo,
+ } => install_one(kind, source_name, repo.as_deref(), None).or_else(|_| {
+ // Some receipts store the installed name separately from the
+ // package name; retry with the requested name.
+ install_one(kind, name, repo.as_deref(), None)
+ }),
+ }
+ }
+
+ fn label(&self) -> &'static str {
+ match self {
+ Self::Catalog(_) => "catalog",
+ Self::Local(_) => "local",
+ Self::Url(_) => "url",
+ Self::Repo { .. } => "repo",
+ }
+ }
+
+ fn repo(&self) -> Option<&str> {
+ match self {
+ Self::Catalog(entry) => entry.repo.as_deref(),
+ Self::Repo { repo, .. } => repo.as_deref(),
+ Self::Local(_) | Self::Url(_) => None,
+ }
+ }
+
+ fn path(&self) -> Option<&str> {
+ match self {
+ Self::Catalog(entry) => entry.path.as_deref(),
+ Self::Local(path) | Self::Url(path) => Some(path),
+ Self::Repo { name, .. } => Some(name),
+ }
+ }
+}
+
+fn resolve_source(
+ _kind: AddonKind,
+ name: &str,
+ receipt: Option<&InstallReceipt>,
+ entry: Option<&CatalogEntry>,
+) -> Result {
+ if let Some(receipt) = receipt {
+ match receipt.source.as_str() {
+ "local" => {
+ let path = receipt
+ .path
+ .clone()
+ .ok_or_else(|| "receipt has no local path".to_string())?;
+ return Ok(UpdateSource::Local(path));
+ }
+ "url" => {
+ let url = receipt
+ .path
+ .clone()
+ .ok_or_else(|| "receipt has no URL".to_string())?;
+ return Ok(UpdateSource::Url(url));
+ }
+ "repo" => {
+ return Ok(UpdateSource::Repo {
+ name: receipt.path.clone().unwrap_or_else(|| name.to_string()),
+ repo: receipt.repo.clone(),
+ });
+ }
+ _ => {}
+ }
+ }
+
+ if let Some(entry) = entry {
+ return Ok(UpdateSource::Catalog(Box::new(entry.clone())));
+ }
+
+ Ok(UpdateSource::Repo {
+ name: name.to_string(),
+ repo: receipt.and_then(|receipt| receipt.repo.clone()),
+ })
+}
+
+fn backup_installed(kind: AddonKind, name: &str) -> Result<(), String> {
+ let Some(path) = kind.installed_path(name) else {
+ return Ok(());
+ };
+ let backup = backup_path(&path);
+ fs::copy(&path, &backup)
+ .map_err(|err| format!("Failed to back up '{}': {}", path.display(), err))?;
+
+ if crate::wasm::is_wasm_file(&path) {
+ backup_if_present(kind, &kind.directory().join(kind.manifest_name(name)))?;
+ }
+ backup_if_present(kind, &kind.receipt_path(name))?;
+ Ok(())
+}
+
+fn backup_if_present(kind: AddonKind, path: &Path) -> Result<(), String> {
+ if path.is_file() {
+ fs::copy(path, kind.backup_path(path))
+ .map_err(|err| format!("Failed to back up '{}': {}", path.display(), err))?;
+ }
+ Ok(())
+}
+
+fn backup_path(path: &Path) -> PathBuf {
+ let file_name = path
+ .file_name()
+ .and_then(|name| name.to_str())
+ .unwrap_or("addon");
+ path.with_file_name(format!("{}.bak", file_name))
+}
+
+fn title(kind: AddonKind) -> &'static str {
+ match kind {
+ AddonKind::Plugin => "Plugin",
+ AddonKind::Effect => "Effect",
+ AddonKind::Extension => "Extension",
+ AddonKind::Command => "Command",
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn semver_comparison_handles_versions_and_fallbacks() {
+ assert!(is_newer(Some("0.2.0"), Some("0.3.0")));
+ assert!(!is_newer(Some("0.3.0"), Some("0.2.0")));
+ assert!(!is_newer(Some("0.3.0"), Some("0.3.0")));
+ assert!(is_newer(None, Some("0.3.0")));
+ assert!(!is_newer(Some("0.3.0"), None));
+ assert!(is_newer(Some("dev"), Some("release")));
+ }
+
+ #[test]
+ fn backup_path_is_next_to_the_artifact() {
+ let path = Path::new("/tmp/xfetch-plugin-weather");
+ assert_eq!(
+ backup_path(path),
+ PathBuf::from("/tmp/xfetch-plugin-weather.bak")
+ );
+ }
+}
diff --git a/src/cli.rs b/src/cli.rs
deleted file mode 100644
index 8a93443..0000000
--- a/src/cli.rs
+++ /dev/null
@@ -1,258 +0,0 @@
-use clap::{Parser, Subcommand};
-
-#[derive(Parser, Debug)]
-#[command(
- author,
- version,
- about,
- long_about = None,
- after_help = "Examples:\n xfetch\n xfetch --config ~/.config/xfetch/config.jsonc\n xfetch --gen-config\n xfetch --gen-config --layout tree\n xfetch --list-layouts\n xfetch --clean-cache\n xfetch --daemon\n xfetch --daemon-stop\n xfetch --no-daemon-live\n xfetch --daemon-live-stop\n xfetch --daemon-live-reload\n xfetch update --check\n xfetch update\n xfetch plugin install animate-logo\n xfetch plugin list --verbose\n xfetch plugin info animate-logo\n xfetch plugin search logo\n xfetch plugin remove animate-logo\n xfetch effects install decrypt\n xfetch effects list --verbose\n xfetch effects info decrypt\n xfetch effects available\n xfetch effects remove decrypt\n xfetch extension install config-roulette\n xfetch extension list --verbose\n xfetch extension info config-roulette\n xfetch extension search night\n xfetch extension remove config-roulette\n xfetch wasm inspect ./plugin.wasm\n xfetch wasm run ./plugin.wasm --request '{\"version\":1,\"kind\":\"info_provider\"}'\n xfetch wasm wit\n xfetch theme list\n xfetch theme set dracula\n xfetch theme remove dracula\n xfetch theme export my-theme"
-)]
-pub struct Cli {
- #[command(subcommand)]
- pub command: Option,
-
- #[arg(short, long, global = true)]
- pub config: Option,
-
- #[arg(long, global = true)]
- pub gen_config: bool,
-
- /// Logo to embed in the generated config, overriding the detected
- /// OS/distro (e.g. `--logo arch`, `--logo windows-11`). Only used with
- /// `--gen-config`; requires network access to the logos catalog.
- #[arg(long, global = true)]
- pub logo: Option,
-
- /// Layout for the generated config (e.g. `section`, `tree`, `compact`).
- /// Only used with `--gen-config`; defaults to `section`. Run
- /// `xfetch --list-layouts` to see every accepted name.
- #[arg(long, global = true)]
- pub layout: Option,
-
- /// Print the layout names accepted by `--layout` and exit.
- #[arg(long, global = true)]
- pub list_layouts: bool,
-
- #[arg(long, global = true)]
- pub clean_cache: bool,
-
- #[arg(long, global = true)]
- pub benchmark: bool,
-
- #[arg(long, global = true)]
- pub daemon: bool,
-
- #[arg(long, global = true)]
- pub daemon_stop: bool,
-
- /// Disable the live stats daemon (`daemon_live` in config) from the
- /// terminal.
- #[arg(long, global = true)]
- pub no_daemon_live: bool,
-
- /// Stop the running live stats daemon.
- #[arg(long, global = true)]
- pub daemon_live_stop: bool,
-
- /// Force hot reload in the live stats daemon (equivalent to
- /// `"daemon_live_reload": true` in the config).
- #[arg(long, global = true)]
- pub daemon_live_reload: bool,
-}
-
-#[derive(Subcommand, Debug)]
-pub enum Commands {
- #[command(alias = "plugins")]
- Plugin {
- #[command(subcommand)]
- action: PluginCommands,
- },
- #[command(alias = "extensions")]
- Extension {
- #[command(subcommand)]
- action: ExtensionCommands,
- },
- Theme {
- #[command(subcommand)]
- action: ThemeCommands,
- },
- #[command(alias = "effect")]
- Effects {
- #[command(subcommand)]
- action: EffectCommands,
- },
- /// WebAssembly guest tooling: inspect artifacts, run them with a raw JSON
- /// request and print the component protocol.
- Wasm {
- #[command(subcommand)]
- action: WasmCommands,
- },
- /// Check for a newer xfetch release and install it.
- Update {
- /// Only check; exit with code 1 when a newer release exists.
- #[arg(long)]
- check: bool,
- /// Install the prebuilt release in place, even for local builds
- /// (Unix only).
- #[arg(long)]
- prebuilt: bool,
- /// Directory holding the xfetch binary to replace (with --prebuilt).
- #[arg(long, value_name = "DIR")]
- bin_dir: Option,
- /// Assume yes for confirmation prompts.
- #[arg(long, short = 'y')]
- yes: bool,
- },
-}
-
-#[derive(Subcommand, Debug)]
-pub enum PluginCommands {
- Install {
- path: String,
- #[arg(long, short)]
- repo: Option,
- /// Expected SHA-256 (hex) of a downloaded wasm artifact.
- #[arg(long, value_name = "HEX")]
- sha256: Option,
- /// Override the installed name for a direct wasm file or URL.
- #[arg(long)]
- name: Option,
- /// Sidecar manifest to attach to a direct wasm file or URL.
- #[arg(long, value_name = "FILE")]
- manifest: Option,
- },
- List {
- /// Show kind, runtime, version, capabilities and enabled state.
- #[arg(long, short)]
- verbose: bool,
- },
- Info {
- name: String,
- },
- /// Search the remote plugin catalog. Omit the query to list everything.
- #[command(alias = "available")]
- Search {
- query: Option,
- /// Emit the matching entries as JSON.
- #[arg(long)]
- json: bool,
- },
- Remove {
- name: String,
- },
-}
-
-#[derive(Subcommand, Debug)]
-pub enum ExtensionCommands {
- Install {
- path: String,
- #[arg(long, short)]
- repo: Option,
- /// Expected SHA-256 (hex) of a downloaded wasm artifact.
- #[arg(long, value_name = "HEX")]
- sha256: Option,
- /// Override the installed name for a direct wasm file or URL.
- #[arg(long)]
- name: Option,
- /// Sidecar manifest to attach to a direct wasm file or URL.
- #[arg(long, value_name = "FILE")]
- manifest: Option,
- },
- List {
- /// Show kind, runtime, version, capabilities and enabled state.
- #[arg(long, short)]
- verbose: bool,
- },
- Info {
- name: String,
- },
- /// Search the remote extension catalog. Omit the query to list everything.
- #[command(alias = "available")]
- Search {
- query: Option,
- /// Emit the matching entries as JSON.
- #[arg(long)]
- json: bool,
- },
- Remove {
- name: String,
- },
-}
-
-#[derive(Subcommand, Debug)]
-pub enum ThemeCommands {
- List,
- Set { name: String },
- Remove { name: String },
- Export { name: String },
-}
-
-#[derive(Subcommand, Debug)]
-pub enum EffectCommands {
- Install {
- path: String,
- #[arg(long, short)]
- repo: Option,
- /// Expected SHA-256 (hex) of a downloaded wasm artifact.
- #[arg(long, value_name = "HEX")]
- sha256: Option,
- /// Override the installed name for a direct wasm file or URL.
- #[arg(long)]
- name: Option,
- /// Sidecar manifest to attach to a direct wasm file or URL.
- #[arg(long, value_name = "FILE")]
- manifest: Option,
- },
- List {
- /// Show kind, runtime, version, capabilities and enabled state.
- #[arg(long, short)]
- verbose: bool,
- },
- Info {
- name: String,
- },
- /// Search the remote effect catalog. Omit the query to list everything.
- #[command(alias = "available")]
- Search {
- query: Option,
- /// Emit the matching entries as JSON.
- #[arg(long)]
- json: bool,
- },
- Remove {
- name: String,
- },
-}
-
-#[derive(Subcommand, Debug)]
-pub enum WasmCommands {
- /// Print the resolved kind, manifest, capabilities and limits of an
- /// artifact without executing it.
- Inspect {
- path: String,
- /// Emit the report as JSON instead of a human-readable summary.
- #[arg(long)]
- json: bool,
- },
- /// Execute a wasm guest with a raw JSON request and print its response.
- /// Useful for authors and for scripted end-to-end checks.
- Run {
- path: String,
- /// JSON request passed to the guest (defaults to `{}`).
- #[arg(long)]
- request: Option,
- /// Read the JSON request from a file instead of `--request`.
- #[arg(long, value_name = "PATH")]
- request_file: Option,
- /// Safety timeout in seconds; overrides the manifest limit.
- #[arg(long)]
- timeout: Option,
- /// Guest contract used to select the component world.
- #[arg(long, value_parser = ["plugin", "effect", "extension"], default_value = "plugin")]
- kind: String,
- },
- /// Print the WIT package for component guests (componentize-py,
- /// componentize-js, wit-bindgen, ...).
- Wit,
-}
diff --git a/src/cli/addon_cmd.rs b/src/cli/addon_cmd.rs
new file mode 100644
index 0000000..25ab0f9
--- /dev/null
+++ b/src/cli/addon_cmd.rs
@@ -0,0 +1,336 @@
+use crate::addons::install::infer_name;
+use crate::addons::model::{AddonEntry, AddonKind};
+use crate::addons::{self, catalog};
+use crate::cli::args::{AddonCommands, Cli};
+use crate::cli::output;
+use crate::cli::output::{print_addon_info_json, print_addon_list_json, print_json};
+use crate::config::{ConfigOverrides, load_config_with_overrides};
+use crate::effects::{install_effect, list_effects, remove_effect};
+use crate::error::XFetchError;
+use crate::extensions::{install_extension, list_extensions, remove_extension};
+use crate::plugins::{install_plugin, list_plugins, remove_plugin};
+use crate::runtime;
+
+pub fn run(
+ kind: AddonKind,
+ action: AddonCommands,
+ cli: &Cli,
+ overrides: &ConfigOverrides,
+ config_path: Option,
+) -> Result<(), XFetchError> {
+ let config = || load_config_with_overrides(config_path.clone(), overrides);
+
+ match action {
+ AddonCommands::Install {
+ path,
+ repo,
+ sha256,
+ name,
+ manifest,
+ all,
+ force,
+ } => install_addon(
+ kind,
+ AddonInstallRequest {
+ path,
+ repo,
+ sha256,
+ name,
+ manifest,
+ all,
+ force,
+ },
+ cli.json,
+ ),
+ AddonCommands::Update {
+ name,
+ all,
+ check,
+ force,
+ } => update_addon(kind, name, all, check, force, cli.json),
+ AddonCommands::Rollback { name } => {
+ addons::update::rollback(kind, &name).map_err(XFetchError::Addon)?;
+ if cli.json {
+ return output::print_json(&serde_json::json!({
+ "schema_version": output::JSON_SCHEMA_VERSION,
+ "status": "rolled-back",
+ "kind": kind.label(),
+ "name": name,
+ }));
+ }
+ runtime::info(format!("Rolled back {} '{}'.", kind.label(), name));
+ Ok(())
+ }
+ AddonCommands::List { verbose } => {
+ let installed = list_installed(kind)?;
+ let config = config();
+ let entries = installed
+ .into_iter()
+ .map(|(name, path)| AddonEntry::load(kind, &name, &path, &config))
+ .collect::>();
+ if cli.json {
+ print_addon_list_json(kind, &entries)
+ } else {
+ addons::report::print_list(kind, &entries, verbose);
+ Ok(())
+ }
+ }
+ AddonCommands::Info { name } => {
+ let path = find_installed(kind, &name).ok_or_else(|| {
+ XFetchError::NotFound(format!("{} '{}' is not installed.", kind.label(), name))
+ })?;
+ let config = config();
+ let entry = AddonEntry::load(kind, &name, &path, &config);
+ if cli.json {
+ print_addon_info_json(&entry)
+ } else {
+ addons::report::print_info(&entry);
+ Ok(())
+ }
+ }
+ AddonCommands::Search { query } => {
+ catalog::print_search(kind, query.as_deref(), cli.json).map_err(XFetchError::Network)
+ }
+ AddonCommands::Remove { name } => {
+ remove_addon(kind, &name)?;
+ if cli.json {
+ return output::print_json(&serde_json::json!({
+ "schema_version": output::JSON_SCHEMA_VERSION,
+ "status": "removed",
+ "kind": kind.label(),
+ "name": name,
+ }));
+ }
+ runtime::info(format!("Removed {} '{}'", kind.label(), name));
+ Ok(())
+ }
+ }
+}
+
+fn list_installed(kind: AddonKind) -> Result, XFetchError> {
+ match kind {
+ AddonKind::Plugin => list_plugins(),
+ AddonKind::Effect => list_effects(),
+ AddonKind::Extension => list_extensions(),
+ AddonKind::Command => crate::commands::list_commands(),
+ }
+ .map_err(XFetchError::Addon)
+}
+
+fn find_installed(kind: AddonKind, name: &str) -> Option {
+ kind.installed_path(name).or_else(|| match kind {
+ AddonKind::Plugin => crate::plugins::find_plugin_binary(name),
+ AddonKind::Effect => crate::effects::find_effect_binary(name),
+ AddonKind::Extension => crate::extensions::find_extension_binary(name),
+ AddonKind::Command => crate::commands::find_command_binary(name),
+ })
+}
+
+fn remove_addon(kind: AddonKind, name: &str) -> Result<(), XFetchError> {
+ match kind {
+ AddonKind::Plugin => remove_plugin(name),
+ AddonKind::Effect => remove_effect(name),
+ AddonKind::Extension => remove_extension(name),
+ AddonKind::Command => crate::commands::remove_command(name),
+ }
+ .map_err(XFetchError::Addon)
+}
+
+struct AddonInstallRequest {
+ path: Option,
+ repo: Option,
+ sha256: Option,
+ name: Option,
+ manifest: Option,
+ all: bool,
+ force: bool,
+}
+
+fn install_addon(
+ kind: AddonKind,
+ request: AddonInstallRequest,
+ json: bool,
+) -> Result<(), XFetchError> {
+ let AddonInstallRequest {
+ path,
+ repo,
+ sha256,
+ name,
+ manifest,
+ all,
+ force,
+ } = request;
+ if runtime::offline()
+ && (all
+ || repo.is_some()
+ || path
+ .as_deref()
+ .is_some_and(|value| is_url(value) || !std::path::Path::new(value).exists()))
+ {
+ return Err(XFetchError::Network(
+ "network access is disabled by --offline".to_string(),
+ ));
+ }
+ if all {
+ if path.is_some() || name.is_some() || manifest.is_some() || sha256.is_some() {
+ return Err(XFetchError::Usage(
+ "--all cannot be combined with a path, --name, --manifest or --sha256".to_string(),
+ ));
+ }
+ let names = addons::update::install_all(kind, force, json).map_err(XFetchError::Addon)?;
+ if json {
+ let installed: Vec = names
+ .iter()
+ .map(|name| {
+ serde_json::json!({
+ "name": name,
+ "path": kind
+ .installed_path(name)
+ .map(|path| path.display().to_string())
+ .unwrap_or_default(),
+ })
+ })
+ .collect();
+ return output::print_json(&serde_json::json!({
+ "schema_version": output::JSON_SCHEMA_VERSION,
+ "status": "installed",
+ "kind": kind.label(),
+ "installed": installed,
+ }));
+ }
+ return Ok(());
+ }
+
+ let path = path.ok_or_else(|| {
+ XFetchError::Usage(format!(
+ "Specify a {} path/name or use --all.",
+ kind.label()
+ ))
+ })?;
+ let direct = name.is_some() || manifest.is_some();
+ let installed = if direct {
+ if repo.is_some() {
+ return Err(XFetchError::Usage(
+ "--name/--manifest apply to direct wasm files or URLs; omit --repo".to_string(),
+ ));
+ }
+ addons::install::install_direct(
+ kind,
+ &path,
+ sha256.as_deref(),
+ name.as_deref(),
+ manifest.as_deref(),
+ )
+ .map_err(XFetchError::Addon)?
+ } else {
+ match kind {
+ AddonKind::Plugin => install_plugin(&path, repo.as_deref(), sha256.as_deref()),
+ AddonKind::Effect => install_effect(&path, repo.as_deref(), sha256.as_deref()),
+ AddonKind::Extension => install_extension(&path, repo.as_deref(), sha256.as_deref()),
+ AddonKind::Command => {
+ crate::commands::install_command(&path, repo.as_deref(), sha256.as_deref())
+ }
+ }
+ .map_err(XFetchError::Addon)?;
+ infer_name(kind, &path, None).map_err(XFetchError::Addon)?
+ };
+
+ let source = if direct {
+ if is_url(&path) { "url" } else { "local" }
+ } else if is_url(&path) {
+ "url"
+ } else if std::path::Path::new(&path).exists() {
+ "local"
+ } else if addons::catalog::find(kind, &installed)
+ .ok()
+ .flatten()
+ .is_some()
+ {
+ "catalog"
+ } else {
+ "repo"
+ };
+ let catalog_entry = if source == "catalog" {
+ addons::catalog::find(kind, &installed).ok().flatten()
+ } else {
+ None
+ };
+ addons::receipt::record(
+ kind,
+ &installed,
+ source,
+ repo.as_deref(),
+ Some(&path),
+ catalog_entry.as_ref(),
+ )
+ .map_err(XFetchError::Addon)?;
+ if json {
+ return output::print_json(&serde_json::json!({
+ "schema_version": output::JSON_SCHEMA_VERSION,
+ "status": "installed",
+ "kind": kind.label(),
+ "name": installed,
+ "path": kind
+ .installed_path(&installed)
+ .map(|path| path.display().to_string())
+ .unwrap_or_default(),
+ "source": source,
+ }));
+ }
+ addons::report::print_install_guidance(kind, &installed);
+ Ok(())
+}
+
+fn update_addon(
+ kind: AddonKind,
+ name: Option,
+ all: bool,
+ check: bool,
+ force: bool,
+ json: bool,
+) -> Result<(), XFetchError> {
+ if json && !check {
+ return Err(XFetchError::Usage(
+ "--json for addon updates requires --check.".to_string(),
+ ));
+ }
+ if runtime::offline() {
+ return Err(XFetchError::Network(
+ "network access is disabled by --offline".to_string(),
+ ));
+ }
+
+ if json {
+ let checks =
+ addons::update::check(kind, name.as_deref(), all).map_err(XFetchError::Network)?;
+ return print_json(&serde_json::json!({
+ "schema_version": crate::cli::output::JSON_SCHEMA_VERSION,
+ "kind": kind.label(),
+ "checks": checks,
+ }));
+ }
+
+ let options = addons::update::UpdateOptions { all, check, force };
+ let available =
+ addons::update::run(kind, name.as_deref(), &options).map_err(XFetchError::Addon)?;
+ if check && available {
+ return Err(XFetchError::Exit(crate::error::EXIT_GENERIC));
+ }
+ Ok(())
+}
+
+fn is_url(value: &str) -> bool {
+ value.starts_with("http://") || value.starts_with("https://")
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn detects_urls() {
+ assert!(is_url("https://example.com/a.wasm"));
+ assert!(is_url("http://example.com/a.wasm"));
+ assert!(!is_url("/tmp/a.wasm"));
+ }
+}
diff --git a/src/cli/args.rs b/src/cli/args.rs
new file mode 100644
index 0000000..9ba0121
--- /dev/null
+++ b/src/cli/args.rs
@@ -0,0 +1,528 @@
+use clap::{Parser, Subcommand, ValueEnum};
+
+#[derive(Parser, Debug)]
+#[command(
+ name = "xfetch",
+ author,
+ version,
+ about,
+ long_about = None,
+ after_help = "Examples:\n xfetch\n xfetch --json\n xfetch --get os,cpu,memory\n xfetch --modules os,kernel,cpu --layout compact\n xfetch --config ~/.config/xfetch/config.jsonc\n xfetch --gen-config\n xfetch --gen-config --layout tree\n xfetch --list-layouts\n xfetch --list-modules\n xfetch --clean-cache\n xfetch --daemon\n xfetch --daemon-stop\n xfetch doctor\n xfetch doctor --json --network\n xfetch modules --json\n xfetch config validate\n xfetch config print\n xfetch config get layout\n xfetch config set layout right\n xfetch completions zsh\n xfetch man\n xfetch addon plugin install animate-logo\n xfetch plugin install animate-logo\n xfetch plugin install --all\n xfetch plugin update --all --check\n xfetch plugin rollback animate-logo\n xfetch plugin list --verbose\n xfetch plugin info animate-logo\n xfetch plugin search logo\n xfetch plugin remove animate-logo\n xfetch effects install decrypt\n xfetch extension install config-roulette\n xfetch wasm inspect ./plugin.wasm\n xfetch wasm run ./plugin.wasm --request '{\"version\":1,\"kind\":\"info_provider\"}'\n xfetch wasm wit\n xfetch theme list\n xfetch theme set dracula\n xfetch theme remove dracula\n xfetch theme export my-theme\n xfetch update --check\n xfetch update"
+)]
+pub struct Cli {
+ #[command(subcommand)]
+ pub command: Option,
+
+ #[arg(short, long, global = true)]
+ pub config: Option,
+
+ #[arg(long, global = true)]
+ pub gen_config: bool,
+
+ /// Logo to embed in the generated config, overriding the detected
+ /// OS/distro (e.g. `--logo arch`, `--logo windows-11`). Only used with
+ /// `--gen-config`; requires network access to the logos catalog.
+ #[arg(long, global = true)]
+ pub logo: Option,
+
+ /// Layout name. Overrides the configured layout at runtime; with
+ /// `--gen-config` it selects the generated layout instead.
+ #[arg(long, global = true)]
+ pub layout: Option,
+
+ /// Theme name. Overrides the configured theme at runtime.
+ #[arg(long, global = true)]
+ pub theme: Option,
+
+ /// Print the layout names accepted by `--layout` and exit.
+ #[arg(long, global = true)]
+ pub list_layouts: bool,
+
+ /// Print the module keys accepted in the config and exit.
+ #[arg(long, global = true)]
+ pub list_modules: bool,
+
+ #[arg(long, global = true)]
+ pub clean_cache: bool,
+
+ /// Back up the config currently in use, including its theme and
+ /// config-roulette routes.
+ #[arg(long, global = true)]
+ pub backup: bool,
+
+ /// Restore the most recent config backup.
+ #[arg(long, global = true)]
+ pub restore: bool,
+
+ #[arg(long, global = true)]
+ pub benchmark: bool,
+
+ #[arg(long, global = true)]
+ pub daemon: bool,
+
+ #[arg(long, global = true)]
+ pub daemon_stop: bool,
+
+ /// Disable the live stats daemon (`daemon_live` in config) from the
+ /// terminal.
+ #[arg(long, global = true)]
+ pub no_daemon_live: bool,
+
+ /// Stop the running live stats daemon.
+ #[arg(long, global = true)]
+ pub daemon_live_stop: bool,
+
+ /// Force hot reload in the live stats daemon (equivalent to
+ /// `"daemon_live_reload": true` in the config).
+ #[arg(long, global = true)]
+ pub daemon_live_reload: bool,
+
+ /// Emit machine-readable JSON.
+ #[arg(long, global = true)]
+ pub json: bool,
+
+ /// Print only specific module keys. Repeat the flag or use commas:
+ /// `--get os,cpu --get memory`.
+ #[arg(long = "get", global = true, value_delimiter = ',', action = clap::ArgAction::Append)]
+ pub get: Vec,
+
+ /// Override the rendered module list with a comma-separated key list.
+ #[arg(long = "modules", alias = "only", global = true)]
+ pub modules: Option,
+
+ /// Control color output.
+ #[arg(long, global = true, value_enum, default_value_t = ColorChoice::Auto)]
+ pub color: ColorChoice,
+
+ /// Disable colors; same as `--color never`.
+ #[arg(long, global = true)]
+ pub no_color: bool,
+
+ /// Disable network access (public IP, catalogs, update checks, logo fetch).
+ #[arg(long, global = true)]
+ pub offline: bool,
+
+ /// Bypass the package/public-IP cache for this run.
+ #[arg(long, global = true)]
+ pub no_cache: bool,
+
+ /// Suppress informational output.
+ #[arg(long, global = true)]
+ pub quiet: bool,
+
+ /// Print extra diagnostics.
+ #[arg(long, global = true)]
+ pub verbose: bool,
+
+ /// Log level: off, error, warn, info, debug or trace. Overrides
+ /// --quiet/--verbose.
+ #[arg(long, global = true, value_enum)]
+ pub log_level: Option,
+
+ /// Emit logs as JSON lines on stderr.
+ #[arg(long, global = true)]
+ pub log_json: bool,
+
+ /// Render the fetched modules with a template file (`{{key}}`).
+ #[arg(long, global = true)]
+ pub template: Option,
+
+ /// Render the fetched modules with an inline template (`{{key}}`).
+ #[arg(long, global = true)]
+ pub format: Option,
+}
+
+#[derive(ValueEnum, Clone, Copy, Debug, PartialEq, Eq, Default)]
+pub enum ColorChoice {
+ #[default]
+ Auto,
+ Always,
+ Never,
+}
+
+#[derive(ValueEnum, Clone, Copy, Debug, PartialEq, Eq, Default)]
+pub enum LogLevel {
+ Off,
+ Error,
+ Warn,
+ #[default]
+ Info,
+ Debug,
+ Trace,
+}
+
+#[derive(ValueEnum, Clone, Copy, Debug, PartialEq, Eq, Default)]
+pub enum SchemaKind {
+ Fetch,
+ Backup,
+ Addon,
+ Update,
+ Doctor,
+ Config,
+ #[default]
+ All,
+}
+
+#[derive(ValueEnum, Clone, Copy, Debug, PartialEq, Eq)]
+pub enum AddonKindArg {
+ Plugin,
+ Effect,
+ Extension,
+ Command,
+}
+
+#[derive(Subcommand, Debug)]
+pub enum Commands {
+ /// Manage plugins.
+ #[command(alias = "plugins")]
+ Plugin {
+ #[command(subcommand)]
+ action: AddonCommands,
+ },
+ /// Manage config-provider extensions.
+ #[command(alias = "extensions")]
+ Extension {
+ #[command(subcommand)]
+ action: AddonCommands,
+ },
+ /// Manage CLI command addons.
+ #[command(alias = "commands")]
+ Command {
+ #[command(subcommand)]
+ action: AddonCommands,
+ },
+ /// Run an installed command addon.
+ Run {
+ /// Installed command name.
+ name: String,
+ /// Render the output through the core layout and logo.
+ #[arg(long)]
+ render: bool,
+ /// Arguments passed to the command.
+ #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
+ args: Vec,
+ },
+ /// Manage local and remote themes.
+ Theme {
+ #[command(subcommand)]
+ action: ThemeCommands,
+ },
+ /// Browse and preview the ASCII logo catalog.
+ Logo {
+ #[command(subcommand)]
+ action: LogoCommands,
+ },
+ /// Manage intro effects.
+ #[command(alias = "effect")]
+ Effects {
+ #[command(subcommand)]
+ action: AddonCommands,
+ },
+ /// Manage any addon kind with one command family.
+ Addon {
+ #[arg(value_enum)]
+ kind: AddonKindArg,
+ #[command(subcommand)]
+ action: AddonCommands,
+ },
+ /// WebAssembly guest tooling: inspect artifacts, run them with a raw JSON
+ /// request and print the component protocol.
+ Wasm {
+ #[command(subcommand)]
+ action: WasmCommands,
+ },
+ /// Check for a newer xfetch release and install it.
+ Update {
+ /// Only check; exit with code 1 when a newer release exists.
+ #[arg(long)]
+ check: bool,
+ /// Install the prebuilt release in place, even for local builds
+ /// (Unix and Windows).
+ #[arg(long)]
+ prebuilt: bool,
+ /// Directory holding the xfetch binary to replace (with --prebuilt).
+ #[arg(long, value_name = "DIR")]
+ bin_dir: Option,
+ /// Assume yes for confirmation prompts.
+ #[arg(long, short = 'y')]
+ yes: bool,
+ /// Restore the previous binary from the update backup.
+ #[arg(long)]
+ rollback: bool,
+ },
+ /// Diagnose the installation, configuration, terminal and addons.
+ Doctor {
+ /// Also check remote catalog and update endpoints.
+ #[arg(long)]
+ network: bool,
+ /// Apply safe automatic fixes for common problems.
+ #[arg(long)]
+ fix: bool,
+ /// Run the info collection benchmark and include it in the report.
+ #[arg(long)]
+ bench: bool,
+ /// Print a preview of the configured logo/image in a TTY.
+ #[arg(long)]
+ image: bool,
+ },
+ /// List the module keys accepted in the config.
+ Modules,
+ /// Inspect or edit the configuration.
+ Config {
+ #[command(subcommand)]
+ action: ConfigCommands,
+ },
+ /// Generate shell completions.
+ Completions {
+ #[arg(value_enum)]
+ shell: clap_complete::Shell,
+ },
+ /// Render the man page.
+ Man {
+ /// Write the page to this path instead of stdout.
+ #[arg(long, value_name = "PATH")]
+ output: Option,
+ },
+ /// Print the JSON Schema for the CLI machine-readable outputs.
+ Schema {
+ #[arg(value_enum, default_value_t = SchemaKind::All)]
+ kind: SchemaKind,
+ },
+ /// Print the resolved config, addon, cache and data paths.
+ Paths,
+ /// Print the platform, terminal, environment and runtime settings.
+ Env,
+ /// Print build information and enabled features.
+ #[command(name = "build-info")]
+ BuildInfo,
+ /// Remove the xfetch binary and optionally its config, cache and data.
+ #[command(name = "self-uninstall")]
+ SelfUninstall {
+ /// Also remove config, cache and data.
+ #[arg(long)]
+ purge: bool,
+ /// Skip the confirmation prompt.
+ #[arg(long, short)]
+ yes: bool,
+ },
+}
+
+#[derive(Subcommand, Debug)]
+pub enum AddonCommands {
+ /// Install an addon from a catalog name, local path, repository, wasm file or URL.
+ Install {
+ path: Option,
+ #[arg(long, short)]
+ repo: Option,
+ /// Expected SHA-256 (hex) of a downloaded wasm artifact.
+ #[arg(long, value_name = "HEX")]
+ sha256: Option,
+ /// Override the installed name for a direct wasm file or URL.
+ #[arg(long)]
+ name: Option,
+ /// Sidecar manifest to attach to a direct wasm file or URL.
+ #[arg(long, value_name = "FILE")]
+ manifest: Option,
+ /// Install every addon available in the catalog.
+ #[arg(long)]
+ all: bool,
+ /// Reinstall addons that are already installed (with --all).
+ #[arg(long)]
+ force: bool,
+ },
+ /// Update an installed addon, or every installed addon with --all.
+ Update {
+ name: Option,
+ /// Update every installed addon.
+ #[arg(long)]
+ all: bool,
+ /// Only check; exit with code 1 when an update is available.
+ #[arg(long)]
+ check: bool,
+ /// Reinstall even when the catalog version is not newer.
+ #[arg(long)]
+ force: bool,
+ },
+ /// Restore the previous artifact saved by the last update.
+ Rollback { name: String },
+ /// List installed addons.
+ List {
+ /// Show kind, runtime, version, capabilities and enabled state.
+ #[arg(long, short)]
+ verbose: bool,
+ },
+ /// Show one installed addon and its configuration snippet.
+ Info { name: String },
+ /// Search the remote catalog. Omit the query to list everything.
+ #[command(alias = "available")]
+ Search { query: Option },
+ /// Remove an installed addon.
+ Remove { name: String },
+}
+
+#[derive(Subcommand, Debug)]
+pub enum ThemeCommands {
+ /// List installed themes.
+ List,
+ /// Search the remote theme registry.
+ Search { query: Option },
+ /// Show metadata for one remote theme.
+ Info { name: String },
+ /// Install a theme from the remote registry.
+ Install {
+ name: String,
+ /// Reinstall an already installed theme.
+ #[arg(long)]
+ force: bool,
+ },
+ /// Update installed themes from the remote registry.
+ Update {
+ name: Option,
+ /// Update every installed theme present in the registry.
+ #[arg(long)]
+ all: bool,
+ /// Only report; exit 1 when an update is available.
+ #[arg(long)]
+ check: bool,
+ /// Reinstall even when the registry version is not newer.
+ #[arg(long)]
+ force: bool,
+ },
+ /// Set the active theme in the config.
+ Set { name: String },
+ /// Remove an installed theme.
+ Remove { name: String },
+ /// Export the current visual config as a reusable theme.
+ Export { name: String },
+}
+
+#[derive(Subcommand, Debug)]
+pub enum LogoCommands {
+ /// List logos from the remote catalog.
+ List { query: Option },
+ /// Print one logo from the remote catalog.
+ Preview { name: String },
+}
+
+#[derive(Subcommand, Debug)]
+pub enum ConfigCommands {
+ /// Parse the config file and validate its schema.
+ Validate,
+ /// Print the resolved config (defaults, theme, extensions and overrides).
+ Print {
+ /// Print the config file as stored instead of the resolved config.
+ #[arg(long)]
+ raw: bool,
+ },
+ /// Print one value by dotted key path.
+ Get { key: String },
+ /// Set one value. Dotted paths and array indices are supported.
+ Set { key: String, value: String },
+ /// Remove one value by dotted key path.
+ Unset { key: String },
+ /// Replace the config with the built-in defaults after a safety backup.
+ Reset {
+ /// Skip the confirmation prompt.
+ #[arg(long, short)]
+ yes: bool,
+ },
+ /// Open the config in $VISUAL or $EDITOR after a safety backup.
+ Edit,
+ /// List saved config backups.
+ Backups,
+ /// Delete old backups, keeping the newest N.
+ Prune {
+ /// Number of backups to keep.
+ #[arg(long, default_value_t = 5)]
+ keep: usize,
+ /// Print what would be deleted without removing files.
+ #[arg(long)]
+ dry_run: bool,
+ },
+ /// Back up the config currently in use.
+ Backup {
+ /// Write to this file or directory instead of the default backup directory.
+ #[arg(long, value_name = "PATH")]
+ output: Option,
+ /// Include installed addon artifacts, manifests and receipts.
+ #[arg(long)]
+ with_addons: bool,
+ /// Compress the backup with gzip.
+ #[arg(long)]
+ compress: bool,
+ /// Encrypt the backup with a passphrase.
+ #[arg(long)]
+ encrypt: bool,
+ /// Read the backup passphrase from this file instead of
+ /// XFETCH_BACKUP_PASSPHRASE.
+ #[arg(long, value_name = "PATH")]
+ passphrase_file: Option,
+ },
+ /// Restore a config backup.
+ Restore {
+ /// Backup file (or directory) to restore. Defaults to the latest backup.
+ #[arg(long, value_name = "PATH")]
+ from: Option,
+ /// Print what would be restored without writing files.
+ #[arg(long)]
+ dry_run: bool,
+ /// Remap files under the original config directory into this root.
+ #[arg(long, value_name = "DIR")]
+ root: Option,
+ /// Read the backup passphrase from this file instead of
+ /// XFETCH_BACKUP_PASSPHRASE.
+ #[arg(long, value_name = "PATH")]
+ passphrase_file: Option,
+ },
+}
+
+#[derive(Subcommand, Debug)]
+pub enum WasmCommands {
+ /// Print the resolved kind, manifest, capabilities and limits of an
+ /// artifact without executing it.
+ Inspect { path: String },
+ /// Execute a wasm guest with a raw JSON request and print its response.
+ /// Useful for authors and for scripted end-to-end checks.
+ Run {
+ path: String,
+ /// JSON request passed to the guest (defaults to `{}`).
+ #[arg(long)]
+ request: Option,
+ /// Read the JSON request from a file instead of `--request`.
+ #[arg(long, value_name = "PATH")]
+ request_file: Option,
+ /// Safety timeout in seconds; overrides the manifest limit.
+ #[arg(long)]
+ timeout: Option,
+ /// Guest contract used to select the component world.
+ #[arg(long, value_parser = ["plugin", "effect", "extension", "command"], default_value = "plugin")]
+ kind: String,
+ },
+ /// Print the WIT package for component guests (componentize-py,
+ /// componentize-js, wit-bindgen, ...).
+ Wit,
+}
+
+#[cfg(test)]
+mod help_tests {
+ use super::*;
+ use clap::CommandFactory;
+
+ #[test]
+ fn all_subcommands_have_descriptions() {
+ fn walk(command: &clap::Command, path: &str) {
+ for subcommand in command.get_subcommands() {
+ if subcommand.get_name() == "help" {
+ continue;
+ }
+ assert!(
+ subcommand.get_about().is_some(),
+ "{path} {} is missing a help description",
+ subcommand.get_name()
+ );
+ walk(subcommand, &format!("{path} {}", subcommand.get_name()));
+ }
+ }
+ walk(&Cli::command(), "xfetch");
+ }
+}
diff --git a/src/cli/backup_cmd.rs b/src/cli/backup_cmd.rs
new file mode 100644
index 0000000..96ebb78
--- /dev/null
+++ b/src/cli/backup_cmd.rs
@@ -0,0 +1,1321 @@
+use crate::addons::model::AddonKind;
+use crate::config::{
+ Config, ConfigOverrides, config_dir, default_config_path, load_config_with_overrides,
+ parse_jsonc_str_strict, resolve_theme_path,
+};
+use crate::error::XFetchError;
+use crate::runtime;
+use base64::Engine;
+use base64::engine::general_purpose::STANDARD as BASE64;
+use flate2::Compression;
+use flate2::read::GzDecoder;
+use flate2::write::GzEncoder;
+use serde::{Deserialize, Serialize};
+use std::collections::HashSet;
+use std::fs;
+use std::io::{Read, Write};
+use std::path::{Path, PathBuf};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+const SCHEMA_VERSION: u32 = 1;
+const BACKUP_PREFIX: &str = "xfetch-backup-";
+const SAFETY_PREFIX: &str = "pre-restore-";
+const MAX_ASSET_BYTES: u64 = 8 * 1024 * 1024;
+const MAX_ADDON_BYTES: u64 = 64 * 1024 * 1024;
+const MAX_TOTAL_ADDON_BYTES: u64 = 512 * 1024 * 1024;
+const ENCRYPTION_MAGIC: &[u8] = b"XFBACKUP1";
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct BackupBundle {
+ pub schema_version: u32,
+ pub created_unix: u64,
+ #[serde(default)]
+ pub created_unix_ms: u64,
+ pub created_utc: String,
+ pub xfetch_version: String,
+ pub config_path: String,
+ pub theme: Option,
+ pub theme_path: Option,
+ pub config_providers: Vec,
+ pub files: Vec,
+ pub missing: Vec,
+ pub warnings: Vec,
+ pub resolved_config: serde_json::Value,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct BackupFile {
+ pub role: String,
+ pub path: String,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub name: Option,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub encoding: Option,
+ pub content: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct MissingFile {
+ pub role: String,
+ pub path: String,
+ pub reason: String,
+}
+
+#[derive(Debug, Deserialize)]
+struct Route {
+ #[serde(rename = "_name", default)]
+ name: Option,
+ path: String,
+}
+
+#[derive(Debug)]
+struct BackupMeta {
+ path: PathBuf,
+ created_unix: u64,
+ created_unix_ms: u64,
+ created_utc: String,
+ files: usize,
+ missing: usize,
+ size: u64,
+ compressed: bool,
+}
+
+pub fn default_backup_dir() -> PathBuf {
+ config_dir().join("xfetch").join("backups")
+}
+
+pub fn backup(
+ config_path: Option,
+ output: Option,
+ with_addons: bool,
+ compress: bool,
+ encrypt: bool,
+ passphrase_file: Option,
+ json: bool,
+) -> Result<(), XFetchError> {
+ let bundle = create_bundle(config_path, with_addons)?;
+ let passphrase = if encrypt {
+ Some(read_passphrase(passphrase_file.as_deref())?)
+ } else {
+ None
+ };
+ let path = write_bundle(
+ &bundle,
+ output.as_deref(),
+ BACKUP_PREFIX,
+ compress,
+ encrypt,
+ passphrase.as_deref(),
+ )?;
+
+ if json {
+ return crate::cli::output::print_json(&serde_json::json!({
+ "schema_version": SCHEMA_VERSION,
+ "path": path.display().to_string(),
+ "files": bundle.files.len(),
+ "missing": bundle.missing.len(),
+ "warnings": bundle.warnings,
+ "with_addons": with_addons,
+ "compressed": compress,
+ "encrypted": encrypt,
+ }));
+ }
+
+ runtime::info(format!("Backup written to {}", path.display()));
+ runtime::info(format!(
+ "Files: {} backed up, {} missing.",
+ bundle.files.len(),
+ bundle.missing.len()
+ ));
+ Ok(())
+}
+
+pub fn restore(
+ config_path: Option,
+ from: Option,
+ dry_run: bool,
+ root: Option,
+ passphrase_file: Option,
+ json: bool,
+) -> Result<(), XFetchError> {
+ let backup_path = match from {
+ Some(value) => {
+ let path = expand_path(&value);
+ if path.is_dir() {
+ latest_in_dir(&path)?
+ } else {
+ path
+ }
+ }
+ None => latest_backup()?,
+ };
+ let passphrase = read_optional_passphrase(passphrase_file.as_deref())?;
+ let bundle = load_bundle(&backup_path, passphrase.as_deref())?;
+
+ let safety = if dry_run {
+ None
+ } else {
+ safety_backup(config_path.clone())?
+ };
+
+ let original_root = Path::new(&bundle.config_path)
+ .parent()
+ .map(Path::to_path_buf)
+ .unwrap_or_else(|| PathBuf::from("."));
+ let remap_root = root.as_ref().map(|value| expand_path(value));
+
+ let mut restored = Vec::new();
+ let mut main_target = None;
+ for file in &bundle.files {
+ let original = PathBuf::from(&file.path);
+ let target = if file.role == "config"
+ && let Some(config_path) = &config_path
+ {
+ expand_path(config_path)
+ } else if let Some(root) = &remap_root
+ && let Ok(relative) = original.strip_prefix(&original_root)
+ {
+ root.join(relative)
+ } else {
+ original
+ };
+
+ if file.role == "config" {
+ main_target = Some(target.clone());
+ }
+ restored.push(target.display().to_string());
+ if dry_run {
+ continue;
+ }
+
+ if let Some(parent) = target.parent() {
+ fs::create_dir_all(parent).map_err(|err| {
+ XFetchError::Config(format!("cannot create '{}': {}", parent.display(), err))
+ })?;
+ }
+ let bytes = if file.encoding.as_deref() == Some("base64") {
+ BASE64.decode(file.content.as_bytes()).map_err(|err| {
+ XFetchError::Config(format!(
+ "cannot decode '{}' from the backup: {}",
+ file.path, err
+ ))
+ })?
+ } else {
+ file.content.as_bytes().to_vec()
+ };
+ crate::atomic_fs::write_atomic(&target, &bytes).map_err(|err| {
+ XFetchError::Config(format!("cannot write '{}': {}", target.display(), err))
+ })?;
+ }
+
+ let validation = if dry_run {
+ None
+ } else {
+ main_target
+ .as_ref()
+ .map(|target| validate_restored_config(target))
+ };
+
+ if json {
+ return crate::cli::output::print_json(&serde_json::json!({
+ "schema_version": SCHEMA_VERSION,
+ "backup": backup_path.display().to_string(),
+ "dry_run": dry_run,
+ "root": root,
+ "restored": restored,
+ "missing": bundle.missing,
+ "safety_backup": safety.as_ref().map(|path| path.display().to_string()),
+ "validation": validation,
+ }));
+ }
+
+ if dry_run {
+ runtime::info(format!(
+ "Would restore {} files from {}",
+ restored.len(),
+ backup_path.display()
+ ));
+ } else {
+ runtime::info(format!(
+ "Restored {} files from {}",
+ restored.len(),
+ backup_path.display()
+ ));
+ }
+ for path in &restored {
+ println!(" {path}");
+ }
+ if let Some(safety) = &safety {
+ runtime::info(format!("Safety backup: {}", safety.display()));
+ }
+ if let Some(validation) = &validation
+ && !validation["valid"].as_bool().unwrap_or(true)
+ {
+ runtime::info(format!(
+ "Warning: the restored config is invalid: {}",
+ validation["error"].as_str().unwrap_or("unknown error")
+ ));
+ }
+ Ok(())
+}
+
+pub fn safety_backup(config_path: Option) -> Result, XFetchError> {
+ match create_bundle(config_path, false) {
+ Ok(bundle) => match write_bundle(&bundle, None, SAFETY_PREFIX, false, false, None) {
+ Ok(path) => Ok(Some(path)),
+ Err(err) => {
+ runtime::info(format!("Warning: could not write the safety backup: {err}"));
+ Ok(None)
+ }
+ },
+ Err(err) => {
+ runtime::info(format!(
+ "Warning: could not back up the current config: {err}"
+ ));
+ Ok(None)
+ }
+ }
+}
+
+pub fn list_backups(json: bool) -> Result<(), XFetchError> {
+ let mut backups = collect_meta(&default_backup_dir())?;
+ backups.sort_by_key(|meta| std::cmp::Reverse((meta.created_unix_ms, meta.created_unix)));
+
+ if json {
+ let entries: Vec = backups
+ .iter()
+ .map(|meta| {
+ serde_json::json!({
+ "path": meta.path.display().to_string(),
+ "created_unix": meta.created_unix,
+ "created_utc": meta.created_utc,
+ "files": meta.files,
+ "missing": meta.missing,
+ "size": meta.size,
+ "compressed": meta.compressed,
+ })
+ })
+ .collect();
+ return crate::cli::output::print_json(&serde_json::json!({
+ "schema_version": SCHEMA_VERSION,
+ "backups": entries,
+ }));
+ }
+
+ if backups.is_empty() {
+ println!("No backups found.");
+ return Ok(());
+ }
+ println!(
+ "{:<20} {:<8} {:<8} {:<10} PATH",
+ "CREATED", "FILES", "MISSING", "SIZE"
+ );
+ for meta in &backups {
+ println!(
+ "{:<20} {:<8} {:<8} {:<10} {}",
+ meta.created_utc,
+ meta.files,
+ meta.missing,
+ format_size(meta.size),
+ meta.path.display()
+ );
+ }
+ Ok(())
+}
+
+pub fn prune(keep: usize, dry_run: bool, json: bool) -> Result<(), XFetchError> {
+ let dir = default_backup_dir();
+ let mut backups = collect_meta(&dir)?;
+ backups.retain(|meta| {
+ meta.path
+ .file_name()
+ .and_then(|name| name.to_str())
+ .is_some_and(|name| name.starts_with(BACKUP_PREFIX))
+ });
+ backups.sort_by_key(|meta| std::cmp::Reverse((meta.created_unix_ms, meta.created_unix)));
+
+ let deleted: Vec<&BackupMeta> = backups.iter().skip(keep).collect();
+ if !dry_run {
+ for meta in &deleted {
+ fs::remove_file(&meta.path).map_err(|err| {
+ XFetchError::Config(format!("cannot delete '{}': {}", meta.path.display(), err))
+ })?;
+ }
+ }
+
+ if json {
+ return crate::cli::output::print_json(&serde_json::json!({
+ "schema_version": SCHEMA_VERSION,
+ "kept": backups.len().saturating_sub(deleted.len()),
+ "deleted": deleted
+ .iter()
+ .map(|meta| meta.path.display().to_string())
+ .collect::>(),
+ "dry_run": dry_run,
+ }));
+ }
+
+ if deleted.is_empty() {
+ runtime::info("No backups to prune.");
+ } else if dry_run {
+ runtime::info(format!("Would delete {} old backups.", deleted.len()));
+ for meta in &deleted {
+ println!(" {}", meta.path.display());
+ }
+ } else {
+ runtime::info(format!("Deleted {} old backups.", deleted.len()));
+ for meta in &deleted {
+ println!(" {}", meta.path.display());
+ }
+ }
+ Ok(())
+}
+
+fn collect_meta(dir: &Path) -> Result, XFetchError> {
+ let entries = match fs::read_dir(dir) {
+ Ok(entries) => entries,
+ Err(err) if err.kind() == std::io::ErrorKind::NotFound => return Ok(Vec::new()),
+ Err(err) => {
+ return Err(XFetchError::Config(format!(
+ "cannot read '{}': {}",
+ dir.display(),
+ err
+ )));
+ }
+ };
+
+ let mut metas = Vec::new();
+ for entry in entries.filter_map(Result::ok) {
+ let path = entry.path();
+ let name = path
+ .file_name()
+ .and_then(|name| name.to_str())
+ .unwrap_or_default();
+ if !(name.starts_with(BACKUP_PREFIX) || name.starts_with(SAFETY_PREFIX)) {
+ continue;
+ }
+ if !name.ends_with(".json") && !name.ends_with(".json.gz") {
+ continue;
+ }
+ let metadata = entry.metadata().ok();
+ let size = metadata.as_ref().map(|meta| meta.len()).unwrap_or(0);
+ let compressed = name.ends_with(".gz");
+ match load_bundle(&path, None) {
+ Ok(bundle) => metas.push(BackupMeta {
+ path,
+ created_unix: bundle.created_unix,
+ created_unix_ms: if bundle.created_unix_ms == 0 {
+ bundle.created_unix * 1000
+ } else {
+ bundle.created_unix_ms
+ },
+ created_utc: bundle.created_utc,
+ files: bundle.files.len(),
+ missing: bundle.missing.len(),
+ size,
+ compressed,
+ }),
+ Err(_) => {
+ let created = metadata
+ .and_then(|meta| meta.modified().ok())
+ .and_then(|time| time.duration_since(UNIX_EPOCH).ok())
+ .map(|duration| duration.as_secs())
+ .unwrap_or(0);
+ metas.push(BackupMeta {
+ path,
+ created_unix: created,
+ created_unix_ms: created * 1000,
+ created_utc: format_utc(created),
+ files: 0,
+ missing: 0,
+ size,
+ compressed,
+ });
+ }
+ }
+ }
+ Ok(metas)
+}
+
+fn validate_restored_config(path: &Path) -> serde_json::Value {
+ match fs::read_to_string(path) {
+ Ok(content) => match parse_jsonc_str_strict(&content) {
+ Ok(value) => match serde_json::from_value::(value) {
+ Ok(_) => serde_json::json!({"valid": true}),
+ Err(err) => serde_json::json!({"valid": false, "error": err.to_string()}),
+ },
+ Err(err) => serde_json::json!({"valid": false, "error": err}),
+ },
+ Err(err) => serde_json::json!({"valid": false, "error": err.to_string()}),
+ }
+}
+
+fn create_bundle(
+ config_path: Option,
+ with_addons: bool,
+) -> Result {
+ let config_path = config_path
+ .map(|value| expand_path(&value))
+ .unwrap_or_else(default_config_path);
+
+ if !config_path.is_file() {
+ return Err(XFetchError::Config(format!(
+ "no config file found at '{}'",
+ config_path.display()
+ )));
+ }
+
+ let main_content = fs::read_to_string(&config_path).map_err(|err| {
+ XFetchError::Config(format!("cannot read '{}': {}", config_path.display(), err))
+ })?;
+
+ let mut files = Vec::new();
+ let mut missing = Vec::new();
+ let mut warnings = Vec::new();
+ let mut seen = HashSet::new();
+
+ add_file_text(
+ &mut files,
+ &mut seen,
+ "config",
+ &config_path,
+ None,
+ &main_content,
+ );
+
+ let mut config: Option = None;
+ match parse_jsonc_str_strict(&main_content) {
+ Ok(value) => match serde_json::from_value(value) {
+ Ok(parsed) => config = Some(parsed),
+ Err(err) => warnings.push(format!("config schema could not be read: {err}")),
+ },
+ Err(err) => warnings.push(format!("config could not be parsed: {err}")),
+ }
+
+ let theme_path = config
+ .as_ref()
+ .and_then(|config| config.theme.as_ref())
+ .and_then(|theme| resolve_theme_path(theme))
+ .map(|path| path.display().to_string());
+
+ let mut providers = Vec::new();
+ if let Some(config) = &config {
+ collect_config_references(
+ config,
+ &config_path,
+ &mut files,
+ &mut missing,
+ &mut warnings,
+ &mut seen,
+ &mut providers,
+ 0,
+ );
+ }
+
+ if with_addons {
+ collect_addons(&mut files, &mut missing, &mut warnings, &mut seen);
+ }
+
+ let resolved = load_config_with_overrides(
+ Some(config_path.to_string_lossy().into_owned()),
+ &ConfigOverrides::default(),
+ );
+ let resolved_config = serde_json::to_value(&resolved).unwrap_or_else(|_| serde_json::json!({}));
+ let created_unix = now_unix();
+ let created_unix_ms = now_unix_ms();
+
+ Ok(BackupBundle {
+ schema_version: SCHEMA_VERSION,
+ created_unix,
+ created_unix_ms,
+ created_utc: format_utc(created_unix),
+ xfetch_version: env!("CARGO_PKG_VERSION").to_string(),
+ config_path: config_path.display().to_string(),
+ theme: config.as_ref().and_then(|config| config.theme.clone()),
+ theme_path,
+ config_providers: providers,
+ files,
+ missing,
+ warnings,
+ resolved_config,
+ })
+}
+
+#[allow(clippy::too_many_arguments)]
+fn collect_config_references(
+ config: &Config,
+ config_path: &Path,
+ files: &mut Vec,
+ missing: &mut Vec,
+ warnings: &mut Vec,
+ seen: &mut HashSet,
+ providers: &mut Vec,
+ depth: usize,
+) {
+ if depth > 5 {
+ warnings.push("config provider nesting is too deep; stopping".to_string());
+ return;
+ }
+
+ collect_theme(config, files, missing, seen);
+ collect_config_asset(config, files, missing, warnings, seen);
+
+ for provider in &config.config_providers {
+ if !providers.iter().any(|name| name == &provider.extension) {
+ providers.push(provider.extension.clone());
+ }
+
+ let routes = provider
+ .args
+ .as_ref()
+ .and_then(|args| args.get("routes"))
+ .and_then(|value| value.as_str())
+ .map(str::to_string)
+ .or_else(|| {
+ provider
+ .extension
+ .to_ascii_lowercase()
+ .contains("roulette")
+ .then(|| "~/.config/xfetch/routes.json".to_string())
+ });
+
+ if let Some(routes) = routes {
+ let routes_path = resolve_relative(config_path.parent(), &routes);
+ match fs::read_to_string(&routes_path) {
+ Ok(content) => {
+ add_file_text(
+ files,
+ seen,
+ "routes",
+ &routes_path,
+ Some(&provider.extension),
+ &content,
+ );
+ match serde_json::from_str::>(&content) {
+ Ok(route_list) => {
+ let base = routes_path
+ .parent()
+ .unwrap_or_else(|| Path::new("."))
+ .to_path_buf();
+ for route in route_list {
+ let path = resolve_relative(Some(&base), &route.path);
+ match fs::read_to_string(&path) {
+ Ok(content) => {
+ let is_new = !seen.contains(&path.display().to_string());
+ add_file_text(
+ files,
+ seen,
+ "route-config",
+ &path,
+ route.name.as_deref(),
+ &content,
+ );
+ if !is_new {
+ continue;
+ }
+ match parse_jsonc_str_strict(&content) {
+ Ok(value) => {
+ match serde_json::from_value::(value) {
+ Ok(route_config) => {
+ collect_config_references(
+ &route_config,
+ &path,
+ files,
+ missing,
+ warnings,
+ seen,
+ providers,
+ depth + 1,
+ );
+ }
+ Err(err) => warnings.push(format!(
+ "route config '{}' schema could not be read: {err}",
+ path.display()
+ )),
+ }
+ }
+ Err(err) => warnings.push(format!(
+ "route config '{}' could not be parsed: {err}",
+ path.display()
+ )),
+ }
+ }
+ Err(err) => missing.push(MissingFile {
+ role: "route-config".to_string(),
+ path: path.display().to_string(),
+ reason: err.to_string(),
+ }),
+ }
+ }
+ }
+ Err(err) => warnings.push(format!(
+ "routes file '{}' could not be parsed: {}",
+ routes_path.display(),
+ err
+ )),
+ }
+ }
+ Err(err) => missing.push(MissingFile {
+ role: "routes".to_string(),
+ path: routes_path.display().to_string(),
+ reason: err.to_string(),
+ }),
+ }
+ }
+
+ if let Some(args) = &provider.args {
+ collect_arg_paths(args, config_path.parent(), files, missing, warnings, seen);
+ }
+ }
+}
+
+fn collect_arg_paths(
+ value: &serde_json::Value,
+ base: Option<&Path>,
+ files: &mut Vec,
+ missing: &mut Vec,
+ warnings: &mut Vec,
+ seen: &mut HashSet,
+) {
+ match value {
+ serde_json::Value::String(text) if looks_like_path(text) => {
+ let path = resolve_relative(base, text);
+ if path.is_file() {
+ add_asset_file(files, missing, warnings, seen, "provider-file", &path, None);
+ }
+ }
+ serde_json::Value::Array(items) => {
+ for item in items {
+ collect_arg_paths(item, base, files, missing, warnings, seen);
+ }
+ }
+ serde_json::Value::Object(map) => {
+ for (key, item) in map {
+ if key == "routes" {
+ continue;
+ }
+ collect_arg_paths(item, base, files, missing, warnings, seen);
+ }
+ }
+ _ => {}
+ }
+}
+
+fn looks_like_path(value: &str) -> bool {
+ if value.starts_with("http://") || value.starts_with("https://") {
+ return false;
+ }
+ value.starts_with('~')
+ || value.starts_with('/')
+ || value.starts_with("./")
+ || value.starts_with("../")
+ || [
+ ".json", ".jsonc", ".txt", ".png", ".jpg", ".jpeg", ".gif", ".bmp", ".ico", ".webp",
+ ".tiff", ".svg",
+ ]
+ .iter()
+ .any(|extension| value.ends_with(extension))
+}
+
+fn collect_theme(
+ config: &Config,
+ files: &mut Vec,
+ missing: &mut Vec,
+ seen: &mut HashSet,
+) {
+ let Some(theme) = &config.theme else {
+ return;
+ };
+ if let Some(path) = resolve_theme_path(theme) {
+ match fs::read_to_string(&path) {
+ Ok(content) => add_file_text(files, seen, "theme", &path, Some(theme), &content),
+ Err(err) => missing.push(MissingFile {
+ role: "theme".to_string(),
+ path: path.display().to_string(),
+ reason: err.to_string(),
+ }),
+ }
+ } else {
+ missing.push(MissingFile {
+ role: "theme".to_string(),
+ path: theme.clone(),
+ reason: "theme not found".to_string(),
+ });
+ }
+}
+
+fn collect_config_asset(
+ config: &Config,
+ files: &mut Vec,
+ missing: &mut Vec,
+ warnings: &mut Vec,
+ seen: &mut HashSet,
+) {
+ let (value, role) = if let Some(path) = &config.logo_path {
+ (Some(path.as_str()), "logo")
+ } else if let Some(path) = &config.ascii {
+ (Some(path.as_str()), "ascii")
+ } else {
+ (None, "asset")
+ };
+ let Some(value) = value else {
+ return;
+ };
+ let path = expand_path(value);
+ if path.is_file() {
+ add_asset_file(files, missing, warnings, seen, role, &path, None);
+ } else {
+ missing.push(MissingFile {
+ role: role.to_string(),
+ path: path.display().to_string(),
+ reason: "file not found".to_string(),
+ });
+ }
+}
+
+fn collect_addons(
+ files: &mut Vec,
+ missing: &mut Vec,
+ warnings: &mut Vec,
+ seen: &mut HashSet,
+) {
+ let mut total = 0u64;
+ for kind in [
+ AddonKind::Plugin,
+ AddonKind::Effect,
+ AddonKind::Extension,
+ AddonKind::Command,
+ ] {
+ let installed = match kind {
+ AddonKind::Plugin => crate::plugins::list_plugins(),
+ AddonKind::Effect => crate::effects::list_effects(),
+ AddonKind::Extension => crate::extensions::list_extensions(),
+ AddonKind::Command => crate::commands::list_commands(),
+ };
+ let installed = match installed {
+ Ok(installed) => installed,
+ Err(err) => {
+ warnings.push(format!("could not list {}: {}", kind.plural_label(), err));
+ continue;
+ }
+ };
+
+ for (name, path) in installed {
+ let label = format!("{}:{}", kind.label(), name);
+ if let Ok(metadata) = fs::metadata(&path) {
+ if metadata.len() > MAX_ADDON_BYTES {
+ warnings.push(format!(
+ "skipping {} artifact ({} > {} bytes)",
+ label,
+ metadata.len(),
+ MAX_ADDON_BYTES
+ ));
+ } else if total + metadata.len() > MAX_TOTAL_ADDON_BYTES {
+ warnings.push(format!(
+ "skipping {} artifact (addon backup size limit reached)",
+ label
+ ));
+ } else if let Ok(bytes) = fs::read(&path) {
+ total += bytes.len() as u64;
+ add_file_bytes(files, seen, "addon-artifact", &path, Some(&label), &bytes);
+ }
+ }
+
+ let manifest = kind.directory().join(kind.manifest_name(&name));
+ if manifest.is_file()
+ && let Ok(content) = fs::read_to_string(&manifest)
+ {
+ add_file_text(
+ files,
+ seen,
+ "addon-manifest",
+ &manifest,
+ Some(&label),
+ &content,
+ );
+ }
+ let receipt = kind.receipt_path(&name);
+ if receipt.is_file()
+ && let Ok(content) = fs::read_to_string(&receipt)
+ {
+ add_file_text(
+ files,
+ seen,
+ "addon-receipt",
+ &receipt,
+ Some(&label),
+ &content,
+ );
+ } else {
+ missing.push(MissingFile {
+ role: "addon-receipt".to_string(),
+ path: receipt.display().to_string(),
+ reason: "receipt not found".to_string(),
+ });
+ }
+ }
+ }
+}
+
+fn add_asset_file(
+ files: &mut Vec,
+ missing: &mut Vec,
+ warnings: &mut Vec,
+ seen: &mut HashSet,
+ role: &str,
+ path: &Path,
+ name: Option<&str>,
+) {
+ if seen.contains(&path.display().to_string()) {
+ return;
+ }
+ let metadata = match fs::metadata(path) {
+ Ok(metadata) => metadata,
+ Err(err) => {
+ missing.push(MissingFile {
+ role: role.to_string(),
+ path: path.display().to_string(),
+ reason: err.to_string(),
+ });
+ return;
+ }
+ };
+ if metadata.len() > MAX_ASSET_BYTES {
+ warnings.push(format!(
+ "skipping asset '{}' ({} > {} bytes)",
+ path.display(),
+ metadata.len(),
+ MAX_ASSET_BYTES
+ ));
+ return;
+ }
+ let bytes = match fs::read(path) {
+ Ok(bytes) => bytes,
+ Err(err) => {
+ missing.push(MissingFile {
+ role: role.to_string(),
+ path: path.display().to_string(),
+ reason: err.to_string(),
+ });
+ return;
+ }
+ };
+ if is_text_asset(path)
+ && let Ok(text) = String::from_utf8(bytes.clone())
+ {
+ add_file_text(files, seen, role, path, name, &text);
+ return;
+ }
+ add_file_bytes(files, seen, role, path, name, &bytes);
+}
+
+fn is_text_asset(path: &Path) -> bool {
+ let extension = path
+ .extension()
+ .and_then(|extension| extension.to_str())
+ .unwrap_or_default()
+ .to_ascii_lowercase();
+ !matches!(
+ extension.as_str(),
+ "png" | "jpg" | "jpeg" | "gif" | "bmp" | "ico" | "webp" | "tiff"
+ )
+}
+
+fn add_file_text(
+ files: &mut Vec,
+ seen: &mut HashSet,
+ role: &str,
+ path: &Path,
+ name: Option<&str>,
+ content: &str,
+) {
+ let key = path.display().to_string();
+ if seen.insert(key.clone()) {
+ files.push(BackupFile {
+ role: role.to_string(),
+ path: key,
+ name: name.map(str::to_string),
+ encoding: None,
+ content: content.to_string(),
+ });
+ }
+}
+
+fn add_file_bytes(
+ files: &mut Vec,
+ seen: &mut HashSet,
+ role: &str,
+ path: &Path,
+ name: Option<&str>,
+ bytes: &[u8],
+) {
+ let key = path.display().to_string();
+ if seen.insert(key.clone()) {
+ files.push(BackupFile {
+ role: role.to_string(),
+ path: key,
+ name: name.map(str::to_string),
+ encoding: Some("base64".to_string()),
+ content: BASE64.encode(bytes),
+ });
+ }
+}
+
+fn write_bundle(
+ bundle: &BackupBundle,
+ output: Option<&str>,
+ prefix: &str,
+ compress: bool,
+ encrypt: bool,
+ passphrase: Option<&str>,
+) -> Result {
+ let path = backup_target(output, prefix, compress, encrypt)?;
+ let text = serde_json::to_string_pretty(bundle)
+ .map_err(|err| XFetchError::Config(format!("cannot serialize backup: {err}")))?;
+ let mut bytes = if compress {
+ gzip_compress(text.as_bytes())
+ .map_err(|err| XFetchError::Config(format!("cannot compress backup: {err}")))?
+ } else {
+ text.into_bytes()
+ };
+ if encrypt {
+ let passphrase = passphrase.ok_or_else(|| {
+ XFetchError::Usage(
+ "encrypted backups need a passphrase via --passphrase-file or XFETCH_BACKUP_PASSPHRASE"
+ .to_string(),
+ )
+ })?;
+ bytes = encrypt_bytes(&bytes, passphrase)
+ .map_err(|err| XFetchError::Config(format!("cannot encrypt backup: {err}")))?;
+ }
+ crate::atomic_fs::write_atomic(&path, &bytes).map_err(|err| {
+ XFetchError::Config(format!("cannot write '{}': {}", path.display(), err))
+ })?;
+ #[cfg(unix)]
+ {
+ use std::os::unix::fs::PermissionsExt;
+ let _ = fs::set_permissions(&path, fs::Permissions::from_mode(0o600));
+ }
+ Ok(path)
+}
+
+fn backup_target(
+ output: Option<&str>,
+ prefix: &str,
+ compress: bool,
+ encrypt: bool,
+) -> Result {
+ let created = now_unix();
+ let extension = if encrypt {
+ if compress {
+ ".json.gz.age"
+ } else {
+ ".json.age"
+ }
+ } else if compress {
+ ".json.gz"
+ } else {
+ ".json"
+ };
+ match output {
+ Some(value) => {
+ let path = expand_path(value);
+ if path.is_dir() || value.ends_with('/') || value.ends_with(std::path::MAIN_SEPARATOR) {
+ fs::create_dir_all(&path).map_err(|err| {
+ XFetchError::Config(format!("cannot create '{}': {}", path.display(), err))
+ })?;
+ Ok(unique_path(&path, prefix, created, extension))
+ } else {
+ if let Some(parent) = path.parent() {
+ fs::create_dir_all(parent).map_err(|err| {
+ XFetchError::Config(format!(
+ "cannot create '{}': {}",
+ parent.display(),
+ err
+ ))
+ })?;
+ }
+ Ok(path)
+ }
+ }
+ None => {
+ let dir = default_backup_dir();
+ fs::create_dir_all(&dir).map_err(|err| {
+ XFetchError::Config(format!("cannot create '{}': {}", dir.display(), err))
+ })?;
+ Ok(unique_path(&dir, prefix, created, extension))
+ }
+ }
+}
+
+fn unique_path(dir: &Path, prefix: &str, created: u64, extension: &str) -> PathBuf {
+ let mut candidate = dir.join(format!("{prefix}{created}{extension}"));
+ let mut counter = 1;
+ while candidate.exists() {
+ candidate = dir.join(format!("{prefix}{created}-{counter}{extension}"));
+ counter += 1;
+ }
+ candidate
+}
+
+fn latest_backup() -> Result {
+ latest_in_dir(&default_backup_dir())
+}
+
+fn latest_in_dir(dir: &Path) -> Result {
+ let mut metas = collect_meta(dir)?;
+ metas.retain(|meta| {
+ meta.path
+ .file_name()
+ .and_then(|name| name.to_str())
+ .is_some_and(|name| name.starts_with(BACKUP_PREFIX))
+ });
+ metas.sort_by_key(|meta| std::cmp::Reverse((meta.created_unix_ms, meta.created_unix)));
+ metas
+ .into_iter()
+ .next()
+ .map(|meta| meta.path)
+ .ok_or_else(|| XFetchError::NotFound(format!("no backups found in '{}'", dir.display())))
+}
+
+fn load_bundle(path: &Path, passphrase: Option<&str>) -> Result {
+ let mut bytes = fs::read(path)
+ .map_err(|err| XFetchError::Config(format!("cannot read '{}': {}", path.display(), err)))?;
+ if bytes.starts_with(ENCRYPTION_MAGIC) {
+ let passphrase = passphrase.ok_or_else(|| {
+ XFetchError::Config(
+ "this backup is encrypted; pass --passphrase-file or set XFETCH_BACKUP_PASSPHRASE"
+ .to_string(),
+ )
+ })?;
+ bytes = decrypt_bytes(&bytes, passphrase).map_err(|err| {
+ XFetchError::Config(format!("cannot decrypt '{}': {}", path.display(), err))
+ })?;
+ }
+ let bytes = if bytes.starts_with(&[0x1f, 0x8b]) {
+ gzip_decompress(&bytes).map_err(|err| {
+ XFetchError::Config(format!("cannot decompress '{}': {}", path.display(), err))
+ })?
+ } else {
+ bytes
+ };
+ let bundle: BackupBundle = serde_json::from_slice(&bytes).map_err(|err| {
+ XFetchError::Config(format!(
+ "'{}' is not a valid xfetch backup: {}",
+ path.display(),
+ err
+ ))
+ })?;
+ if bundle.schema_version != SCHEMA_VERSION {
+ return Err(XFetchError::Config(format!(
+ "unsupported backup schema version {} (expected {})",
+ bundle.schema_version, SCHEMA_VERSION
+ )));
+ }
+ Ok(bundle)
+}
+
+fn gzip_compress(bytes: &[u8]) -> std::io::Result> {
+ let mut encoder = GzEncoder::new(Vec::new(), Compression::default());
+ encoder.write_all(bytes)?;
+ encoder.finish()
+}
+
+fn gzip_decompress(bytes: &[u8]) -> std::io::Result> {
+ let mut decoder = GzDecoder::new(bytes);
+ let mut output = Vec::new();
+ decoder.read_to_end(&mut output)?;
+ Ok(output)
+}
+
+fn read_optional_passphrase(file: Option<&str>) -> Result, XFetchError> {
+ if let Some(file) = file {
+ let text = fs::read_to_string(file).map_err(|err| {
+ XFetchError::Config(format!("cannot read passphrase '{}': {}", file, err))
+ })?;
+ let passphrase = text.trim_end_matches(['\r', '\n']).to_string();
+ if passphrase.is_empty() {
+ return Err(XFetchError::Config(
+ "the passphrase file is empty".to_string(),
+ ));
+ }
+ return Ok(Some(passphrase));
+ }
+ match std::env::var("XFETCH_BACKUP_PASSPHRASE") {
+ Ok(passphrase) if !passphrase.is_empty() => Ok(Some(passphrase)),
+ _ => Ok(None),
+ }
+}
+
+fn read_passphrase(file: Option<&str>) -> Result {
+ read_optional_passphrase(file)?.ok_or_else(|| {
+ XFetchError::Usage("set XFETCH_BACKUP_PASSPHRASE or pass --passphrase-file".to_string())
+ })
+}
+
+fn encrypt_bytes(bytes: &[u8], passphrase: &str) -> Result, String> {
+ use argon2::{Algorithm, Argon2, Params, Version};
+ use chacha20poly1305::aead::{Aead, KeyInit};
+ use chacha20poly1305::{XChaCha20Poly1305, XNonce};
+
+ let mut salt = [0u8; 16];
+ let mut nonce = [0u8; 24];
+ getrandom::getrandom(&mut salt).map_err(|err| err.to_string())?;
+ getrandom::getrandom(&mut nonce).map_err(|err| err.to_string())?;
+
+ let params = Params::new(19 * 1024, 2, 1, Some(32)).map_err(|err| err.to_string())?;
+ let argon = Argon2::new(Algorithm::Argon2id, Version::V0x13, params);
+ let mut key = [0u8; 32];
+ argon
+ .hash_password_into(passphrase.as_bytes(), &salt, &mut key)
+ .map_err(|err| err.to_string())?;
+
+ let cipher = XChaCha20Poly1305::new_from_slice(&key).map_err(|err| err.to_string())?;
+ let nonce = XNonce::try_from(&nonce[..]).map_err(|_| "invalid nonce".to_string())?;
+ let ciphertext = cipher
+ .encrypt(&nonce, bytes)
+ .map_err(|err| err.to_string())?;
+
+ let mut output =
+ Vec::with_capacity(ENCRYPTION_MAGIC.len() + salt.len() + nonce.len() + ciphertext.len());
+ output.extend_from_slice(ENCRYPTION_MAGIC);
+ output.extend_from_slice(&salt);
+ output.extend_from_slice(&nonce);
+ output.extend_from_slice(&ciphertext);
+ Ok(output)
+}
+
+fn decrypt_bytes(bytes: &[u8], passphrase: &str) -> Result, String> {
+ use argon2::{Algorithm, Argon2, Params, Version};
+ use chacha20poly1305::aead::{Aead, KeyInit};
+ use chacha20poly1305::{XChaCha20Poly1305, XNonce};
+
+ if !bytes.starts_with(ENCRYPTION_MAGIC) {
+ return Err("not an encrypted xfetch backup".to_string());
+ }
+ let header = ENCRYPTION_MAGIC.len();
+ let salt_end = header + 16;
+ let nonce_end = salt_end + 24;
+ if bytes.len() < nonce_end + 16 {
+ return Err("encrypted backup is truncated".to_string());
+ }
+ let salt = &bytes[header..salt_end];
+ let nonce = &bytes[salt_end..nonce_end];
+ let ciphertext = &bytes[nonce_end..];
+
+ let params = Params::new(19 * 1024, 2, 1, Some(32)).map_err(|err| err.to_string())?;
+ let argon = Argon2::new(Algorithm::Argon2id, Version::V0x13, params);
+ let mut key = [0u8; 32];
+ argon
+ .hash_password_into(passphrase.as_bytes(), salt, &mut key)
+ .map_err(|err| err.to_string())?;
+
+ let cipher = XChaCha20Poly1305::new_from_slice(&key).map_err(|err| err.to_string())?;
+ let nonce = XNonce::try_from(nonce).map_err(|_| "invalid nonce".to_string())?;
+ cipher
+ .decrypt(&nonce, ciphertext)
+ .map_err(|_| "decryption failed".to_string())
+}
+
+fn resolve_relative(base: Option<&Path>, value: &str) -> PathBuf {
+ let expanded = expand_path(value);
+ if expanded.is_absolute() {
+ return expanded;
+ }
+ if let Some(base) = base {
+ let candidate = base.join(&expanded);
+ if candidate.exists() {
+ return candidate;
+ }
+ }
+ expanded
+}
+
+fn expand_path(value: &str) -> PathBuf {
+ if value == "~" {
+ return dirs::home_dir().unwrap_or_else(|| PathBuf::from(value));
+ }
+ if let Some(rest) = value.strip_prefix("~/")
+ && let Some(home) = dirs::home_dir()
+ {
+ return home.join(rest);
+ }
+ PathBuf::from(value)
+}
+
+fn now_unix() -> u64 {
+ SystemTime::now()
+ .duration_since(UNIX_EPOCH)
+ .map(|duration| duration.as_secs())
+ .unwrap_or(0)
+}
+
+fn now_unix_ms() -> u64 {
+ SystemTime::now()
+ .duration_since(UNIX_EPOCH)
+ .map(|duration| duration.as_millis() as u64)
+ .unwrap_or(0)
+}
+
+fn format_utc(secs: u64) -> String {
+ let days = (secs / 86_400) as i64;
+ let remainder = secs % 86_400;
+ let (year, month, day) = civil_from_days(days);
+ let hour = remainder / 3_600;
+ let minute = (remainder % 3_600) / 60;
+ let second = remainder % 60;
+ format!("{year:04}-{month:02}-{day:02}T{hour:02}:{minute:02}:{second:02}Z")
+}
+
+fn civil_from_days(days: i64) -> (i64, u32, u32) {
+ let z = days + 719_468;
+ let era = if z >= 0 { z } else { z - 146_096 } / 146_097;
+ let doe = z - era * 146_097;
+ let yoe = (doe - doe / 1_460 + doe / 36_524 - doe / 146_096) / 365;
+ let year = yoe + era * 400;
+ let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
+ let mp = (5 * doy + 2) / 153;
+ let day = doy - (153 * mp + 2) / 5 + 1;
+ let month = if mp < 10 { mp + 3 } else { mp - 9 };
+ let year = year + i64::from(month <= 2);
+ (year, month as u32, day as u32)
+}
+
+fn format_size(bytes: u64) -> String {
+ const UNITS: [&str; 5] = ["B", "KiB", "MiB", "GiB", "TiB"];
+ let mut size = bytes as f64;
+ let mut unit = 0usize;
+ while size >= 1024.0 && unit + 1 < UNITS.len() {
+ size /= 1024.0;
+ unit += 1;
+ }
+ if unit == 0 {
+ format!("{bytes} B")
+ } else {
+ format!("{size:.1} {}", UNITS[unit])
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn format_utc_matches_a_known_timestamp() {
+ assert_eq!(format_utc(0), "1970-01-01T00:00:00Z");
+ assert_eq!(format_utc(1_600_000_000), "2020-09-13T12:26:40Z");
+ }
+
+ #[test]
+ fn expand_path_handles_home_and_relative_paths() {
+ assert!(expand_path("~/x").is_absolute());
+ assert_eq!(expand_path("relative"), PathBuf::from("relative"));
+ }
+
+ #[test]
+ fn text_and_binary_files_roundtrip_through_base64() {
+ let original = b"\x00\x01hello";
+ let encoded = BASE64.encode(original);
+ assert_eq!(BASE64.decode(encoded).unwrap(), original);
+ }
+}
diff --git a/src/cli/build_info_cmd.rs b/src/cli/build_info_cmd.rs
new file mode 100644
index 0000000..3f48e2b
--- /dev/null
+++ b/src/cli/build_info_cmd.rs
@@ -0,0 +1,62 @@
+use crate::cli::output;
+use crate::error::XFetchError;
+use serde_json::{Value, json};
+
+pub fn collect() -> Value {
+ json!({
+ "schema_version": output::JSON_SCHEMA_VERSION,
+ "name": "xfetch",
+ "package": env!("CARGO_PKG_NAME"),
+ "version": env!("CARGO_PKG_VERSION"),
+ "target": {
+ "os": std::env::consts::OS,
+ "arch": std::env::consts::ARCH,
+ "family": std::env::consts::FAMILY,
+ },
+ "profile": if cfg!(debug_assertions) { "debug" } else { "release" },
+ "features": {
+ "wasm": cfg!(feature = "wasm"),
+ "update": cfg!(feature = "update"),
+ "encryption": true,
+ "color": true,
+ },
+ "rust_version": option_env!("CARGO_PKG_RUST_VERSION")
+ .filter(|value| !value.is_empty())
+ .unwrap_or("unknown"),
+ })
+}
+
+pub fn run(json: bool) -> Result<(), XFetchError> {
+ let value = collect();
+ if json {
+ return output::print_json(&value);
+ }
+
+ println!("name: {}", value["name"].as_str().unwrap_or("?"));
+ println!(
+ "package: {}",
+ value["package"].as_str().unwrap_or("?")
+ );
+ println!(
+ "version: {}",
+ value["version"].as_str().unwrap_or("?")
+ );
+ println!(
+ "target: {} {} ({})",
+ value["target"]["os"].as_str().unwrap_or("?"),
+ value["target"]["arch"].as_str().unwrap_or("?"),
+ value["target"]["family"].as_str().unwrap_or("?")
+ );
+ println!(
+ "profile: {}",
+ value["profile"].as_str().unwrap_or("?")
+ );
+ println!("wasm support: {}", value["features"]["wasm"]);
+ println!("update support: {}", value["features"]["update"]);
+ println!("encryption: {}", value["features"]["encryption"]);
+ println!(
+ "rust version: {}",
+ value["rust_version"].as_str().unwrap_or("unknown")
+ );
+ Ok(())
+}
diff --git a/src/cli/completions.rs b/src/cli/completions.rs
new file mode 100644
index 0000000..e6fabe4
--- /dev/null
+++ b/src/cli/completions.rs
@@ -0,0 +1,54 @@
+use crate::cli::args::Cli;
+use crate::error::XFetchError;
+use clap::CommandFactory;
+use clap_complete::Shell;
+use std::io::Write;
+
+pub fn completions(shell: Shell) -> Result<(), XFetchError> {
+ let mut command = Cli::command();
+ let mut buffer = Vec::new();
+ clap_complete::generate(shell, &mut command, "xfetch", &mut buffer);
+ let mut stdout = std::io::stdout();
+ match stdout.write_all(&buffer).and_then(|()| stdout.flush()) {
+ Ok(()) => Ok(()),
+ Err(err) if err.kind() == std::io::ErrorKind::BrokenPipe => Ok(()),
+ Err(err) => Err(XFetchError::Fatal(format!(
+ "failed to write completions: {err}"
+ ))),
+ }
+}
+
+pub fn man(output: Option) -> Result<(), XFetchError> {
+ let mut buffer = Vec::new();
+ clap_mangen::Man::new(Cli::command())
+ .render(&mut buffer)
+ .map_err(|err| XFetchError::Fatal(format!("failed to render man page: {err}")))?;
+
+ match output {
+ Some(path) => {
+ let path = std::path::PathBuf::from(path);
+ if let Some(parent) = path.parent() {
+ std::fs::create_dir_all(parent).map_err(|err| {
+ XFetchError::Fatal(format!("cannot create '{}': {}", parent.display(), err))
+ })?;
+ }
+ crate::atomic_fs::write_atomic(&path, &buffer).map_err(|err| {
+ XFetchError::Fatal(format!("cannot write '{}': {}", path.display(), err))
+ })?;
+ crate::runtime::info(format!("Wrote man page to {}", path.display()));
+ }
+ None => {
+ let mut stdout = std::io::stdout();
+ match stdout.write_all(&buffer).and_then(|()| stdout.flush()) {
+ Ok(()) => {}
+ Err(err) if err.kind() == std::io::ErrorKind::BrokenPipe => {}
+ Err(err) => {
+ return Err(XFetchError::Fatal(format!(
+ "failed to write man page: {err}"
+ )));
+ }
+ }
+ }
+ }
+ Ok(())
+}
diff --git a/src/cli/config_cmd.rs b/src/cli/config_cmd.rs
new file mode 100644
index 0000000..06336ba
--- /dev/null
+++ b/src/cli/config_cmd.rs
@@ -0,0 +1,610 @@
+use crate::cli::args::{Cli, ConfigCommands};
+use crate::cli::output::print_json;
+use crate::config::{
+ Config, ConfigOverrides, default_config_path, load_config_with_overrides,
+ parse_jsonc_file_strict, parse_jsonc_str_strict, resolve_theme_path,
+};
+use crate::error::XFetchError;
+use crate::runtime;
+use serde_json::Value;
+use std::fs;
+use std::io::IsTerminal;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+pub fn run(
+ action: ConfigCommands,
+ cli: &Cli,
+ overrides: &ConfigOverrides,
+ config_path: Option,
+) -> Result<(), XFetchError> {
+ let path = config_path
+ .clone()
+ .map(PathBuf::from)
+ .unwrap_or_else(default_config_path);
+
+ match action {
+ ConfigCommands::Validate => validate(&path, cli, config_path.is_some()),
+ ConfigCommands::Print { raw } => {
+ print_config(&path, raw, cli, overrides, config_path.clone())
+ }
+ ConfigCommands::Get { key } => get_value(&path, &key, cli, overrides, config_path),
+ ConfigCommands::Set { key, value } => set_value(&path, &key, &value, cli),
+ ConfigCommands::Unset { key } => unset_value(&path, &key, cli),
+ ConfigCommands::Reset { yes } => reset_config(&path, yes, cli),
+ ConfigCommands::Edit => edit_config(&path, cli),
+ ConfigCommands::Backups => crate::cli::backup_cmd::list_backups(cli.json),
+ ConfigCommands::Prune { keep, dry_run } => {
+ crate::cli::backup_cmd::prune(keep, dry_run, cli.json)
+ }
+ ConfigCommands::Backup {
+ output,
+ with_addons,
+ compress,
+ encrypt,
+ passphrase_file,
+ } => crate::cli::backup_cmd::backup(
+ config_path,
+ output,
+ with_addons,
+ compress,
+ encrypt,
+ passphrase_file,
+ cli.json,
+ ),
+ ConfigCommands::Restore {
+ from,
+ dry_run,
+ root,
+ passphrase_file,
+ } => crate::cli::backup_cmd::restore(
+ config_path,
+ from,
+ dry_run,
+ root,
+ passphrase_file,
+ cli.json,
+ ),
+ }
+}
+
+fn validate(path: &Path, cli: &Cli, explicit: bool) -> Result<(), XFetchError> {
+ if !path.exists() {
+ if explicit {
+ return Err(XFetchError::Config(format!(
+ "config file '{}' does not exist",
+ path.display()
+ )));
+ }
+ if cli.json {
+ return print_json(&serde_json::json!({
+ "schema_version": 1,
+ "valid": true,
+ "path": path.display().to_string(),
+ "exists": false,
+ }));
+ }
+ runtime::info(format!(
+ "Config not found at {}; defaults will be used.",
+ path.display()
+ ));
+ return Ok(());
+ }
+
+ let value = parse_jsonc_file_strict(path).map_err(XFetchError::Config)?;
+ let config: Config = serde_json::from_value(value)
+ .map_err(|err| XFetchError::Config(format!("invalid config schema: {err}")))?;
+
+ if let Some(theme) = &config.theme
+ && resolve_theme_path(theme).is_none()
+ {
+ return Err(XFetchError::Config(format!(
+ "theme '{}' referenced by the config was not found",
+ theme
+ )));
+ }
+
+ if cli.json {
+ return print_json(&serde_json::json!({
+ "schema_version": 1,
+ "valid": true,
+ "path": path.display().to_string(),
+ "exists": true,
+ }));
+ }
+ println!("Config OK: {}", path.display());
+ Ok(())
+}
+
+fn print_config(
+ path: &Path,
+ raw: bool,
+ cli: &Cli,
+ overrides: &ConfigOverrides,
+ config_path: Option,
+) -> Result<(), XFetchError> {
+ if raw {
+ let content = fs::read_to_string(path).map_err(|err| {
+ XFetchError::Config(format!("cannot read '{}': {}", path.display(), err))
+ })?;
+ print!("{content}");
+ if !content.ends_with('\n') {
+ println!();
+ }
+ return Ok(());
+ }
+
+ let config = load_config_with_overrides(config_path, overrides);
+ let value = serde_json::to_value(&config)
+ .map_err(|err| XFetchError::Config(format!("failed to serialize config: {err}")))?;
+ if cli.json {
+ return print_json(&value);
+ }
+ let text = serde_json::to_string_pretty(&value)
+ .map_err(|err| XFetchError::Config(format!("failed to serialize config: {err}")))?;
+ println!("{text}");
+ Ok(())
+}
+
+fn get_value(
+ path: &Path,
+ key: &str,
+ cli: &Cli,
+ overrides: &ConfigOverrides,
+ config_path: Option,
+) -> Result<(), XFetchError> {
+ let config = load_config_with_overrides(config_path, overrides);
+ let value = serde_json::to_value(&config)
+ .map_err(|err| XFetchError::Config(format!("failed to serialize config: {err}")))?;
+ let found = lookup(&value, key).ok_or_else(|| {
+ XFetchError::NotFound(format!(
+ "config key '{}' was not found in {}",
+ key,
+ path.display()
+ ))
+ })?;
+
+ if cli.json {
+ return print_json(found);
+ }
+ match found {
+ Value::String(text) => println!("{text}"),
+ other => {
+ let text = serde_json::to_string_pretty(other).unwrap_or_default();
+ println!("{text}");
+ }
+ }
+ Ok(())
+}
+
+fn set_value(path: &Path, key: &str, value: &str, cli: &Cli) -> Result<(), XFetchError> {
+ let content = if path.exists() {
+ fs::read_to_string(path).map_err(|err| {
+ XFetchError::Config(format!("cannot read '{}': {}", path.display(), err))
+ })?
+ } else {
+ "{\n}\n".to_string()
+ };
+
+ let parsed_value =
+ serde_json::from_str::(value).unwrap_or_else(|_| Value::String(value.to_string()));
+ let new_json = serde_json::to_string(&parsed_value)
+ .map_err(|err| XFetchError::Config(format!("failed to serialize the value: {err}")))?;
+ let segments = crate::cli::jsonc_edit::parse_path(key);
+
+ let updated = if let Some(updated) =
+ crate::cli::jsonc_edit::replace_value_preserving(&content, &segments, &new_json)
+ {
+ updated
+ } else if !key.contains('.')
+ && let Value::String(text) = &parsed_value
+ && let Some(updated) = set_top_level_string(&content, key, text)
+ {
+ updated
+ } else {
+ let mut root = parse_jsonc_str_strict(&content).map_err(XFetchError::Config)?;
+ set_path(&mut root, key, parsed_value)?;
+ serde_json::to_string_pretty(&root)
+ .map_err(|err| XFetchError::Config(format!("failed to serialize config: {err}")))?
+ };
+
+ let updated_value = parse_jsonc_str_strict(&updated).map_err(XFetchError::Config)?;
+ serde_json::from_value::(updated_value).map_err(|err| {
+ XFetchError::Config(format!(
+ "the new value would make the config invalid: {err}"
+ ))
+ })?;
+
+ if let Some(parent) = path.parent() {
+ fs::create_dir_all(parent).map_err(|err| {
+ XFetchError::Config(format!("cannot create '{}': {}", parent.display(), err))
+ })?;
+ }
+ crate::atomic_fs::write_atomic(path, updated.as_bytes()).map_err(|err| {
+ XFetchError::Config(format!("cannot write '{}': {}", path.display(), err))
+ })?;
+
+ if cli.json {
+ return print_json(&serde_json::json!({
+ "schema_version": 1,
+ "path": path.display().to_string(),
+ "key": key,
+ "value": value,
+ }));
+ }
+ runtime::info(format!("Set {} = {}", key, value));
+ Ok(())
+}
+
+fn unset_value(path: &Path, key: &str, cli: &Cli) -> Result<(), XFetchError> {
+ let content = fs::read_to_string(path)
+ .map_err(|err| XFetchError::Config(format!("cannot read '{}': {}", path.display(), err)))?;
+ let segments = crate::cli::jsonc_edit::parse_path(key);
+
+ let line_removed = remove_top_level_key(&content, key);
+ let updated = if let Some(updated) = line_removed
+ && parse_jsonc_str_strict(&updated).is_ok()
+ {
+ updated
+ } else {
+ let mut root = parse_jsonc_str_strict(&content).map_err(XFetchError::Config)?;
+ remove_path(&mut root, &segments)?;
+ serde_json::to_string_pretty(&root)
+ .map_err(|err| XFetchError::Config(format!("failed to serialize config: {err}")))?
+ };
+
+ let updated_value = parse_jsonc_str_strict(&updated).map_err(XFetchError::Config)?;
+ serde_json::from_value::(updated_value).map_err(|err| {
+ XFetchError::Config(format!(
+ "removing the value would make the config invalid: {err}"
+ ))
+ })?;
+
+ if let Some(parent) = path.parent() {
+ fs::create_dir_all(parent).map_err(|err| {
+ XFetchError::Config(format!("cannot create '{}': {}", parent.display(), err))
+ })?;
+ }
+ crate::atomic_fs::write_atomic(path, updated.as_bytes()).map_err(|err| {
+ XFetchError::Config(format!("cannot write '{}': {}", path.display(), err))
+ })?;
+
+ if cli.json {
+ return print_json(&serde_json::json!({
+ "schema_version": 1,
+ "path": path.display().to_string(),
+ "key": key,
+ "status": "unset",
+ }));
+ }
+ runtime::info(format!("Unset {key}"));
+ Ok(())
+}
+
+fn remove_top_level_key(content: &str, key: &str) -> Option {
+ let double = format!("\"{}\"", key);
+ let single = format!("'{}'", key);
+ let bare = format!("{}:", key);
+ let mut changed = false;
+ let mut output = String::new();
+ for line in content.lines() {
+ let trimmed = line.trim_start();
+ let is_key = trimmed.starts_with(&double)
+ || trimmed.starts_with(&single)
+ || trimmed.starts_with(&bare);
+ if !changed && is_key {
+ changed = true;
+ continue;
+ }
+ output.push_str(line);
+ output.push('\n');
+ }
+ changed.then_some(output)
+}
+
+fn remove_path(
+ root: &mut Value,
+ segments: &[crate::cli::jsonc_edit::Segment],
+) -> Result<(), XFetchError> {
+ use crate::cli::jsonc_edit::Segment;
+ if segments.is_empty() {
+ return Err(XFetchError::Usage("empty config key".to_string()));
+ }
+
+ let mut current = root;
+ for segment in &segments[..segments.len() - 1] {
+ current = match (current, segment) {
+ (Value::Object(map), Segment::Key(key)) => map.get_mut(key).ok_or_else(|| {
+ XFetchError::NotFound(format!("config key '{}' was not found", key))
+ })?,
+ (Value::Array(items), Segment::Index(index)) => {
+ items.get_mut(*index).ok_or_else(|| {
+ XFetchError::NotFound(format!("array index {index} was not found"))
+ })?
+ }
+ _ => {
+ return Err(XFetchError::NotFound(
+ "config path was not found".to_string(),
+ ));
+ }
+ };
+ }
+
+ match (current, segments.last().expect("checked above")) {
+ (Value::Object(map), Segment::Key(key)) => map
+ .remove(key)
+ .map(|_| ())
+ .ok_or_else(|| XFetchError::NotFound(format!("config key '{}' was not found", key))),
+ (Value::Array(items), Segment::Index(index)) => {
+ if *index < items.len() {
+ items.remove(*index);
+ Ok(())
+ } else {
+ Err(XFetchError::NotFound(format!(
+ "array index {index} was not found"
+ )))
+ }
+ }
+ _ => Err(XFetchError::NotFound(
+ "config path was not found".to_string(),
+ )),
+ }
+}
+
+fn reset_config(path: &Path, yes: bool, cli: &Cli) -> Result<(), XFetchError> {
+ if path.exists() && !yes {
+ if std::io::stdin().is_terminal() {
+ eprint!(
+ "Replace '{}' with the built-in defaults? [y/N]: ",
+ path.display()
+ );
+ let mut answer = String::new();
+ std::io::stdin()
+ .read_line(&mut answer)
+ .map_err(|err| XFetchError::Fatal(format!("cannot read confirmation: {err}")))?;
+ if !matches!(answer.trim().to_ascii_lowercase().as_str(), "y" | "yes") {
+ return Ok(());
+ }
+ } else {
+ return Err(XFetchError::Usage(
+ "refusing to reset the config without --yes in non-interactive mode".to_string(),
+ ));
+ }
+ }
+
+ let safety = crate::cli::backup_cmd::safety_backup(Some(path.display().to_string()))?;
+ crate::config::write_default_config(path).map_err(XFetchError::Config)?;
+
+ if cli.json {
+ return print_json(&serde_json::json!({
+ "schema_version": 1,
+ "path": path.display().to_string(),
+ "status": "reset",
+ "safety_backup": safety.as_ref().map(|path| path.display().to_string()),
+ }));
+ }
+ runtime::info(format!("Config reset to defaults: {}", path.display()));
+ if let Some(safety) = safety {
+ runtime::info(format!("Safety backup: {}", safety.display()));
+ }
+ Ok(())
+}
+
+fn edit_config(path: &Path, cli: &Cli) -> Result<(), XFetchError> {
+ let safety = crate::cli::backup_cmd::safety_backup(Some(path.display().to_string()))?;
+ let editor = std::env::var("VISUAL")
+ .or_else(|_| std::env::var("EDITOR"))
+ .map_err(|_| XFetchError::Usage("set $VISUAL or $EDITOR to edit the config".to_string()))?;
+ let status = Command::new(&editor)
+ .arg(path)
+ .status()
+ .map_err(|err| XFetchError::Fatal(format!("cannot run '{}': {err}", editor)))?;
+ if !status.success() {
+ return Err(XFetchError::Fatal(format!(
+ "editor '{}' exited with status {}",
+ editor, status
+ )));
+ }
+
+ validate_config_file(path)?;
+ if cli.json {
+ return print_json(&serde_json::json!({
+ "schema_version": 1,
+ "path": path.display().to_string(),
+ "status": "edited",
+ "safety_backup": safety.as_ref().map(|path| path.display().to_string()),
+ }));
+ }
+ runtime::info(format!("Config edited and validated: {}", path.display()));
+ if let Some(safety) = safety {
+ runtime::info(format!("Safety backup: {}", safety.display()));
+ }
+ Ok(())
+}
+
+fn validate_config_file(path: &Path) -> Result<(), XFetchError> {
+ let content = fs::read_to_string(path)
+ .map_err(|err| XFetchError::Config(format!("cannot read '{}': {}", path.display(), err)))?;
+ let value = parse_jsonc_str_strict(&content).map_err(XFetchError::Config)?;
+ serde_json::from_value::(value)
+ .map(|_| ())
+ .map_err(|err| XFetchError::Config(format!("invalid config schema: {err}")))
+}
+
+fn lookup<'a>(value: &'a Value, key: &str) -> Option<&'a Value> {
+ let mut current = value;
+ for part in key.split('.') {
+ current = match current {
+ Value::Object(map) => map.get(part)?,
+ Value::Array(items) => items.get(part.parse::().ok()?)?,
+ _ => return None,
+ };
+ }
+ Some(current)
+}
+
+fn set_path(root: &mut Value, key: &str, value: Value) -> Result<(), XFetchError> {
+ let segments = crate::cli::jsonc_edit::parse_path(key);
+ if segments.is_empty() {
+ return Err(XFetchError::Usage("empty config key".to_string()));
+ }
+ set_path_segments(root, &segments, value)
+}
+
+fn set_path_segments(
+ current: &mut Value,
+ segments: &[crate::cli::jsonc_edit::Segment],
+ value: Value,
+) -> Result<(), XFetchError> {
+ use crate::cli::jsonc_edit::Segment;
+ if segments.is_empty() {
+ *current = value;
+ return Ok(());
+ }
+
+ match &segments[0] {
+ Segment::Key(name) => {
+ if !current.is_object() {
+ *current = Value::Object(serde_json::Map::new());
+ }
+ let object = current.as_object_mut().expect("object just ensured");
+ let entry = object.entry(name.clone()).or_insert(Value::Null);
+ set_path_segments(entry, &segments[1..], value)
+ }
+ Segment::Index(index) => {
+ if !current.is_array() {
+ *current = Value::Array(Vec::new());
+ }
+ let items = current.as_array_mut().expect("array just ensured");
+ if *index > items.len() {
+ return Err(XFetchError::Usage(format!(
+ "array index {index} is out of range (length {})",
+ items.len()
+ )));
+ }
+ if *index == items.len() {
+ items.push(Value::Null);
+ }
+ set_path_segments(&mut items[*index], &segments[1..], value)
+ }
+ }
+}
+
+/// Replaces a top-level quoted string without touching comments or the rest of
+/// the document. Returns `None` when the key cannot be edited in place.
+fn set_top_level_string(content: &str, key: &str, value: &str) -> Option {
+ let mut found = false;
+ let mut result = String::new();
+ let double = format!("\"{}\"", key);
+ let single = format!("'{}'", key);
+ let bare = format!("{}:", key);
+
+ for line in content.lines() {
+ let trimmed = line.trim_start();
+ let is_key = trimmed.starts_with(&double)
+ || trimmed.starts_with(&single)
+ || trimmed.starts_with(&bare);
+ if !found && is_key {
+ if let Some(colon) = line.find(':') {
+ let head = &line[colon + 1..];
+ let trimmed_head = head.trim_start();
+ let skip = head.len() - trimmed_head.len();
+ if let Some(quote) = trimmed_head.chars().next()
+ && (quote == '"' || quote == '\'')
+ {
+ let open = colon + 1 + skip;
+ if let Some(relative) = line[open + 1..].find(quote) {
+ let close = open + 1 + relative;
+ result.push_str(&line[..open]);
+ result.push('"');
+ result.push_str(value);
+ result.push('"');
+ result.push_str(&line[close + 1..]);
+ found = true;
+ result.push('\n');
+ continue;
+ }
+ }
+ }
+ if !found {
+ let indent: String = line.chars().take_while(|c| c.is_whitespace()).collect();
+ result.push_str(&indent);
+ result.push('"');
+ result.push_str(key);
+ result.push_str("\": \"");
+ result.push_str(value);
+ result.push('"');
+ found = true;
+ result.push('\n');
+ continue;
+ }
+ }
+ result.push_str(line);
+ result.push('\n');
+ }
+
+ if found {
+ return Some(result);
+ }
+
+ let index = content.find('{')?;
+ let rest = &content[index + 1..];
+ let rest_trimmed = rest.trim_start();
+ let needs_comma = !(rest_trimmed.is_empty() || rest_trimmed.starts_with('}'));
+ let mut output = String::with_capacity(content.len() + key.len() + value.len() + 8);
+ output.push_str(&content[..=index]);
+ output.push_str("\n \"");
+ output.push_str(key);
+ output.push_str("\": \"");
+ output.push_str(value);
+ output.push('"');
+ if needs_comma {
+ output.push(',');
+ }
+ output.push_str(rest);
+ Some(output)
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn lookup_supports_dotted_paths_and_indices() {
+ let value = serde_json::json!({"colors": {"cpu": "red"}, "modules": ["os", "cpu"]});
+ assert_eq!(
+ lookup(&value, "colors.cpu"),
+ Some(&Value::String("red".to_string()))
+ );
+ assert_eq!(
+ lookup(&value, "modules.1"),
+ Some(&Value::String("cpu".to_string()))
+ );
+ assert_eq!(lookup(&value, "modules.9"), None);
+ assert_eq!(lookup(&value, "missing"), None);
+ }
+
+ #[test]
+ fn set_top_level_string_preserves_comments() {
+ let content = "{\n // keep me\n \"layout\": \"section\",\n \"theme\": \"nord\"\n}\n";
+ let updated = set_top_level_string(content, "layout", "right").unwrap();
+ assert!(updated.contains("// keep me"));
+ assert!(updated.contains("\"layout\": \"right\""));
+ assert!(updated.contains("\"theme\": \"nord\""));
+ }
+
+ #[test]
+ fn set_top_level_string_inserts_a_missing_key() {
+ let content = "{\n \"theme\": \"nord\"\n}\n";
+ let updated = set_top_level_string(content, "layout", "right").unwrap();
+ assert!(updated.contains("\"layout\": \"right\""));
+ assert!(updated.contains("\"theme\": \"nord\""));
+ }
+
+ #[test]
+ fn set_top_level_string_handles_an_empty_object() {
+ let updated = set_top_level_string("{\n}\n", "layout", "right").unwrap();
+ let parsed = crate::config::parse_jsonc_str_strict(&updated).expect("valid jsonc");
+ assert_eq!(parsed["layout"], "right");
+ }
+}
diff --git a/src/cli/dispatch.rs b/src/cli/dispatch.rs
new file mode 100644
index 0000000..297f612
--- /dev/null
+++ b/src/cli/dispatch.rs
@@ -0,0 +1,183 @@
+use crate::addons::model::AddonKind;
+use crate::cli::args::{AddonKindArg, Cli, Commands};
+use crate::cli::{
+ Context, addon_cmd, backup_cmd, build_info_cmd, completions, config_cmd, doctor, env_cmd,
+ fetch, logo_cmd, modules, overrides, paths_cmd, run_cmd, schema_cmd, settings, theme_cmd,
+ uninstall_cmd, update_cmd, wasm_cmd,
+};
+use crate::error::XFetchError;
+use crate::runtime;
+
+pub fn run(mut cli: Cli) -> Result<(), XFetchError> {
+ settings::init(&cli);
+ overrides::validate(&cli)?;
+ let overrides = overrides::build(&cli);
+ let ctx = Context {
+ config_path: cli.config.clone(),
+ overrides,
+ };
+ let json = cli.json;
+
+ if cli.backup {
+ return backup_cmd::backup(cli.config.clone(), None, false, false, false, None, json);
+ }
+
+ if cli.restore {
+ return backup_cmd::restore(cli.config.clone(), None, false, None, None, json);
+ }
+
+ if cli.list_layouts {
+ if json {
+ return crate::cli::output::print_json(&crate::ui::LAYOUT_NAMES);
+ }
+ for name in crate::ui::LAYOUT_NAMES {
+ println!("{name}");
+ }
+ return Ok(());
+ }
+
+ if cli.list_modules {
+ return modules::print_modules(json);
+ }
+
+ if cli.clean_cache {
+ return crate::cache::clean()
+ .map_err(|err| XFetchError::CleanCache(err.to_string()))
+ .map(|()| {
+ if json {
+ let _ = crate::cli::output::print_json(&serde_json::json!({"cleaned": true}));
+ } else {
+ runtime::info("Cache cleaned.");
+ }
+ });
+ }
+
+ if cli.daemon_stop {
+ let stopped = crate::ui::stop_daemon();
+ if json {
+ return crate::cli::output::print_json(&serde_json::json!({"stopped": stopped}));
+ }
+ runtime::info(if stopped {
+ "Daemon stopped."
+ } else {
+ "No daemon running."
+ });
+ return Ok(());
+ }
+
+ if cli.daemon_live_stop {
+ let stopped = crate::ui::stop_live_daemon();
+ if json {
+ return crate::cli::output::print_json(&serde_json::json!({"stopped": stopped}));
+ }
+ runtime::info(if stopped {
+ "Live daemon stopped."
+ } else {
+ "No live daemon running."
+ });
+ return Ok(());
+ }
+
+ if cli.gen_config {
+ let path = crate::config::generate_config(
+ cli.config.clone(),
+ cli.logo.as_deref(),
+ cli.layout.as_deref(),
+ )
+ .map_err(|err| XFetchError::GenConfig(err.to_string()))?;
+ if json {
+ return crate::cli::output::print_json(&serde_json::json!({
+ "path": path.display().to_string(),
+ }));
+ }
+ runtime::info(format!("Generated config: {}", path.display()));
+ runtime::info("Run xfetch to see the new layout.");
+ return Ok(());
+ }
+
+ match cli.command.take() {
+ Some(Commands::Plugin { action }) => addon_cmd::run(
+ AddonKind::Plugin,
+ action,
+ &cli,
+ &ctx.overrides,
+ ctx.config_path.clone(),
+ ),
+ Some(Commands::Extension { action }) => addon_cmd::run(
+ AddonKind::Extension,
+ action,
+ &cli,
+ &ctx.overrides,
+ ctx.config_path.clone(),
+ ),
+ Some(Commands::Effects { action }) => addon_cmd::run(
+ AddonKind::Effect,
+ action,
+ &cli,
+ &ctx.overrides,
+ ctx.config_path.clone(),
+ ),
+ Some(Commands::Addon { kind, action }) => addon_cmd::run(
+ addon_kind(kind),
+ action,
+ &cli,
+ &ctx.overrides,
+ ctx.config_path.clone(),
+ ),
+ Some(Commands::Command { action }) => addon_cmd::run(
+ AddonKind::Command,
+ action,
+ &cli,
+ &ctx.overrides,
+ ctx.config_path.clone(),
+ ),
+ Some(Commands::Run { name, render, args }) => {
+ run_cmd::run(&name, &args, render, cli.json, &ctx)
+ }
+ Some(Commands::Theme { action }) => theme_cmd::run(action, &cli, &ctx),
+ Some(Commands::Logo { action }) => logo_cmd::run(action, cli.json),
+ Some(Commands::Wasm { action }) => wasm_cmd::run(action, &cli),
+ Some(Commands::Update {
+ check,
+ prebuilt,
+ bin_dir,
+ yes,
+ rollback,
+ }) => update_cmd::run(check, prebuilt, bin_dir, yes, rollback, &cli),
+ Some(Commands::Doctor {
+ network,
+ fix,
+ bench,
+ image,
+ }) => doctor::run(
+ network,
+ fix,
+ bench,
+ image,
+ cli.json,
+ ctx.config_path.clone(),
+ &ctx.overrides,
+ ),
+ Some(Commands::Modules) => modules::print_modules(json),
+ Some(Commands::Config { action }) => {
+ config_cmd::run(action, &cli, &ctx.overrides, ctx.config_path.clone())
+ }
+ Some(Commands::Completions { shell }) => completions::completions(shell),
+ Some(Commands::Man { output }) => completions::man(output),
+ Some(Commands::Schema { kind }) => schema_cmd::run(kind),
+ Some(Commands::Paths) => paths_cmd::run(ctx.config_path.clone(), cli.json),
+ Some(Commands::Env) => env_cmd::run(ctx.config_path.clone(), cli.json),
+ Some(Commands::BuildInfo) => build_info_cmd::run(cli.json),
+ Some(Commands::SelfUninstall { purge, yes }) => uninstall_cmd::run(purge, yes, cli.json),
+ None => fetch::run(&cli, &ctx),
+ }
+}
+
+fn addon_kind(kind: AddonKindArg) -> AddonKind {
+ match kind {
+ AddonKindArg::Plugin => AddonKind::Plugin,
+ AddonKindArg::Effect => AddonKind::Effect,
+ AddonKindArg::Extension => AddonKind::Extension,
+ AddonKindArg::Command => AddonKind::Command,
+ }
+}
diff --git a/src/cli/doctor/mod.rs b/src/cli/doctor/mod.rs
new file mode 100644
index 0000000..06d79f9
--- /dev/null
+++ b/src/cli/doctor/mod.rs
@@ -0,0 +1,713 @@
+use crate::addons::model::AddonKind;
+pub mod platform;
+use crate::config::{
+ Config, ConfigOverrides, default_config_path, load_config_with_overrides,
+ parse_jsonc_file_strict, resolve_theme_path,
+};
+use crate::error::XFetchError;
+use crate::runtime;
+use crate::ui;
+use platform::PlatformInfo;
+use serde::Serialize;
+use std::io::IsTerminal;
+use std::time::Duration;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
+#[serde(rename_all = "lowercase")]
+pub enum Status {
+ Ok,
+ Warn,
+ Fail,
+}
+
+impl Status {
+ fn label(self) -> &'static str {
+ match self {
+ Status::Ok => "ok",
+ Status::Warn => "warn",
+ Status::Fail => "fail",
+ }
+ }
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct Check {
+ pub category: String,
+ pub name: String,
+ pub status: Status,
+ pub detail: String,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct Fix {
+ pub action: String,
+ pub detail: String,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct DoctorReport {
+ pub schema_version: u32,
+ pub version: &'static str,
+ pub platform: PlatformInfo,
+ pub checks: Vec,
+ pub fixes: Vec,
+ pub benchmark: Vec,
+}
+
+pub fn run(
+ network: bool,
+ fix: bool,
+ bench: bool,
+ image: bool,
+ json: bool,
+ config_path: Option,
+ overrides: &ConfigOverrides,
+) -> Result<(), XFetchError> {
+ let (mut report, config) = build_report(network, fix, config_path, overrides);
+ if bench {
+ let (_info, benchmark) = crate::info::Info::with_config(&config, true);
+ report.benchmark = benchmark;
+ }
+ let failures = report
+ .checks
+ .iter()
+ .filter(|check| check.status == Status::Fail)
+ .count();
+
+ if json {
+ crate::cli::output::print_json(&report)?;
+ } else {
+ print_human(&report);
+ if image && std::io::stdout().is_terminal() {
+ println!();
+ println!("[image]");
+ if let Err(err) = crate::ui::preview_logo(&config) {
+ crate::runtime::warn(format!("image preview failed: {err}"));
+ }
+ }
+ }
+
+ if failures > 0 {
+ return Err(XFetchError::Exit(crate::error::EXIT_GENERIC));
+ }
+ Ok(())
+}
+
+fn build_report(
+ network: bool,
+ fix: bool,
+ config_path: Option,
+ overrides: &ConfigOverrides,
+) -> (DoctorReport, Config) {
+ let mut checks = Vec::new();
+ let mut fixes = Vec::new();
+ check_environment(&mut checks);
+ let config = check_configuration(&mut checks, &mut fixes, fix, config_path, overrides);
+ check_terminal(&mut checks, &config);
+ check_addons(&mut checks);
+ check_cache(&mut checks, &mut fixes, fix);
+ if network {
+ check_network(&mut checks);
+ }
+
+ (
+ DoctorReport {
+ schema_version: crate::cli::output::JSON_SCHEMA_VERSION,
+ version: env!("CARGO_PKG_VERSION"),
+ platform: platform::collect(),
+ checks,
+ fixes,
+ benchmark: Vec::new(),
+ },
+ config,
+ )
+}
+
+fn push(
+ checks: &mut Vec,
+ category: &str,
+ name: &str,
+ status: Status,
+ detail: impl Into,
+) {
+ checks.push(Check {
+ category: category.to_string(),
+ name: name.to_string(),
+ status,
+ detail: detail.into(),
+ });
+}
+
+fn check_environment(checks: &mut Vec) {
+ let profile = if cfg!(debug_assertions) {
+ "debug"
+ } else {
+ "release"
+ };
+ push(
+ checks,
+ "environment",
+ "version",
+ Status::Ok,
+ format!("xfetch {} ({profile})", env!("CARGO_PKG_VERSION")),
+ );
+
+ match std::env::current_exe() {
+ Ok(path) => push(
+ checks,
+ "environment",
+ "binary",
+ if path.is_file() {
+ Status::Ok
+ } else {
+ Status::Fail
+ },
+ path.display().to_string(),
+ ),
+ Err(err) => push(
+ checks,
+ "environment",
+ "binary",
+ Status::Warn,
+ format!("cannot resolve the running binary: {err}"),
+ ),
+ }
+
+ for (name, status) in [
+ ("TERM", Status::Ok),
+ ("TERM_PROGRAM", Status::Ok),
+ ("KITTY_WINDOW_ID", Status::Ok),
+ ("COLORTERM", Status::Ok),
+ ("XDG_SESSION_TYPE", Status::Ok),
+ ("XDG_CURRENT_DESKTOP", Status::Ok),
+ ("SHELL", Status::Ok),
+ ] {
+ if let Ok(value) = std::env::var(name) {
+ push(checks, "environment", name, status, value);
+ }
+ }
+}
+
+fn check_configuration(
+ checks: &mut Vec,
+ fixes: &mut Vec,
+ fix: bool,
+ config_path: Option,
+ overrides: &ConfigOverrides,
+) -> Config {
+ let path = config_path
+ .as_ref()
+ .map(std::path::PathBuf::from)
+ .unwrap_or_else(default_config_path);
+
+ if path.exists() {
+ match parse_jsonc_file_strict(&path) {
+ Ok(value) => match serde_json::from_value::(value) {
+ Ok(_) => push(
+ checks,
+ "config",
+ "file",
+ Status::Ok,
+ path.display().to_string(),
+ ),
+ Err(err) => push(
+ checks,
+ "config",
+ "schema",
+ Status::Fail,
+ format!("invalid config schema: {err}"),
+ ),
+ },
+ Err(err) => push(checks, "config", "file", Status::Fail, err),
+ }
+ } else {
+ if fix {
+ match crate::config::write_default_config(&path) {
+ Ok(()) => {
+ fixes.push(Fix {
+ action: "generate-config".to_string(),
+ detail: path.display().to_string(),
+ });
+ push(
+ checks,
+ "config",
+ "file",
+ Status::Ok,
+ format!("{} (generated)", path.display()),
+ );
+ }
+ Err(err) => push(
+ checks,
+ "config",
+ "file",
+ Status::Fail,
+ format!("cannot generate '{}': {}", path.display(), err),
+ ),
+ }
+ } else {
+ push(
+ checks,
+ "config",
+ "file",
+ Status::Warn,
+ format!("{} (not found; defaults are used)", path.display()),
+ );
+ }
+ }
+
+ let config = load_config_with_overrides(config_path, overrides);
+
+ if let Some(theme) = &config.theme {
+ let status = if resolve_theme_path(theme).is_some() {
+ Status::Ok
+ } else {
+ Status::Warn
+ };
+ push(checks, "config", "theme", status, theme.clone());
+ } else {
+ push(checks, "config", "theme", Status::Ok, "default".to_string());
+ }
+
+ match config.layout.as_deref() {
+ Some(layout) if ui::is_known_layout(layout) => {
+ push(checks, "config", "layout", Status::Ok, layout.to_string())
+ }
+ Some(layout) => push(
+ checks,
+ "config",
+ "layout",
+ Status::Warn,
+ format!("{layout} (not in --list-layouts; the default is used)"),
+ ),
+ None => push(
+ checks,
+ "config",
+ "layout",
+ Status::Ok,
+ "default".to_string(),
+ ),
+ }
+
+ push(
+ checks,
+ "config",
+ "modules",
+ Status::Ok,
+ config.modules.len().to_string(),
+ );
+ push(
+ checks,
+ "config",
+ "cache",
+ Status::Ok,
+ if config.disable_cache.unwrap_or(false) {
+ "disabled".to_string()
+ } else {
+ "enabled".to_string()
+ },
+ );
+ push(
+ checks,
+ "config",
+ "network probes",
+ Status::Ok,
+ if config.disable_ip_fetching.unwrap_or(false) {
+ "disabled".to_string()
+ } else {
+ "enabled".to_string()
+ },
+ );
+
+ config
+}
+
+fn check_terminal(checks: &mut Vec, config: &Config) {
+ let is_tty = std::io::stdout().is_terminal();
+ push(
+ checks,
+ "terminal",
+ "stdout",
+ if is_tty { Status::Ok } else { Status::Warn },
+ if is_tty {
+ "tty".to_string()
+ } else {
+ "not a tty (images and effects are disabled)".to_string()
+ },
+ );
+
+ let width = match crossterm::terminal::size() {
+ Ok((width, height)) if width > 0 && height > 0 => {
+ push(
+ checks,
+ "terminal",
+ "size",
+ Status::Ok,
+ format!("{width}x{height}"),
+ );
+ width as usize
+ }
+ _ => {
+ push(
+ checks,
+ "terminal",
+ "size",
+ Status::Warn,
+ "unavailable (falls back to 80x24 geometry)".to_string(),
+ );
+ 80
+ }
+ };
+
+ let protocol = image_protocol(config);
+ push(checks, "terminal", "image protocol", Status::Ok, protocol);
+
+ let diagnostics = ui::logo_diagnostics(config, width);
+ push(
+ checks,
+ "terminal",
+ "logo",
+ if diagnostics.path_exists {
+ Status::Ok
+ } else {
+ Status::Warn
+ },
+ diagnostics
+ .path
+ .clone()
+ .unwrap_or_else(|| "default".to_string()),
+ );
+ push(
+ checks,
+ "terminal",
+ "logo kind",
+ Status::Ok,
+ if diagnostics.is_image {
+ "image"
+ } else {
+ "ascii"
+ },
+ );
+ if let Some(requested) = diagnostics.requested_width {
+ push(
+ checks,
+ "terminal",
+ "logo width requested",
+ Status::Ok,
+ requested.to_string(),
+ );
+ }
+ if let Some(printed) = diagnostics.printed_width {
+ push(
+ checks,
+ "terminal",
+ "logo width printed",
+ Status::Ok,
+ printed.to_string(),
+ );
+ }
+ if let Some(lines) = diagnostics.ascii_lines {
+ push(
+ checks,
+ "terminal",
+ "logo lines",
+ Status::Ok,
+ lines.to_string(),
+ );
+ }
+ push(
+ checks,
+ "terminal",
+ "logo gap",
+ Status::Ok,
+ diagnostics.gap.to_string(),
+ );
+ if let Some(content_width) = diagnostics.content_width {
+ let label = if config.layout.as_deref() == Some("right") {
+ "content width (right)"
+ } else {
+ "content width"
+ };
+ push(
+ checks,
+ "terminal",
+ label,
+ Status::Ok,
+ content_width.to_string(),
+ );
+ }
+ if let Some(image_x) = diagnostics.image_x {
+ push(
+ checks,
+ "terminal",
+ "image column",
+ Status::Ok,
+ image_x.to_string(),
+ );
+ }
+}
+
+fn image_protocol(config: &Config) -> &'static str {
+ if std::env::var_os("KITTY_WINDOW_ID").is_some() && config.logo_kitty.unwrap_or(true) {
+ return "kitty graphics";
+ }
+ let term_program = std::env::var("TERM_PROGRAM").unwrap_or_default();
+ let lc_terminal = std::env::var("LC_TERMINAL").unwrap_or_default();
+ for value in [&term_program, &lc_terminal] {
+ if value.contains("iTerm")
+ || value.contains("WezTerm")
+ || value.contains("mintty")
+ || value.contains("rio")
+ || value.contains("WarpTerminal")
+ {
+ return "iterm inline image";
+ }
+ }
+ "half blocks"
+}
+
+fn check_addons(checks: &mut Vec) {
+ for kind in [
+ AddonKind::Plugin,
+ AddonKind::Effect,
+ AddonKind::Extension,
+ AddonKind::Command,
+ ] {
+ let installed = match kind {
+ AddonKind::Plugin => crate::plugins::list_plugins(),
+ AddonKind::Effect => crate::effects::list_effects(),
+ AddonKind::Extension => crate::extensions::list_extensions(),
+ AddonKind::Command => crate::commands::list_commands(),
+ };
+ match installed {
+ Ok(entries) => {
+ let total = entries.len();
+ let receipts = entries
+ .iter()
+ .filter(|(name, _)| kind.receipt_path(name).is_file())
+ .count();
+ let status = if total > 0 && receipts < total {
+ Status::Warn
+ } else {
+ Status::Ok
+ };
+ push(
+ checks,
+ "addons",
+ kind.plural_label(),
+ status,
+ format!(
+ "{total} installed, {receipts} with install receipt, {}",
+ kind.directory().display()
+ ),
+ );
+ }
+ Err(err) => push(checks, "addons", kind.plural_label(), Status::Warn, err),
+ }
+ }
+}
+
+fn check_cache(checks: &mut Vec, fixes: &mut Vec, fix: bool) {
+ let cache = dirs::cache_dir()
+ .map(|dir| dir.join("xfetch").join("cache.json"))
+ .unwrap_or_else(|| std::path::PathBuf::from("cache.json"));
+ if cache.exists() {
+ let size = std::fs::metadata(&cache)
+ .map(|meta| meta.len())
+ .unwrap_or(0);
+ let valid = std::fs::read_to_string(&cache)
+ .ok()
+ .and_then(|content| serde_json::from_str::(&content).ok())
+ .is_some();
+ if !valid && fix {
+ match std::fs::remove_file(&cache) {
+ Ok(()) => {
+ fixes.push(Fix {
+ action: "remove-invalid-cache".to_string(),
+ detail: cache.display().to_string(),
+ });
+ push(
+ checks,
+ "cache",
+ "file",
+ Status::Ok,
+ format!("{} (removed invalid cache)", cache.display()),
+ );
+ }
+ Err(err) => push(
+ checks,
+ "cache",
+ "file",
+ Status::Fail,
+ format!("cannot remove '{}': {}", cache.display(), err),
+ ),
+ }
+ } else {
+ push(
+ checks,
+ "cache",
+ "file",
+ if valid { Status::Ok } else { Status::Warn },
+ format!(
+ "{} ({size} bytes{})",
+ cache.display(),
+ if valid { "" } else { ", invalid JSON" }
+ ),
+ );
+ }
+ } else {
+ push(
+ checks,
+ "cache",
+ "file",
+ Status::Ok,
+ format!("{} (not created yet)", cache.display()),
+ );
+ }
+}
+
+fn check_network(checks: &mut Vec) {
+ if runtime::offline() {
+ push(
+ checks,
+ "network",
+ "checks",
+ Status::Warn,
+ "skipped because --offline is set".to_string(),
+ );
+ return;
+ }
+
+ let urls = [
+ (
+ "plugins catalog",
+ "https://raw.githubusercontent.com/xfetch-cli/plugins/main/index.json",
+ ),
+ (
+ "effects catalog",
+ "https://raw.githubusercontent.com/xfetch-cli/effects/main/index.json",
+ ),
+ (
+ "extensions catalog",
+ "https://raw.githubusercontent.com/xfetch-cli/extensions/main/index.json",
+ ),
+ (
+ "update API",
+ "https://api.github.com/repos/xfetch-cli/xfetch/releases/latest",
+ ),
+ ];
+
+ for (name, url) in urls {
+ match probe(url) {
+ Ok(status) if (200..300).contains(&status) => push(
+ checks,
+ "network",
+ name,
+ Status::Ok,
+ format!("HTTP {status}"),
+ ),
+ Ok(status) => push(
+ checks,
+ "network",
+ name,
+ Status::Warn,
+ format!("HTTP {status}"),
+ ),
+ Err(err) => push(checks, "network", name, Status::Fail, err),
+ }
+ }
+}
+
+fn probe(url: &str) -> Result {
+ let response = ureq::get(url)
+ .config()
+ .timeout_global(Some(Duration::from_secs(4)))
+ .build()
+ .call()
+ .map_err(|err| err.to_string())?;
+ Ok(response.status().as_u16())
+}
+
+fn print_human(report: &DoctorReport) {
+ println!(
+ "xfetch {} doctor — {} {} ({})",
+ report.version, report.platform.os, report.platform.arch, report.platform.family
+ );
+ if !runtime::quiet() {
+ for detail in &report.platform.details {
+ println!(" {:<22} {}", detail.name, detail.value);
+ }
+ }
+
+ let mut current = "";
+ for check in &report.checks {
+ if runtime::quiet() && check.status == Status::Ok {
+ continue;
+ }
+ if check.category != current {
+ current = &check.category;
+ println!();
+ println!("[{}]", check.category);
+ }
+ println!(
+ " {:<6} {:<24} {}",
+ check.status.label(),
+ check.name,
+ check.detail
+ );
+ }
+
+ if !report.fixes.is_empty() {
+ println!();
+ println!("[fixes]");
+ for fix in &report.fixes {
+ println!(" {:<24} {}", fix.action, fix.detail);
+ }
+ }
+
+ if !report.benchmark.is_empty() {
+ println!();
+ println!("[benchmark]");
+ for line in &report.benchmark {
+ println!(" {line}");
+ }
+ }
+
+ let failures = report
+ .checks
+ .iter()
+ .filter(|check| check.status == Status::Fail)
+ .count();
+ let warnings = report
+ .checks
+ .iter()
+ .filter(|check| check.status == Status::Warn)
+ .count();
+ println!();
+ println!(
+ "{} checks: {} failures, {} warnings",
+ report.checks.len(),
+ failures,
+ warnings
+ );
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn status_labels_are_stable() {
+ assert_eq!(Status::Ok.label(), "ok");
+ assert_eq!(Status::Warn.label(), "warn");
+ assert_eq!(Status::Fail.label(), "fail");
+ }
+
+ #[test]
+ fn image_protocol_prefers_kitty() {
+ // The test process inherits the environment; only assert that the
+ // function returns one of the documented values.
+ let config = Config::default();
+ let protocol = image_protocol(&config);
+ assert!(["kitty graphics", "iterm inline image", "half blocks"].contains(&protocol));
+ }
+}
diff --git a/src/cli/doctor/platform/linux.rs b/src/cli/doctor/platform/linux.rs
new file mode 100644
index 0000000..24bc491
--- /dev/null
+++ b/src/cli/doctor/platform/linux.rs
@@ -0,0 +1,62 @@
+use super::{Detail, command_exists, env_detail};
+
+pub fn collect() -> Vec {
+ let mut details = Vec::new();
+
+ if let Ok(content) = std::fs::read_to_string("/etc/os-release") {
+ for line in content.lines() {
+ if let Some(value) = line.strip_prefix("PRETTY_NAME=") {
+ details.push(detail("Distribution", trim_quotes(value)));
+ } else if let Some(value) = line.strip_prefix("VERSION_ID=") {
+ details.push(detail("Distribution version", trim_quotes(value)));
+ } else if let Some(value) = line.strip_prefix("ID=") {
+ details.push(detail("Distribution id", trim_quotes(value)));
+ }
+ }
+ }
+
+ if let Some(detail) = env_detail("WSL_DISTRO_NAME") {
+ details.push(detail);
+ } else if let Ok(version) = std::fs::read_to_string("/proc/version")
+ && version.to_ascii_lowercase().contains("microsoft")
+ {
+ details.push(detail("WSL", "yes"));
+ }
+
+ for name in [
+ "XDG_SESSION_TYPE",
+ "XDG_CURRENT_DESKTOP",
+ "WAYLAND_DISPLAY",
+ "DISPLAY",
+ ] {
+ if let Some(detail) = env_detail(name) {
+ details.push(detail);
+ }
+ }
+
+ let managers: Vec<&str> = ["pacman", "dpkg", "rpm", "apk", "nix", "flatpak", "brew"]
+ .into_iter()
+ .filter(|command| command_exists(command))
+ .collect();
+ details.push(detail(
+ "Package managers",
+ if managers.is_empty() {
+ "none detected".to_string()
+ } else {
+ managers.join(", ")
+ },
+ ));
+
+ details
+}
+
+fn detail(name: &str, value: impl Into) -> Detail {
+ Detail {
+ name: name.to_string(),
+ value: value.into(),
+ }
+}
+
+fn trim_quotes(value: &str) -> String {
+ value.trim().trim_matches('"').to_string()
+}
diff --git a/src/cli/doctor/platform/macos.rs b/src/cli/doctor/platform/macos.rs
new file mode 100644
index 0000000..97588a0
--- /dev/null
+++ b/src/cli/doctor/platform/macos.rs
@@ -0,0 +1,31 @@
+use super::{Detail, env_detail};
+
+pub fn collect() -> Vec {
+ let mut details = Vec::new();
+
+ if let Ok(output) = std::process::Command::new("sw_vers")
+ .arg("-productVersion")
+ .output()
+ && output.status.success()
+ {
+ let version = String::from_utf8_lossy(&output.stdout).trim().to_string();
+ if !version.is_empty() {
+ details.push(detail("macOS version", version));
+ }
+ }
+
+ for name in ["TERM_PROGRAM", "SHELL", "SSH_CONNECTION"] {
+ if let Some(detail) = env_detail(name) {
+ details.push(detail);
+ }
+ }
+
+ details
+}
+
+fn detail(name: &str, value: impl Into) -> Detail {
+ Detail {
+ name: name.to_string(),
+ value: value.into(),
+ }
+}
diff --git a/src/cli/doctor/platform/mod.rs b/src/cli/doctor/platform/mod.rs
new file mode 100644
index 0000000..a48d386
--- /dev/null
+++ b/src/cli/doctor/platform/mod.rs
@@ -0,0 +1,77 @@
+use serde::Serialize;
+
+#[derive(Debug, Clone, Serialize)]
+pub struct Detail {
+ pub name: String,
+ pub value: String,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct PlatformInfo {
+ pub os: String,
+ pub arch: String,
+ pub family: String,
+ pub details: Vec,
+}
+
+pub fn collect() -> PlatformInfo {
+ PlatformInfo {
+ os: std::env::consts::OS.to_string(),
+ arch: std::env::consts::ARCH.to_string(),
+ family: std::env::consts::FAMILY.to_string(),
+ details: platform_details(),
+ }
+}
+
+#[cfg(target_os = "linux")]
+pub fn command_exists(command: &str) -> bool {
+ std::env::var_os("PATH")
+ .map(|paths| std::env::split_paths(&paths).any(|dir| dir.join(command).is_file()))
+ .unwrap_or(false)
+}
+
+pub fn env_detail(name: &str) -> Option {
+ std::env::var(name).ok().map(|value| Detail {
+ name: name.to_string(),
+ value,
+ })
+}
+
+#[cfg(target_os = "linux")]
+mod linux;
+#[cfg(target_os = "macos")]
+mod macos;
+#[cfg(target_os = "windows")]
+mod windows;
+
+#[cfg(target_os = "linux")]
+fn platform_details() -> Vec {
+ linux::collect()
+}
+
+#[cfg(target_os = "macos")]
+fn platform_details() -> Vec {
+ macos::collect()
+}
+
+#[cfg(target_os = "windows")]
+fn platform_details() -> Vec {
+ windows::collect()
+}
+
+#[cfg(not(any(target_os = "linux", target_os = "macos", target_os = "windows")))]
+fn platform_details() -> Vec {
+ Vec::new()
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn platform_info_has_os_and_arch() {
+ let info = collect();
+ assert!(!info.os.is_empty());
+ assert!(!info.arch.is_empty());
+ }
+}
diff --git a/src/cli/doctor/platform/windows.rs b/src/cli/doctor/platform/windows.rs
new file mode 100644
index 0000000..d79bd34
--- /dev/null
+++ b/src/cli/doctor/platform/windows.rs
@@ -0,0 +1,17 @@
+use super::{Detail, env_detail};
+
+pub fn collect() -> Vec {
+ let mut details = Vec::new();
+ for name in [
+ "PROCESSOR_ARCHITECTURE",
+ "SESSIONNAME",
+ "WT_SESSION",
+ "HOMEDRIVE",
+ "USERPROFILE",
+ ] {
+ if let Some(detail) = env_detail(name) {
+ details.push(detail);
+ }
+ }
+ details
+}
diff --git a/src/cli/env_cmd.rs b/src/cli/env_cmd.rs
new file mode 100644
index 0000000..236aeda
--- /dev/null
+++ b/src/cli/env_cmd.rs
@@ -0,0 +1,104 @@
+use crate::cli::{build_info_cmd, paths_cmd};
+use crate::error::XFetchError;
+use crate::runtime;
+use serde_json::{Map, Value, json};
+
+pub fn collect(config_path: Option) -> Value {
+ let mut environment = Map::new();
+ for name in [
+ "TERM",
+ "TERM_PROGRAM",
+ "KITTY_WINDOW_ID",
+ "COLORTERM",
+ "SHELL",
+ "XDG_SESSION_TYPE",
+ "XDG_CURRENT_DESKTOP",
+ "WAYLAND_DISPLAY",
+ "DISPLAY",
+ "XDG_CONFIG_HOME",
+ "XDG_CACHE_HOME",
+ "XDG_STATE_HOME",
+ ] {
+ if let Ok(value) = std::env::var(name) {
+ environment.insert(name.to_string(), Value::String(value));
+ }
+ }
+
+ json!({
+ "schema_version": crate::cli::output::JSON_SCHEMA_VERSION,
+ "build": build_info_cmd::collect(),
+ "platform": crate::cli::doctor::platform::collect(),
+ "environment": environment,
+ "settings": {
+ "log_level": runtime::log_level().as_str(),
+ "log_json": runtime::log_json(),
+ "offline": runtime::offline(),
+ "no_color": runtime::no_color(),
+ "quiet": runtime::quiet(),
+ "verbose": runtime::verbose(),
+ },
+ "paths": paths_cmd::collect(config_path),
+ })
+}
+
+pub fn run(config_path: Option, json: bool) -> Result<(), XFetchError> {
+ let value = collect(config_path);
+ if json {
+ return crate::cli::output::print_json(&value);
+ }
+
+ println!("[build]");
+ println!(
+ "version: {}",
+ value["build"]["version"].as_str().unwrap_or("?")
+ );
+ println!(
+ "target: {} {}",
+ value["build"]["target"]["os"].as_str().unwrap_or("?"),
+ value["build"]["target"]["arch"].as_str().unwrap_or("?")
+ );
+ println!(
+ "profile: {}",
+ value["build"]["profile"].as_str().unwrap_or("?")
+ );
+
+ println!();
+ println!("[platform]");
+ if let Some(details) = value["platform"]["details"].as_array() {
+ for detail in details {
+ println!(
+ " {:<22} {}",
+ detail["name"].as_str().unwrap_or("?"),
+ detail["value"].as_str().unwrap_or("?")
+ );
+ }
+ }
+
+ println!();
+ println!("[environment]");
+ if let Some(environment) = value["environment"].as_object() {
+ for (key, value) in environment {
+ println!(" {:<22} {}", key, value.as_str().unwrap_or("?"));
+ }
+ }
+
+ println!();
+ println!("[settings]");
+ if let Some(settings) = value["settings"].as_object() {
+ for (key, value) in settings {
+ println!(" {:<22} {}", key, value);
+ }
+ }
+
+ println!();
+ println!("[paths]");
+ if let Some(paths) = value["paths"].as_object() {
+ for (key, value) in paths {
+ if key == "schema_version" {
+ continue;
+ }
+ println!(" {:<22} {}", key, value.as_str().unwrap_or("-"));
+ }
+ }
+ Ok(())
+}
diff --git a/src/cli/fetch.rs b/src/cli/fetch.rs
new file mode 100644
index 0000000..dfe4b18
--- /dev/null
+++ b/src/cli/fetch.rs
@@ -0,0 +1,138 @@
+use crate::cli::args::Cli;
+use crate::cli::{Context, output, template};
+use crate::config::{Config, ModuleConfig};
+use crate::error::XFetchError;
+use crate::info::Info;
+use crate::runtime;
+
+pub fn run(cli: &Cli, ctx: &Context) -> Result<(), XFetchError> {
+ let config = ctx.load_config();
+
+ let output_mode = !cli.get.is_empty() || cli.template.is_some() || cli.format.is_some();
+ let daemon = cli.daemon || config.daemon || (config.daemon_live && !cli.no_daemon_live);
+ if daemon && (cli.json || output_mode) {
+ return Err(XFetchError::Usage(
+ "daemon mode cannot be combined with --json, --get, --template or --format."
+ .to_string(),
+ ));
+ }
+
+ runtime::debug(format!(
+ "config: {}",
+ ctx.config_path
+ .clone()
+ .unwrap_or_else(|| crate::config::default_config_path().display().to_string())
+ ));
+ runtime::debug(format!(
+ "layout: {}",
+ config.layout.as_deref().unwrap_or("default")
+ ));
+ runtime::trace(format!("configured modules: {}", config.modules.len()));
+
+ if !cli.get.is_empty() {
+ let keys = cli.get.clone();
+ let collect_config = config_with_modules(&config, &keys);
+ let (info, _) = Info::with_config(&collect_config, false);
+ let values = output::collect_values(&info, &collect_config, &keys);
+ return output::print_values(&values, &keys, cli.json);
+ }
+
+ if let Some(template_source) = template_source(cli)? {
+ let keys = template::keys(&template_source);
+ let collect_config = config_with_modules(&config, &keys);
+ let (info, _) = Info::with_config(&collect_config, false);
+ let context = template::context(&info, &collect_config, &keys);
+ let rendered = template::render(&template_source, &context);
+ print!("{rendered}");
+ if !rendered.ends_with('\n') {
+ println!();
+ }
+ return Ok(());
+ }
+
+ if cli.json {
+ let (info, bench_lines) = Info::with_config(&config, cli.benchmark);
+ let json = output::FetchJson::from_info(&info, bench_lines);
+ return output::print_json(&json);
+ }
+
+ let (info, bench_lines) = Info::with_config(&config, cli.benchmark);
+ if cli.daemon || config.daemon {
+ crate::ui::draw_daemon(&info, &config);
+ } else if config.daemon_live && !cli.no_daemon_live {
+ let config_path = ctx.config_path.clone().or_else(|| {
+ let default = crate::config::default_config_path();
+ default
+ .exists()
+ .then(|| default.to_string_lossy().into_owned())
+ });
+ let reload = config.daemon_live_reload || cli.daemon_live_reload;
+ crate::ui::draw_live_daemon(&info, &config, config_path, reload);
+ } else {
+ crate::ui::draw(&info, &config);
+ }
+
+ if !bench_lines.is_empty() {
+ println!("\n--- Benchmark -------------------------------");
+ for line in &bench_lines {
+ println!("{}", line);
+ }
+ println!("---------------------------------------------");
+ }
+ Ok(())
+}
+
+fn config_with_modules(config: &Config, keys: &[String]) -> Config {
+ let mut config = config.clone();
+ config.modules = keys
+ .iter()
+ .filter(|key| !is_special_key(key))
+ .map(|key| {
+ let probe = if key == "packages_breakdown" {
+ "packages"
+ } else {
+ key
+ };
+ ModuleConfig::Simple(probe.to_string())
+ })
+ .collect();
+ config
+}
+
+fn is_special_key(key: &str) -> bool {
+ matches!(key, "palette" | "header" | "sep" | "version" | "name")
+}
+
+fn template_source(cli: &Cli) -> Result, XFetchError> {
+ if let Some(template) = &cli.format {
+ return Ok(Some(template.clone()));
+ }
+ if let Some(path) = &cli.template {
+ let content = std::fs::read_to_string(path).map_err(|err| {
+ XFetchError::Config(format!("cannot read template '{}': {}", path, err))
+ })?;
+ return Ok(Some(content));
+ }
+ Ok(None)
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn special_keys_are_not_probed() {
+ assert!(is_special_key("header"));
+ assert!(is_special_key("palette"));
+ assert!(!is_special_key("os"));
+ assert!(!is_special_key("packages:pacman"));
+ }
+
+ #[test]
+ fn collect_config_only_keeps_module_keys() {
+ let config = Config::default();
+ let keys = vec!["os".to_string(), "header".to_string(), "cpu".to_string()];
+ let collected = config_with_modules(&config, &keys);
+ assert_eq!(collected.modules.len(), 2);
+ }
+}
diff --git a/src/cli/jsonc_edit.rs b/src/cli/jsonc_edit.rs
new file mode 100644
index 0000000..e0e54d3
--- /dev/null
+++ b/src/cli/jsonc_edit.rs
@@ -0,0 +1,307 @@
+use std::ops::Range;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Segment {
+ Key(String),
+ Index(usize),
+}
+
+pub fn parse_path(path: &str) -> Vec {
+ path.split('.')
+ .filter(|part| !part.is_empty())
+ .map(|part| match part.parse::() {
+ Ok(index) => Segment::Index(index),
+ Err(_) => Segment::Key(part.to_string()),
+ })
+ .collect()
+}
+
+pub fn replace_value_preserving(text: &str, path: &[Segment], new_value: &str) -> Option {
+ let mut parser = Parser::new(text);
+ let span = parser.find(path)?;
+ let mut output = String::with_capacity(text.len() + new_value.len());
+ output.push_str(&text[..span.start]);
+ output.push_str(new_value);
+ output.push_str(&text[span.end..]);
+ Some(output)
+}
+
+struct Parser<'a> {
+ text: &'a str,
+ bytes: &'a [u8],
+ pos: usize,
+}
+
+impl<'a> Parser<'a> {
+ fn new(text: &'a str) -> Self {
+ Self {
+ text,
+ bytes: text.as_bytes(),
+ pos: 0,
+ }
+ }
+
+ fn peek(&self) -> Option {
+ self.bytes.get(self.pos).copied()
+ }
+
+ fn bump(&mut self) -> Option {
+ let byte = self.peek()?;
+ self.pos += 1;
+ Some(byte)
+ }
+
+ fn skip_ws(&mut self) {
+ loop {
+ while self.peek().is_some_and(|byte| byte.is_ascii_whitespace()) {
+ self.pos += 1;
+ }
+ if self.bytes.get(self.pos..self.pos + 2) == Some(b"//") {
+ self.pos += 2;
+ while let Some(byte) = self.peek() {
+ self.pos += 1;
+ if byte == b'\n' {
+ break;
+ }
+ }
+ continue;
+ }
+ if self.bytes.get(self.pos..self.pos + 2) == Some(b"/*") {
+ self.pos += 2;
+ while self.pos + 1 < self.bytes.len() {
+ if &self.bytes[self.pos..self.pos + 2] == b"*/" {
+ self.pos += 2;
+ break;
+ }
+ self.pos += 1;
+ }
+ continue;
+ }
+ break;
+ }
+ }
+
+ fn parse_string(&mut self) -> Option {
+ if self.peek() != Some(b'"') {
+ return None;
+ }
+ let start = self.pos;
+ self.pos += 1;
+ while let Some(byte) = self.bump() {
+ match byte {
+ b'\\' => {
+ self.bump();
+ }
+ b'"' => {
+ let raw = &self.text[start..self.pos];
+ return serde_json::from_str::(raw).ok();
+ }
+ _ => {}
+ }
+ }
+ None
+ }
+
+ fn skip_string(&mut self) -> bool {
+ if self.peek() != Some(b'"') {
+ return false;
+ }
+ self.pos += 1;
+ while let Some(byte) = self.bump() {
+ match byte {
+ b'\\' => {
+ self.bump();
+ }
+ b'"' => return true,
+ _ => {}
+ }
+ }
+ false
+ }
+
+ fn skip_value(&mut self) -> bool {
+ self.skip_ws();
+ match self.peek() {
+ Some(b'{') => self.skip_object(),
+ Some(b'[') => self.skip_array(),
+ Some(b'"') => self.skip_string(),
+ Some(_) => {
+ while let Some(byte) = self.peek() {
+ if byte.is_ascii_whitespace() || matches!(byte, b',' | b'}' | b']') {
+ break;
+ }
+ if byte == b'/'
+ && matches!(self.bytes.get(self.pos + 1), Some(b'/') | Some(b'*'))
+ {
+ break;
+ }
+ self.pos += 1;
+ }
+ true
+ }
+ None => false,
+ }
+ }
+
+ fn skip_object(&mut self) -> bool {
+ if self.bump() != Some(b'{') {
+ return false;
+ }
+ loop {
+ self.skip_ws();
+ if self.peek() == Some(b'}') {
+ self.pos += 1;
+ return true;
+ }
+ if !self.skip_string() {
+ return false;
+ }
+ self.skip_ws();
+ if self.bump() != Some(b':') {
+ return false;
+ }
+ if !self.skip_value() {
+ return false;
+ }
+ self.skip_ws();
+ match self.peek() {
+ Some(b',') => self.pos += 1,
+ Some(b'}') => {
+ self.pos += 1;
+ return true;
+ }
+ _ => return false,
+ }
+ }
+ }
+
+ fn skip_array(&mut self) -> bool {
+ if self.bump() != Some(b'[') {
+ return false;
+ }
+ loop {
+ self.skip_ws();
+ if self.peek() == Some(b']') {
+ self.pos += 1;
+ return true;
+ }
+ if !self.skip_value() {
+ return false;
+ }
+ self.skip_ws();
+ match self.peek() {
+ Some(b',') => self.pos += 1,
+ Some(b']') => {
+ self.pos += 1;
+ return true;
+ }
+ _ => return false,
+ }
+ }
+ }
+
+ fn find(&mut self, path: &[Segment]) -> Option> {
+ self.skip_ws();
+ if path.is_empty() {
+ let start = self.pos;
+ if self.skip_value() {
+ return Some(start..self.pos);
+ }
+ return None;
+ }
+
+ match &path[0] {
+ Segment::Key(key) => {
+ if self.bump() != Some(b'{') {
+ return None;
+ }
+ loop {
+ self.skip_ws();
+ if self.peek() == Some(b'}') {
+ return None;
+ }
+ let found_key = self.parse_string()?;
+ self.skip_ws();
+ if self.bump() != Some(b':') {
+ return None;
+ }
+ if found_key == *key {
+ return self.find(&path[1..]);
+ }
+ if !self.skip_value() {
+ return None;
+ }
+ self.skip_ws();
+ match self.peek() {
+ Some(b',') => self.pos += 1,
+ Some(b'}') => return None,
+ _ => return None,
+ }
+ }
+ }
+ Segment::Index(index) => {
+ if self.bump() != Some(b'[') {
+ return None;
+ }
+ let mut current = 0usize;
+ loop {
+ self.skip_ws();
+ if self.peek() == Some(b']') {
+ return None;
+ }
+ if current == *index {
+ return self.find(&path[1..]);
+ }
+ if !self.skip_value() {
+ return None;
+ }
+ self.skip_ws();
+ match self.peek() {
+ Some(b',') => {
+ self.pos += 1;
+ current += 1;
+ }
+ Some(b']') => return None,
+ _ => return None,
+ }
+ }
+ }
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn replaces_a_nested_scalar_and_keeps_comments() {
+ let text = "{\n // keep\n \"colors\": {\n \"cpu\": \"red\", // note\n \"os\": \"cyan\"\n }\n}\n";
+ let path = parse_path("colors.cpu");
+ let output = replace_value_preserving(text, &path, "\"green\"").unwrap();
+ assert!(output.contains("// keep"));
+ assert!(output.contains("// note"));
+ assert!(output.contains("\"cpu\": \"green\""));
+ }
+
+ #[test]
+ fn replaces_an_array_element() {
+ let text = "{ \"modules\": [\"os\", \"cpu\", \"memory\"] }";
+ let path = parse_path("modules.1");
+ let output = replace_value_preserving(text, &path, "\"kernel\"").unwrap();
+ assert_eq!(output, "{ \"modules\": [\"os\", \"kernel\", \"memory\"] }");
+ }
+
+ #[test]
+ fn rejects_missing_paths() {
+ let text = "{ \"colors\": { \"cpu\": \"red\" } }";
+ assert!(replace_value_preserving(text, &parse_path("colors.gpu"), "\"blue\"").is_none());
+ }
+
+ #[test]
+ fn handles_escaped_keys() {
+ let text = "{ \"a\\\"b\": 1 }";
+ let output = replace_value_preserving(text, &parse_path("a\"b"), "2").unwrap();
+ assert_eq!(output, "{ \"a\\\"b\": 2 }");
+ }
+}
diff --git a/src/cli/logo_cmd.rs b/src/cli/logo_cmd.rs
new file mode 100644
index 0000000..251cbb8
--- /dev/null
+++ b/src/cli/logo_cmd.rs
@@ -0,0 +1,83 @@
+use crate::cli::args::LogoCommands;
+use crate::cli::output;
+use crate::error::XFetchError;
+use crate::logos;
+
+pub fn run(action: LogoCommands, json: bool) -> Result<(), XFetchError> {
+ match action {
+ LogoCommands::List { query } => list(query.as_deref(), json),
+ LogoCommands::Preview { name } => preview(&name, json),
+ }
+}
+
+fn list(query: Option<&str>, json: bool) -> Result<(), XFetchError> {
+ let index = logos::fetch_index().map_err(XFetchError::Network)?;
+ let query = query.map(|query| query.to_ascii_lowercase());
+ let entries: Vec<&logos::LogoEntry> = index
+ .logos
+ .iter()
+ .filter(|entry| {
+ let Some(query) = &query else {
+ return true;
+ };
+ entry.id.to_ascii_lowercase().contains(query)
+ || entry
+ .aliases
+ .iter()
+ .any(|alias| alias.to_ascii_lowercase().contains(query))
+ || entry.file.to_ascii_lowercase().contains(query)
+ })
+ .collect();
+
+ if json {
+ let entries: Vec = entries
+ .iter()
+ .map(|entry| {
+ serde_json::json!({
+ "id": entry.id,
+ "file": entry.file,
+ "aliases": entry.aliases,
+ })
+ })
+ .collect();
+ return output::print_json(&serde_json::json!({
+ "schema_version": output::JSON_SCHEMA_VERSION,
+ "logos": entries,
+ }));
+ }
+
+ println!("{:<24} {:<40} ALIASES", "ID", "FILE");
+ for entry in entries {
+ println!(
+ "{:<24} {:<40} {}",
+ entry.id,
+ entry.file,
+ entry.aliases.join(", ")
+ );
+ }
+ Ok(())
+}
+
+fn preview(name: &str, json: bool) -> Result<(), XFetchError> {
+ let index = logos::fetch_index().map_err(XFetchError::Network)?;
+ let entry = logos::find_entry(&index, name).ok_or_else(|| {
+ XFetchError::NotFound(format!("logo '{}' was not found in the catalog", name))
+ })?;
+ let art = logos::fetch_art(entry).map_err(XFetchError::Network)?;
+
+ if json {
+ return output::print_json(&serde_json::json!({
+ "schema_version": output::JSON_SCHEMA_VERSION,
+ "id": entry.id,
+ "file": entry.file,
+ "aliases": entry.aliases,
+ "art": art,
+ }));
+ }
+
+ print!("{art}");
+ if !art.ends_with('\n') {
+ println!();
+ }
+ Ok(())
+}
diff --git a/src/cli/mod.rs b/src/cli/mod.rs
new file mode 100644
index 0000000..7b8818f
--- /dev/null
+++ b/src/cli/mod.rs
@@ -0,0 +1,41 @@
+pub mod addon_cmd;
+pub mod args;
+pub mod backup_cmd;
+pub mod build_info_cmd;
+pub mod completions;
+pub mod config_cmd;
+pub mod dispatch;
+pub mod doctor;
+pub mod env_cmd;
+pub mod fetch;
+pub mod jsonc_edit;
+pub mod logo_cmd;
+pub mod modules;
+pub mod output;
+pub mod overrides;
+pub mod paths_cmd;
+pub mod run_cmd;
+pub mod schema_cmd;
+pub mod settings;
+pub mod template;
+pub mod theme_cmd;
+pub mod uninstall_cmd;
+pub mod update_cmd;
+pub mod wasm_cmd;
+
+pub use args::Cli;
+pub use dispatch::run;
+
+use crate::config::{Config, ConfigOverrides, load_config_with_overrides};
+
+/// Per-invocation CLI state shared by the command handlers.
+pub struct Context {
+ pub config_path: Option,
+ pub overrides: ConfigOverrides,
+}
+
+impl Context {
+ pub fn load_config(&self) -> Config {
+ load_config_with_overrides(self.config_path.clone(), &self.overrides)
+ }
+}
diff --git a/src/cli/modules.rs b/src/cli/modules.rs
new file mode 100644
index 0000000..e554938
--- /dev/null
+++ b/src/cli/modules.rs
@@ -0,0 +1,201 @@
+use serde::Serialize;
+
+#[derive(Debug, Clone, Copy, Serialize)]
+pub struct ModuleInfo {
+ pub key: &'static str,
+ pub description: &'static str,
+ pub platforms: &'static str,
+}
+
+/// Canonical module keys accepted in `modules`. Keep this list in sync with
+/// `ui::nodes::get_module_value` and the documentation tables.
+pub const MODULES: &[ModuleInfo] = &[
+ ModuleInfo {
+ key: "os",
+ description: "Operating system name and architecture",
+ platforms: "all",
+ },
+ ModuleInfo {
+ key: "kernel",
+ description: "Kernel version",
+ platforms: "all",
+ },
+ ModuleInfo {
+ key: "hostname",
+ description: "Machine hostname",
+ platforms: "all",
+ },
+ ModuleInfo {
+ key: "host",
+ description: "Alias for hostname",
+ platforms: "all",
+ },
+ ModuleInfo {
+ key: "user",
+ description: "Current user",
+ platforms: "all",
+ },
+ ModuleInfo {
+ key: "shell",
+ description: "Login shell",
+ platforms: "all",
+ },
+ ModuleInfo {
+ key: "terminal",
+ description: "Terminal emulator",
+ platforms: "all",
+ },
+ ModuleInfo {
+ key: "wm",
+ description: "Desktop environment or window manager",
+ platforms: "linux,macos,windows",
+ },
+ ModuleInfo {
+ key: "cpu",
+ description: "CPU model, cores and frequency",
+ platforms: "all",
+ },
+ ModuleInfo {
+ key: "gpu",
+ description: "GPU model and vendor",
+ platforms: "all",
+ },
+ ModuleInfo {
+ key: "memory",
+ description: "RAM usage",
+ platforms: "all",
+ },
+ ModuleInfo {
+ key: "swap",
+ description: "Swap usage",
+ platforms: "all",
+ },
+ ModuleInfo {
+ key: "disk",
+ description: "Disk usage",
+ platforms: "all",
+ },
+ ModuleInfo {
+ key: "battery",
+ description: "Battery status",
+ platforms: "linux,macos,windows",
+ },
+ ModuleInfo {
+ key: "uptime",
+ description: "System uptime",
+ platforms: "all",
+ },
+ ModuleInfo {
+ key: "packages",
+ description: "Installed package count",
+ platforms: "all",
+ },
+ ModuleInfo {
+ key: "packages:",
+ description: "Count for one package manager (pacman, dpkg, rpm, apk, nix, brew, flatpak, ...)",
+ platforms: "all",
+ },
+ ModuleInfo {
+ key: "datetime",
+ description: "Local date and time",
+ platforms: "all",
+ },
+ ModuleInfo {
+ key: "local_ip",
+ description: "Local IPv4 address",
+ platforms: "all",
+ },
+ ModuleInfo {
+ key: "local_ip:v6",
+ description: "Local IPv6 address",
+ platforms: "all",
+ },
+ ModuleInfo {
+ key: "public_ip",
+ description: "Public IP address (network)",
+ platforms: "all",
+ },
+ ModuleInfo {
+ key: "interfaces",
+ description: "Network interface summary",
+ platforms: "all",
+ },
+ ModuleInfo {
+ key: "palette",
+ description: "Terminal color palette",
+ platforms: "all",
+ },
+ ModuleInfo {
+ key: "header",
+ description: "user@hostname header",
+ platforms: "all",
+ },
+ ModuleInfo {
+ key: "sep",
+ description: "Separator line",
+ platforms: "all",
+ },
+ ModuleInfo {
+ key: "plugin:",
+ description: "Lines returned by an info plugin",
+ platforms: "all",
+ },
+];
+
+pub fn find(key: &str) -> Option<&'static ModuleInfo> {
+ if let Some(info) = MODULES.iter().find(|info| info.key == key) {
+ return Some(info);
+ }
+ if key.starts_with("packages:") && key.len() > "packages:".len() {
+ return MODULES.iter().find(|info| info.key == "packages:");
+ }
+ if key.starts_with("plugin:") && key.len() > "plugin:".len() {
+ return MODULES.iter().find(|info| info.key == "plugin:");
+ }
+ None
+}
+
+pub fn is_known(key: &str) -> bool {
+ find(key).is_some()
+}
+
+pub fn print_modules(json: bool) -> Result<(), crate::error::XFetchError> {
+ if json {
+ let output = serde_json::to_string_pretty(MODULES)
+ .map_err(|err| crate::error::XFetchError::Fatal(err.to_string()))?;
+ println!("{output}");
+ return Ok(());
+ }
+
+ println!("{:<18} {:<20} DESCRIPTION", "KEY", "PLATFORMS");
+ for module in MODULES {
+ println!(
+ "{:<18} {:<20} {}",
+ module.key, module.platforms, module.description
+ );
+ }
+ Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn known_keys_and_patterns() {
+ assert!(is_known("os"));
+ assert!(is_known("packages:pacman"));
+ assert!(is_known("plugin:banner"));
+ assert!(!is_known("packages:"));
+ assert!(!is_known("plugin:"));
+ assert!(!is_known("nope"));
+ }
+
+ #[test]
+ fn registry_keys_are_unique() {
+ let mut keys: Vec<&str> = MODULES.iter().map(|info| info.key).collect();
+ keys.sort_unstable();
+ keys.dedup();
+ assert_eq!(keys.len(), MODULES.len());
+ }
+}
diff --git a/src/cli/output.rs b/src/cli/output.rs
new file mode 100644
index 0000000..cff3ddb
--- /dev/null
+++ b/src/cli/output.rs
@@ -0,0 +1,259 @@
+use crate::addons::model::{AddonEntry, AddonKind};
+use crate::config::Config;
+use crate::error::XFetchError;
+use crate::info::Info;
+use crate::runtime;
+use crate::ui::nodes::{format_palette, get_module_value};
+use console::strip_ansi_codes;
+use serde::Serialize;
+use std::collections::BTreeMap;
+
+pub const JSON_SCHEMA_VERSION: u32 = 1;
+
+#[derive(Debug, Serialize)]
+pub struct PackageCount {
+ pub manager: String,
+ pub count: String,
+}
+
+#[derive(Debug, Serialize)]
+pub struct FetchJson {
+ pub schema_version: u32,
+ pub name: &'static str,
+ pub version: &'static str,
+ pub os: String,
+ pub kernel: String,
+ pub hostname: String,
+ pub user: String,
+ pub shell: String,
+ pub terminal: String,
+ pub desktop: String,
+ pub cpu: String,
+ pub gpu: Vec,
+ pub memory: String,
+ pub swap: String,
+ pub disks: Vec,
+ pub battery: String,
+ pub uptime: String,
+ pub packages: String,
+ pub packages_breakdown: Vec,
+ pub datetime: String,
+ pub local_ip: String,
+ pub local_ip_v6: String,
+ pub public_ip: String,
+ pub network_interfaces: String,
+ pub plugins: BTreeMap>,
+ #[serde(skip_serializing_if = "Vec::is_empty")]
+ pub benchmark: Vec,
+}
+
+impl FetchJson {
+ pub fn from_info(info: &Info, benchmark: Vec) -> Self {
+ let packages_breakdown = info
+ .packages_breakdown
+ .iter()
+ .map(|(manager, count)| PackageCount {
+ manager: manager.clone(),
+ count: count.clone(),
+ })
+ .collect();
+ let plugins: BTreeMap> = info
+ .plugin_info
+ .iter()
+ .map(|(key, lines)| {
+ (
+ key.clone(),
+ lines
+ .iter()
+ .map(|line| strip_ansi_codes(line).to_string())
+ .collect(),
+ )
+ })
+ .collect();
+
+ Self {
+ schema_version: JSON_SCHEMA_VERSION,
+ name: "xfetch",
+ version: env!("CARGO_PKG_VERSION"),
+ os: info.os.clone(),
+ kernel: info.kernel.clone(),
+ hostname: info.host_name.clone(),
+ user: info.user.clone(),
+ shell: info.shell.clone(),
+ terminal: info.terminal.clone(),
+ desktop: info.desktop.clone(),
+ cpu: info.cpu.clone(),
+ gpu: info.gpu.clone(),
+ memory: info.memory.clone(),
+ swap: info.swap.clone(),
+ disks: info.disks.clone(),
+ battery: info.battery.clone(),
+ uptime: info.uptime.clone(),
+ packages: info.packages.clone(),
+ packages_breakdown,
+ datetime: info.datetime.clone(),
+ local_ip: info.local_ip.clone(),
+ local_ip_v6: info.local_ip_v6.clone(),
+ public_ip: info.public_ip.clone(),
+ network_interfaces: info.network_interfaces.clone(),
+ plugins,
+ benchmark,
+ }
+ }
+}
+
+#[derive(Debug, Serialize)]
+pub struct GetJson {
+ pub schema_version: u32,
+ pub values: BTreeMap>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct AddonJson {
+ pub kind: String,
+ pub name: String,
+ pub path: String,
+ pub runtime: String,
+ pub manifest_kind: String,
+ pub version: Option,
+ pub description: Option,
+ pub enabled: bool,
+ pub capabilities: Vec,
+ pub limits: Option,
+ pub config: Vec,
+ pub manifest_source: Option,
+ pub installed_source: Option,
+}
+
+impl AddonJson {
+ pub fn from_entry(entry: &AddonEntry) -> Self {
+ Self {
+ kind: entry.kind.label().to_string(),
+ name: entry.name.clone(),
+ path: entry.path.display().to_string(),
+ runtime: entry.runtime.as_str().to_string(),
+ manifest_kind: entry.manifest_kind().to_string(),
+ version: entry.version().map(str::to_string),
+ description: entry.description().map(str::to_string),
+ enabled: entry.enabled,
+ capabilities: entry.capability_lines(),
+ limits: entry.limits_line(),
+ config: entry.config_snippet(),
+ manifest_source: entry.manifest_source.clone(),
+ installed_source: entry.receipt.as_ref().map(|receipt| receipt.source.clone()),
+ }
+ }
+}
+
+#[derive(Debug, Serialize)]
+pub struct AddonListJson {
+ pub schema_version: u32,
+ pub kind: String,
+ pub addons: Vec,
+}
+
+#[derive(Debug, Serialize)]
+pub struct AddonInfoJson {
+ pub schema_version: u32,
+ #[serde(flatten)]
+ pub addon: AddonJson,
+}
+
+pub fn print_json(value: &T) -> Result<(), XFetchError> {
+ let text = serde_json::to_string_pretty(value)
+ .map_err(|err| XFetchError::Fatal(format!("failed to serialize JSON: {}", err)))?;
+ println!("{text}");
+ Ok(())
+}
+
+pub fn value_for_key(info: &Info, config: &Config, key: &str) -> Option {
+ let value: Option = if key == "palette" {
+ Some(format_palette(config))
+ } else if key == "name" {
+ Some("xfetch".to_string())
+ } else if key == "version" {
+ Some(env!("CARGO_PKG_VERSION").to_string())
+ } else if key == "header" {
+ Some(format!("{}@{}", info.user, info.host_name))
+ } else if key == "sep" {
+ Some("---".to_string())
+ } else if let Some(lines) = info.plugin_info.get(key) {
+ Some(lines.join("\n"))
+ } else {
+ get_module_value(info, key)
+ };
+
+ value.map(|text: String| {
+ if runtime::no_color() {
+ strip_ansi_codes(&text).to_string()
+ } else {
+ text
+ }
+ })
+}
+
+pub fn collect_values(
+ info: &Info,
+ config: &Config,
+ keys: &[String],
+) -> BTreeMap> {
+ keys.iter()
+ .map(|key| (key.clone(), value_for_key(info, config, key)))
+ .collect()
+}
+
+pub fn print_values(
+ values: &BTreeMap>,
+ keys: &[String],
+ json: bool,
+) -> Result<(), XFetchError> {
+ if json {
+ let values = values
+ .iter()
+ .map(|(key, value)| {
+ (
+ key.clone(),
+ value
+ .as_ref()
+ .map(|text| strip_ansi_codes(text).to_string()),
+ )
+ })
+ .collect();
+ return print_json(&GetJson {
+ schema_version: JSON_SCHEMA_VERSION,
+ values,
+ });
+ }
+
+ if keys.len() == 1 {
+ if let Some(Some(value)) = values.iter().next().map(|(_, value)| value) {
+ println!("{value}");
+ }
+ return Ok(());
+ }
+
+ for key in keys {
+ let value = values
+ .get(key)
+ .and_then(|value| value.as_deref())
+ .unwrap_or("");
+ let single_line = value.replace('\n', "\\n");
+ println!("{key}={single_line}");
+ }
+ Ok(())
+}
+
+pub fn print_addon_list_json(kind: AddonKind, entries: &[AddonEntry]) -> Result<(), XFetchError> {
+ print_json(&AddonListJson {
+ schema_version: JSON_SCHEMA_VERSION,
+ kind: kind.label().to_string(),
+ addons: entries.iter().map(AddonJson::from_entry).collect(),
+ })
+}
+
+pub fn print_addon_info_json(entry: &AddonEntry) -> Result<(), XFetchError> {
+ print_json(&AddonInfoJson {
+ schema_version: JSON_SCHEMA_VERSION,
+ addon: AddonJson::from_entry(entry),
+ })
+}
diff --git a/src/cli/overrides.rs b/src/cli/overrides.rs
new file mode 100644
index 0000000..1bce5e3
--- /dev/null
+++ b/src/cli/overrides.rs
@@ -0,0 +1,126 @@
+use crate::cli::args::Cli;
+use crate::cli::modules;
+use crate::config::{ConfigOverrides, ModuleConfig, resolve_theme_path};
+use crate::error::XFetchError;
+use crate::runtime;
+
+pub fn build(cli: &Cli) -> ConfigOverrides {
+ let modules = cli.modules.as_ref().and_then(|list| {
+ let parsed: Vec