karnel-termux 4.9.0 → 4.9.2

package/karnel/tools/ai/cline/bin/cline

@@ -0,0 +1,28 @@
+#!/data/data/com.termux/files/usr/bin/bash
+
+UBUNTU_ROOTFS="__UBUNTU_ROOTFS__"
+
+EXCLUDE_REGEX="^(PATH|LD_PRELOAD|LD_LIBRARY_PATH|PREFIX|HOME|PWD|OLDPWD|SHELL|IFS|_|SHLVL|PROMPT_COMMAND|TERMCAP|LS_COLORS|TERM)="
+
+ENV_ARGS=()
+while IFS= read -r line; do
+	if [[ -n "$line" && ! "$line" =~ $EXCLUDE_REGEX ]]; then
+		ENV_ARGS+=("--env" "$line")
+	fi
+done < <(env)
+
+ENV_ARGS+=(
+	"--env" "SSL_CERT_FILE=/etc/ssl/certs/ca-certificates.crt"
+	"--env" "TERM=$TERM"
+	"--env" "HOME=/root"
+)
+
+unset LD_PRELOAD
+proot-distro login \
+	"${ENV_ARGS[@]}" \
+	--termux-home \
+	--shared-tmp \
+	--bind "$UBUNTU_ROOTFS/root/.cline:/root/.cline" \
+	--work-dir $PWD \
+	ubuntu \
+	-- /root/.cline/bin/cline "$@"

package/karnel/tools/ai/cline/helper/cline_helper.c

@@ -0,0 +1,54 @@
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <libgen.h>
+#include <limits.h>
+#include <stdio.h>
+
+int main(int argc, char** argv) {
+    // 1. Clear conflicting Android Bionic preloads and search paths
+    unsetenv("LD_PRELOAD");
+    unsetenv("LD_LIBRARY_PATH");
+
+    // 2. Set dynamic resolver and SSL configurations for Termux environment
+    setenv("SSL_CERT_FILE", "/data/data/com.termux/files/usr/etc/tls/cert.pem", 1);
+
+    // 3. Resolve current executable directory
+    char exec_path[PATH_MAX];
+    ssize_t len = readlink("/proc/self/exe", exec_path, sizeof(exec_path) - 1);
+    if (len == -1) {
+        return 1;
+    }
+    exec_path[len] = '\0';
+    char* dir = dirname(exec_path);
+
+    // 4. Construct paths for the glibc loader and the real binary
+    char* loader = "/data/data/com.termux/files/usr/glibc/lib/ld-linux-aarch64.so.1";
+    char real_bin[] = "/data/data/com.termux/files/home/.local/share/karnel-data/cline/cline";
+    char lib_path[] = "/data/data/com.termux/files/usr/glibc/lib";
+
+    // 5. Construct argument array for execv
+    // Format: [loader, --library-path, lib_path, real_bin, ...original_args]
+    char** new_argv = malloc((argc + 4) * sizeof(char*));
+    if (!new_argv) {
+        return 1;
+    }
+
+    new_argv[0] = loader;
+    new_argv[1] = "--library-path";
+    new_argv[2] = lib_path;
+    new_argv[3] = real_bin;
+
+    for (int i = 1; i < argc; i++) {
+        new_argv[i + 3] = argv[i];
+    }
+    new_argv[argc + 3] = NULL;
+
+    // 6. Execute the glibc loader to run the real binary
+    execv(loader, new_argv);
+
+    // If execv returns, an error occurred
+    perror("execv");
+    free(new_argv);
+    return 1;
+}

package/karnel/tools/ai/gga/termux.patch

