buninu-linux 0.2.0

package/initramfs/buninu/apps/tts/tts.js

@@ -0,0 +1,214 @@
+#!/usr/bin/env bun
+
+// Wraps native-bridge's raw speak()/ttsStatus() -- which never block, since
+// TextToSpeech's completion signal is a callback the far side has no way to
+// push to us over this protocol -- in the polling loop most callers actually
+// want. Invoked as a subprocess this necessarily blocks the caller until
+// speech finishes (or --async is given): that is expected, the same as any
+// other CLI tool that waits for the thing it started.
+import { speak, ttsStatus, available } from "../native-bridge/native-bridge.js"
+
+// Buninu is cross-OS, not just Android: when native-bridge isn't available,
+// fall back to a locally-spawned platform TTS command instead of just
+// failing. This block is copied verbatim from jsmdcui's own
+// src/index.js detectTtsCmd() (same pitch/speed/lang math, same command
+// construction) rather than reimplemented, since the PowerShell quoting in
+// the win32 branch is exactly the kind of thing that is easy to silently
+// break by hand-retyping and hard to verify without a real Windows machine.
+//
+// One deliberate omission from the original: it ends with an
+// `if (Bun.which("tts")) return {cmd:['tts'],via:'arg'}` fallback. Calling
+// that from inside this exact script (also registered as Buninu's "tts"
+// command, ahead of anything else named "tts" on PATH) would just be this
+// script invoking itself -- the same self-reference risk xclip.js avoids
+// around ClipboardManager's own "xclip" search, so it is left out here.
+function detectTtsCmd(speed, pitch) {
+  const platform = process.platform;
+
+  const lang = process.env.TTS_LANG || 'zh-TW'
+  process.env.TTS_LANG = lang ;
+
+  if (platform === "android") {
+    if (Bun.which("termux-tts-speak"))
+      return { cmd: ["termux-tts-speak", "-p", String(pitch), "-r", String(speed)], via: "arg" };
+  }
+
+  if (platform === "darwin") {
+    // say -r <wpm>; pitch via [[pbas n]] embedded TTS command (0-127, 48 = normal)
+    const rate = Math.round(175 * speed);
+    const pitchN = Math.max(0, Math.min(127, Math.round(48 * pitch)));
+    return {
+      cmd: ["say", "-r", String(rate)],
+      via: "arg",
+      textTransform: pitchN !== 48 ? (t) => `[[pbas ${pitchN}]] ${t}` : null,
+    };
+  }
+
+  if (platform === "win32") {
+    // Rate property: -10 to 10 (0 = normal); pitch via SSML <prosody>
+    const rate = Math.max(-10, Math.min(10, Math.round((speed - 1) * 10)));
+    const pitchPct = Math.round((pitch - 1) * 100);
+    const pitchAttr = (pitchPct >= 0 ? "+" : "") + pitchPct + "%";
+    for (const shell of ["pwsh.exe", "powershell.exe"]) {
+      if (Bun.which(shell)) {
+        const psCmd =
+          "Add-Type -AssemblyName System.Speech; " +
+          `$s = New-Object System.Speech.Synthesis.SpeechSynthesizer; $s.Rate = ${rate}; ` +
+          `$t = [Console]::In.ReadToEnd(); ` +
+          `$x = [System.Security.SecurityElement]::Escape($t); ` +
+          `$s.SpeakSsml('<speak xml:lang="${lang}" version="1.0" xmlns="http://www.w3.org/2001/10/synthesis"><prosody pitch="${pitchAttr}">' + $x + '</prosody></speak>')`;
+        return { cmd: [shell, "-NoProfile", "-Command", psCmd], via: "stdin" };
+      }
+    }
+  }
+
+  // Linux / Android fallback: espeak-ng / espeak
+  // Speed: -s <wpm> (175 = normal), Pitch: -p <n> (0-99, 50 = normal)
+  for (const bin of ["espeak-ng", "espeak"]) {
+    if (Bun.which(bin)) {
+      const spd = Math.round(175 * speed);
+      const pit = Math.max(0, Math.min(99, Math.round(50 * pitch)));
+      return { cmd: [bin, '-s', spd, '-p', pit], via: "arg" };
+    }
+  }
+
+  return null;
+}
+
+// Also copied verbatim (as the spawn side of the same jsmdcui code path,
+// runTts) other than operating on the whole text at once instead of
+// per-sentence, since a CLI invocation has no buffer/cursor to highlight
+// against sentence by sentence the way the jsmdcui TUI does.
+async function speakViaPlatformCommand(text, cmd) {
+  const spawnOpts = { stdout: "ignore", stderr: "ignore", env: process.env };
+  spawnOpts.stdin = cmd.via === "stdin" ? new Blob([text]) : "ignore";
+
+  if (cmd.via === "arg") {
+    text = (text + "")
+      .replace(/^-+/, "")
+      .replaceAll("`", "")
+      .replaceAll("$", "");
+    if (cmd.textTransform) text = cmd.textTransform(text);
+  }
+  const args = cmd.via === "arg" ? [...cmd.cmd, text] : cmd.cmd;
+  const proc = Bun.spawn(args, spawnOpts);
+  return await proc.exited;
+}
+
+// Not too short: each tick is a full unix-socket round trip, and TTS
+// utterances run several seconds at minimum, so polling faster just burns
+// cycles without getting the answer any sooner.
+const POLL_MS = 500
+
+// No wall-clock cap by default. Real TTS tooling doesn't invent one: espeak-ng
+// has no timeout concept at all (its man page documents speed/pitch/gaps but
+// nothing about how long it may block), and Windows SAPI's WaitUntilDone
+// treats -1 ("wait forever") as the documented default -- a fixed cap here
+// would just mean this tool gives up early on long text, which has nothing
+// to do with the host actually being broken. The loop below still can't hang
+// on a genuinely dead host: each poll has call()'s own 5s timeout (throws,
+// caught below), and the loop condition itself already exits the moment
+// status leaves "speaking" -- "unknown"/"error" are the real failure signal,
+// not a timer. Pass --timeout to opt into a bounded wait instead.
+const argv = process.argv.slice(2)
+
+if (argv.includes("--help") || argv.includes("-h")) {
+  console.log(`
+ Usage: tts <text>
+  tts "hello world"
+  tts -f "interrupt and say this instead"
+  tts -a "say this, don't wait for it to finish"
+  tts --timeout 30000 "give up after 30s if still speaking"
+  tts --pitch 1.2 --speed 0.8 "slower and higher-pitched"
+
+ -f, --flush       interrupt whatever is currently speaking
+ -a, --async       print the handle and exit immediately instead of polling
+ --timeout <ms>    give up and exit non-zero after this long (default: none,
+                    wait as long as it takes -- matches espeak-ng/SAPI)
+ --pitch <n>       1.0 is normal (default: $TTS_PITCH, or 1 if unset)
+ --speed <n>       1.0 is normal (default: $TTS_SPEED, or 1 if unset)
+`)
+  process.exit(0)
+}
+
+const flush = argv.includes("-f") || argv.includes("--flush")
+const isAsync = argv.includes("-a") || argv.includes("--async")
+
+const optValue = (flag, envFallback) => {
+  const i = argv.indexOf(flag)
+  const raw = i !== -1 ? argv[i + 1] : process.env[envFallback]
+  const n = Number(raw)
+  return Number.isFinite(n) ? n : 1
+}
+const timeoutIdx = argv.indexOf("--timeout")
+const maxWaitMs = timeoutIdx !== -1 ? Number(argv[timeoutIdx + 1]) : null
+const pitch = optValue("--pitch", "TTS_PITCH")
+const speed = optValue("--speed", "TTS_SPEED")
+
+const valueFlags = new Set(["--timeout", "--pitch", "--speed"])
+const text = argv.find((a, i) => !a.startsWith("-") && !valueFlags.has(argv[i - 1])) ?? ""
+
+if (!available()) {
+  // No Android native bridge -- fall back to a local platform TTS command
+  // (see detectTtsCmd() above). flush/polling/handles are all native-bridge
+  // concepts specific to Android's async TextToSpeech callback; there is no
+  // equivalent "interrupt what's currently speaking" here, so -f/--flush is
+  // silently a no-op on this path.
+  const cmd = detectTtsCmd(speed, pitch)
+  if (!cmd) {
+    console.error("no TTS backend found: no native bridge, and no termux-tts-speak/say/PowerShell/espeak-ng/espeak on PATH")
+    process.exit(1)
+  }
+
+  if (isAsync) {
+    speakViaPlatformCommand(text, cmd)
+    process.exit(0)
+  }
+
+  const code = await speakViaPlatformCommand(text, cmd)
+  process.exit(code === 0 ? 0 : 1)
+}
+
+let handle
+try {
+  handle = await speak(text, speed, pitch, flush)
+} catch (e) {
+  console.error(`speak failed: ${e.message}`)
+  process.exit(1)
+}
+
+if (isAsync) {
+  console.log(handle)
+  process.exit(0)
+}
+
+const start = Date.now()
+let status = "speaking"
+
+while (status === "speaking") {
+  if (maxWaitMs != null && Date.now() - start > maxWaitMs) {
+    console.error(`tts: gave up waiting for "${handle}" after ${maxWaitMs}ms`)
+    process.exit(1)
+  }
+
+  await new Promise(resolve => setTimeout(resolve, POLL_MS))
+
+  try {
+    status = await ttsStatus(handle)
+  } catch (e) {
+    console.error(`ttsStatus failed: ${e.message}`)
+    process.exit(1)
+  }
+}
+
+if (status === "error") {
+  console.error(`tts: "${handle}" reported an error`)
+  process.exit(1)
+}
+
+if (status === "unknown") {
+  console.error(`tts: "${handle}" went unknown before finishing`)
+  process.exit(1)
+}
+
+process.exit(0)

