buninu-linux 0.2.0

package/initramfs/buninu/bin/libsh-loader.c

@@ -0,0 +1,135 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+static char *append_script_suffix(const char *path) {
+    size_t path_len = strlen(path);
+    char *script_path = malloc(path_len + sizeof(".sh"));
+
+    if (!script_path) {
+        return NULL;
+    }
+
+    memcpy(script_path, path, path_len);
+    memcpy(script_path + path_len, ".sh", sizeof(".sh"));
+    return script_path;
+}
+
+static char *multicall_path_for(const char *script_path) {
+    const char *slash = strrchr(script_path, '/');
+    size_t directory_len = slash ? (size_t)(slash - script_path + 1) : 0;
+    char *multicall_path = malloc(directory_len + sizeof("multicall.sh"));
+
+    if (!multicall_path) {
+        return NULL;
+    }
+
+    memcpy(multicall_path, script_path, directory_len);
+    memcpy(multicall_path + directory_len,
+           "multicall.sh", sizeof("multicall.sh"));
+    return multicall_path;
+}
+
+static char *find_script_path(const char *invoked_as) {
+    if (!invoked_as || !*invoked_as) {
+        return NULL;
+    }
+
+    /* Relative and absolute paths are used exactly as supplied. */
+    if (strchr(invoked_as, '/')) {
+        return append_script_suffix(invoked_as);
+    }
+
+    const char *path = getenv("PATH");
+    if (!path) {
+        return NULL;
+    }
+
+    size_t name_len = strlen(invoked_as);
+    const char *entry = path;
+
+    for (;;) {
+        const char *separator = strchr(entry, ':');
+        size_t entry_len = separator ? (size_t)(separator - entry) : strlen(entry);
+        const char *directory = entry_len ? entry : ".";
+        size_t directory_len = entry_len ? entry_len : 1;
+        int needs_slash = directory[directory_len - 1] != '/';
+        size_t executable_len = directory_len + needs_slash + name_len;
+        char *executable_path = malloc(executable_len + 1);
+
+        if (!executable_path) {
+            return NULL;
+        }
+
+        memcpy(executable_path, directory, directory_len);
+        if (needs_slash) {
+            executable_path[directory_len] = '/';
+        }
+        memcpy(executable_path + directory_len + needs_slash,
+               invoked_as, name_len + 1);
+
+        if (access(executable_path, X_OK) == 0) {
+            char *script_path = append_script_suffix(executable_path);
+            free(executable_path);
+            return script_path;
+        }
+
+        free(executable_path);
+        if (!separator) {
+            break;
+        }
+        entry = separator + 1;
+    }
+
+    return NULL;
+}
+
+int main(int argc, char *argv[]) {
+    char *path = find_script_path(argv[0]);
+    if (!path) {
+        fprintf(stderr, "Cannot locate loader in PATH: %s\n",
+                argv[0] ? argv[0] : "(null)");
+        return 127;
+    }
+
+    if (access(path, F_OK) != 0) {
+        char *companion_path = path;
+        path = multicall_path_for(companion_path);
+
+        if (!path || access(path, F_OK) != 0) {
+            fprintf(stderr,
+                    "Companion scripts not found: %s or %s\n",
+                    companion_path,
+                    path ? path : "multicall.sh");
+            free(path);
+            free(companion_path);
+            return 127;
+        }
+
+        free(companion_path);
+    }
+
+    // new argv: ["sh", script, argv[1], ..., NULL]
+    char **new_argv = malloc(sizeof(char *) * (argc + 2));
+    if (!new_argv) {
+        free(path);
+        return 1;
+    }
+
+    new_argv[0] = argv[0];
+    new_argv[1] = path;
+
+    for (int i = 1; i < argc; i++) {
+        new_argv[i + 1] = argv[i];
+    }
+
+    new_argv[argc + 1] = NULL;
+
+    execv("/system/bin/sh", new_argv);
+
+    perror("/system/bin/sh");
+    free(new_argv);
+    free(path);
+    return 127;
+}