@@ -0,0 +1,70 @@
+#!/usr/bin/env bash
+# Parches Termux para gentleman-guardian-angel
+# Se aplica al repo upstream después del clone, antes del install.sh
+set -e
+
+REPO_DIR="$1"
+[ -d "$REPO_DIR" ] || { echo "Usage: $0 <repo-dir>" >&2; exit 1; }
+
+# --- install.sh ---
+# 1) Fix shebang for Termux
+sed -i '1s|#!/usr/bin/env bash|#!/data/data/com.termux/files/usr/bin/bash|' "$REPO_DIR/install.sh"
+
+# 2) Agregar detección de Termux en detect_os()
+sed -i '/^  if \[\[ -n "\${GGA_TEST_OS:-}" \]\]; then$/,/^$/{
+  /^$/a\
+\
+  if [[ -n "${TERMUX_VERSION:-}" ]]; then\
+    echo "termux"\
+    return 0\
+  fi
+}' "$REPO_DIR/install.sh"
+
+# 3) Agregar TERMUX para INSTALL_DIR (después del bloque windows)
+sed -i '/INSTALL_DIR="\$HOME\/bin"/,/elif \[\[ -w "\/usr\/local\/bin" \]\]/{
+  /elif \[\[ -w "\/usr\/local\/bin" \]\]/i\
+elif [[ "$GGA_OS" == "termux" ]]; then\
+    INSTALL_DIR="${PREFIX:-/data/data/com.termux/files/usr}/bin"\
+    mkdir -p "$INSTALL_DIR"
+}' "$REPO_DIR/install.sh"
+
+# 4) Agregar TERMUX para LIB_INSTALL_DIR (después del bloque windows)
+sed -i '/LIB_INSTALL_DIR="\$HOME\/bin\/lib\/gga"/,/else$/{
+  /else$/i\
+elif [[ "$GGA_OS" == "termux" ]]; then\
+    LIB_INSTALL_DIR="${PREFIX:-/data/data/com.termux/files/usr}/share/gga/lib"
+}' "$REPO_DIR/install.sh"
+
+# --- bin/gga ---
+# 5) Fix shebang for Termux (/usr/bin/env doesn't exist)
+sed -i '1s|#!/usr/bin/env bash|#!/data/data/com.termux/files/usr/bin/bash|' "$REPO_DIR/bin/gga"
+
+# 6) Agregar detección de Termux en detect_os()
+sed -i '/^detect_os() {$/,/^}$/{
+  /^  case "\$(uname -s)" in$/i\
+  if [[ -n "${TERMUX_VERSION:-}" ]]; then\
+    echo "termux"\
+    return 0\
+  fi
+}' "$REPO_DIR/bin/gga"
+
+# --- uninstall.sh ---
+# 7) Fix shebang for Termux
+sed -i '1s|#!/usr/bin/env bash|#!/data/data/com.termux/files/usr/bin/bash|' "$REPO_DIR/uninstall.sh"
+
+# 8) Agregar detección de Termux en detect_os()
+sed -i '/^detect_os() {$/,/^}$/{
+  /^  case "\$(uname -s)" in$/i\
+  if [[ -n "${TERMUX_VERSION:-}" ]]; then\
+    echo "termux"\
+    return 0\
+  fi
+}' "$REPO_DIR/uninstall.sh"
+
+# 9) Agregar Termux path al array LOCATIONS
+sed -i '/  "\$HOME\/bin\/gga"/a\  "${PREFIX:-/data/data/com.termux/files/usr}/bin/gga"' "$REPO_DIR/uninstall.sh"
+
+# 10) Agregar Termux lib path al loop de limpieza
+sed -i 's|for lib_dir in "\$HOME/.local/share/gga" "\$HOME/bin/lib/gga";|for lib_dir in "$HOME/.local/share/gga" "$HOME/bin/lib/gga" "${PREFIX:-/data/data/com.termux/files/usr}/share/gga";|' "$REPO_DIR/uninstall.sh"
+
+echo "Termux patches applied successfully"

package/karnel/tools/lang/bun/bin/bunx

@@ -0,0 +1,27 @@
+#!/data/data/com.termux/files/usr/bin/bash
+
+UBUNTU_ROOTFS="__UBUNTU_ROOTFS__"
+
+EXCLUDE_REGEX="^(PATH|LD_PRELOAD|LD_LIBRARY_PATH|PREFIX|HOME|PWD|OLDPWD|SHELL|IFS|_|SHLVL|PROMPT_COMMAND|TERMCAP|LS_COLORS|TERM)="
+
+ENV_ARGS=()
+while IFS= read -r line; do
+	if [[ -n "$line" && ! "$line" =~ $EXCLUDE_REGEX ]]; then
+		ENV_ARGS+=("--env" "$line")
+	fi
+done < <(env)
+
+ENV_ARGS+=(
+	"--env" "SSL_CERT_FILE=/etc/ssl/certs/ca-certificates.crt"
+	"--env" "TERM=$TERM"
+	"--env" "HOME=/root"
+)
+
+unset LD_PRELOAD
+proot-distro login \
+	"${ENV_ARGS[@]}" \
+	--termux-home \
+	--shared-tmp \
+	--work-dir $PWD \
+	ubuntu \
+	-- /usr/local/bin/bun "$@"

