buninu-linux 0.2.0

package/initramfs/buninu/apps/musl-la/LICENSES/gcc_runtime_exception.txt

@@ -0,0 +1,73 @@
+GCC RUNTIME LIBRARY EXCEPTION
+
+Version 3.1, 31 March 2009
+
+Copyright (C) 2009 Free Software Foundation, Inc. <http://fsf.org/>
+
+Everyone is permitted to copy and distribute verbatim copies of this
+license document, but changing it is not allowed.
+
+This GCC Runtime Library Exception ("Exception") is an additional
+permission under section 7 of the GNU General Public License, version
+3 ("GPLv3"). It applies to a given file (the "Runtime Library") that
+bears a notice placed by the copyright holder of the file stating that
+the file is governed by GPLv3 along with this Exception.
+
+When you use GCC to compile a program, GCC may combine portions of
+certain GCC header files and runtime libraries with the compiled
+program. The purpose of this Exception is to allow compilation of
+non-GPL (including proprietary) programs to use, in this way, the
+header files and runtime libraries covered by this Exception.
+
+0. Definitions.
+
+A file is an "Independent Module" if it either requires the Runtime
+Library for execution after a Compilation Process, or makes use of an
+interface provided by the Runtime Library, but is not otherwise based
+on the Runtime Library.
+
+"GCC" means a version of the GNU Compiler Collection, with or without
+modifications, governed by version 3 (or a specified later version) of
+the GNU General Public License (GPL) with the option of using any
+subsequent versions published by the FSF.
+
+"GPL-compatible Software" is software whose conditions of propagation,
+modification and use would permit combination with GCC in accord with
+the license of GCC.
+
+"Target Code" refers to output from any compiler for a real or virtual
+target processor architecture, in executable form or suitable for
+input to an assembler, loader, linker and/or execution
+phase. Notwithstanding that, Target Code does not include data in any
+format that is used as a compiler intermediate representation, or used
+for producing a compiler intermediate representation.
+
+The "Compilation Process" transforms code entirely represented in
+non-intermediate languages designed for human-written code, and/or in
+Java Virtual Machine byte code, into Target Code. Thus, for example,
+use of source code generators and preprocessors need not be considered
+part of the Compilation Process, since the Compilation Process can be
+understood as starting with the output of the generators or
+preprocessors.
+
+A Compilation Process is "Eligible" if it is done using GCC, alone or
+with other GPL-compatible software, or if it is done without using any
+work based on GCC. For example, using non-GPL-compatible Software to
+optimize any GCC intermediate representations would not qualify as an
+Eligible Compilation Process.
+
+1. Grant of Additional Permission.
+
+You have permission to propagate a work of Target Code formed by
+combining the Runtime Library with Independent Modules, even if such
+propagation would otherwise violate the terms of GPLv3, provided that
+all Target Code was generated by Eligible Compilation Processes. You
+may then convey such a combination under terms of your choice,
+consistent with the licensing of the Independent Modules.
+
+2. No Weakening of GCC Copyleft.
+
+The availability of this Exception does not imply any general
+presumption that third-party software is unaffected by the copyleft
+requirements of the license of GCC.
+

package/initramfs/buninu/apps/musl-la/LICENSE_musl.txt