package/initramfs/buninu/bin/multicall.sh

@@ -0,0 +1,103 @@
+#!/bin/sh
+
+if [ -f /proc/$$/cmdline ] ; then
+  args=$(tr '\0' '\n' < /proc/$$/cmdline)
+  caller=$(printf '%s\n' "$args" | head -n 1)
+
+  # Buninu Linux implements /bin/sh in Bun. Its interpreter chain makes the
+  # first three cmdline entries /bin/bun, /bin/sh, and the invoked launcher;
+  # Android's native loader instead keeps the launcher in the first entry.
+  # Match only the exact Buninu chain so the existing Android and conventional
+  # Linux paths retain their current behaviour.
+  second=$(printf '%s\n' "$args" | head -n 2 | tail -n 1)
+  if [ "$caller" = /bin/bun ] && [ "$second" = /bin/sh ] ; then
+    caller=$(printf '%s\n' "$args" | head -n 3 | tail -n 1)
+  fi
+
+  callerb=$(basename "$caller")
+else
+  callerb=$(basename "$0")
+fi
+
+if [ "$callerb" = sh ] ; then
+  callerb=$(basename "$0")
+fi
+
+sd=$(dirname "$(realpath "$0")")
+
+prog_base=$sd/../apps/$callerb/$callerb
+
+# echo $prog_base
+
+if [ -f "$sd/$callerb.sh" ] ; then
+  exec /bin/sh "$sd/$callerb.sh" "$@"
+elif [ -f "$prog_base".sh ] ; then
+  exec /bin/sh "$prog_base".sh "$@"
+elif [ -f "$prog_base".js ] ; then
+  exec bun "$prog_base".js "$@"
+elif [ -f "$prog_base".mjs ] ; then
+  exec bun "$prog_base".mjs "$@"
+elif [ -f "$prog_base".ts ] ; then
+  exec bun "$prog_base".ts "$@"
+elif [ -f "$prog_base".mts ] ; then
+  exec bun "$prog_base".mts "$@"
+fi
+
+exit 127
+
+realscript="$PKG_RDIR"/bin/"$callerb.sh"
+realjs="$PKG_RDIR"/bin/"$callerb.js"
+realmjs="$PKG_RDIR"/bin/"$callerb.mjs"
+realtool="$PKG_RDIR/$callerb"
+
+jtool_list="
+javac
+javap
+javadoc
+jcmd
+jar
+jarsigner
+jconsole
+jdb
+jdeprscan
+jdeps
+jhsdb
+jimage
+jinfo
+jlink
+jmap
+jmod
+jpackage
+jps
+jshell
+jstack
+jstat
+jstatd
+serialver
+jfr
+jrunscript
+keytool
+rmiregistry
+"
+ 
+if [ -f "$realscript" ] ; then
+  exec sh "$realscript" "$@"
+elif [ -f "$realjs" ] ; then
+  exec sh "$shr" node "$realjs" "$@"
+elif [ -f "$realmjs" ] ; then
+  exec sh "$shr" node "$realmjs" "$@"
+elif [ "$callerb" = "run" ] ; then
+  exec sh "$shr" "$@"
+elif [ -d "$realtool" ] ; then
+  exec sh "$shr" "$callerb" "$@"
+elif [ -f "$PKG_RDIR"/bin/java.sh ] &&
+    echo "$jtool_list" | grep -q "^$callerb$" ; then
+  exec sh "$PKG_RDIR"/bin/java.sh --tool-name "$callerb" "$@"
+else
+  exec sh "$shr" pkg run "$callerb" "$@"
+fi
+
+
+export ANCI_SCRIPT_LOADER_PATH=""
+
+exec "$PKG_RDIR"/bin/shloader

package/initramfs/buninu/bin/native-bridge.bat

@@ -0,0 +1,3 @@
+@echo off
+call "%~dp0bun.bat" "%~dp0..\apps\native-bridge\native-bridge.js" %*
+exit /b %ERRORLEVEL%

package/initramfs/buninu/bin/rz.bat