package/karnel/tools/lang/bun/src/bun-android-shim.c

@@ -0,0 +1,481 @@
+/**
+ * bun-android-shim.c — LD_PRELOAD shim for Bun on Android/Termux
+ *
+ * Dual purpose:
+ *
+ * 1. opendir/openat64 interception for bionic:
+ *    Bun's project-root discovery traverses up the directory tree.
+ *    On Termux, Android's sandbox makes /data/ and /data/data/
+ *    readable at the syscall level but returns "Permission denied"
+ *    or causes Bun to abort with "Cannot read directory /data/".
+ *    This shim intercepts opendir/openat64 and returns ENOENT
+ *    for these paths, so Bun's traversal stops at the sandbox
+ *    boundary instead of crashing.
+ *
+ * 2. mmap fix for compiled standalone binaries:
+ *    `bun build --compile` produces ELF binaries where the embedded
+ *    Bun runtime contains hardcoded (non-relocated) absolute pointers
+ *    to the `.bun` section and other data sections (e.g., 0x5730000).
+ *    On PIE loading, these addresses are never mapped, causing SEGFAULT.
+ *    The constructor maps critical sections at their ELF virtual addresses
+ *    via MAP_FIXED so the pointers resolve correctly.
+ */
+
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <stdint.h>
+#include <stdarg.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <dlfcn.h>
+#include <dirent.h>
+
+/* ================================================================
+ * PART 1: opendir/openat64 interception
+ * ================================================================ */
+
+/* CWD captured at shim load time — used as redirect for inaccessible ancestors */
+static char shim_cwd[4096] = {0};
+static int shim_cwd_len = 0;
+
+/* Original functions (resolved via dlsym) */
+typedef DIR *(*opendir_fn_t)(const char *);
+typedef int (*open_fn_t)(const char *, int, ...);
+typedef int (*openat64_fn_t)(int, const char *, int, ...);
+static opendir_fn_t real_opendir = NULL;
+static openat64_fn_t real_openat64 = NULL;
+
+/* Check if a path is an inaccessible ancestor that needs redirect */
+static int needs_redirect(const char *path) {
+    if (!path || path[0] == '\0') return 0;
+    /* Redirect "/", "/data/", and "/data/data/" to CWD */
+    if (path[0] == '/' && path[1] == '\0') return 1;  /* exactly "/" */
+    if (strncmp(path, "/data/", 6) == 0) {
+        /* Don't redirect if it's the Termux sandbox itself */
+        if (strncmp(path, "/data/data/com.termux", 21) == 0)
+            return 0;
+        return 1;
+    }
+    return 0;
+}
+
+/* Redirect open to CWD — uses a fresh dlsym so it works from any interceptor */
+static int open_cwd_redirect_impl(int flags, mode_t mode) {
+    if (shim_cwd_len == 0) {
+        errno = ENOENT;
+        return -1;
+    }
+    open_fn_t real = (open_fn_t)dlsym(RTLD_NEXT, "open");
+    if (!real) {
+        errno = ENOENT;
+        return -1;
+    }
+    return real(shim_cwd, flags, mode);
+}
+
+static int should_block(const char *path) {
+    /* Block exact "/data/" paths that are NOT under /data/data/com.termux */
+    if (path && strncmp(path, "/data/", 6) == 0) {
+        if (strncmp(path, "/data/data/com.termux", 21) != 0)
+            return 1;
+    }
+    return 0;
+}
+
+DIR *opendir(const char *path) {
+    if (!real_opendir) {
+        real_opendir = (opendir_fn_t)dlsym(RTLD_NEXT, "opendir");
+    }
+    /* Redirect blocked ancestors to CWD so bun's directory walk succeeds */
+    if (needs_redirect(path) && shim_cwd_len > 0) {
+        return real_opendir(shim_cwd);
+    }
+    if (should_block(path)) {
+        errno = ENOENT;
+        return NULL;
+    }
+    return real_opendir(path);
+}
+
+int openat64(int fd, const char *path, int flags, ...) {
+    if (!real_openat64) {
+        real_openat64 = (openat64_fn_t)dlsym(RTLD_NEXT, "openat64");
+    }
+
+    /* Pass mode if O_CREAT is set */
+    mode_t mode = 0;
+    if (flags & O_CREAT) {
+        va_list ap;
+        va_start(ap, flags);
+        mode = (mode_t)va_arg(ap, int);
+        va_end(ap);
+    }
+
+    /* Redirect blocked ancestors to CWD so bun's directory walk succeeds */
+    if (needs_redirect(path) && shim_cwd_len > 0) {
+        return real_openat64(fd, shim_cwd, flags, mode);
+    }
+    if (should_block(path)) {
+        errno = ENOENT;
+        return -1;
+    }
+    return real_openat64(fd, path, flags, mode);
+}
+
+
+/* ================================================================
+ * open/open64 interception — Android sandbox blocks open("/")
+ *
+ * Bun v1.3.14's resolver calls openat64(AT_FDCWD, "/", O_DIRECTORY)
+ * as part of its directory info walk.  The kernel returns EACCES
+ * because Android's sandbox restricts root access.
+ *
+ * Returning EACCES or ENOENT both cause bun's resolver to abort
+ * with "CouldntReadCurrentDirectory" (bun treats ANY ancestor-open
+ * failure as fatal in v1.3.14 — this is fixed in a later commit,
+ * PR #28782, which skips permission-denied ancestors).
+ *
+ * Our fix: redirect "/" to the current working directory instead of
+ * failing.  Bun gets a valid directory fd, completes its walk, and
+ * doesn't crash.  The entries read will be the CWD entries (not root
+ * entries), but that is harmless since root never has bun config files.
+ * ================================================================ */
+
+static open_fn_t real_open = NULL;
+
+int open(const char *path, int flags, ...) {
+    if (!real_open)
+        real_open = (open_fn_t)dlsym(RTLD_NEXT, "open");
+
+    /* Redirect blocked ancestors to CWD so bun's directory walk succeeds */
+    if (needs_redirect(path)) {
+        mode_t m = 0;
+        if (flags & O_CREAT) {
+            va_list ap;
+            va_start(ap, flags);
+            m = (mode_t)va_arg(ap, int);
+            va_end(ap);
+        }
+        return open_cwd_redirect_impl(flags, m);
+    }
+    if (should_block(path)) {
+        errno = ENOENT;
+        return -1;
+    }
+
+    mode_t mode = 0;
+    if (flags & O_CREAT) {
+        va_list ap;
+        va_start(ap, flags);
+        mode = (mode_t)va_arg(ap, int);
+        va_end(ap);
+    }
+    return real_open(path, flags, mode);
+}
+
+int open64(const char *path, int flags, ...) {
+    if (!real_open)
+        real_open = (open_fn_t)dlsym(RTLD_NEXT, "open");
+
+    /* Redirect blocked ancestors to CWD so bun's directory walk succeeds */
+    if (needs_redirect(path)) {
+        mode_t m = 0;
+        if (flags & O_CREAT) {
+            va_list ap;
+            va_start(ap, flags);
+            m = (mode_t)va_arg(ap, int);
+            va_end(ap);
+        }
+        return open_cwd_redirect_impl(flags, m);
+    }
+    if (should_block(path)) {
+        errno = ENOENT;
+        return -1;
+    }
+
+    mode_t mode = 0;
+    if (flags & O_CREAT) {
+        va_list ap;
+        va_start(ap, flags);
+        mode = (mode_t)va_arg(ap, int);
+        va_end(ap);
+    }
+    return real_open(path, flags, mode);
+}
+
+
+/* ================================================================
+ * getcwd fallback — Android's getcwd() fails with
+ * "CouldntReadCurrentDirectory" when the process was started via
+ * execv() with a relative cwd.  Read /proc/self/cwd as fallback.
+ * ================================================================ */
+
+typedef char *(*getcwd_fn_t)(char *, size_t);
+static getcwd_fn_t real_getcwd = NULL;
+
+char *getcwd(char *buf, size_t size) {
+    if (!real_getcwd)
+        real_getcwd = (getcwd_fn_t)dlsym(RTLD_NEXT, "getcwd");
+
+    /* Try real getcwd first */
+    char *result = real_getcwd(buf, size);
+    if (result) return result;
+
+    /* Fallback: read /proc/self/cwd symlink */
+    ssize_t len = readlink("/proc/self/cwd", buf, size - 1);
+    if (len < 0) return NULL;
+    buf[len] = '\0';
+    return buf;
+}
+
+
+/* ================================================================
+ * linkat/link → copy fallback
+ *
+ * Android restricts hardlink creation across mount points and app
+ * sandboxes.  Bun's installer tries linkat() first; when the kernel
+ * returns EACCES/EPERM, Bun aborts instead of falling back to copy.
+ * This interception converts hardlink requests into copy_file_range
+ * (or read+write fallback), so Bun's install flow succeeds.
+ * ================================================================ */
+
+#include <sys/sendfile.h>
+
+static int copy_file(const char *src, const char *dst) {
+    int fd_in = open(src, O_RDONLY);
+    if (fd_in < 0) return -1;
+
+    struct stat st;
+    if (fstat(fd_in, &st) < 0) { close(fd_in); return -1; }
+
+    int fd_out = open(dst, O_WRONLY | O_CREAT | O_TRUNC, st.st_mode);
+    if (fd_out < 0) { close(fd_in); return -1; }
+
+    ssize_t sent = 0;
+    off_t offset = 0;
+    while (offset < st.st_size) {
+        sent = sendfile(fd_out, fd_in, &offset, st.st_size - offset);
+        if (sent <= 0) break;
+    }
+
+    close(fd_in);
+    close(fd_out);
+    return (offset == st.st_size) ? 0 : -1;
+}
+
+int linkat(int olddirfd, const char *oldpath,
+           int newdirfd, const char *newpath, int flags) {
+    /* Resolve absolute paths for copy fallback */
+    char src[PATH_MAX], dst[PATH_MAX];
+
+    if (oldpath && oldpath[0] != '/') {
+        char dir[PATH_MAX];
+        if (olddirfd == AT_FDCWD) {
+            if (getcwd(dir, sizeof(dir)) == NULL) return -1;
+        } else {
+            char fdpath[32];
+            snprintf(fdpath, sizeof(fdpath), "/proc/self/fd/%d", olddirfd);
+            ssize_t n = readlink(fdpath, dir, sizeof(dir) - 1);
+            if (n < 0) return -1;
+            dir[n] = '\0';
+        }
+        snprintf(src, sizeof(src), "%s/%s", dir, oldpath);
+    } else {
+        snprintf(src, sizeof(src), "%s", oldpath ? oldpath : "");
+    }
+
+    if (newpath && newpath[0] != '/') {
+        char dir[PATH_MAX];
+        if (newdirfd == AT_FDCWD) {
+            if (getcwd(dir, sizeof(dir)) == NULL) return -1;
+        } else {
+            char fdpath[32];
+            snprintf(fdpath, sizeof(fdpath), "/proc/self/fd/%d", newdirfd);
+            ssize_t n = readlink(fdpath, dir, sizeof(dir) - 1);
+            if (n < 0) return -1;
+            dir[n] = '\0';
+        }
+        snprintf(dst, sizeof(dst), "%s/%s", dir, newpath);
+    } else {
+        snprintf(dst, sizeof(dst), "%s", newpath ? newpath : "");
+    }
+
+    return copy_file(src, dst);
+}
+
+int link(const char *oldpath, const char *newpath) {
+    return copy_file(oldpath, newpath);
+}
+
+/* ================================================================
+ * PART 3: mmap fix for compiled standalone binaries
+ * ================================================================ */
+
+/* ELF64 structures */
+typedef struct {
+    unsigned char e_ident[16];
+    uint16_t e_type;
+    uint16_t e_machine;
+    uint32_t e_version;
+    uint64_t e_entry;
+    uint64_t e_phoff;
+    uint64_t e_shoff;
+    uint32_t e_flags;
+    uint16_t e_ehsize;
+    uint16_t e_phentsize;
+    uint16_t e_phnum;
+    uint16_t e_shentsize;
+    uint16_t e_shnum;
+    uint16_t e_shstrndx;
+} Elf64_Ehdr;
+
+typedef struct {
+    uint32_t sh_name;
+    uint32_t sh_type;
+    uint64_t sh_flags;
+    uint64_t sh_addr;
+    uint64_t sh_offset;
+    uint64_t sh_size;
+    uint32_t sh_link;
+    uint32_t sh_info;
+    uint64_t sh_addralign;
+    uint64_t sh_entsize;
+} Elf64_Shdr;
+
+/* Known hardcoded addresses in Bun standalone binaries
+ * These are the ELF virtual addresses that Bun's embedded runtime
+ * references with non-relocated absolute pointers.
+ * Add more as discovered from crash reports. */
+static const uint64_t known_addresses[] = {
+    0x5730000,  /* .bun section — embedded source code metadata */
+};
+static const int num_known_addresses =
+    sizeof(known_addresses) / sizeof(known_addresses[0]);
+
+static inline uint64_t page_align_down(uint64_t addr) {
+    return addr & ~(uint64_t)(0xFFF);
+}
+
+static inline uint64_t page_align_up(uint64_t addr) {
+    return (addr + 0xFFF) & ~(uint64_t)(0xFFF);
+}
+
+/* Find a section by name in the section header string table */
+static int find_section_by_name(int fd, const Elf64_Ehdr *ehdr,
+                                 const char *name, Elf64_Shdr *out) {
+    if (ehdr->e_shstrndx >= ehdr->e_shnum) return -1;
+
+    /* Read section header string table */
+    Elf64_Shdr shstrtab;
+    if (lseek(fd, ehdr->e_shoff + ehdr->e_shstrndx * ehdr->e_shentsize,
+              SEEK_SET) < 0) return -1;
+    if (read(fd, &shstrtab, sizeof(shstrtab)) != sizeof(shstrtab)) return -1;
+
+    char *strtab = malloc(shstrtab.sh_size);
+    if (!strtab) return -1;
+    if (lseek(fd, shstrtab.sh_offset, SEEK_SET) < 0) { free(strtab); return -1; }
+    if (read(fd, strtab, shstrtab.sh_size) != (ssize_t)shstrtab.sh_size) {
+        free(strtab); return -1;
+    }
+
+    Elf64_Shdr shdr;
+    int found = 0;
+    for (int i = 0; i < ehdr->e_shnum; i++) {
+        if (lseek(fd, ehdr->e_shoff + i * ehdr->e_shentsize, SEEK_SET) < 0) break;
+        if (read(fd, &shdr, sizeof(shdr)) != sizeof(shdr)) break;
+
+        const char *sname = (shdr.sh_name < shstrtab.sh_size)
+                            ? strtab + shdr.sh_name : "";
+        if (strcmp(sname, name) == 0) {
+            memcpy(out, &shdr, sizeof(shdr));
+            found = 1;
+            break;
+        }
+    }
+    free(strtab);
+    return found ? 0 : -1;
+}
+
+/* Map a section at its virtual address with MAP_FIXED */
+static int map_section_at_vaddr(int fd, const Elf64_Shdr *shdr) {
+    uint64_t map_addr = page_align_down(shdr->sh_addr);
+    uint64_t map_end = page_align_up(shdr->sh_addr + shdr->sh_size);
+    uint64_t map_size = map_end - map_addr;
+
+    if (shdr->sh_type == 8) { /* SHT_NOBITS */
+        void *addr = mmap((void *)(uintptr_t)map_addr, map_size,
+                          PROT_READ | PROT_WRITE,
+                          MAP_PRIVATE | MAP_FIXED | MAP_ANONYMOUS, -1, 0);
+        return (addr == MAP_FAILED) ? -1 : 0;
+    }
+
+    /* PROGBITS: map from file */
+    uint64_t file_off = shdr->sh_offset - (shdr->sh_addr - map_addr);
+    void *addr = mmap((void *)(uintptr_t)map_addr, map_size, PROT_READ,
+                      MAP_PRIVATE | MAP_FIXED, fd, file_off);
+    return (addr == MAP_FAILED) ? -1 : 0;
+}
+
+/* Constructor: fix compiled standalone binaries */
+static void fix_bun_standalone(void) {
+    const char *exe_path = "/proc/self/exe";
+    int fd = open(exe_path, O_RDONLY);
+    if (fd < 0) {
+        char cmdline[256];
+        int cfd = open("/proc/self/cmdline", O_RDONLY);
+        if (cfd >= 0) {
+            int n = read(cfd, cmdline, sizeof(cmdline) - 1);
+            close(cfd);
+            if (n > 0) {
+                cmdline[n] = '\0';
+                fd = open(cmdline, O_RDONLY);
+            }
+        }
+        if (fd < 0) return;
+    }
+
+    Elf64_Ehdr ehdr;
+    if (read(fd, &ehdr, sizeof(ehdr)) != sizeof(ehdr)) { close(fd); return; }
+
+    /* Verify ELF64 */
+    if (ehdr.e_ident[0] != 0x7f || ehdr.e_ident[1] != 'E' ||
+        ehdr.e_ident[2] != 'L' || ehdr.e_ident[3] != 'F') { close(fd); return; }
+    if (ehdr.e_ident[4] != 2) { close(fd); return; }
+    if (ehdr.e_shentsize != sizeof(Elf64_Shdr)) { close(fd); return; }
+
+    /* Try to find and map the .bun section */
+    Elf64_Shdr bun;
+    if (find_section_by_name(fd, &ehdr, ".bun", &bun) == 0) {
+        map_section_at_vaddr(fd, &bun);
+    }
+
+    /* Try known absolute addresses (fallback) */
+    for (int i = 0; i < num_known_addresses; i++) {
+        uint64_t vaddr = known_addresses[i];
+        /* Check if already mapped by section name above */
+        if (bun.sh_addr == vaddr && bun.sh_size > 0) continue;
+
+        /* Try direct mmap from file (vaddr == file offset in bun binaries) */
+        uint64_t pg = page_align_down(vaddr);
+        mmap((void *)(uintptr_t)pg, 0x1000, PROT_READ,
+             MAP_PRIVATE | MAP_FIXED, fd, pg);
+    }
+
+    close(fd);
+}
+
+/* Constructor runs at process start — captures CWD and fixes standalone bins */
+__attribute__((constructor(1)))
+static void init(void) {
+    /* Capture CWD for "/" redirect before any sandbox restriction matters */
+    if (getcwd(shim_cwd, sizeof(shim_cwd)) != NULL) {
+        shim_cwd_len = strlen(shim_cwd);
+    }
+
+    fix_bun_standalone();
+}