@@ -0,0 +1,193 @@
+musl as a whole is licensed under the following standard MIT license:
+
+----------------------------------------------------------------------
+Copyright © 2005-2020 Rich Felker, et al.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+----------------------------------------------------------------------
+
+Authors/contributors include:
+
+A. Wilcox
+Ada Worcester
+Alex Dowad
+Alex Suykov
+Alexander Monakov
+Andre McCurdy
+Andrew Kelley
+Anthony G. Basile
+Aric Belsito
+Arvid Picciani
+Bartosz Brachaczek
+Benjamin Peterson
+Bobby Bingham
+Boris Brezillon
+Brent Cook
+Chris Spiegel
+Clément Vasseur
+Daniel Micay
+Daniel Sabogal
+Daurnimator
+David Carlier
+David Edelsohn
+Denys Vlasenko
+Dmitry Ivanov
+Dmitry V. Levin
+Drew DeVault
+Emil Renner Berthing
+Fangrui Song
+Felix Fietkau
+Felix Janda
+Gianluca Anzolin
+Hauke Mehrtens
+He X
+Hiltjo Posthuma
+Isaac Dunham
+Jaydeep Patil
+Jens Gustedt
+Jeremy Huntwork
+Jo-Philipp Wich
+Joakim Sindholt
+John Spencer
+Julien Ramseier
+Justin Cormack
+Kaarle Ritvanen
+Khem Raj
+Kylie McClain
+Leah Neukirchen
+Luca Barbato
+Luka Perkov
+Lynn Ochs
+M Farkas-Dyck (Strake)
+Mahesh Bodapati
+Markus Wichmann
+Masanori Ogino
+Michael Clark
+Michael Forney
+Mikhail Kremnyov
+Natanael Copa
+Nicholas J. Kain
+orc
+Pascal Cuoq
+Patrick Oppenlander
+Petr Hosek
+Petr Skocik
+Pierre Carrier
+Reini Urban
+Rich Felker
+Richard Pennington
+Ryan Fairfax
+Samuel Holland
+Segev Finer
+Shiz
+sin
+Solar Designer
+Stefan Kristiansson
+Stefan O'Rear
+Szabolcs Nagy
+Timo Teräs
+Trutz Behn
+Will Dietz
+William Haddon
+William Pitcock
+
+Portions of this software are derived from third-party works licensed
+under terms compatible with the above MIT license:
+
+The TRE regular expression implementation (src/regex/reg* and
+src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed
+under a 2-clause BSD license (license text in the source files). The
+included version has been heavily modified by Rich Felker in 2012, in
+the interests of size, simplicity, and namespace cleanliness.
+
+Much of the math library code (src/math/* and src/complex/*) is
+Copyright © 1993,2004 Sun Microsystems or
+Copyright © 2003-2011 David Schultz or
+Copyright © 2003-2009 Steven G. Kargl or
+Copyright © 2003-2009 Bruce D. Evans or
+Copyright © 2008 Stephen L. Moshier or
+Copyright © 2017-2018 Arm Limited
+and labelled as such in comments in the individual source files. All
+have been licensed under extremely permissive terms.
+
+The ARM memcpy code (src/string/arm/memcpy.S) is Copyright © 2008
+The Android Open Source Project and is licensed under a two-clause BSD
+license. It was taken from Bionic libc, used on Android.
+
+The AArch64 memcpy and memset code (src/string/aarch64/*) are
+Copyright © 1999-2019, Arm Limited.
+
+The implementation of DES for crypt (src/crypt/crypt_des.c) is
+Copyright © 1994 David Burren. It is licensed under a BSD license.
+
+The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was
+originally written by Solar Designer and placed into the public
+domain. The code also comes with a fallback permissive license for use
+in jurisdictions that may not recognize the public domain.
+
+The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011
+Lynn Ochs and is licensed under an MIT-style license.
+
+The x86_64 port was written by Nicholas J. Kain and is licensed under
+the standard MIT terms.
+
+The mips and microblaze ports were originally written by Richard
+Pennington for use in the ellcc project. The original code was adapted
+by Rich Felker for build system and code conventions during upstream
+integration. It is licensed under the standard MIT terms.
+
+The mips64 port was contributed by Imagination Technologies and is
+licensed under the standard MIT terms.
+
+The powerpc port was also originally written by Richard Pennington,
+and later supplemented and integrated by John Spencer. It is licensed
+under the standard MIT terms.
+
+All other files which have no copyright comments are original works
+produced specifically for use as part of this library, written either
+by Rich Felker, the main author of the library, or by one or more
+contibutors listed above. Details on authorship of individual files
+can be found in the git version control history of the project. The
+omission of copyright and license comments in each file is in the
+interest of source tree size.
+
+In addition, permission is hereby granted for all public header files
+(include/* and arch/*/bits/*) and crt files intended to be linked into
+applications (crt/*, ldso/dlstart.c, and arch/*/crt_arch.h) to omit
+the copyright notice and permission notice otherwise required by the
+license, and to use these files without any requirement of
+attribution. These files include substantial contributions from:
+
+Bobby Bingham
+John Spencer
+Nicholas J. Kain
+Rich Felker
+Richard Pennington
+Stefan Kristiansson
+Szabolcs Nagy
+
+all of whom have explicitly granted such permission.
+
+This file previously contained text expressing a belief that most of
+the files covered by the above exception were sufficiently trivial not
+to be subject to copyright, resulting in confusion over whether it
+negated the permissions granted in the license. In the spirit of
+permissive licensing, and of not having licensing issues being an
+obstacle to adoption, that text has been removed.

package/initramfs/buninu/apps/musl-la/NOTICE

@@ -0,0 +1,41 @@
+This product includes third-party components:
+
+- ld-musl-aarch64.so.1
+  License: MIT
+  See: ./LICENSE_musl.txt
+
+  The musl dynamic loader, version 1.2.5, as packaged by Alpine Linux
+  (package musl, version 1.2.5-r10, aarch64).
+
+  Upstream musl source:
+  https://musl.libc.org/releases/musl-1.2.5.tar.gz
+
+  Alpine's CDN serves only the current pkgrel of each branch, and 1.2.5-r10
+  has since been superseded, so it is no longer downloadable there. An
+  archived copy of that exact build ships in the Alpine aarch64 rootfs
+  published by Termux proot-distro, which reports Alpine 3.22.2 and
+  musl 1.2.5-r10 in its apk database:
+  https://github.com/termux/proot-distro/releases/download/v4.30.1/alpine-aarch64-pd-v4.30.1.tar.xz
+
+  SHA-256 (verified byte-for-byte identical to lib/ld-musl-aarch64.so.1 in
+  that rootfs):
+    ld-musl-aarch64.so.1: da9c2d18642cf67ade0947b88b6859385c085fdbc6a022f5a8b518d7677e55df
+
+- libgcc_s.so.1 / libstdc++.so.6
+  License: GPL-3.0 + GCC Runtime Library Exception
+  See: ./LICENSES/GPL-3.0.txt and ./LICENSES/gcc_runtime_exception.txt
+
+  Built from GCC 14.2.0, as packaged by Alpine Linux 3.22
+  (packages libgcc and libstdc++, version 14.2.0-r6, aarch64).
+
+  Upstream GCC source:
+  https://gcc.gnu.org/pub/gcc/releases/gcc-14.2.0/gcc-14.2.0.tar.xz
+
+  Alpine's build recipe and patches (Corresponding Source for this exact
+  build), pinned to the commit matching pkgrel=6:
+  https://gitlab.alpinelinux.org/alpine/aports/-/blob/fbf60319be3bbaf6dd32ef55cc6fb7189e05c266/main/gcc/APKBUILD
+
+  SHA-256 (verified byte-for-byte identical to the official Alpine 3.22
+  aarch64 packages):
+    libgcc_s.so.1:  2d945d6ce360769b41fbffc652c2440014bbd69416f13fe206fbac19d32c9431
+    libstdc++.so.6: 85f2cd6db79578ab58be4d12b7df7482ebc003a37496c7544956d9157f8a2b3f

