karnel-termux 4.18.2 → 4.18.3

package/README.md

@@ -8,7 +8,7 @@
 
 <p align="center">
   <a href="https://github.com/karnel-termuxOFC/karnel-termux">
-    <img src="https://img.shields.io/badge/version-4.18.2-0078D4?style=for-the-badge" alt="Version">
+    <img src="https://img.shields.io/badge/version-4.18.3-0078D4?style=for-the-badge" alt="Version">
   </a>
   <a href="https://www.npmjs.com/package/karnel-termux">
     <img src="https://img.shields.io/npm/v/karnel-termux?style=for-the-badge&logo=npm&color=cb3837" alt="npm">
@@ -78,7 +78,7 @@ Why it's great:
 ### Via checksummed GitHub release (recommended)
 
 ```bash
-version=4.18.2
+version=4.18.3
 tmpdir=$(mktemp -d) && trap 'rm -rf "$tmpdir"' EXIT
 base="https://github.com/karnel-termuxOFC/karnel-termux/releases/download/v$version"
 curl -fsSL "$base/karnel-termux-install.sh" -o "$tmpdir/karnel-termux-install.sh"

package/docs/CHANGELOG.md

@@ -6,6 +6,14 @@ layout: base
 
 # Documentation Changelog
 
+## 4.18.3
+
+- **Every command that installs something now adapts what it put on PATH.** The dispatcher brackets `install`, `update`, `upgrade`, `reinstall`, `restore`, `plugin`, `supabase`, `deploy`, `voice`, `robin`, `pg`, `open` and `init` with a snapshot of the writable parts of PATH (`path|size|mtime` per entry) and afterwards adapts exactly the entries that appeared or changed. That closes the gap the registries could never close: an installer that never calls the compatibility layer, one that names a command its registry does not mention, and a file restored from an archive with its original timestamp all end up wrapped anyway. Sweeping the prefix instead was measured on this device at 51 seconds of `readelf` over 800 entries (and 875 seconds with `readelf -l`); diffing a snapshot takes 60 ms and touches nothing the command did not write. The exit code of the command is taken before adaptation and returned unchanged.
+- **The AI reinstall fallback adapts what it installed.** `_run_ai_tool_action` called `$install_fn` and returned without passing through its adapt call, so those binaries stayed unwrapped.
+- **An install can no longer report success for a command that does not start.** A device audit of all 169 catalogued tools found 21 installed and 147 absent — and exactly one of them dead: `$PREFIX/bin/freebuff` had been left as npm's shim, which exits 1 on Termux with "Unsupported platform: android arm64", while `karnel install ai --freebuff` still reported "already installed". Both paths of `install_freebuff` now prove the entry runs before returning, the same way `_fix_freebuff_runtime` already proves the runtime does. The audit is green afterwards: freebuff `0.2.22`, bun `1.4.2`, supabase `2.20.8`, zero broken.
+- **The compatibility suite is part of the test run.** `tests/android-compat.sh` had never been listed in `tests/run.sh`, so its cases only ever ran by hand; it now runs in `npm test` and in CI, and every other file under `tests/` was checked against the list while adding it.
+- **Tests.** Five new cases in `tests/android-compat.sh` (a binary created during a command, a binary rewritten in place, only the entries that changed, an exit code that cannot change, and the dispatcher wiring itself) plus two in `tests/ai-installer-hardening.sh` (a dead freebuff entry fails, a live one is accepted), taking the suites to 28 and 11 cases. Every branch was proven to fail first: dropping the adapt call fails 1 case, dropping the snapshot fails 1, making `compat_adapt_since` a no-op fails 2, removing the AI fallback's adapt fails 1, removing the already-installed verification fails 1, and turning that verification into a no-op fails both new freebuff cases.
+
 ## 4.18.2
 
 - **Wrappers no longer hand a preload to glibc.** `login(1)` exports `LD_PRELOAD=$PREFIX/lib/libtermux-exec-ld-preload.so`, a bionic object; glibc's `ld.so` cannot load it, so every wrapped tool died before `main()` with `.../glibc/lib/libc.so: invalid ELF header`. Tier 3's own preload was fatal in the other direction: exporting the glibc `libtermux-exec.so` shim left every bionic child of the tool failing with `library "libc.so.6" not found`. Every wrapper now starts with `unset LD_PRELOAD`, and tier 3 exports `PATH` only.

package/karnel/RELEASE_COMMIT

@@ -1 +1 @@
-fff0d351f344943ef88e0745cc0f7f56c7aaf970
+4f1840c76ffba58dde286b506142fa1f9e5ee1d8

package/karnel/cli/karnel.sh

@@ -2,6 +2,7 @@
 
 import "@/utils/log"
 import "@/utils/colors"
+import "@/utils/compat"
 
 : "${KARNEL_VERSION:=unknown}"
 
@@ -67,8 +68,23 @@ _karnel_dispatch() {
 
   if [[ -f "$command_file" ]]; then
     import "@/cli/commands/$cmd"
+    # Every command that can put a binary on PATH is bracketed by a snapshot
+    # of PATH, and whatever changed inside it is adapted afterwards. That is
+    # what makes the layer cover *all* tools: an installer that never calls
+    # compat itself, one that names a command its registry does not mention,
+    # and one that restores a file from an archive all end up here anyway.
+    local compat_snap=""
+    case "$cmd" in
+    install | update | upgrade | reinstall | restore | plugin | supabase | deploy | voice | robin | pg | open | init)
+      compat_snap="$(compat_path_snapshot 2>/dev/null)" || compat_snap=""
+      ;;
+    esac
     "${cmd}_main" "$@"
-    return $?
+    local cmd_rc=$?
+    if [[ -n "$compat_snap" ]]; then
+      compat_adapt_since "$compat_snap" || true
+    fi
+    return "$cmd_rc"
   fi
 
   import "@/tools/plugins/install"

package/karnel/tools/ai/all.sh

@@ -230,6 +230,13 @@ _run_ai_tool_action() {
     return "$uninstall_rc"
   fi
   "$install_fn"
+  local install_rc=$?
+  # The fallback path never passes through _run_ai_tool_action's adapt call,
+  # so the binaries this install just wrote would stay unwrapped.
+  if ((install_rc == 0)); then
+    _ai_tool_compat_adapt "$id"
+  fi
+  return "$install_rc"
 }
 
 _all_ai_tools_action() {

package/karnel/tools/ai/freebuff/install.sh

@@ -23,6 +23,7 @@ install_freebuff() {
     log_info "Freebuff is already installed"
     _fix_freebuff_runtime || true
     _install_freebuff_entry || true
+    _verify_freebuff_entry || return 1
     return 2
   fi
 
@@ -42,6 +43,7 @@ install_freebuff() {
   _fix_freebuff_shebang || return 1
   _fix_freebuff_runtime || return 1
   _install_freebuff_entry || return 1
+  _verify_freebuff_entry || return 1
   log_success "Freebuff installed"
 }
 
@@ -96,6 +98,25 @@ _freebuff_binary_runs() {
   ((rc == 0))
 }
 
+# npm recreates its shim at $PREFIX/bin/freebuff on every global operation, and
+# that shim cannot start on Android - so an install can look successful while
+# the command itself is dead. Every path therefore proves the entry runs before
+# reporting success, the same way _fix_freebuff_runtime proves the runtime does.
+_verify_freebuff_entry() {
+  local entry rc=0
+  entry="$(command -v freebuff 2>/dev/null)"
+  if [[ -z "$entry" || ! -e "$entry" ]]; then
+    log_error "Freebuff is not on PATH after install"
+    return 1
+  fi
+  { timeout 30 "$entry" --version >/dev/null 2>&1; rc=$?; } 2>/dev/null
+  if ((rc != 0)); then
+    log_error "Freebuff does not run after install (exit $rc)"
+    return 1
+  fi
+  return 0
+}
+
 _freebuff_target_key() {
   case "$(uname -m)" in
   aarch64 | arm64) printf 'linux-arm64\n' ;;

package/karnel/utils/compat.sh

@@ -534,13 +534,11 @@ compat_fix_shebangs() {
   printf '%s\n' "$fixed"
 }
 
-# Adapts whatever a tool has just put on PATH. Wraps a glibc ELF so the
-# kernel can start it; leaves native binaries, scripts and text files alone.
-# Always returns 0: adaptation is an optimisation, never a reason to fail an
-# install or an update.
-compat_adapt_installed() {
-  local tool="$1" path real
-  path="$(command -v -- "$tool" 2>/dev/null)" || return 0
+# Adapts one resolved path. Wraps a glibc ELF so the kernel can start it;
+# leaves native binaries, scripts and text files alone. Always returns 0:
+# adaptation is an optimisation, never a reason to fail an install.
+_compat_adapt_path() {
+  local path="$1" real
   [[ -n "$path" ]] || return 0
   real="$(readlink -f -- "$path" 2>/dev/null || printf '%s' "$path")"
   [[ -f "$real" && -x "$real" ]] || return 0
@@ -560,6 +558,57 @@ compat_adapt_installed() {
   return 0
 }
 
+# Adapts whatever a tool has just put on PATH.
+compat_adapt_installed() {
+  local tool="$1" path
+  path="$(command -v -- "$tool" 2>/dev/null)" || return 0
+  [[ -n "$path" ]] || return 0
+  _compat_adapt_path "$path"
+}
+
+# Records every direct entry of the writable parts of PATH as
+# "path|size|mtime", printed to a temporary file. Taken before a command runs
+# so the layer can afterwards adapt exactly what that command touched.
+#
+# Sweeping the whole prefix instead would need readelf on every ELF, which
+# measures 60+ seconds over a Termux bin directory of 800 entries; diffing a
+# snapshot adapts only the handful of files that actually changed. It also
+# means no installer has to declare its binary names: a tool that installs a
+# command its registry does not mention is still covered, and a file restored
+# from an archive with its original mtime is caught by being a new path.
+compat_path_snapshot() {
+  local dir tmp
+  tmp="$(mktemp "${TMPDIR:-${KARNEL_CACHE:-/tmp}}/karnel-compat-snap.XXXXXX" 2>/dev/null)" || return 1
+  local IFS=':'
+  for dir in $PATH; do
+    [[ -n "$dir" && -d "$dir" && -w "$dir" ]] || continue
+    find "$dir" -maxdepth 1 \( -type f -o -type l \) -printf '%p|%s|%T@\n' 2>/dev/null || true
+  done | sort >"$tmp" || true
+  printf '%s\n' "$tmp"
+}
+
+# Adapts every PATH entry that appeared or changed since a snapshot, then
+# removes both files. Returns 0 unconditionally.
+compat_adapt_since() {
+  local snap="$1" tmp dir path
+  [[ -f "$snap" ]] || return 0
+  tmp="$(mktemp "${TMPDIR:-${KARNEL_CACHE:-/tmp}}/karnel-compat-now.XXXXXX" 2>/dev/null)" || {
+    rm -f -- "$snap"
+    return 0
+  }
+  local IFS=':'
+  for dir in $PATH; do
+    [[ -n "$dir" && -d "$dir" && -w "$dir" ]] || continue
+    find "$dir" -maxdepth 1 \( -type f -o -type l \) -printf '%p|%s|%T@\n' 2>/dev/null || true
+  done | sort >"$tmp" || true
+  while IFS= read -r path; do
+    [[ -n "$path" ]] || continue
+    _compat_adapt_path "$path" || true
+  done < <(comm -13 -- "$snap" "$tmp" 2>/dev/null | cut -d'|' -f1)
+  rm -f -- "$snap" "$tmp"
+  return 0
+}
+
 # Human-readable one-liner for doctor output.
 compat_describe() {
   local file="$1" kind interp real

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "karnel-termux",
-  "version": "4.18.2",
+  "version": "4.18.3",
   "description": "Modular Dev Environment for Termux — install languages, databases, AI agents, editors, and more with one command",
   "bin": {
     "karnel": "karnel/bin/karnel"