package/karnel/tools/lang/bun/src/bun-bundle.c

@@ -0,0 +1,96 @@
+/**
+ * bun-bundle — Post-process a Bun compiled standalone binary for Android Termux.
+ *
+ * Bun's `bun build --compile` produces standalone ELF binaries that crash on
+ * Android because the embedded Bun runtime contains hardcoded (non-relocated)
+ * absolute pointers. This tool wraps the compiled binary with a shell script
+ * that sets LD_PRELOAD to load the bun-android-shim.so fix library.
+ *
+ * Usage after bun build --compile:
+ *   bun build --compile hello.ts
+ *   bun-bundle hello
+ *   ./hello     # Now works!
+ *
+ * The tool renames hello -> hello.bun and creates a shell wrapper hello.
+ */
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <libgen.h>
+#include <errno.h>
+#include <sys/stat.h>
+
+/* Default shim path on Termux */
+#define DEFAULT_SHIM "/data/data/com.termux/files/usr/lib/bun-android-shim.so"
+
+int main(int argc, char *argv[]) {
+    if (argc < 2) {
+        fprintf(stderr, "Usage: bun-bundle <compiled-binary> [shim-path]\n");
+        fprintf(stderr, "\nPost-processes a Bun compiled binary to work on Android Termux.\n");
+        fprintf(stderr, "Renames <binary> -> <binary>.bun and creates a shell wrapper.\n");
+        fprintf(stderr, "\nExample:\n");
+        fprintf(stderr, "  bun build --compile hello.ts\n");
+        fprintf(stderr, "  bun-bundle hello\n");
+        fprintf(stderr, "  ./hello   # Works!\n");
+        return 1;
+    }
+
+    const char *binary = argv[1];
+    const char *shim_path = (argc >= 3) ? argv[2] : DEFAULT_SHIM;
+
+    /* Build the .bun filename: binary + ".bun" */
+    size_t binlen = strlen(binary);
+    char *bun_binary = malloc(binlen + 5);
+    if (!bun_binary) { perror("malloc"); return 1; }
+    memcpy(bun_binary, binary, binlen);
+    memcpy(bun_binary + binlen, ".bun", 5);
+
+    /* Check the original binary exists */
+    if (access(binary, F_OK) < 0) {
+        fprintf(stderr, "Error: %s not found\n", binary);
+        free(bun_binary);
+        return 1;
+    }
+
+    /* Rename binary -> binary.bun */
+    if (rename(binary, bun_binary) < 0) {
+        fprintf(stderr, "Error renaming %s -> %s: %s\n",
+                binary, bun_binary, strerror(errno));
+        free(bun_binary);
+        return 1;
+    }
+
+    /* Get basename for the wrapper */
+    char *bin_copy = strdup(binary);
+    const char *base = basename(bin_copy);
+
+    /* Create the shell wrapper */
+    FILE *f = fopen(binary, "w");
+    if (!f) {
+        fprintf(stderr, "Error creating wrapper %s: %s\n",
+                binary, strerror(errno));
+        rename(bun_binary, binary);
+        free(bun_binary);
+        free(bin_copy);
+        return 1;
+    }
+
+    fprintf(f, "#!/data/data/com.termux/files/usr/bin/bash\n");
+    fprintf(f, "# Auto-generated wrapper for Bun compiled binary\n");
+    fprintf(f, "# bun-bundle post-processor\n");
+    fprintf(f, "export LD_PRELOAD=%s\n", shim_path);
+    fprintf(f, "exec \"$(dirname \"$0\")/%s.bun\" \"$@\"\n", base);
+
+    fclose(f);
+    chmod(binary, 0755);
+
+    printf("Bundled: %s  ->  %s (wrapper) + %s.bun (binary)\n", binary, binary, binary);
+    printf("Shim:   %s\n", shim_path);
+    printf("\nRun it: ./%s\n", base);
+
+    free(bun_binary);
+    free(bin_copy);
+    return 0;
+}

