scripts/uninstall_oss.sh
Rama main · réplica de lectura del repositorio original.
#!/bin/sh
# Omnigent uninstaller. POSIX sh by design so it still works when the Python
# wheel is wedged or PATH is broken.
set -u
MARKER_BEGIN="# >>> Omnigent installer >>>"
MARKER_END="# <<< Omnigent installer <<<"
TAB=$(printf '\t')
TARGETS=""
DRY_RUN=false
YES=false
JSON=false
FORCE=false
PURGE=false
NO_BACKUP=false
PURGE_WORKSPACE=false
MODIFY_EXTERNAL_CONFIG=false
ASSUME_INFERRED=false
DESTRUCTIVE_FLAG=false
EXPLICIT_TARGET=false
DONE=0
SKIPPED=0
FAILED=0
REPORTED=0
EXIT_CODE=0
ACTIONS_FILE="$(mktemp "${TMPDIR:-/tmp}/omnigent-uninstall-actions.XXXXXX")" || exit 1
BACKUPS_FILE="$(mktemp "${TMPDIR:-/tmp}/omnigent-uninstall-backups.XXXXXX")" || exit 1
cleanup() {
rm -f "$ACTIONS_FILE" "$BACKUPS_FILE"
}
trap cleanup EXIT HUP INT TERM
usage() {
cat <<'EOF'
Usage: uninstall_oss.sh [cli|state|desktop-data|all ...] [flags]
Flags:
--purge Remove state data (backs up first)
--purge-workspace With --purge, also remove ~/omnigent non-interactively
--dry-run Print planned actions only
--yes Non-interactive for auto-removable artifacts
--json Emit a machine-readable summary
--force SIGKILL stubborn processes and override refusals
--modify-external-config Allow marker-scoped third-party config edits
--no-backup Skip purge backup creation
--assume-inferred Allow inferred entries when combined with their gates
EOF
}
json_escape() {
printf '%s' "$1" | sed 's/\\/\\\\/g; s/"/\\"/g; s/ /\\t/g'
}
record_action() {
artifact="$1"
path="$2"
planned="$3"
status="$4"
gate="$5"
detail="$6"
case "$status" in
done) DONE=$((DONE + 1)) ;;
skipped) SKIPPED=$((SKIPPED + 1)) ;;
failed) FAILED=$((FAILED + 1)); EXIT_CODE=1 ;;
reported) REPORTED=$((REPORTED + 1)) ;;
esac
printf '{"artifact":"%s","path":"%s","planned":"%s","status":"%s","gate":%s,"detail":"%s"}\n' \
"$(json_escape "$artifact")" \
"$(json_escape "$path")" \
"$(json_escape "$planned")" \
"$(json_escape "$status")" \
"$(if [ -n "$gate" ]; then printf '"%s"' "$(json_escape "$gate")"; else printf 'null'; fi)" \
"$(json_escape "$detail")" >>"$ACTIONS_FILE"
if [ "$JSON" != true ]; then
printf '%s: %s (%s)\n' "$status" "$artifact${path:+ $path}" "$detail"
fi
}
has_target() {
case " $TARGETS " in
*" $1 "*) return 0 ;;
*) return 1 ;;
esac
}
add_target() {
case "$1" in
all)
add_target cli
add_target state
add_target desktop-data
;;
cli | state | desktop-data)
if ! has_target "$1"; then
TARGETS="${TARGETS}${TARGETS:+ }$1"
fi
;;
*)
usage >&2
exit 3
;;
esac
}
while [ "$#" -gt 0 ]; do
case "$1" in
--purge) PURGE=true; DESTRUCTIVE_FLAG=true; add_target state ;;
--purge-workspace) PURGE_WORKSPACE=true; DESTRUCTIVE_FLAG=true ;;
--dry-run) DRY_RUN=true ;;
--yes) YES=true; DESTRUCTIVE_FLAG=true ;;
--json) JSON=true ;;
--force) FORCE=true; DESTRUCTIVE_FLAG=true ;;
--modify-external-config) MODIFY_EXTERNAL_CONFIG=true; DESTRUCTIVE_FLAG=true ;;
--no-backup) NO_BACKUP=true; DESTRUCTIVE_FLAG=true ;;
--assume-inferred) ASSUME_INFERRED=true; DESTRUCTIVE_FLAG=true ;;
-h | --help) usage; exit 0 ;;
--*) usage >&2; exit 3 ;;
*) EXPLICIT_TARGET=true; add_target "$1" ;;
esac
shift
done
if [ "$EXPLICIT_TARGET" != true ]; then
add_target cli
fi
if [ "$DESTRUCTIVE_FLAG" != true ]; then
DRY_RUN=true
fi
state_home() {
if [ -n "${OMNIGENT_DATA_DIR:-}" ]; then
printf '%s\n' "$OMNIGENT_DATA_DIR"
else
printf '%s/.omnigent\n' "$HOME"
fi
}
is_pid_alive() {
pid="$1"
[ -n "$pid" ] || return 1
kill -0 "$pid" 2>/dev/null || return 1
state="$(ps -o stat= -p "$pid" 2>/dev/null | awk 'NR == 1 { print $1 }')"
case "$state" in
Z*) return 1 ;;
esac
return 0
}
stop_pid() {
pid="$1"
origin="$2"
if ! is_pid_alive "$pid"; then
record_action process "$origin" stop done "" "already stopped"
return 0
fi
if [ "$DRY_RUN" = true ]; then
record_action process "$origin" stop reported "" "would SIGTERM pid $pid"
return 0
fi
kill -TERM "$pid" 2>/dev/null || true
i=0
while [ "$i" -lt 50 ]; do
if ! is_pid_alive "$pid"; then
record_action process "$origin" stop done "" "stopped pid $pid"
return 0
fi
sleep 0.1
i=$((i + 1))
done
if [ "$FORCE" = true ]; then
kill -KILL "$pid" 2>/dev/null || true
record_action process "$origin" stop done "" "SIGKILL sent to pid $pid"
return 0
fi
record_action process "$origin" stop failed "--force" "pid $pid did not stop"
EXIT_CODE=2
return 1
}
stop_processes() {
home_dir="$(state_home)"
pidfiles="$(mktemp "${TMPDIR:-/tmp}/omnigent-uninstall-pidfiles.XXXXXX")" || return 1
: >"$pidfiles"
if [ -d "$home_dir" ]; then
for root in "$home_dir/run" "$home_dir/daemons" "$home_dir/runners" "$home_dir/local_server"; do
[ -d "$root" ] || continue
find "$root" -type f \( -name '*.pid' -o -name 'local_server.pid' \) 2>/dev/null >>"$pidfiles" || true
done
for pidfile in "$home_dir/local_server.pid" "$home_dir/host.pid"; do
[ -f "$pidfile" ] && printf '%s\n' "$pidfile" >>"$pidfiles"
done
while IFS= read -r pidfile; do
[ -n "$pidfile" ] || continue
pid="$(awk 'NR == 1 { sub(/[^0-9].*$/, ""); print; exit }' "$pidfile" 2>/dev/null || true)"
[ -n "$pid" ] && stop_pid "$pid" "$pidfile" || true
done <"$pidfiles"
fi
if command -v tmux >/dev/null 2>&1; then
sessions_file="$(mktemp "${TMPDIR:-/tmp}/omnigent-uninstall-tmux.XXXXXX")" || return 1
tmux list-sessions -F '#S' >"$sessions_file" 2>/dev/null || true
while IFS= read -r session; do
case "$session" in
omnigent:*)
if [ "$DRY_RUN" = true ]; then
record_action tmux "$session" stop reported "" "would kill tmux session"
elif tmux kill-session -t "$session" 2>/dev/null; then
record_action tmux "$session" stop done "" "killed tmux session"
else
record_action tmux "$session" stop failed "" "failed to kill tmux session"
fi
;;
esac
done <"$sessions_file"
rm -f "$sessions_file"
fi
rm -f "$pidfiles"
if [ "$EXIT_CODE" = 2 ]; then
return 1
fi
}
unload_launch_agents() {
[ -n "${OMNIGENT_UNINSTALL_LEDGER_MANIFEST:-}" ] && [ -f "$OMNIGENT_UNINSTALL_LEDGER_MANIFEST" ] || return 0
while IFS="$TAB" read -r artifact kind unit_path label source confidence rest; do
[ "$artifact" = launch_agent ] || continue
if [ "$DRY_RUN" = true ]; then
record_action launch_agent "$unit_path" unload reported "" "would unload $kind $label"
continue
fi
case "$kind" in
launchd)
if command -v launchctl >/dev/null 2>&1; then
launchctl bootout "gui/$(id -u)" "$unit_path" >/dev/null 2>&1 || launchctl unload "$unit_path" >/dev/null 2>&1 || true
record_action launch_agent "$unit_path" unload done "" "requested launchd unload for $label"
else
record_action launch_agent "$unit_path" unload skipped "" "launchctl not found"
fi
;;
systemd_user)
if command -v systemctl >/dev/null 2>&1; then
systemctl --user disable --now "$label" >/dev/null 2>&1 || systemctl --user stop "$label" >/dev/null 2>&1 || true
record_action launch_agent "$unit_path" unload done "" "requested systemd user stop for $label"
else
record_action launch_agent "$unit_path" unload skipped "" "systemctl not found"
fi
;;
*)
record_action launch_agent "$unit_path" unload skipped "" "unknown launch agent kind $kind"
;;
esac
if [ -e "$unit_path" ]; then
if rm -f "$unit_path"; then
record_action launch_agent "$unit_path" remove done "" "removed unit file"
else
record_action launch_agent "$unit_path" remove failed "" "failed to remove unit file"
fi
else
record_action launch_agent "$unit_path" remove skipped "" "unit file already absent"
fi
done <"$OMNIGENT_UNINSTALL_LEDGER_MANIFEST"
}
profile_candidates() {
printf '%s\n' \
"$HOME/.zprofile" \
"$HOME/.zshrc" \
"$HOME/.bash_profile" \
"$HOME/.bashrc" \
"$HOME/.profile" \
"$HOME/.config/fish/config.fish"
if [ -d "$HOME/.config/fish/conf.d" ]; then
find "$HOME/.config/fish/conf.d" -type f -name '*.fish' 2>/dev/null
fi
}
has_shell_install_signal() {
[ -n "${OMNIGENT_UNINSTALL_LEDGER_SOURCE:-}" ] && [ "$OMNIGENT_UNINSTALL_LEDGER_SOURCE" != unknown ] && return 0
[ -f "$(state_home)/installation_id" ] && return 0
command -v omnigent >/dev/null 2>&1 && return 0
command -v omni >/dev/null 2>&1 && return 0
profiles_file="$(mktemp "${TMPDIR:-/tmp}/omnigent-uninstall-anchor-profiles.XXXXXX")" || return 1
profile_candidates >"$profiles_file"
while IFS= read -r profile; do
if profile_has_block "$profile"; then
rm -f "$profiles_file"
return 0
fi
done <"$profiles_file"
rm -f "$profiles_file"
return 1
}
profile_has_block() {
[ -f "$1" ] || return 1
awk -v begin="$MARKER_BEGIN" -v end="$MARKER_END" '
$0 == begin { found_begin=1 }
found_begin && $0 == end { found_end=1 }
END { exit(found_begin && found_end ? 0 : 1) }
' "$1"
}
sha256_file() {
file="$1"
if command -v sha256sum >/dev/null 2>&1; then
sha256sum "$file" | awk '{print $1}'
elif command -v shasum >/dev/null 2>&1; then
shasum -a 256 "$file" | awk '{print $1}'
elif command -v openssl >/dev/null 2>&1; then
openssl dgst -sha256 "$file" | awk '{print $NF}'
else
return 1
fi
}
write_profile_block() {
profile="$1"
output="$2"
awk -v begin="$MARKER_BEGIN" -v end="$MARKER_END" '
$0 == begin { printing=1 }
printing { print }
printing && $0 == end { exit }
' "$profile" >"$output"
}
remove_profile_block() {
profile="$1"
expected_sha="${2:-}"
if ! profile_has_block "$profile"; then
record_action profile_block "$profile" remove skipped "" "marker block absent"
return 0
fi
line_range="$(awk -v begin="$MARKER_BEGIN" -v end="$MARKER_END" '
$0 == begin { start=NR }
start && $0 == end { print start "-" NR; exit }
' "$profile")"
if [ "$DRY_RUN" = true ]; then
record_action profile_block "$profile" remove reported "" "would remove lines $line_range"
return 0
fi
if [ -n "$expected_sha" ]; then
block_file="$(mktemp "${TMPDIR:-/tmp}/omnigent-uninstall-block.XXXXXX")" || return 1
write_profile_block "$profile" "$block_file"
actual_sha="$(sha256_file "$block_file" 2>/dev/null || true)"
rm -f "$block_file"
if [ -z "$actual_sha" ]; then
record_action profile_block "$profile" remove failed "" "could not verify block hash"
return 1
fi
if [ "$actual_sha" != "$expected_sha" ] && [ "$FORCE" != true ]; then
record_action profile_block "$profile" remove failed "--force" "marker block hash mismatch; refusing tampered block"
EXIT_CODE=3
return 1
fi
fi
backup="$profile.omnigent.bak.$(date -u +%Y%m%dT%H%M%SZ)"
tmp="$(mktemp "$profile.omnigent.tmp.XXXXXX")" || return 1
if ! cp "$profile" "$backup"; then
record_action profile_block "$profile" remove failed "" "failed to write backup"
return 1
fi
if awk -v begin="$MARKER_BEGIN" -v end="$MARKER_END" '
$0 == begin { skipping=1; found=1; next }
skipping && $0 == end { skipping=0; next }
!skipping { print }
END { exit(found ? 0 : 42) }
' "$profile" >"$tmp" && mv "$tmp" "$profile"; then
record_action profile_block "$profile" remove done "" "block removed, backup at $backup"
else
rm -f "$tmp"
record_action profile_block "$profile" remove failed "" "failed to remove block"
fi
}
cleanup_profiles() {
if [ -n "${OMNIGENT_UNINSTALL_LEDGER_MANIFEST:-}" ] && [ -f "$OMNIGENT_UNINSTALL_LEDGER_MANIFEST" ]; then
while IFS="$TAB" read -r artifact profile expected_sha source confidence rest; do
[ "$artifact" = profile_block ] || continue
remove_profile_block "$profile" "$expected_sha"
[ "$EXIT_CODE" = 3 ] && return 1
done <"$OMNIGENT_UNINSTALL_LEDGER_MANIFEST"
else
profiles_file="$(mktemp "${TMPDIR:-/tmp}/omnigent-uninstall-profiles.XXXXXX")" || return 1
profile_candidates >"$profiles_file"
while IFS= read -r profile; do
[ -n "$profile" ] || continue
if profile_has_block "$profile"; then
remove_profile_block "$profile" ""
if [ "$EXIT_CODE" = 3 ]; then
rm -f "$profiles_file"
return 1
fi
fi
done <"$profiles_file"
rm -f "$profiles_file"
fi
}
remove_delimited_external_config() {
path="$1"
marker="$2"
[ -f "$path" ] || { record_action external_config "$path" remove skipped "" "already absent"; return 0; }
if ! grep -F "$marker" "$path" >/dev/null 2>&1; then
record_action external_config "$path" remove skipped "" "marker absent"
return 0
fi
if [ "$DRY_RUN" = true ]; then
record_action external_config "$path" remove reported "" "would remove marker block $marker"
return 0
fi
backup="$path.omnigent.bak.$(date -u +%Y%m%dT%H%M%SZ)"
tmp="$(mktemp "$path.omnigent.tmp.XXXXXX")" || return 1
cp "$path" "$backup" || { record_action external_config "$path" remove failed "" "failed to write backup"; return 1; }
if awk -v marker="$marker" '
index($0, marker) && !skipping { skipping=1; found=1; next }
index($0, marker) && skipping { skipping=0; next }
!skipping { print }
END { exit(found && !skipping ? 0 : 42) }
' "$path" >"$tmp" && mv "$tmp" "$path"; then
record_action external_config "$path" remove done "" "removed marker block, backup at $backup"
else
rm -f "$tmp"
record_action external_config "$path" remove failed "" "failed to remove marker block"
fi
}
remove_keyed_external_config() {
path="$1"
marker="$2"
format="$3"
[ -f "$path" ] || { record_action external_config "$path" remove skipped "" "already absent"; return 0; }
if [ "$DRY_RUN" = true ]; then
record_action external_config "$path" remove reported "" "would remove $marker from $format config"
return 0
fi
if [ "$format" = toml ]; then
backup="$path.omnigent.bak.$(date -u +%Y%m%dT%H%M%SZ)"
tmp="$(mktemp "$path.omnigent.tmp.XXXXXX")" || return 1
cp "$path" "$backup" || { record_action external_config "$path" remove failed "" "failed to write backup"; return 1; }
if awk -v marker="$marker" '
$0 == "[" marker "]" || $0 ~ "^\\[" marker "\\." { skipping=1; found=1; next }
skipping && /^\[/ { skipping=0 }
!skipping { print }
END { exit(found ? 0 : 42) }
' "$backup" >"$tmp" && mv "$tmp" "$path"; then
record_action external_config "$path" remove done "" "removed TOML table $marker, backup at $backup"
else
rm -f "$tmp"
record_action external_config "$path" remove skipped "" "TOML table $marker absent"
fi
return 0
fi
py="$(command -v python3 2>/dev/null || command -v python 2>/dev/null || true)"
if [ -z "$py" ]; then
record_action external_config "$path" remove skipped "" "python not found for structured config edit"
return 0
fi
backup="$path.omnigent.bak.$(date -u +%Y%m%dT%H%M%SZ)"
cp "$path" "$backup" || { record_action external_config "$path" remove failed "" "failed to write backup"; return 1; }
if "$py" - "$path" "$marker" "$format" <<'PY'
import json
import sys
from pathlib import Path
path = Path(sys.argv[1])
marker = sys.argv[2]
fmt = sys.argv[3]
if fmt != "json":
raise SystemExit(42)
original = path.read_text()
data = json.loads(original)
current = data
parts = marker.split(".")
for part in parts[:-1]:
current = current.get(part, {}) if isinstance(current, dict) else {}
if not isinstance(current, dict) or parts[-1] not in current:
raise SystemExit(42)
current.pop(parts[-1])
indent = 2 if "\n \"" in original else None
path.write_text(json.dumps(data, indent=indent, sort_keys=False) + "\n")
PY
then
record_action external_config "$path" remove done "" "removed $marker, backup at $backup"
else
record_action external_config "$path" remove skipped "" "unsupported structured format; backup kept at $backup"
fi
}
cleanup_external_configs() {
[ -n "${OMNIGENT_UNINSTALL_LEDGER_MANIFEST:-}" ] && [ -f "$OMNIGENT_UNINSTALL_LEDGER_MANIFEST" ] || return 0
while IFS="$TAB" read -r artifact path marker format expected_sha source confidence rest; do
[ "$artifact" = external_config ] || continue
if [ "$MODIFY_EXTERNAL_CONFIG" != true ]; then
record_action external_config "$path" remove skipped "--modify-external-config" "gate not provided"
continue
fi
if { [ "$source" = inferred ] || [ "$confidence" = low ] || [ "$confidence" = medium ]; } && [ "$ASSUME_INFERRED" != true ]; then
record_action external_config "$path" remove skipped "--assume-inferred" "confidence gate not provided"
continue
fi
if [ "$format" = delimited_block ]; then
remove_delimited_external_config "$path" "$marker"
else
remove_keyed_external_config "$path" "$marker" "$format"
fi
done <"$OMNIGENT_UNINSTALL_LEDGER_MANIFEST"
}
archive_path_for() {
target="$1"
if [ -n "${XDG_STATE_HOME:-}" ]; then
backup_root="$XDG_STATE_HOME/omnigent-backups"
else
backup_root="$HOME/.omnigent-backups"
fi
mkdir -p "$backup_root" || return 1
ts="$(date -u +%Y-%m-%dT%H-%M-%SZ)"
base="$(printf '%s' "$target" | sed 's/[^A-Za-z0-9._-]/_/g; s/^_*//; s/_*$//')"
if command -v zstd >/dev/null 2>&1; then
printf '%s/%s-%s-%s.tar.zst\n' "$backup_root" "$ts" "$base" "$$"
else
printf '%s/%s-%s-%s.tar.gz\n' "$backup_root" "$ts" "$base" "$$"
fi
}
backup_path() {
target="$1"
[ -e "$target" ] || return 0
if [ "$NO_BACKUP" = true ]; then
return 0
fi
archive="$(archive_path_for "$target")" || return 1
parent="$(dirname "$target")"
base="$(basename "$target")"
case "$archive" in
*.tar.zst)
tar_tmp="$(mktemp "$archive.tar.XXXXXX")" || return 1
if ! tar -cf "$tar_tmp" -C "$parent" "$base"; then
rm -f "$tar_tmp" "$archive"
return 1
fi
if ! zstd -q -o "$archive" "$tar_tmp"; then
rm -f "$tar_tmp" "$archive"
return 1
fi
rm -f "$tar_tmp"
;;
*.tar.gz)
tar -czf "$archive" -C "$parent" "$base" || return 1
;;
esac
printf '%s\n' "$archive" >>"$BACKUPS_FILE"
record_action backup "$target" archive done "" "restore with: tar -xf $archive -C $parent"
}
remove_tree() {
artifact="$1"
path="$2"
gate="$3"
if [ ! -e "$path" ]; then
record_action "$artifact" "$path" remove skipped "" "already absent"
return 0
fi
if [ -n "$gate" ]; then
record_action "$artifact" "$path" remove skipped "$gate" "gate not provided"
return 0
fi
if [ "$DRY_RUN" = true ]; then
size="$(du -sk "$path" 2>/dev/null | awk '{print $1 " KiB"}' || printf unknown)"
record_action "$artifact" "$path" remove reported "" "would remove $size"
return 0
fi
if backup_path "$path" && rm -rf "$path"; then
record_action "$artifact" "$path" remove done "" "removed"
else
record_action "$artifact" "$path" remove failed "" "failed to remove"
fi
}
desktop_paths() {
case "$(uname -s)" in
Darwin)
printf '%s\n' \
"$HOME/Library/Application Support/Omnigent" \
"$HOME/Library/Caches/Omnigent" \
"$HOME/Library/Logs/Omnigent"
;;
*)
printf '%s\n' \
"${XDG_CONFIG_HOME:-$HOME/.config}/Omnigent" \
"${XDG_CACHE_HOME:-$HOME/.cache}/Omnigent" \
"${XDG_STATE_HOME:-$HOME/.local/state}/Omnigent"
;;
esac
}
purge_state() {
remove_tree state "$(state_home)" ""
workspace="$HOME/omnigent"
if [ -e "$workspace" ]; then
if [ "$PURGE_WORKSPACE" = true ]; then
remove_tree workspace "$workspace" ""
elif [ "$YES" = true ]; then
record_action workspace "$workspace" remove skipped "--purge-workspace" "workspace kept"
elif [ "$DRY_RUN" = true ]; then
record_action workspace "$workspace" remove reported "--purge-workspace" "would prompt separately"
else
printf 'Remove workspace %s? [y/N] ' "$workspace" >/dev/tty 2>/dev/null || true
answer=
IFS= read -r answer </dev/tty 2>/dev/null || true
case "$answer" in
y | Y | yes | YES | Yes) remove_tree workspace "$workspace" "" ;;
*) record_action workspace "$workspace" remove skipped "--purge-workspace" "workspace kept" ;;
esac
fi
fi
}
purge_desktop_data() {
desktop_file="$(mktemp "${TMPDIR:-/tmp}/omnigent-uninstall-desktop.XXXXXX")" || return 1
desktop_paths >"$desktop_file"
while IFS= read -r path; do
[ -n "$path" ] || continue
remove_tree desktop_data "$path" ""
done <"$desktop_file"
rm -f "$desktop_file"
}
report_shared_deps() {
for dep in uv node npm tmux bwrap databricks; do
dep_path="$(command -v "$dep" 2>/dev/null || true)"
if [ -n "$dep_path" ]; then
record_action shared_dep "$dep" report reported "" "present at $dep_path; not removed"
fi
done
}
uninstall_wheel() {
if [ "$DRY_RUN" = true ]; then
record_action wheel omnigent remove reported "" "would run uv tool uninstall omnigent"
return 0
fi
if ! command -v uv >/dev/null 2>&1; then
if ! command -v omnigent >/dev/null 2>&1 && ! command -v omni >/dev/null 2>&1; then
record_action wheel omnigent remove skipped "" "already absent"
return 0
fi
record_action wheel omnigent remove failed "" "uv not found; remove the tool manually"
return 1
fi
uv_output="$(mktemp "${TMPDIR:-/tmp}/omnigent-uninstall-uv.XXXXXX")" || return 1
if uv tool uninstall omnigent >"$uv_output" 2>&1; then
rm -f "$uv_output"
record_action wheel omnigent remove done "" "uv tool uninstall omnigent"
else
output="$(cat "$uv_output" 2>/dev/null || true)"
rm -f "$uv_output"
case "$output" in
*'not installed'* | *'No tool'* | *'not found'*)
record_action wheel omnigent remove skipped "" "already absent"
;;
*)
record_action wheel omnigent remove failed "" "uv tool uninstall failed: $output"
;;
esac
fi
}
emit_json() {
printf '{\n'
printf ' "schema_version": 1,\n'
printf ' "dry_run": %s,\n' "$DRY_RUN"
printf ' "ledger_source": "%s",\n' "${OMNIGENT_UNINSTALL_LEDGER_SOURCE:-unknown}"
printf ' "actions": [\n'
first=true
if [ -f "$ACTIONS_FILE" ]; then
while IFS= read -r line; do
if [ "$first" = true ]; then first=false; else printf ',\n'; fi
printf ' %s' "$line"
done <"$ACTIONS_FILE"
fi
printf '\n ],\n'
printf ' "backups": ['
first=true
if [ -f "$BACKUPS_FILE" ]; then
while IFS= read -r line; do
if [ "$first" = true ]; then first=false; else printf ','; fi
printf '"%s"' "$(json_escape "$line")"
done <"$BACKUPS_FILE"
fi
printf '],\n'
printf ' "summary": {"done": %s, "skipped": %s, "failed": %s, "reported": %s},\n' "$DONE" "$SKIPPED" "$FAILED" "$REPORTED"
printf ' "exit_code": %s\n' "$EXIT_CODE"
printf '}\n'
}
if ! has_shell_install_signal; then
record_action anchor omnigent detect failed "" "no Omnigent install detected"
EXIT_CODE=3
[ "$JSON" = true ] && emit_json
exit "$EXIT_CODE"
fi
unload_launch_agents
if ! stop_processes; then
[ "$JSON" = true ] && emit_json
exit "$EXIT_CODE"
fi
if has_target cli; then
cleanup_profiles
if [ "$EXIT_CODE" = 3 ]; then
[ "$JSON" = true ] && emit_json
exit "$EXIT_CODE"
fi
cleanup_external_configs
fi
if has_target state; then
if [ "$PURGE" = true ]; then
purge_state
else
record_action state "$(state_home)" remove skipped "--purge" "state preserved"
fi
fi
if has_target desktop-data; then
purge_desktop_data
fi
report_shared_deps
if has_target cli; then
uninstall_wheel
fi
if [ "$JSON" = true ]; then
emit_json
elif [ "$DRY_RUN" = true ]; then
printf 'Preview only — nothing was changed. Re-run with --yes to apply CLI cleanup, or --purge --yes to remove state.\n'
elif [ -f "$BACKUPS_FILE" ]; then
while IFS= read -r backup; do
printf 'backup: %s\n' "$backup"
done <"$BACKUPS_FILE"
fi
exit "$EXIT_CODE"