@@ -0,0 +1,3 @@
+@echo off
+call "%~dp0bun.bat" "%~dp0..\apps\jsgotty\rz.js" %*
+exit /b %ERRORLEVEL%

package/initramfs/buninu/bin/rz.sh

@@ -0,0 +1,5 @@
+#!/bin/sh
+
+sd=$(dirname "$(realpath "$0")")
+
+exec bun "$sd"/../apps/jsgotty/rz.js "$@"

package/initramfs/buninu/bin/shc.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env bun
+
+process.exit(await Bun.spawn(process.argv.slice(2), {
+  stdio: [0, 1, 2],
+}).exited);

package/initramfs/buninu/bin/showimg.bat

@@ -0,0 +1,3 @@
+@echo off
+call "%~dp0bun.bat" "%~dp0..\apps\jsgotty\gotty.js" --viu %*
+exit /b %ERRORLEVEL%

package/initramfs/buninu/bin/showimg.sh

@@ -0,0 +1,5 @@
+#!/bin/sh
+
+sd=$(dirname "$(realpath "$0")")
+
+exec bun "$sd"/../apps/jsgotty/gotty.js --viu "$@"

package/initramfs/buninu/bin/switch_to_android.sh

@@ -0,0 +1,9 @@
+#!/bin/sh
+
+sd=$(dirname "$0")
+
+annl=androidNativeLibs
+
+ln -sfT $annl/libbun.so "$sd"/bun
+
+ln -sfT $annl/libsh-loader.so "$sd"/shloader

package/initramfs/buninu/bin/switch_to_linux.sh

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+sd=$(dirname "$0")
+
+ln -sfT bun.sh "$sd"/bun
+
+ln -sfT multicall.sh "$sd"/shloader

package/initramfs/buninu/bin/sz.bat

@@ -0,0 +1,3 @@
+@echo off
+call "%~dp0bun.bat" "%~dp0..\apps\jsgotty\sz.js" %*
+exit /b %ERRORLEVEL%

package/initramfs/buninu/bin/sz.sh

@@ -0,0 +1,5 @@
+#!/bin/sh
+
+sd=$(dirname "$(realpath "$0")")
+
+exec bun "$sd"/../apps/jsgotty/sz.js "$@"

package/initramfs/buninu/bin/tts.bat

@@ -0,0 +1,3 @@
+@echo off
+call "%~dp0bun.bat" "%~dp0..\apps\tts\tts.js" %*
+exit /b %ERRORLEVEL%

package/initramfs/buninu/bin/xclip.bat

@@ -0,0 +1,3 @@
+@echo off
+call "%~dp0bun.bat" "%~dp0..\apps\xclip\xclip.js" %*
+exit /b %ERRORLEVEL%

package/initramfs/buninu/bin/xdg-open.bat

@@ -0,0 +1,3 @@
+@echo off
+call "%~dp0bun.bat" "%~dp0..\apps\xdg-open\xdg-open.js" %*
+exit /b %ERRORLEVEL%