package/initramfs/buninu/apps/xclip/xclip.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env bun
+
+// Ported from ../tmpk/bin/xclip.sh (the DroidScript-era xclip). That version
+// bridged to native only through DroidScript's dsapi.pipe; this one uses
+// native-bridge instead. The core semantics are unchanged: "primary" is
+// local-file-only (matches X11's mouse-selection clipboard, which xclip also
+// keeps separate from the real clipboard), and only "-selection clipboard"
+// (or its "-clip"/"-clipboard" shorthand) touches the real system clipboard.
+import { getcb, setcb, available } from "../native-bridge/native-bridge.js"
+import { ClipboardManager } from "../jsmdcui/src/platform/clipboard.js"
+
+// Buninu is cross-OS, not just Android, so the "clipboard" register falls
+// back through: native-bridge (Android) -> jsmdcui's own ClipboardManager
+// (win32/darwin only, see below) -> wl-copy/wl-paste (Linux, Wayland).
+//
+// ClipboardManager is deliberately NOT used on Linux-like platforms
+// (including Android): its own backend detection searches PATH for a binary
+// literally named "xclip" there, and this script is itself registered as
+// Buninu's "xclip" command, ahead of any real system xclip on PATH -- using
+// it here would make this script shell out to itself. Its win32/darwin
+// branches never search for "xclip" at all, so those two are safe.
+let desktopClipboard = null
+function getDesktopClipboard() {
+  if (process.platform !== "win32" && process.platform !== "darwin") return null
+  if (!desktopClipboard) desktopClipboard = new ClipboardManager()
+  return desktopClipboard
+}
+
+const wlAvailable = () => !!(Bun.which("wl-copy") && Bun.which("wl-paste"))
+const wlRead = () => {
+  const proc = Bun.spawnSync(["wl-paste", "--no-newline"])
+  return proc.success ? new TextDecoder().decode(proc.stdout) : null
+}
+const wlWrite = (text) => Bun.spawnSync(["wl-copy"], { stdin: Buffer.from(text) }).success
+
+const argv = process.argv.slice(2)
+
+if (argv.includes("--help") || argv.includes("-h")) {
+  console.log(`
+ Usage: Paste/Copy
+  xclip -o [-selection clipboard]
+  xclip -o [-clip]
+  echo hello | xclip [-selection clipboard]
+  echo hello | xclip [-clip]
+
+ Uses primary by default(mouse selection)
+`)
+  process.exit(0)
+}
+
+const selMatch = argv.join(" ").match(/-selection\s+(\S+)/)
+const cb = selMatch ? selMatch[1]
+  : argv.some(a => a.includes("-clip")) ? "clipboard"
+  : "primary"
+
+process.stderr.write(`\x1b[35mClipboard 剪貼板📋 ： ${cb} \n\x1b[0m`)
+
+const cbf = `${process.env.HOME}/.xclip.${cb}`
+const useNative = cb !== "primary"
+const desktop = useNative ? getDesktopClipboard() : null
+
+if (useNative && !available() && !desktop && !wlAvailable())
+  process.stderr.write(`no system clipboard found (no native bridge, no ClipboardManager backend, no wl-copy/wl-paste)\nNo native clipboard now!\n`)
+
+const isPaste = argv.some(a => a.toLowerCase() === "-o")
+
+if (isPaste) {
+  process.stderr.write(`\x1b[33mPaste 貼上 📋 \n\x1b[0m`)
+
+  if (useNative) {
+    if (available()) {
+      try {
+        await Bun.write(cbf, (await getcb()) ?? "")
+      } catch (e) {
+        process.stderr.write(`getcb failed: ${e.message}\n`)
+      }
+    } else if (desktop) {
+      try {
+        await Bun.write(cbf, desktop.read("clipboard") ?? "")
+      } catch (e) {
+        process.stderr.write(`clipboard read failed: ${e.message}\n`)
+      }
+    } else if (wlAvailable()) {
+      const text = wlRead()
+      if (text != null) await Bun.write(cbf, text)
+    }
+  }
+
+  const file = Bun.file(cbf)
+  if (await file.exists()) process.stdout.write(new Uint8Array(await file.arrayBuffer()))
+} else {
+  process.stderr.write(`\x1b[33mCopy 複製 ✂️ \n\x1b[0m`)
+
+  const input = await Bun.stdin.arrayBuffer()
+  await Bun.write(cbf, input)
+
+  if (useNative) {
+    if (available()) {
+      try {
+        await setcb(new TextDecoder().decode(input))
+      } catch (e) {
+        process.stderr.write(`setcb failed: ${e.message}\n`)
+      }
+    } else if (desktop) {
+      try {
+        desktop.write(new TextDecoder().decode(input), "clipboard")
+      } catch (e) {
+        process.stderr.write(`clipboard write failed: ${e.message}\n`)
+      }
+    } else if (wlAvailable()) {
+      wlWrite(new TextDecoder().decode(input))
+    }
+  }
+}
+
+// Explicit exit: call()'s own timeout race means every await above is
+// guaranteed to settle, but a getcb()/setcb() that hit that timeout leaves
+// an abandoned fetch running, which keeps Bun's event loop alive on its own.
+// Without this, xclip could still hang after printing everything it needs
+// to -- the shell would just never get its prompt back.
+process.exit(0)

