buninu 0.1.1

package/bin/init.js

@@ -0,0 +1,395 @@
+#!/usr/bin/env bun
+
+import pkg from "../package.json" with { type: "json" };
+import { existsSync, mkdirSync } from "node:fs";
+import { tmpdir as systemTmpDir } from "node:os";
+import { basename, delimiter, dirname, isAbsolute, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const binDir = dirname(fileURLToPath(import.meta.url));
+const rootDir = resolve(binDir, "..");
+const REPO_ROOT = rootDir;
+
+function fail(message) {
+  console.error(`${pkg.name}: ${message}`);
+  process.exit(1);
+}
+
+function usage() {
+  return `${pkg.name} - ${pkg.description}
+
+Usage:
+  ${pkg.name} [init options] [jsgotty options]
+
+Init options:
+  -h, --help             Show this help and exit
+  -V, --version          Show version and runtime information, then exit
+  --readme               Render README.md in the terminal and exit
+  --shell <path|name>    Override buninu.shell for this run
+  --command <command>    Override buninu.command for this run
+
+Package configuration:
+  package.json contains a buninu section for default and platform settings.
+  buninu.shell          Select the shell to start
+  buninu.command        Run a startup command before entering the shell
+
+All other options are forwarded to jsgotty. Without buninu.command, the
+selected shell starts directly. With a command, it runs from the package.json
+directory and then returns to the interactive shell regardless of exit status.
+`;
+}
+
+async function handleInformationArguments(arguments_) {
+  if (arguments_.includes("-h") || arguments_.includes("--help")) {
+    console.log(usage());
+    return true;
+  }
+
+  if (arguments_.includes("-V") || arguments_.includes("--version")) {
+    console.log(`${pkg.name}: ${pkg.description}`);
+    console.log("Version:", pkg.version);
+    console.log("Runtime:", `Bun ${Bun.version}`);
+    console.log("Platform:", `${process.platform}/${process.arch}`);
+    return true;
+  }
+
+  if (arguments_.includes("--readme")) {
+    const readmePath = resolve(REPO_ROOT, "README.md");
+    if (!await pathExists(readmePath)) fail(`README not found: ${readmePath}`);
+    const markdown = await Bun.file(readmePath).text();
+    process.stdout.write(Bun.markdown.ansi(markdown, { hyperlinks: true }));
+    if (!markdown.endsWith("\n")) process.stdout.write("\n");
+    return true;
+  }
+
+  return false;
+}
+
+function splitCommand(command) {
+  const words = [];
+  let word = "";
+  let quote = "";
+  let escaped = false;
+
+  for (const char of command.trim()) {
+    if (escaped) {
+      word += char;
+      escaped = false;
+    } else if (char === "\\" && quote !== "'") {
+      escaped = true;
+    } else if (quote) {
+      if (char === quote) quote = "";
+      else word += char;
+    } else if (char === "'" || char === '"') {
+      quote = char;
+    } else if (/\s/.test(char)) {
+      if (word) words.push(word), word = "";
+    } else {
+      word += char;
+    }
+  }
+
+  if (escaped || quote) fail("invalid quoting in package.json scripts.start");
+  if (word) words.push(word);
+  return words;
+}
+
+async function pathExists(path) {
+  return Bun.file(path).exists();
+}
+
+async function findCommand(command) {
+  if (!command) return null;
+  if (command.includes("/") || command.includes("\\")) {
+    const path = isAbsolute(command) ? command : resolve(rootDir, command);
+    return await pathExists(path) ? path : null;
+  }
+  return Bun.which(command);
+}
+
+async function detectEnvironment() {
+  const windows = process.platform === "win32" || Boolean(process.env.WINDIR);
+  const android = !windows && (
+    process.platform === "android" ||
+    await pathExists("/system/bin/linker64") ||
+    Boolean(process.env.ANDROID_ROOT && process.env.ANDROID_DATA)
+  );
+
+  if (windows) {
+    return {
+      name: "windows",
+      shell:
+        await findCommand(process.env.COMSPEC) ||
+        Bun.which("pwsh.exe") ||
+        Bun.which("powershell.exe") ||
+        Bun.which("cmd.exe") ||
+        "cmd.exe",
+    };
+  }
+
+  if (android) {
+    return {
+      name: "android",
+      shell:
+        await findCommand(process.env.SHELL) ||
+        (await pathExists("/system/bin/sh") ? "/system/bin/sh" : null) ||
+        Bun.which("sh") ||
+        "sh",
+    };
+  }
+
+  if (process.platform === "darwin") {
+    return {
+      name: "macos",
+      shell:
+        await findCommand(process.env.SHELL) ||
+        Bun.which("zsh") ||
+        Bun.which("bash") ||
+        Bun.which("sh") ||
+        "/bin/zsh",
+    };
+  }
+
+  if (process.platform === "linux") {
+    return {
+      name: "linux",
+      shell:
+        await findCommand(process.env.SHELL) ||
+        Bun.which("bash") ||
+        Bun.which("sh") ||
+        "/bin/sh",
+    };
+  }
+
+  return {
+    name: `unix:${process.platform}`,
+    shell:
+      await findCommand(process.env.SHELL) ||
+      Bun.which("bash") ||
+      Bun.which("sh") ||
+      "/bin/sh",
+  };
+}
+
+async function runPlatformSwitch(environment) {
+  const scriptName = environment.name === "android"
+    ? "switch_to_android.sh"
+    : environment.name === "linux"
+      ? "switch_to_linux.sh"
+      : null;
+  if (!scriptName) return;
+
+  const scriptPath = resolve(binDir, scriptName);
+  if (!await pathExists(scriptPath)) {
+    fail(`platform switch script does not exist: ${scriptPath}`);
+  }
+
+  const shell = environment.name === "android" && await pathExists("/system/bin/sh")
+    ? "/system/bin/sh"
+    : Bun.which("sh") || "/bin/sh";
+  const result = Bun.spawn([shell, scriptPath], {
+    cwd: rootDir,
+    env: { ...process.env },
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit",
+  });
+  const status = await result.exited;
+  if (status !== 0) {
+    fail(`${scriptName} failed with exit ${status}`);
+  }
+}
+
+function getFreePort() {
+  const listener = Bun.listen({
+    hostname: "127.0.0.1",
+    port: 0,
+    socket: {
+      data() {},
+    },
+  });
+  const port = listener.port;
+  listener.stop(true);
+  return port;
+}
+
+async function createChildEnvironment(environment) {
+  const packageDir = dirname(rootDir);
+  const androidCacheDir = resolve(packageDir, "cache");
+  const tmpDir = process.env.TMPDIR || (
+    environment.name === "android"
+      ? existsSync(androidCacheDir)
+        ? androidCacheDir
+        : resolve(rootDir, "tmp")
+      : systemTmpDir()
+  );
+  const homeDir = process.env.HOME || rootDir;
+  const envFile = await pathExists(resolve(rootDir, ".bashrc"))
+    ? resolve(rootDir, ".bashrc")
+    : await pathExists(resolve(homeDir, ".bashrc"))
+      ? resolve(homeDir, ".bashrc")
+      : null;
+
+  mkdirSync(tmpDir, { recursive: true });
+
+  const inheritedPath = process.env.PATH || "";
+  const hasTermuxExecPreload =
+    environment.name === "android" &&
+    String(process.env.LD_PRELOAD || "").includes("libtermux-exec.so");
+  const pathEntries = [
+    ...(hasTermuxExecPreload ? ["/system/bin"] : []),
+    inheritedPath,
+    binDir,
+  ].filter(Boolean);
+
+  return {
+    ...process.env,
+    PATH: pathEntries.join(delimiter),
+    HOME: homeDir,
+    TMPDIR: tmpDir,
+    SHELL: process.env.SHELL || environment.shell,
+    BUNINU_HOME: rootDir,
+    ...(envFile ? { ENV: envFile } : {}),
+    TERM: process.env.TERM || "xterm-256color",
+    COLORTERM: process.env.COLORTERM || "truecolor",
+    DISPLAY: process.env.DISPLAY || "127.0.0.1:0",
+  };
+}
+
+function readInitArguments(arguments_) {
+  const forwarded = [];
+  let shell = null;
+  let command = null;
+
+  for (let index = 0; index < arguments_.length; index += 1) {
+    const argument = arguments_[index];
+    if (argument === "--shell" || argument === "--terminal") {
+      shell = arguments_[index + 1];
+      if (!shell) fail(`${argument} requires a command or executable path`);
+      index += 1;
+    } else if (argument.startsWith("--shell=") || argument.startsWith("--terminal=")) {
+      shell = argument.slice(argument.indexOf("=") + 1);
+      if (!shell) fail(`${argument.split("=")[0]} requires a command or executable path`);
+    } else if (argument === "--command") {
+      command = arguments_[index + 1];
+      if (!command) fail("--command requires a shell command string");
+      index += 1;
+    } else if (argument.startsWith("--command=")) {
+      command = argument.slice("--command=".length);
+      if (!command) fail("--command requires a shell command string");
+    } else {
+      forwarded.push(argument);
+    }
+  }
+
+  return { shell, command, forwarded };
+}
+
+function shellCommandArguments(shell, command) {
+  if (!command) return [shell];
+
+  const shellName = basename(shell).toLowerCase();
+  if (shellName === "cmd" || shellName === "cmd.exe") {
+    const quotedShell = `"${shell.replaceAll('"', '""')}"`;
+    return [shell, "/d", "/s", "/c", `${command} & ${quotedShell}`];
+  }
+
+  if (["powershell", "powershell.exe", "pwsh", "pwsh.exe"].includes(shellName)) {
+    const escapedShell = shell.replaceAll("'", "''");
+    return [
+      shell,
+      "-NoLogo",
+      "-Command",
+      `& { ${command}; if (-not $?) { Write-Error 'Startup command failed' }; & '${escapedShell}' -NoExit }`,
+    ];
+  }
+
+  const wrapped =
+    `(\n${command}\n)\n` +
+    `status=$?\n` +
+    `if [ "$status" -ne 0 ]; then\n` +
+    `  echo "buninu: startup command failed with exit $status" >&2\n` +
+    `fi\n` +
+    `exec "$0"`;
+  // The argument after the command string becomes $0. Passing the shell path
+  // as argv avoids interpolating or quoting an executable path inside the
+  // user's shell command.
+  return [shell, "-c", wrapped, shell];
+}
+
+const startScript = pkg.scripts?.start;
+if (typeof startScript !== "string" || !startScript.trim()) {
+  fail("package.json does not define scripts.start");
+}
+
+if (await handleInformationArguments(process.argv.slice(2))) process.exit(0);
+
+const command = splitCommand(startScript);
+if (!command.length) fail("package.json scripts.start is empty");
+
+// Use the Bun currently running init.js instead of relying on a second PATH lookup.
+if (command[0] === "bun") command[0] = process.execPath;
+
+const environment = await detectEnvironment();
+await runPlatformSwitch(environment);
+const initArguments = readInitArguments(process.argv.slice(2));
+const configuredShell =
+  pkg.buninu?.shell?.[environment.name] ??
+  pkg.buninu?.shell?.default ??
+  null;
+const requestedShell =
+  initArguments.shell ||
+  configuredShell;
+
+if (requestedShell) {
+  const resolvedShell = await findCommand(requestedShell);
+  if (!resolvedShell) {
+    fail(`configured shell does not exist: ${requestedShell}`);
+  }
+  environment.shell = resolvedShell;
+}
+
+const commandConfiguration = pkg.buninu?.command;
+const configuredCommand =
+  typeof commandConfiguration === "string"
+    ? commandConfiguration
+    : commandConfiguration?.[environment.name] ??
+      commandConfiguration?.default ??
+      null;
+const startupCommand = initArguments.command ?? configuredCommand;
+
+const forwardedArguments = initArguments.forwarded;
+const hasExplicitPort = forwardedArguments.some((argument) =>
+  argument === "-p" ||
+  argument === "--port" ||
+  argument.startsWith("--port=")
+);
+const portArguments = hasExplicitPort ? [] : ["-p", String(getFreePort())];
+const childEnvironment = await createChildEnvironment(environment);
+
+console.error(
+  `${pkg.name}@${pkg.version}: ${environment.name}/${process.arch}, ` +
+  `port=${portArguments[1] || "user-defined"}, shell=${environment.shell}`,
+);
+
+const child = Bun.spawn(
+  [
+    ...command,
+    ...portArguments,
+    ...forwardedArguments,
+    ...shellCommandArguments(environment.shell, startupCommand),
+  ],
+  {
+    cwd: rootDir,
+    env: childEnvironment,
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit",
+  },
+);
+
+for (const signal of ["SIGINT", "SIGTERM"]) {
+  process.on(signal, () => child.kill(signal));
+}
+
+process.exit(await child.exited);

package/bin/jmi.sh

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

package/bin/jsgotty.sh

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

package/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/bin/multicall.sh

@@ -0,0 +1,90 @@
+#!/bin/sh
+
+args=$(tr '\0' '\n' < /proc/$$/cmdline)
+
+caller=$(echo "$args" | head -n 1)
+
+callerb=$(basename "$caller")
+
+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/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/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/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/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "buninu",
+  "version": "0.1.1",
+  "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",
+  "bin": {
+    "buninu": "bin/init.js"
+  },
+  "buninu": {
+    "shell": {
+      "default": null,
+      "android": null,
+      "linux": null,
+      "macos": null,
+      "windows": null
+    },
+    "command": {
+      "default": null,
+      "android": "echo Welcome to Buninu Android",
+      "linux": null,
+      "macos": null,
+      "windows": null
+    }
+  },
+  "scripts": {
+    "start": "bun ./apps/jsgotty/gotty.js --reconnect -r -w --webgl",
+    "check": "node --check ./bin/init.js"
+  }
+}