package/initramfs/buninu/apps/musl-la/musl-la.sh

@@ -0,0 +1,36 @@
+#!/bin/sh
+
+sd=$(dirname "$(realpath "$0")")
+
+muslbin=$sd/../../bin/androidNativeLibs/libld-musl.so
+
+if [ ! -f "$muslbin" ] ; then
+  muslbin=$sd/ld-musl-aarch64.so.1
+fi
+
+use_env=
+if [ "$1" = -e ] ; then
+  shift
+  use_env=1
+fi
+
+elfdir=
+for arg; do
+  if [ -f "$arg" ] ; then
+    elf_magic=$(od -A n -t x1 -N 4 "$arg" 2>/dev/null | tr -d '[:space:]')
+    if [ "$elf_magic" = 7f454c46 ] ; then
+      elfdir=$(dirname "$(realpath "$arg")")
+      break
+    fi
+  fi
+done
+
+library_path=$sd${elfdir:+:$elfdir}${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}
+
+if [ "$use_env" = 1 ] ; then
+  LD_LIBRARY_PATH=$library_path
+  export LD_LIBRARY_PATH
+  exec "$muslbin" "$@"
+fi
+
+exec "$muslbin" --library-path "$library_path" "$@"

package/initramfs/buninu/apps/native-bridge/native-bridge.js