package/initramfs/buninu/apps/xdg-open/xdg-open.js

@@ -0,0 +1,151 @@
+#!/usr/bin/env bun
+
+// Android goes through native-bridge's xdgOpen (MainActivity.java validates
+// the path stays under Buninu's home and serves it back out through a
+// read-only content:// provider; a bare URL just goes to ACTION_VIEW). The
+// other platforms each have their own "open with whatever the OS thinks is
+// the default handler" mechanism -- macOS/Windows are real OS
+// commands/APIs, but Linux's is conventionally *also* a command named
+// xdg-open, so this script has to be careful not to find itself on PATH.
+import {
+  xdgOpen as bridgeOpen, available, openWebView, showWebView,
+} from "../native-bridge/native-bridge.js"
+const fs = require("fs")
+
+// MINAPK_WEBVIEW names *which* of the host app's WebViews to open into (0 is
+// the console, 1 the app WebView, -1 whichever is in front); unset means the
+// unchanged behavior of handing the target to the system's default handler.
+// It is read here rather than being detected by the host, because it is an
+// environment variable of this Bun process tree -- the host app's own process
+// cannot see a value exported in this shell a moment ago, and the whole point
+// of the variable is that it can be.
+//
+// Deliberately never Number()/parseInt(): Number("") is 0, and 0 is a
+// perfectly valid WebView id, so an exported-but-empty MINAPK_WEBVIEW= (the
+// usual way to switch something off) would come out meaning "open in the
+// console" -- i.e. navigate the terminal away. parseInt would likewise turn
+// "1x" into 1. Only a bare optionally-signed integer counts; anything else is
+// reported and treated as unset.
+function webViewIdFromEnv() {
+  const raw = (process.env.MINAPK_WEBVIEW ?? "").trim()
+  if (raw === "") return null
+  if (!/^-?\d+$/.test(raw)) {
+    process.stderr.write(
+      `xdg-open: ignoring MINAPK_WEBVIEW=${raw} (not an integer WebView id)\n`)
+    return null
+  }
+  return Number(raw)
+}
+
+// Only URLs. A filesystem path stays on the bridgeOpen path even when
+// MINAPK_WEBVIEW is set: WebView's setAllowFileAccess defaults to false from
+// API 30 on, so a file:// URL under Buninu's home would load as a blank page,
+// whereas the host's xdgOpen already serves that file properly through its
+// read-only content:// provider.
+const isUrl = (target) => /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(target)
+
+// The host answers with the id it actually used -- a JSON number -- and with
+// a string when something went wrong: "error: no such WebView: 9" from the
+// dispatcher, or rpc.mjs's own "Unknown func ..." when the APK is older than
+// these functions and does not list them in _discover. rpc.mjs also *resolves*
+// to an Error object instead of throwing when the fetch itself fails. So
+// success is checked as "is genuinely a number", never by parsing the result:
+// see webViewIdFromEnv above for why a coercing parse is dangerous here.
+//
+// showWebView(-1) means "switch to the next one", not "the one just loaded",
+// so the switch uses the id openWebView resolved and handed back, not the id
+// that was asked for.
+async function openInWebView(id, url) {
+  const opened = await openWebView(id, url)
+  if (typeof opened !== "number" || !Number.isInteger(opened)) {
+    process.stderr.write(
+      `xdg-open: MINAPK_WEBVIEW=${id}: ${opened?.message ?? opened}\n`)
+    return false
+  }
+
+  const shown = await showWebView(opened)
+  if (typeof shown !== "number" || !Number.isInteger(shown)) {
+    // Loaded but not brought to the front: say so rather than reporting
+    // success for something the user cannot see, but do not fall back to the
+    // system handler either -- the page really is loaded in that WebView.
+    process.stderr.write(
+      `xdg-open: loaded in WebView ${opened} but could not switch to it: ` +
+      `${shown?.message ?? shown}\n`)
+  }
+  return true
+}
+
+// Buninu's own bin/ is prepended to PATH ahead of any real system binary of
+// the same name (same concern as xclip.js/tts.js), and this script is
+// itself registered as Buninu's "xdg-open" command -- a naive PATH search
+// would just find this file. Skip Buninu's own bin dir and keep looking
+// further down PATH for wherever a real xdg-open actually lives.
+function findSystemXdgOpen() {
+  const ownBinDir = process.env.BUNINU_HOME ? `${process.env.BUNINU_HOME}/bin` : null
+  for (const dir of (process.env.PATH || "").split(":").filter(Boolean)) {
+    if (dir === ownBinDir) continue
+    const candidate = `${dir}/xdg-open`
+    try {
+      fs.accessSync(candidate, fs.constants.X_OK)
+      return candidate
+    } catch {}
+  }
+  return null
+}
+
+async function runCommand(args) {
+  const proc = Bun.spawn(args, { stdout: "ignore", stderr: "ignore" })
+  return (await proc.exited) === 0
+}
+
+const argv = process.argv.slice(2)
+
+if (argv.length === 0 || argv.includes("-h") || argv.includes("--help")) {
+  console.log("usage: xdg-open <file-or-url>")
+  process.exit(argv.length === 0 ? 1 : 0)
+}
+
+const target = argv[0]
+let ok = false
+
+try {
+  if (process.platform === "android") {
+    if (available()) {
+      const webViewId = webViewIdFromEnv()
+      // A failed WebView open falls back to the system handler rather than
+      // failing outright: the request was "open this", and MINAPK_WEBVIEW
+      // only says where it would be preferred. openInWebView has already
+      // explained on stderr why it could not.
+      ok = webViewId !== null && isUrl(target)
+        ? (await openInWebView(webViewId, target)) || (await bridgeOpen(target))
+        : await bridgeOpen(target)
+    } else if (Bun.which("termux-open")) {
+      // Plain Termux (no minapk) still reports platform "android" but has
+      // no PKG_BRIDGE_SOCK -- termux-open (Termux:API) does the same
+      // ACTION_VIEW-based open, same fallback relationship as tts.js's
+      // termux-tts-speak branch when native-bridge isn't available.
+      ok = await runCommand(["termux-open", target])
+    } else {
+      throw new Error("no native bridge and no termux-open (install termux-api, or run inside minapk's APK)")
+    }
+  } else if (process.platform === "darwin") {
+    ok = await runCommand(["open", target])
+  } else if (process.platform === "win32") {
+    // start is a cmd builtin, not a real executable, and needs an empty ""
+    // title argument first or it treats a quoted target as the title.
+    ok = await runCommand(["cmd", "/c", "start", "", target])
+  } else {
+    const real = findSystemXdgOpen()
+    if (!real) throw new Error("no system xdg-open found on PATH")
+    ok = await runCommand([real, target])
+  }
+} catch (e) {
+  process.stderr.write(`xdg-open: ${e.message}\n`)
+  process.exit(1)
+}
+
+// Explicit exit: bridgeOpen() goes through native-bridge's call(), whose own
+// timeout race leaves an abandoned fetch running the event loop on a
+// timeout -- without this, xdg-open could hang after printing everything it
+// needs to.
+process.exit(ok ? 0 : 1)