package/karnel/utils/env.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 
-KARNEL_VERSION="4.9.0"
+KARNEL_VERSION="4.9.2"
 
 # -------------------------
 # Directorios del usuario

package/karnel/utils/log.sh

@@ -556,6 +556,7 @@ progress_start() {
 	local total=$1
 	local message="${2:-Progress}"
 	_progress_current=0
+	_progress_filled=0
 	_progress_total=$total
 	_progress_width=50
 	printf "    ${D_CYAN}%s${D_NC}" "$message"
@@ -572,15 +573,22 @@ progress_update() {
 	local current=$1
 	local total=$2
 	local width="${_progress_width:-50}"
-	local percentage=$((current * 100 / total))
-	local filled=$((current * width / total))
-	local empty=$((width - filled))
-
-	local bar=""
-	for ((i = 0; i < filled; i++)); do bar+="█"; done
-	for ((i = 0; i < empty; i++)); do bar+="░"; done
+	local target_filled=$((current * width / total))
+
+	local prev="${_progress_filled:-0}"
+	[[ "$target_filled" -lt "$prev" ]] && prev=0
+
+	local anim i j bar pct
+	for ((i = prev + 1; i <= target_filled; i++)); do
+		bar=""
+		for ((j = 0; j < i; j++)); do bar="${bar}█"; done
+		for ((j = i; j < width; j++)); do bar="${bar}░"; done
+		pct=$((i * 100 / width))
+		printf "\r    ${D_CYAN}[${D_NC}${D_GREEN}%s${D_NC}${D_CYAN}]${D_NC} %3d%%" "$bar" "$pct"
+		sleep 0.003 2>/dev/null || true
+	done
 
-	printf "\r    ${D_CYAN}[${D_NC}${D_GREEN}%s${D_NC}${D_CYAN}]${D_NC} %3d%%" "$bar" "$percentage"
+	_progress_filled="$target_filled"
 }
 
 progress_done() {

package/karnel/utils/version.sh

@@ -98,8 +98,8 @@ _get_remote_github_version() {
   tag=$(echo "$raw" | grep '"tag_name":' | sed -E 's/.*"([^"]+)".*/\1/')
 
   if [ -z "$tag" ]; then
-    raw=$(_spin_capture "Checking GitHub tags" curl -fsSL "https://api.github.com/repos/$repo/tags?per_page=5" 2>/dev/null)
-    tag=$(echo "$raw" | grep '"name":' | head -1 | sed -E 's/.*"([^"]+)".*/\1/')
+    raw=$(_spin_capture "Checking GitHub tags" curl -fsSL "https://api.github.com/repos/$repo/tags?per_page=100" 2>/dev/null)
+    tag=$(echo "$raw" | grep '"name":' | sed -E 's/.*"([^"]+)".*/\1/' | sort -V | tail -1)
   fi
 
   _parse_version "$tag"

package/package.json

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