package/initramfs/buninu/demo-server.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env bun
+
+// Smallest end-to-end demo of the WebView bridge: serve one fixed page on a
+// port nobody picked in advance, then have xdg-open put it in the host app's
+// app WebView and switch to it. Run it from a Buninu shell inside minapk's
+// APK:
+//
+//   bun demo-server.js
+//
+// Outside such an APK it still runs and still serves; xdg-open just falls
+// back to whatever that platform's default handler is (see apps/xdg-open).
+
+const BODY = "Hello 你好 こんにちは"
+
+// port: 0 asks the OS for a free port instead of guessing one and racing
+// whatever already has it -- Buninu's own launcher picks jsgotty's port the
+// same way. The real number is only knowable after the listener exists, so
+// the URL is built from server.port, never from a constant.
+// hostname stays on loopback: this is a demo page for the WebView on this
+// device, not something other machines on the network should reach.
+const server = Bun.serve({
+  hostname: "127.0.0.1",
+  port: 0,
+  fetch() {
+    // charset is not optional here: without it the WebView guesses an
+    // encoding for the response, and the CJK half of BODY is what shows up
+    // as mojibake when it guesses wrong.
+    return new Response(BODY, {
+      headers: { "Content-Type": "text/plain; charset=utf-8" },
+    })
+  },
+})
+
+// 127.0.0.1 rather than localhost: the listener is bound to the v4 loopback
+// address specifically, while "localhost" can resolve to ::1 first and give
+// the WebView a connection refused before it ever tries v4.
+const url = `http://127.0.0.1:${server.port}`
+console.log(`demo-server: serving ${JSON.stringify(BODY)} at ${url}`)
+
+// Buninu puts its own bin/ on PATH, so "xdg-open" normally resolves to
+// apps/xdg-open through the shloader. Fall back to running the script
+// directly for the case where this file is run outside a Buninu shell (a bare
+// `bun demo-server.js` in a checkout), where that PATH entry is not there.
+const xdgOpen = Bun.which("xdg-open")
+const command = xdgOpen
+  ? [xdgOpen, url]
+  : [process.execPath, `${import.meta.dir}/apps/xdg-open/xdg-open.js`, url]
+
+// MINAPK_WEBVIEW is read by xdg-open itself, not by the host app -- it names
+// which WebView to load into (1 is the app WebView) and brings it to the
+// front. Passed to this one child rather than exported, so it changes nothing
+// for the rest of the session.
+const child = Bun.spawn(command, {
+  env: { ...process.env, MINAPK_WEBVIEW: "1" },
+  stdout: "inherit",
+  stderr: "inherit",
+})
+
+if (await child.exited !== 0)
+  console.error(`demo-server: ${command[0]} exited with ${child.exitCode}; page is still served at ${url}`)
+
+// The server has to outlive the open: the WebView fetches the page after
+// xdg-open has already returned. Ctrl-C to stop.
+console.log("demo-server: Ctrl-C to stop")

package/initramfs/buninu/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "buninu",
+  "version": "0.4.12",
+  "description": "Buninu is a portable, self-bootstrapping Unix-like userspace built on Bun that runs across operating systems",
+  "type": "module",
+  "main": "./bin/init.js",
+  "license": "MIT",
+  "author": "Dr. John (醫者小智)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jjtseng93/buninu.git"
+  },
+  "homepage": "https://github.com/jjtseng93/buninu#readme",
+  "bugs": {
+    "url": "https://github.com/jjtseng93/buninu/issues"
+  },
+  "keywords": [
+    "bun",
+    "terminal",
+    "web-terminal",
+    "browser-terminal",
+    "shell",
+    "userspace",
+    "portable",
+    "cross-platform",
+    "android",
+    "termux",
+    "pty",
+    "self-bootstrapping"
+  ],
+  "bin": {
+    "buninu": "bin/init.js"
+  },
+  "buninu": {
+    "shell": {
+      "default": null,
+      "android": null,
+      "linux": null,
+      "macos": null,
+      "windows": null
+    },
+    "command": {
+      "default": "echo Welcome to Buninu, Try: glow apps/cmdlist, Help: buninu-help",
+      "android": "if command -v libmain.so >/dev/null 2>&1; then libmain.so; else printf '%s\\n' '# Welcome to Buninu Android' '- Try: glow apps/cmdlist' '- Help: buninu-help'; fi",
+      "linux": null,
+      "macos": null,
+      "windows": null
+    },
+    "exitAfterCmd": false,
+    "backToConsole": true,
+    "xdgDataHome": null,
+    "hideExtraKeys": false
+  },
+  "scripts": {
+    "start": "bun ./apps/jsgotty/gotty.js --reconnect -r -w --webgl -a 127.0.0.1",
+    "local": "bun ./apps/bunmsh/index.js -c 'exec bunmsh'",
+    "check": "node --check ./bin/init.js"
+  }
+}

package/initramfs/etc/resolv.conf

@@ -0,0 +1 @@
+nameserver 10.0.2.3