package/initramfs/buninu/bin/bun.bat

@@ -0,0 +1,37 @@
+@echo off
+setlocal EnableExtensions EnableDelayedExpansion
+
+set "BUNINU_BUN_ARCHIVE=%~dp0..\apps\bun\bunBin.tgz"
+set "BUNINU_BUN_WX=%~dp0bun-wx.exe"
+set "BUNINU_EXTRACT_BUN="
+
+if exist "%BUNINU_BUN_ARCHIVE%" (
+  if not exist "%BUNINU_BUN_WX%" set "BUNINU_EXTRACT_BUN=1"
+
+  if exist "%BUNINU_BUN_WX%" if exist "%SystemRoot%\System32\WindowsPowerShell\v1.0\powershell.exe" (
+    for /f "delims=" %%U in ('"%SystemRoot%\System32\WindowsPowerShell\v1.0\powershell.exe" -NoLogo -NoProfile -NonInteractive -Command "if ((Get-Item -LiteralPath $env:BUNINU_BUN_ARCHIVE).LastWriteTimeUtc -gt (Get-Item -LiteralPath $env:BUNINU_BUN_WX).LastWriteTimeUtc) { '1' }"') do set "BUNINU_EXTRACT_BUN=%%U"
+  )
+)
+
+if defined BUNINU_EXTRACT_BUN (
+  tar -xzf "%BUNINU_BUN_ARCHIVE%" -C "%~dp0"
+  if errorlevel 1 (
+    echo Failed to extract Bun archive: %BUNINU_BUN_ARCHIVE% 1>&2
+    exit /b 1
+  )
+)
+
+if exist "%~dp0bun-wx.exe" (
+  "%~dp0bun-wx.exe" %*
+  exit /b !ERRORLEVEL!
+)
+
+for /f "delims=" %%B in ('where bun.exe 2^>nul') do (
+  if /I not "%%~dpB"=="%~dp0" (
+    "%%~fB" %*
+    exit /b !ERRORLEVEL!
+  )
+)
+
+echo Bun Binary not found: %~dp0bun-wx.exe ^(and no external bun.exe found in PATH^) 1>&2
+exit /b 127