@@ -0,0 +1,199 @@
+// Called from a jsmdcui `js back` block (a Bun process), never from `js front`:
+// the `unix` fetch option native-bridge relies on only works under Bun, not
+// inside the Android WebView that renders front code.
+// rpc.mjs's rpc.* Proxy exists so a caller can dial an RPC by a name it only
+// knows at runtime; every call here uses a fixed, known-in-advance name, so
+// there is nothing that sugar buys us. Going straight to rpcraw also gets us
+// a real envp slot -- rpc.foo(...) always sends envp as {} (it is fed by the
+// Proxy's own internal `this`, not anything a caller supplies).
+import { rpcraw, switchBackend } from "../jsmdcui/src/cui/rpc.mjs"
+
+// PKG_BRIDGE_SOCK carries whatever rpc.mjs's rpcFetchOpt() needs after
+// decodeURIComponent(new URL("unix:"+sock).pathname): percent-encoded
+// (e.g. "%00native-bridge") for a Linux abstract-namespace socket -- an env
+// var cannot carry a literal NUL byte, but it can carry the three ASCII
+// characters "%00" -- or a plain path for a real filesystem socket, which
+// has nothing that needs encoding and passes through unchanged. Either way,
+// native-bridge.js does not decide which; it forwards the value as-is.
+const sock = process.env.PKG_BRIDGE_SOCK
+
+if (sock) switchBackend(`unix:${sock}`)
+
+// rpc.mjs never throws for a call the far side does not implement; it
+// resolves to a string starting with "Unknown func" instead (evalBack/rpcraw
+// in rpc.mjs both use this exact prefix). Default here is the same silent
+// behavior; call nothrow(false) to make native-bridge throw in that case
+// instead, so a missing PKG_BRIDGE_SOCK or an unimplemented host method fails
+// loudly rather than being mistaken for a successful result. Any value other
+// than an explicit `false` (including calling nothrow() with no argument)
+// restores the default silent behavior.
+let noThrowUnknownFunc = true
+
+export function nothrow(bool)
+{
+  noThrowUnknownFunc = bool !== false
+}
+
+// fetch() never times out on its own: if the host never answers (main thread
+// wedged, bridge crashed mid-request, anything), the await below would hang
+// forever without this race. The abandoned rpcraw() call keeps running in
+// the background after the race settles -- Bun's event loop treats a
+// pending fetch as a reason to stay alive, so it is not enough for this
+// function to merely return; whatever ultimately calls call() must still
+// process.exit() once it is done, or the process itself will not exit even
+// though every await has resolved.
+const DEFAULT_TIMEOUT_MS = 5000
+
+export async function call(name, args = [], envp, timeoutMs = DEFAULT_TIMEOUT_MS)
+{
+  if (!sock)
+    throw new Error(`native-bridge: PKG_BRIDGE_SOCK is not set (not running inside minapk's APK)`)
+
+  const result = await Promise.race([
+    rpcraw(name, args, envp),
+    new Promise((_, reject) =>
+      setTimeout(() => reject(new Error(
+        `native-bridge: "${name}" timed out after ${timeoutMs}ms`)), timeoutMs)),
+  ])
+
+  if (!noThrowUnknownFunc && typeof result === "string" && result.startsWith("Unknown func"))
+    throw new Error(`native-bridge: host does not implement "${name}"`)
+
+  return result
+}
+
+export const available = () => !!sock
+
+// clipboardRead/clipboardWrite are long enough to want a short alias; toast
+// already is one. The Java dispatcher accepts either spelling over the wire
+// and lists both in its _discover response, so calling the alias directly
+// (e.g. from the CLI below, or another rpcraw caller) works too, not just
+// through these.
+export const toast = (text, long = false) => call("toast", [text, long])
+
+export const clipboardRead = () => call("clipboardRead")
+export const getcb = clipboardRead
+
+export const clipboardWrite = (text) => call("clipboardWrite", [text])
+export const setcb = clipboardWrite
+
+// TTS has no push/callback path over this protocol -- speak() only waits for
+// the host to accept the utterance, not for it to finish speaking, and
+// returns a handle immediately. Poll ttsStatus(handle) yourself ("speaking",
+// "done", "error", or "unknown" once a terminal state has already been
+// consumed) until it leaves "speaking"; apps/tts wraps that loop for the
+// common case instead of every caller writing its own.
+// Only text is required. 1.0 is normal for both speed and pitch, same
+// convention as termux-tts-speak's -p/-r; native-bridge does not assume any
+// particular caller's own default (jsmdcui's TTS_PITCH/TTS_SPEED, for
+// instance, default to 1/1.5 -- that is jsmdcui's own choice, read
+// TTS_PITCH/TTS_SPEED yourself if you want to honor it).
+export const speak = (text, speed = 1, pitch = 1, flush = false) =>
+  call("speak", [text, speed, pitch, flush])
+
+export const ttsStatus = (handle) => call("ttsStatus", [handle])
+export const tts = ttsStatus
+
+// target is either a URL (any scheme:// prefix, opened via ACTION_VIEW same
+// as a WebView link tap) or a path under Buninu's home -- served back out
+// through a read-only content:// provider, since the home directory is
+// otherwise private to this app and a raw file:// Uri would be rejected by
+// the receiving app on modern Android.
+export const xdgOpen = (target) => call("xdgOpen", [target])
+
+// The host has exactly two WebViews, both alive from startup and neither ever
+// created nor closed at runtime: WEBVIEW_CONSOLE (0) is the jsgotty terminal
+// this shell is being rendered in, WEBVIEW_APP (1) is the app WebView, which
+// simply starts out blank and behind. WEBVIEW_CURRENT (-1) means whichever
+// one is in front right now, and is the default wherever an id is optional.
+// All four functions also go by openwv/evalwv/showwv/currwv, both here and
+// over the wire (the Java dispatcher answers to either spelling and lists
+// both in _discover), on the same grounds as getcb/setcb above.
+export const WEBVIEW_CURRENT = -1
+export const WEBVIEW_CONSOLE = 0
+export const WEBVIEW_APP = 1
+
+// Loads url into a WebView *without* bringing it to the front, so
+// openWebView(WEBVIEW_APP, url) while the user is looking at the terminal is
+// a plain background load -- showWebView is the only thing that changes what
+// is on screen. Omitting url loads nothing and just reports the id back,
+// which is how -1 gets resolved to a real id. Returns the id loaded into.
+export const openWebView = (id = WEBVIEW_CURRENT, url = "") =>
+  call("openWebView", [id, url])
+export const openwv = openWebView
+
+// Resolves to the value the expression produced -- a real number/string/
+// object, not a string containing one -- because the host sends
+// evaluateJavascript's own JSON text straight back as the response body.
+// undefined, a function, and a thrown exception all arrive as null: WebView
+// itself does not distinguish them, so return something JSON can carry when
+// you need to tell them apart. A page that never answers is given up on by
+// the host (inside this module's own call timeout) and comes back as an
+// "error: ..." string rather than hanging.
+export const evalWebView = (id, js) => call("evalWebView", [id, js])
+export const evalwv = evalWebView
+
+// Brings a WebView to the front. The bottom key bar (Ctrl/Alt/Shift and
+// friends), the volume-key menu and the back key all act on whatever is in
+// front, so this is also what re-points them. An id of -1 -- the default --
+// switches to the next WebView rather than being a no-op, which with two of
+// them is simply a toggle. Returns the id now in front.
+export const showWebView = (id = WEBVIEW_CURRENT) => call("showWebView", [id])
+export const showwv = showWebView
+
+// The id of the WebView in front, for code that wants to put something back
+// the way it found it.
+export const currWebView = () => call("currWebView")
+export const currwv = currWebView
+
+// `bun native-bridge.js <func> [args...]`, dispatched straight to call(func,
+// args) -- not restricted to toast/clipboardRead/clipboardWrite, exactly like
+// calling rpcraw(func, args) would be. This is a raw RPC, equivalent to a
+// native function call on the host side: the result can be any JSON value
+// (string, number, boolean, null, array, object), not just a plain object,
+// so it is printed as-is rather than assumed to have any particular shape.
+// Each arg is JSON.parse'd when it parses cleanly (so `42`, `true`, `[1,2]`,
+// `{"a":1}` arrive as their real types) and kept as a plain string otherwise
+// (so `hi` stays "hi" rather than failing to parse as JSON). No func given at
+// all defaults to `_discover`, so a bare `bun native-bridge.js` lists what
+// the far side implements instead of erroring.
+export async function main()
+{
+  const [name = "_discover", ...rawArgs] = process.argv.slice(2)
+
+  const args = rawArgs.map(arg => {
+    try { return JSON.parse(arg) } catch { return arg }
+  })
+
+  try
+  {
+    const result = await call(name, args)
+
+    // Display-only: _discover's real value (an object, relied on as-is by
+    // rpc.mjs's own dispatch gate -- see FrontendDiscoverApi/rpcraw) is
+    // never touched. This only changes what gets printed here, one
+    // function per line instead of JSON.stringify's single-line output, so
+    // the list is easy to grep.
+    if (name === "_discover" && result && typeof result === "object")
+    {
+      const lines = Object.entries(result).map(([k, v]) => `"${k}":${JSON.stringify(v)}`)
+      console.log("{\n" + lines.join(",\n") + "\n}")
+    }
+    else
+    {
+      console.log(JSON.stringify(result))
+    }
+  }
+  catch (e)
+  {
+    console.error(e.message)
+    process.exit(1)
+  }
+
+  // Explicit exit even on success: see the note above call()'s timeout race
+  // -- an abandoned rpcraw() from a prior timeout can keep the process alive
+  // on its own otherwise.
+  process.exit(0)
+}
+
+if (import.meta.main) main()

package/initramfs/buninu/apps/native-bridge/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "native-bridge",
+  "version": "0.1.0",
+  "description": "Call the Android host app (toast, clipboard, ...) from a Buninu Bun back script, over the unix socket minapk exposes as PKG_BRIDGE_SOCK",
+  "type": "module",
+  "main": "./native-bridge.js",
+  "license": "MIT"
+}