766 lines
28 KiB
Bash
766 lines
28 KiB
Bash
#!/usr/bin/env bash
|
|
set -e
|
|
|
|
# Thin POSIX wrapper that delegates to the canonical Python installer
|
|
# (scripts/bootstrap.py). Platform bootstraps should prefer calling the
|
|
# Python script using --no-delegate and -q/--quiet for quiet/non-interactive mode.
|
|
|
|
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
|
|
REPO="$(cd "$SCRIPT_DIR/.." && pwd -P)"
|
|
|
|
# Prefer repo venv python, then system pythons
|
|
if [ -x "$REPO/.venv/bin/python" ]; then
|
|
PY="$REPO/.venv/bin/python"
|
|
elif [ -x "$REPO/.venv/bin/python3" ]; then
|
|
PY="$REPO/.venv/bin/python3"
|
|
elif command -v python3 >/dev/null 2>&1; then
|
|
PY="python3"
|
|
elif command -v python >/dev/null 2>&1; then
|
|
PY="python"
|
|
else
|
|
echo "Error: No Python interpreter found; please install Python 3 or create the project's .venv." >&2
|
|
exit 1
|
|
fi
|
|
|
|
# Translate -q into --quiet for the Python installer
|
|
ARGS=()
|
|
for a in "$@"; do
|
|
if [ "$a" = "-q" ]; then
|
|
ARGS+=("--quiet")
|
|
else
|
|
ARGS+=("$a")
|
|
fi
|
|
done
|
|
|
|
exec "$PY" "$REPO/scripts/bootstrap.py" --no-delegate "${ARGS[@]}"
|
|
|
|
# Prompt helper: read from the controlling terminal so prompts still work
|
|
# when stdout/stderr are redirected or piped (e.g., piping output to sed).
|
|
prompt_yes_no() {
|
|
local prompt="$1"
|
|
local default="${2:-n}"
|
|
local answer
|
|
if [[ "${QUIET:-false}" == "true" ]]; then
|
|
answer="$default"
|
|
else
|
|
if [[ -t 0 ]]; then
|
|
read -r -p "$prompt" answer
|
|
elif [[ -e /dev/tty ]]; then
|
|
read -r -p "$prompt" answer < /dev/tty
|
|
else
|
|
answer="$default"
|
|
fi
|
|
fi
|
|
echo "$answer"
|
|
}
|
|
|
|
attempt_fix_urllib3() {
|
|
local venv_py="$1"
|
|
echo "Attempting automatic urllib3 fix in venv: $venv_py" >&2
|
|
# Temporarily disable set -e to inspect return codes ourselves
|
|
set +e
|
|
"$venv_py" -m pip uninstall urllib3-future -y >/dev/null 2>&1 || true
|
|
"$venv_py" -m pip install --upgrade --force-reinstall urllib3
|
|
local pip_ret=$?
|
|
# Best-effort install/update for niquests; non-fatal
|
|
"$venv_py" -m pip install niquests -U >/dev/null 2>&1 || true
|
|
set -e
|
|
|
|
if [[ $pip_ret -ne 0 ]]; then
|
|
echo "ERROR: pip failed to reinstall urllib3 (exit $pip_ret)" >&2
|
|
return 2
|
|
fi
|
|
|
|
# Verify fix
|
|
if "$venv_py" -c 'from SYS.env_check import check_urllib3_compat; ok,msg = check_urllib3_compat(); import sys; sys.exit(0 if ok else 2)'; then
|
|
echo "Success: urllib3 issues resolved" >&2
|
|
return 0
|
|
fi
|
|
|
|
echo "ERROR: urllib3 fix attempt incomplete (import check failed)" >&2
|
|
|
|
# Detect potential interfering .pth files in site-packages
|
|
echo "Searching for interfering .pth files in the venv site-packages..." >&2
|
|
local site_pkgs
|
|
site_pkgs=$("$venv_py" - <<'PY'
|
|
import json, site, sysconfig
|
|
paths = []
|
|
try:
|
|
paths.extend(site.getsitepackages())
|
|
except Exception:
|
|
pass
|
|
try:
|
|
p = sysconfig.get_paths().get('purelib')
|
|
if p:
|
|
paths.append(p)
|
|
except Exception:
|
|
pass
|
|
seen = []
|
|
out = []
|
|
for s in paths:
|
|
if s and s not in seen:
|
|
seen.append(s)
|
|
out.append(s)
|
|
print("\n".join(out))
|
|
PY
|
|
)
|
|
local pths=()
|
|
if [[ -n "$site_pkgs" ]]; then
|
|
while IFS= read -r sp; do
|
|
if [[ -d "$sp" ]]; then
|
|
while IFS= read -r f; do
|
|
if [[ -n "$f" ]]; then
|
|
if grep -qi 'urllib3_future' "$f" >/dev/null 2>&1 || grep -qi 'urllib3-future' "$f" >/dev/null 2>&1; then
|
|
pths+=("$f")
|
|
fi
|
|
fi
|
|
done < <(find "$sp" -maxdepth 1 -type f -name '*.pth' -print 2>/dev/null)
|
|
fi
|
|
done <<< "$site_pkgs"
|
|
fi
|
|
|
|
if [[ ${#pths[@]} -eq 0 ]]; then
|
|
echo "No obvious interfering .pth files found in site-packages. Manual inspection recommended." >&2
|
|
return 3
|
|
fi
|
|
|
|
echo "Found the following potentially interfering .pth files:" >&2
|
|
for p in "${pths[@]}"; do echo " - $p" >&2; done
|
|
|
|
if [[ "$REMOVE_PTH" == "true" || "$FIX_URLLIB3" == "true" ]]; then
|
|
echo "Removing .pth files (automatic removal due to --fix-urllib3)..." >&2
|
|
for p in "${pths[@]}"; do
|
|
rm -f "$p"
|
|
echo "Removed: $p" >&2
|
|
done
|
|
else
|
|
if [[ "$QUIET" == "true" ]]; then
|
|
echo "Detected interfering .pth files but cannot prompt in quiet mode. Re-run with --remove-pth to remove them automatically." >&2
|
|
return 3
|
|
fi
|
|
resp="$(prompt_yes_no 'Remove these files now? (y/N) ' 'n')"
|
|
if [[ "$resp" != "y" && "$resp" != "Y" ]]; then
|
|
echo "User declined to remove .pth files. Aborting." >&2
|
|
return 3
|
|
fi
|
|
for p in "${pths[@]}"; do
|
|
rm -f "$p"
|
|
echo "Removed: $p" >&2
|
|
done
|
|
fi
|
|
|
|
# Re-run reinstall & verify
|
|
echo "Reinstalling urllib3 after .pth removal..." >&2
|
|
set +e
|
|
"$venv_py" -m pip install --upgrade --force-reinstall urllib3
|
|
local pip_ret2=$?
|
|
set -e
|
|
if [[ $pip_ret2 -ne 0 ]]; then
|
|
echo "ERROR: pip reinstall failed after .pth removal (exit $pip_ret2)" >&2
|
|
return 2
|
|
fi
|
|
if "$venv_py" -c 'from SYS.env_check import check_urllib3_compat; ok,msg = check_urllib3_compat(); import sys; sys.exit(0 if ok else 2)'; then
|
|
echo "Success: urllib3 issues resolved after .pth removal" >&2
|
|
return 0
|
|
fi
|
|
|
|
echo "ERROR: urllib3 still not importable after .pth removal" >&2
|
|
return 3
|
|
}
|
|
|
|
usage() {
|
|
cat <<EOF
|
|
Usage: $0 [options]
|
|
Options:
|
|
-e, --editable Install project in editable mode (pip -e .)
|
|
-p, --venv <path> Venv path (default: .venv)
|
|
--python <python> Python executable to use (e.g. python3)
|
|
-d, --desktop Create a desktop launcher (~/.local/share/applications and ~/Desktop)
|
|
-n, --no-install Skip pip install
|
|
--no-playwright Skip installing Playwright browsers (default: install chromium)
|
|
--playwright-browsers <list> Comma-separated list of browsers to install (default: chromium)
|
|
-q, --quiet Quiet / non-interactive mode; abort on errors instead of prompting
|
|
-F, --fix-urllib3 Attempt to automatically fix known urllib3 issues in the venv if detected
|
|
-R, --remove-pth When fixing urllib3, automatically remove interfering .pth files (like urllib3_future.pth)
|
|
-f, --force Overwrite existing venv without prompting
|
|
-h, --help Show this help
|
|
EOF
|
|
}
|
|
|
|
while [[ $# -gt 0 ]]; do
|
|
case "$1" in
|
|
-e|--editable) EDITABLE=true; shift;;
|
|
-p|--venv) VENV_PATH="$2"; shift 2;;
|
|
--python) PYTHON_CMD="$2"; shift 2;;
|
|
-d|--desktop) DESKTOP=true; shift;;
|
|
-n|--no-install) NOINSTALL=true; shift;;
|
|
-f|--force) FORCE=true; shift;;
|
|
-F|--fix-urllib3) FIX_URLLIB3=true; shift;;
|
|
-R|--remove-pth) REMOVE_PTH=true; shift;;
|
|
-q|--quiet) QUIET=true; shift;;
|
|
-h|--help) usage; exit 0;;
|
|
--no-playwright) NO_PLAYWRIGHT=true; shift;;
|
|
--playwright-browsers) PLAYWRIGHT_BROWSERS="$2"; shift 2;;
|
|
*) echo "Unknown option: $1"; usage; exit 1;;
|
|
esac
|
|
done
|
|
|
|
if [[ -n "$PYTHON_CMD" ]]; then
|
|
PY="$PYTHON_CMD"
|
|
elif command -v python3 >/dev/null 2>&1; then
|
|
PY=python3
|
|
elif command -v python >/dev/null 2>&1; then
|
|
PY=python
|
|
else
|
|
echo "ERROR: No python executable found; install Python or pass --python <path>" >&2
|
|
exit 2
|
|
fi
|
|
|
|
echo "Using Python: $PY"
|
|
|
|
# Operate from the repository root (parent of the scripts dir) so relative
|
|
# operations (like creating the venv and pip install) act on the project root
|
|
# regardless of where this script was invoked from.
|
|
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
|
|
REPO="$(cd "$SCRIPT_DIR/.." && pwd)"
|
|
if ! cd "$REPO"; then
|
|
echo "ERROR: Failed to change to repo root: $REPO" >&2
|
|
exit 2
|
|
fi
|
|
echo "Operating from repo root: $REPO"
|
|
|
|
# If running as root (via sudo), warn the user because bootstrap will create files
|
|
# in the repo that may end up owned by root (e.g., the .venv directory).
|
|
if [[ "$EUID" -eq 0 ]]; then
|
|
echo "WARNING: Running bootstrap as root. This may create files owned by root (e.g., .venv). Consider running without sudo unless you intend system-level installs." >&2
|
|
fi
|
|
|
|
# Basic sanity check: ensure the detected repo root actually looks like the project
|
|
if [[ ! -f "$REPO/pyproject.toml" && ! -f "$REPO/scripts/pyproject.toml" && ! -f "$REPO/setup.py" && ! -f "$REPO/CLI.py" ]]; then
|
|
echo "WARNING: Detected repo root ($REPO) does not contain pyproject.toml, setup.py, or CLI.py; attempting to locate project root via git or current working directory..." >&2
|
|
if git -C "$SCRIPT_DIR/.." rev-parse --show-toplevel >/dev/null 2>&1; then
|
|
REPO="$(git -C "$SCRIPT_DIR/.." rev-parse --show-toplevel)"
|
|
if ! cd "$REPO"; then
|
|
echo "ERROR: Failed to change to repo root: $REPO" >&2
|
|
exit 2
|
|
fi
|
|
echo "Operating from repo root (detected via git): $REPO"
|
|
elif git -C "$PWD" rev-parse --show-toplevel >/dev/null 2>&1; then
|
|
REPO="$(git -C "$PWD" rev-parse --show-toplevel)"
|
|
if ! cd "$REPO"; then
|
|
echo "ERROR: Failed to change to repo root: $REPO" >&2
|
|
exit 2
|
|
fi
|
|
echo "Operating from repo root (detected via current working dir): $REPO"
|
|
else
|
|
echo "ERROR: Could not determine the project root. Please run the script from the project root or supply --repo <path>." >&2
|
|
exit 2
|
|
fi
|
|
fi
|
|
|
|
if [[ -d "$VENV_PATH" ]]; then
|
|
# Detect whether the existing venv has a working python executable
|
|
VENV_PY=""
|
|
for cand in "$VENV_PATH/bin/python" "$VENV_PATH/bin/python3" "$VENV_PATH/Scripts/python.exe"; do
|
|
if [[ -x "$cand" ]]; then
|
|
VENV_PY="$cand"
|
|
break
|
|
fi
|
|
done
|
|
|
|
if [[ "$FORCE" == "true" ]]; then
|
|
echo "Removing existing venv $VENV_PATH"
|
|
rm -rf "$VENV_PATH"
|
|
else
|
|
if [[ -z "$VENV_PY" ]]; then
|
|
if [[ "$QUIET" == "true" ]]; then
|
|
echo "ERROR: Existing venv appears incomplete or broken (no python executable). Use --force to recreate." >&2
|
|
exit 4
|
|
fi
|
|
REPLY="$(prompt_yes_no "$VENV_PATH exists but appears invalid (no python executable). Overwrite to recreate? (y/N) " 'n')"
|
|
if [[ "$REPLY" != "y" && "$REPLY" != "Y" ]]; then
|
|
echo "Aborted."; exit 4
|
|
fi
|
|
rm -rf "$VENV_PATH"
|
|
else
|
|
if [[ "$QUIET" == "true" ]]; then
|
|
echo "Using existing venv at $VENV_PATH (quiet mode)"
|
|
else
|
|
REPLY="$(prompt_yes_no "$VENV_PATH already exists. Overwrite? (y/N) (default: use existing venv) " 'n')"
|
|
if [[ "$REPLY" == "y" || "$REPLY" == "Y" ]]; then
|
|
echo "Removing existing venv $VENV_PATH"
|
|
rm -rf "$VENV_PATH"
|
|
else
|
|
echo "Continuing using existing venv at $VENV_PATH"
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if [[ -d "$VENV_PATH" && -n "${VENV_PY:-}" && -x "${VENV_PY:-}" ]]; then
|
|
echo "Using existing venv at $VENV_PATH"
|
|
else
|
|
echo "Creating venv at $VENV_PATH"
|
|
$PY -m venv "$VENV_PATH"
|
|
VENV_PY="$VENV_PATH/bin/python"
|
|
fi
|
|
|
|
if [[ ! -x "$VENV_PY" ]]; then
|
|
echo "ERROR: venv python not found at $VENV_PY" >&2
|
|
exit 3
|
|
fi
|
|
|
|
if [[ "$NOINSTALL" != "true" ]]; then # If not explicitly requested, auto-select editable install for development checkouts (no prompt)
|
|
if [[ "$EDITABLE" != "true" ]]; then
|
|
if [[ -d "$REPO/.git" ]] || git -C "$REPO" rev-parse --is-inside-work-tree >/dev/null 2>&1; then
|
|
EDITABLE=true
|
|
echo "Detected development checkout; performing editable install for development"
|
|
fi
|
|
fi
|
|
echo "Upgrading pip, setuptools, wheel..."
|
|
"$VENV_PY" -m pip install -U pip setuptools wheel
|
|
|
|
if [[ "$EDITABLE" == "true" ]]; then
|
|
echo "Installing project in editable mode..."
|
|
"$VENV_PY" -m pip install -e "$REPO/scripts"
|
|
else
|
|
echo "Installing project..."
|
|
"$VENV_PY" -m pip install "$REPO/scripts"
|
|
fi
|
|
|
|
# Verify the installed CLI module can be imported. This helps catch packaging
|
|
# or installation problems early (e.g., missing modules or mispackaged project).
|
|
echo "Verifying installed CLI import..."
|
|
if "$VENV_PY" -c 'import importlib; importlib.import_module("scripts.cli_entry")' >/dev/null 2>&1; then
|
|
echo "OK: 'scripts.cli_entry' is importable in the venv."
|
|
|
|
# Ensure the top-level 'CLI' module is importable (required by legacy entrypoints).
|
|
# For PEP 660 editable installs, create a small .pth in the venv site-packages
|
|
# pointing at the repo root so `import CLI` works from any working directory.
|
|
if ! "$VENV_PY" -c 'import importlib; importlib.import_module("CLI")' >/dev/null 2>&1; then
|
|
echo "Top-level 'CLI' not importable; writing venv site-packages .pth pointing at repo root..." >&2
|
|
|
|
site_pkg_dir=$("$VENV_PY" - <<'PY'
|
|
import os, site, sysconfig
|
|
candidates = []
|
|
try:
|
|
candidates.append(sysconfig.get_paths().get('purelib'))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
candidates.extend(site.getsitepackages())
|
|
except Exception:
|
|
pass
|
|
for p in candidates:
|
|
if p and os.path.isdir(p):
|
|
print(p)
|
|
break
|
|
PY
|
|
)
|
|
|
|
if [[ -z "${site_pkg_dir:-}" || ! -d "${site_pkg_dir:-}" ]]; then
|
|
echo "ERROR: unable to determine venv site-packages directory to write .pth; aborting." >&2
|
|
exit 6
|
|
fi
|
|
|
|
pth_file="$site_pkg_dir/medeia_repo.pth"
|
|
printf "%s\n" "$REPO" > "$pth_file"
|
|
|
|
if "$VENV_PY" -c 'import importlib; importlib.import_module("CLI")' >/dev/null 2>&1; then
|
|
echo "OK: top-level 'CLI' is now importable (after .pth)." >&2
|
|
|
|
# Also verify we can run the packaged entrypoint using module form. If this fails
|
|
# it suggests site-packages/.pth wasn't processed reliably by the interpreter.
|
|
if "$VENV_PY" -m scripts.cli_entry --help >/dev/null 2>&1; then
|
|
echo "OK: 'python -m scripts.cli_entry' runs in the venv." >&2
|
|
else
|
|
echo "ERROR: 'python -m scripts.cli_entry' failed in the venv despite .pth being written; aborting." >&2
|
|
exit 6
|
|
fi
|
|
else
|
|
echo "ERROR: top-level 'CLI' still not importable after writing .pth ($pth_file)." >&2
|
|
exit 6
|
|
fi
|
|
fi
|
|
|
|
else
|
|
echo "WARNING: Could not import 'scripts.cli_entry' from the venv." >&2
|
|
echo "Action: Try running: $VENV_PY -m pip install -e \"$REPO/scripts\" or inspect the venv site-packages to verify the installation." >&2
|
|
fi
|
|
|
|
echo "Verifying environment for known issues (urllib3 compatibility)..."
|
|
if ! "$VENV_PY" -c 'from SYS.env_check import check_urllib3_compat; ok,msg = check_urllib3_compat(); print(msg); import sys; sys.exit(0 if ok else 2)'; then
|
|
echo "ERROR: Bootstrap detected a potentially broken 'urllib3' installation. See message above." >&2
|
|
echo "You can attempt to fix with:" >&2
|
|
echo " $VENV_PY -m pip uninstall urllib3-future -y" >&2
|
|
echo " $VENV_PY -m pip install --upgrade --force-reinstall urllib3" >&2
|
|
echo " $VENV_PY -m pip install niquests -U" >&2
|
|
echo "" >&2
|
|
if [[ "$FIX_URLLIB3" == "true" ]]; then
|
|
echo "Attempting automatic fix (--fix-urllib3 requested)..." >&2
|
|
if attempt_fix_urllib3 "$VENV_PY"; then
|
|
echo "Success: urllib3 issues resolved; continuing..." >&2
|
|
else
|
|
echo "ERROR: Automatic fix did not resolve the issue; inspect .pth files in site-packages (e.g., urllib3_future.pth) and remove them, then re-run with --fix-urllib3" >&2
|
|
exit 7
|
|
fi
|
|
else
|
|
if [[ "$QUIET" == "true" ]]; then
|
|
echo "ERROR: Bootstrap detected a potentially broken 'urllib3' installation. Use --fix-urllib3 to attempt an automatic fix." >&2
|
|
exit 7
|
|
fi
|
|
REPLY="$(prompt_yes_no 'Attempt automatic fix now? (y/N) ' 'n')"
|
|
if [[ "$REPLY" == "y" || "$REPLY" == "Y" ]]; then
|
|
AUTOFIX_INTERACTIVE=1
|
|
if attempt_fix_urllib3 "$VENV_PY"; then
|
|
echo "Success: urllib3 issues resolved; continuing..." >&2
|
|
else
|
|
echo "ERROR: Automatic fix did not resolve the issue; aborting." >&2
|
|
exit 7
|
|
fi
|
|
else
|
|
echo "Aborting bootstrap. Re-run with --fix-urllib3 to attempt an automatic fix or run the commands above." >&2
|
|
exit 7
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
# Install Playwright browsers (default: chromium) unless explicitly disabled
|
|
if [[ "$NO_PLAYWRIGHT" != "true" && "$NOINSTALL" != "true" ]]; then
|
|
echo "Ensuring Playwright browsers are installed (browsers=$PLAYWRIGHT_BROWSERS)..."
|
|
# Install package if missing in venv
|
|
if ! "$VENV_PY" -c 'import importlib, sys; importlib.import_module("playwright")' >/dev/null 2>&1; then
|
|
echo "'playwright' package not found in venv; installing via pip..."
|
|
"$VENV_PY" -m pip install playwright
|
|
fi
|
|
|
|
# Compute install behavior: 'all' means install all engines, otherwise split comma list
|
|
if [[ "$PLAYWRIGHT_BROWSERS" == "all" ]]; then
|
|
echo "Installing all Playwright browsers..."
|
|
"$VENV_PY" -m playwright install || echo "Warning: Playwright browser install failed" >&2
|
|
else
|
|
IFS=',' read -ra PWB <<< "$PLAYWRIGHT_BROWSERS"
|
|
for b in "${PWB[@]}"; do
|
|
b_trimmed=$(echo "$b" | tr -d '[:space:]')
|
|
if [[ -n "$b_trimmed" ]]; then
|
|
echo "Installing Playwright browser: $b_trimmed"
|
|
"$VENV_PY" -m playwright install "$b_trimmed" || echo "Warning: Playwright install for $b_trimmed failed" >&2
|
|
fi
|
|
done
|
|
fi
|
|
fi
|
|
else
|
|
echo "Skipping install (--no-install)"
|
|
fi
|
|
|
|
# Install Deno (official installer) - installed automatically
|
|
if command -v deno >/dev/null 2>&1; then
|
|
echo "Deno already installed: $(deno --version | head -n 1)"
|
|
else
|
|
echo "Installing Deno via official installer (https://deno.land)..."
|
|
if command -v curl >/dev/null 2>&1; then
|
|
curl -fsSL https://deno.land/install.sh | sh
|
|
elif command -v wget >/dev/null 2>&1; then
|
|
wget -qO- https://deno.land/install.sh | sh
|
|
else
|
|
echo "ERROR: curl or wget is required to install Deno automatically; please install Deno manually." >&2
|
|
fi
|
|
export DENO_INSTALL="${DENO_INSTALL:-$HOME/.deno}"
|
|
export PATH="$DENO_INSTALL/bin:$PATH"
|
|
if command -v deno >/dev/null 2>&1; then
|
|
echo "Deno installed: $(deno --version | head -n 1)"
|
|
else
|
|
echo "Warning: Deno installer completed but 'deno' not found on PATH; add $HOME/.deno/bin to your PATH or restart your shell." >&2
|
|
fi
|
|
fi
|
|
|
|
# Ensure mpv is available (used by some pipelines). Best-effort install if missing.
|
|
install_mpv_if_missing() {
|
|
if command -v mpv >/dev/null 2>&1; then
|
|
echo "mpv found: $(mpv --version 2>/dev/null | head -n 1 || echo 'mpv')"
|
|
return 0
|
|
fi
|
|
|
|
echo "mpv not found on PATH; attempting to install..." >&2
|
|
|
|
local prefix=""
|
|
if [[ $(id -u) -ne 0 ]]; then
|
|
if command -v sudo >/dev/null 2>&1; then
|
|
prefix="sudo"
|
|
else
|
|
echo "Warning: mpv is missing and sudo is not available; install mpv manually and ensure it's on PATH." >&2
|
|
return 0
|
|
fi
|
|
fi
|
|
|
|
# Try a few common package managers.
|
|
if command -v apt-get >/dev/null 2>&1; then
|
|
$prefix apt-get update -y >/dev/null 2>&1 || $prefix apt-get update || true
|
|
$prefix env DEBIAN_FRONTEND=noninteractive apt-get install -y mpv || true
|
|
elif command -v apt >/dev/null 2>&1; then
|
|
$prefix apt update -y >/dev/null 2>&1 || $prefix apt update || true
|
|
$prefix env DEBIAN_FRONTEND=noninteractive apt install -y mpv || true
|
|
elif command -v dnf >/dev/null 2>&1; then
|
|
$prefix dnf install -y mpv || true
|
|
elif command -v yum >/dev/null 2>&1; then
|
|
$prefix yum install -y mpv || true
|
|
elif command -v pacman >/dev/null 2>&1; then
|
|
$prefix pacman -S --noconfirm mpv || true
|
|
elif command -v zypper >/dev/null 2>&1; then
|
|
$prefix zypper --non-interactive install mpv || true
|
|
elif command -v apk >/dev/null 2>&1; then
|
|
$prefix apk add --no-interactive mpv || $prefix apk add mpv || true
|
|
elif command -v brew >/dev/null 2>&1; then
|
|
brew install mpv || true
|
|
else
|
|
echo "Warning: mpv is missing and no supported package manager was found. Install mpv manually and ensure it's on PATH." >&2
|
|
return 0
|
|
fi
|
|
|
|
if command -v mpv >/dev/null 2>&1; then
|
|
echo "mpv installed: $(mpv --version 2>/dev/null | head -n 1 || echo 'mpv')"
|
|
else
|
|
echo "Warning: attempted to install mpv but it is still not on PATH. Install mpv manually." >&2
|
|
fi
|
|
}
|
|
|
|
install_mpv_if_missing
|
|
|
|
if [[ "$DESKTOP" == "true" ]]; then
|
|
echo "Creating desktop launcher..."
|
|
EXEC_PATH="$VENV_PATH/bin/mm"
|
|
if [[ ! -x "$EXEC_PATH" ]]; then
|
|
# fallback to python -m
|
|
EXEC_PATH="$VENV_PY -m scripts.cli_entry"
|
|
fi
|
|
|
|
APPDIR="$HOME/.local/share/applications"
|
|
mkdir -p "$APPDIR"
|
|
DESKTOP_FILE="$APPDIR/medeia-macina.desktop"
|
|
cat > "$DESKTOP_FILE" <<EOF
|
|
[Desktop Entry]
|
|
Name=Medeia-Macina
|
|
Comment=Launch Medeia-Macina
|
|
Exec=$EXEC_PATH
|
|
Terminal=false
|
|
Type=Application
|
|
Categories=Utility;
|
|
EOF
|
|
chmod +x "$DESKTOP_FILE" || true
|
|
if [[ -d "$HOME/Desktop" ]]; then
|
|
cp "$DESKTOP_FILE" "$HOME/Desktop/"
|
|
chmod +x "$HOME/Desktop/$(basename "$DESKTOP_FILE")" || true
|
|
fi
|
|
echo "Desktop launcher created: $DESKTOP_FILE"
|
|
fi
|
|
|
|
# Install a global 'mm' launcher so it can be invoked from any shell.
|
|
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
|
|
REPO="$(cd "$SCRIPT_DIR/.." && pwd)"
|
|
USER_BIN="${XDG_BIN_HOME:-$HOME/.local/bin}"
|
|
# If running as root, prefer a system-wide location that is likely on PATH (/usr/local/bin)
|
|
if [[ $(id -u) -eq 0 && -w "/usr/local/bin" ]]; then
|
|
USER_BIN="/usr/local/bin"
|
|
fi
|
|
mkdir -p "$USER_BIN"
|
|
if [[ -f "$USER_BIN/mm" ]]; then
|
|
echo "Backing up existing $USER_BIN/mm to $USER_BIN/mm.bak.$(date +%s)"
|
|
mv "$USER_BIN/mm" "$USER_BIN/mm.bak.$(date +%s)"
|
|
fi
|
|
cat > "$USER_BIN/mm" <<'MM'
|
|
#!/usr/bin/env bash
|
|
set -e
|
|
|
|
# REPO is injected at install time; try to resolve canonical project root using
|
|
# git when available to avoid mistakenly selecting parent directories.
|
|
# Try to locate the repo root dynamically. Use the embedded __REPO__ value as a hint,
|
|
# but prefer to discover a repo from the current working directory or git.
|
|
REPO="__REPO__"
|
|
# If the placeholder does not appear to point at a repo, attempt discovery.
|
|
if [ ! -f "$REPO/CLI.py" ] && [ ! -f "$REPO/pyproject.toml" ] && [ ! -f "$REPO/scripts/pyproject.toml" ]; then
|
|
# First try to find a git toplevel from the current working directory.
|
|
if command -v git >/dev/null 2>&1; then
|
|
gitroot=$(git -C "$(pwd -P)" rev-parse --show-toplevel 2>/dev/null || true)
|
|
if [ -n "$gitroot" ]; then
|
|
REPO="$gitroot"
|
|
fi
|
|
fi
|
|
fi
|
|
# If still unresolved, walk up from the CWD looking for signs of the project.
|
|
if [ ! -f "$REPO/CLI.py" ] && [ ! -f "$REPO/pyproject.toml" ] && [ ! -f "$REPO/scripts/pyproject.toml" ]; then
|
|
CUR="$(pwd -P)"
|
|
while [ "$CUR" != "/" ] && [ "$CUR" != "" ]; do
|
|
if [ -f "$CUR/CLI.py" ] || [ -f "$CUR/pyproject.toml" ] || [ -f "$CUR/scripts/pyproject.toml" ]; then
|
|
REPO="$CUR"
|
|
break
|
|
fi
|
|
CUR="$(dirname "$CUR")"
|
|
done
|
|
fi
|
|
# At this point REPO may still be wrong if mm was invoked outside any project; keep the embedded path as a last resort.
|
|
|
|
VENV="$REPO/.venv"
|
|
# Ensure tools installed into the venv are discoverable to subprocess-based providers
|
|
export PATH="$VENV/bin:$PATH"
|
|
|
|
# Ensure top-level repo modules (e.g. CLI.py) are importable even when 'mm' is
|
|
# invoked from outside the repo directory.
|
|
export PYTHONPATH="$REPO${PYTHONPATH+:$PYTHONPATH}"
|
|
|
|
# Debug mode: set MM_DEBUG=1 to print repository, venv, and import diagnostics
|
|
if [ -n "${MM_DEBUG:-}" ]; then
|
|
echo "MM_DEBUG: diagnostics" >&2
|
|
echo "Resolved REPO: $REPO" >&2
|
|
echo "Resolved VENV: $VENV" >&2
|
|
echo "PYTHONPATH: ${PYTHONPATH:-}" >&2
|
|
echo "VENV exists: $( [ -d "$VENV" ] && echo yes || echo no )" >&2
|
|
echo "Candidates:" >&2
|
|
echo " VENV/bin/mm: $( [ -x "$VENV/bin/mm" ] && echo yes || echo no )" >&2
|
|
echo " VENV/bin/python3: $( [ -x "$VENV/bin/python3" ] && echo yes || echo no )" >&2
|
|
echo " VENV/bin/python: $( [ -x "$VENV/bin/python" ] && echo yes || echo no )" >&2
|
|
echo " system python3: $(command -v python3 || echo none)" >&2
|
|
echo " system python: $(command -v python || echo none)" >&2
|
|
for pycmd in "$VENV/bin/python3" "$VENV/bin/python" "$(command -v python3 2>/dev/null)" "$(command -v python 2>/dev/null)"; do
|
|
if [ -n "$pycmd" ] && [ -x "$pycmd" ]; then
|
|
echo "---- Testing with: $pycmd ----" >&2
|
|
"$pycmd" - <<'PY'
|
|
import sys, importlib, traceback, importlib.util
|
|
print('sys.executable:', sys.executable)
|
|
print('sys.path (first 8):', sys.path[:8])
|
|
for mod in ('CLI','medeia_macina','scripts.cli_entry'):
|
|
try:
|
|
spec = importlib.util.find_spec(mod)
|
|
print(mod, 'spec:', spec)
|
|
if spec:
|
|
m = importlib.import_module(mod)
|
|
print(mod, 'loaded at', getattr(m, '__file__', None))
|
|
except Exception:
|
|
print(mod, 'import failed')
|
|
traceback.print_exc()
|
|
PY
|
|
fi
|
|
done
|
|
echo "MM_DEBUG: end diagnostics" >&2
|
|
fi
|
|
|
|
# Prefer venv's python3, then venv's python (module invocation - more deterministic)
|
|
if [ -x "$VENV/bin/python3" ]; then
|
|
exec "$VENV/bin/python3" -m scripts.cli_entry "$@"
|
|
fi
|
|
if [ -x "$VENV/bin/python" ]; then
|
|
exec "$VENV/bin/python" -m scripts.cli_entry "$@"
|
|
fi
|
|
|
|
# Fallback: packaged console script in the venv (older pip-generated wrapper)
|
|
if [ -x "$VENV/bin/mm" ]; then
|
|
exec "$VENV/bin/mm" "$@"
|
|
fi
|
|
|
|
# Fallback to system python3, then system python (only if it's Python 3)
|
|
if command -v python3 >/dev/null 2>&1; then
|
|
exec python3 -m scripts.cli_entry "$@"
|
|
fi
|
|
if command -v python >/dev/null 2>&1; then
|
|
if python -c 'import sys; sys.exit(0 if sys.version_info[0] >= 3 else 1)'; then
|
|
exec python -m scripts.cli_entry "$@"
|
|
fi
|
|
fi
|
|
|
|
printf "Error: no suitable Python 3 interpreter found. Activate the venv with 'source %s/bin/activate' or install Python 3.\n" "$VENV" >&2
|
|
exit 127
|
|
MM
|
|
|
|
# Inject absolute repo path into the installed script so global launcher prefers the project venv
|
|
# Replace __REPO__ placeholder robustly using Python (preferred) else fallback to sed
|
|
if command -v python >/dev/null 2>&1; then
|
|
python - <<PY "$USER_BIN/mm" "$REPO"
|
|
import sys
|
|
fn=sys.argv[1]; repo=sys.argv[2]
|
|
with open(fn,'r', encoding='utf-8') as f:
|
|
s = f.read()
|
|
s = s.replace('__REPO__', repo)
|
|
with open(fn,'w', encoding='utf-8') as f:
|
|
f.write(s)
|
|
PY
|
|
else
|
|
escaped_repo=$(printf '%s' "$REPO" | sed -e 's/[\/&]/\\&/g')
|
|
sed -i "s|__REPO__|$escaped_repo|g" "$USER_BIN/mm" || true
|
|
fi
|
|
chmod +x "$USER_BIN/mm"
|
|
|
|
# Verify injection succeeded
|
|
if grep -Fq "$REPO" "$USER_BIN/mm"; then
|
|
echo "Installed global 'mm' launcher with REPO=$REPO"
|
|
else
|
|
echo "ERROR: failed to inject repository path into $USER_BIN/mm; inspect file: $USER_BIN/mm" >&2
|
|
fi
|
|
|
|
# Quick verification of the global launcher; helps catch packaging issues early.
|
|
if "$USER_BIN/mm" --help >/dev/null 2>&1; then
|
|
echo "Global 'mm' launcher verified: $USER_BIN/mm runs correctly."
|
|
else
|
|
# Capture error output to detect permission issues
|
|
err=$( { "$USER_BIN/mm" --help >/dev/null 2>&1 || true; } 2>&1 || true )
|
|
echo "Warning: Global 'mm' launcher failed to run in this shell. Error: ${err:-unknown}" >&2
|
|
|
|
# If we detected a permission denied (e.g., filesystem mounted noexec), fall back to user-local bin
|
|
if echo "${err}" | grep -qi "Permission denied" || [[ ${err:-} == *"Permission denied"* ]]; then
|
|
FALLBACK_BIN="$HOME/.local/bin"
|
|
mkdir -p "$FALLBACK_BIN"
|
|
# Backup the problematic file and copy to fallback (use a single timestamp variable)
|
|
backup="$USER_BIN/mm.broken.$(date +%s)"
|
|
if mv "$USER_BIN/mm" "$backup" 2>/dev/null; then
|
|
echo "Moved non-executable launcher to backup: $backup" >&2
|
|
cp "$backup" "$FALLBACK_BIN/mm" 2>/dev/null || true
|
|
chmod +x "$FALLBACK_BIN/mm" 2>/dev/null || true
|
|
USER_BIN="$FALLBACK_BIN"
|
|
echo "Installed launcher to fallback location: $USER_BIN/mm" >&2
|
|
echo "Ensure '$USER_BIN' is on your PATH (e.g. add 'export PATH=\"$USER_BIN:\$PATH\"' to your shell rc)." >&2
|
|
else
|
|
echo "Failed to move the launcher for fallback installation; manual inspection recommended: $USER_BIN/mm" >&2
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
# Ensure the user's bin is on PATH for future sessions by adding to ~/.profile if needed
|
|
if ! echo ":$PATH:" | grep -q ":$USER_BIN:"; then
|
|
PROFILE="$HOME/.profile"
|
|
if [ ! -f "$PROFILE" ]; then
|
|
if [ -f "$HOME/.bash_profile" ]; then
|
|
PROFILE="$HOME/.bash_profile"
|
|
elif [ -f "$HOME/.bashrc" ]; then
|
|
PROFILE="$HOME/.bashrc"
|
|
elif [ -f "$HOME/.zshrc" ]; then
|
|
PROFILE="$HOME/.zshrc"
|
|
else
|
|
PROFILE="$HOME/.profile"
|
|
fi
|
|
fi
|
|
|
|
if ! grep -q "ensure user local bin is on PATH" "$PROFILE" 2>/dev/null; then
|
|
cat >> "$PROFILE" <<PROFILE_SNIPPET
|
|
# Added by Medeia-Macina setup: ensure user local bin is on PATH
|
|
if [ -d "$HOME/.local/bin" ] && [[ ":$PATH:" != *":$HOME/.local/bin:"* ]]; then
|
|
PATH="$HOME/.local/bin:$PATH"
|
|
fi
|
|
PROFILE_SNIPPET
|
|
echo "Added $USER_BIN export to $PROFILE; restart your shell or source $PROFILE to use 'mm' from anywhere"
|
|
fi
|
|
fi
|
|
|
|
cat <<EOF
|
|
|
|
Bootstrap complete.
|
|
To activate the virtualenv:
|
|
source $VENV_PATH/bin/activate
|
|
To run the app:
|
|
$VENV_PATH/bin/mm # if installed as a console script
|
|
$VENV_PY -m scripts.cli_entry # alternative
|
|
|
|
Global launcher installed: $USER_BIN/mm
|
|
|
|
If the global 'mm' launcher fails to run, collect diagnostics with MM_DEBUG=1:
|
|
MM_DEBUG=1 mm
|
|
EOF
|