package/initramfs/buninu/bin/bun.sh

@@ -0,0 +1,57 @@
+#!/bin/sh
+
+sd=$(dirname "$(realpath "$0")")
+
+bunBinTgz=$sd/../apps/bun/bunBin.tgz
+
+annl=androidNativeLibs
+
+if [ -f /system/bin/linker64 ] ; then
+  if [ -f "$sd"/$annl/libbun.so ] ; then
+    exec "$sd"/$annl/libbun.so "$@"
+  elif uname -m | grep -q aarch64 ; then
+    bunBin="$sd"/bun-la
+  else
+    bunBin="$sd"/bun-lx
+  fi
+elif [ -d "$WINDIR" ] ; then
+  bunBin="$sd"/bun-wx.exe
+elif uname -m | grep -q aarch64 ; then
+  bunBin="$sd"/bun-la
+else
+  bunBin="$sd"/bun-lx
+fi
+
+
+if [ -f "$bunBinTgz" ] &&
+   [ "$bunBinTgz" -nt "$bunBin" ] ; then
+  tar -xzvf "$bunBinTgz" -C "$sd"
+fi
+
+ 
+if [ -f "$bunBin" ] ; then
+  exec "$bunBin" "$@"
+fi
+
+# The package bin directory can contain a `bun` symlink back to this script.
+# Search PATH manually so that a system/user-installed Bun outside this
+# directory can be used without recursively executing bun.sh again.
+oldIFS=$IFS
+IFS=:
+for pathDir in ${PATH:-} ; do
+  [ -n "$pathDir" ] || pathDir=.
+  if [ "$(realpath "$pathDir" 2>/dev/null)" = "$sd" ] ; then
+    continue
+  fi
+
+  for externalBun in "$pathDir/bun" "$pathDir/bun.exe" ; do
+    if [ -f "$externalBun" ] && [ -x "$externalBun" ] ; then
+      IFS=$oldIFS
+      exec "$externalBun" "$@"
+    fi
+  done
+done
+IFS=$oldIFS
+
+echo "Bun Binary not found: $bunBin (and no external Bun found in PATH)" 1>&2
+exit 127

package/initramfs/buninu/bin/buninu-help.bat

@@ -0,0 +1,4 @@
+@echo off
+call "%~dp0bun.bat" "%~dp0..\apps\jsmdcui\src\index.js" --cat "%~dp0..\README.md"
+call "%~dp0bun.bat" "%~dp0..\apps\jsgotty\gotty.js" --viu "%~dp0..\icon.png"
+exit /b %ERRORLEVEL%

package/initramfs/buninu/bin/buninu-help.sh

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+sd=$(dirname "$(realpath "$0")")
+root=$sd/..
+
+bun "$root"/apps/jsmdcui/src/index.js --cat "$root"/README.md
+exec bun "$root"/apps/jsgotty/gotty.js --viu "$root"/icon.png

package/initramfs/buninu/bin/bunmsh.bat

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

package/initramfs/buninu/bin/bunmsh.sh

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

package/initramfs/buninu/bin/bunx.bat

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

package/initramfs/buninu/bin/glow.bat

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

package/initramfs/buninu/bin/glow.sh

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