buninu 0.4.5 → 0.4.7

package/apps/jsgotty/static/js/kitty.js

@@ -20,9 +20,32 @@
     touchScroll: null,
     contextMenu: null,
     imageContextBound: false,
-    socket: null
+    socket: null,
+    // False until the client has sent its first resize. Until then cols/rows
+    // above are placeholders, not the PTY's real geometry.
+    sizeFromClient: false
   };
 
+  //  The PTY size only reaches us through the resize messages the client
+  //  sends. A placement that arrives before the first of those would be laid
+  //  out against 80x24 instead of the terminal the user is looking at, so
+  //  borrow xterm's own geometry until the real size shows up.
+  function syncViewerSize() {
+    if (state.sizeFromClient) {
+      return;
+    }
+    const xterm = terminal && terminal.__gottyXterm;
+    if (!xterm) {
+      return;
+    }
+    if (Number.isFinite(xterm.cols) && xterm.cols > 0) {
+      state.cols = xterm.cols;
+    }
+    if (Number.isFinite(xterm.rows) && xterm.rows > 0) {
+      state.rows = xterm.rows;
+    }
+  }
+
   function browserTerminalState() {
     const xterm = terminal && terminal.__gottyXterm;
     const active = xterm && xterm.buffer && xterm.buffer.active;
@@ -152,6 +175,7 @@
   }
 
   function createPlacementMarker(cursor) {
+    syncViewerSize();
     const xterm = terminal && terminal.__gottyXterm;
     if (!xterm || typeof xterm.registerMarker !== "function") {
       return null;
@@ -372,6 +396,7 @@
       return;
     }
     const { control, cursor, intrinsicWidth, intrinsicHeight, sourceRect } = node.__kittyPlacement;
+    syncViewerSize();
     const metrics = cellMetrics();
     const anchor = anchorOffset();
     const controlCols = Math.max(0, Number.parseInt(control.c || "0", 10) || 0);
@@ -825,6 +850,17 @@
     const generation = (node.__kittyGeneration || 0) + 1;
     node.__kittyGeneration = generation;
 
+    //  Bind before the decode, not after it. The server sends the placement
+    //  ahead of the synthetic newlines that scroll room for the image, so the
+    //  scroll this layout depends on can land while we are still decoding.
+    //  Binding afterwards left the very first image of a session with no
+    //  listener to correct it, which is why it could come out blank while
+    //  every later image in the same session was fine.
+    bindViewportScroll();
+    bindTerminalRender();
+    bindTouchScrolling();
+    bindImageContextMenu();
+
     const asset = await resolveImageAsset(message.image, control);
     if (!asset || node.__kittyGeneration !== generation) {
       return;
@@ -839,11 +875,14 @@
       intrinsicHeight: asset.height,
       sourceRect: asset.sourceRect,
     };
-    node.__kittyImageElement.src = objectUrl;
-    bindViewportScroll();
-    bindTerminalRender();
-    bindTouchScrolling();
-    bindImageContextMenu();
+    const imageElement = node.__kittyImageElement;
+    imageElement.onload = () => {
+      imageElement.onload = null;
+      if (node.__kittyGeneration === generation) {
+        layoutNode(node);
+      }
+    };
+    imageElement.src = objectUrl;
     layoutNode(node);
   }
 
@@ -995,7 +1034,14 @@
     return nativeRemoveEventListener.call(this, type, listener, options);
   };
 
-  const descriptor = Object.getOwnPropertyDescriptor(WebSocket.prototype, "onmessage");
+  // Walk the prototype chain to find the native onmessage descriptor.
+  // Safari/WebKit defines it on a parent prototype (e.g. EventTarget),
+  // not directly on WebSocket.prototype, so a single-level lookup fails.
+  let descriptor = null;
+  for (let proto = WebSocket.prototype; proto; proto = Object.getPrototypeOf(proto)) {
+    descriptor = Object.getOwnPropertyDescriptor(proto, "onmessage");
+    if (descriptor) break;
+  }
   Object.defineProperty(WebSocket.prototype, "onmessage", {
     configurable: true,
     enumerable: descriptor ? descriptor.enumerable : true,
@@ -1004,14 +1050,13 @@
     },
     set(handler) {
       this.__kittyOnMessage = handler;
-      if (!descriptor || !descriptor.set) {
-        return;
-      }
       if (typeof handler !== "function") {
-        descriptor.set.call(this, handler);
+        if (descriptor && descriptor.set) {
+          descriptor.set.call(this, handler);
+        }
         return;
       }
-      descriptor.set.call(this, function (event) {
+      const wrapped = function (event) {
         state.socket = this;
         inspectTerminalOutput(event.data);
         if (typeof event.data === "string" && event.data[0] === MSG_KITTY) {
@@ -1020,7 +1065,13 @@
           }
         }
         return handler.call(this, event);
-      });
+      };
+      if (descriptor && descriptor.set) {
+        descriptor.set.call(this, wrapped);
+      } else {
+        // Fallback: use addEventListener when no native setter is available.
+        this.addEventListener("message", wrapped);
+      }
     }
   });
 
@@ -1034,9 +1085,11 @@
         const resize = JSON.parse(data.slice(1));
         if (resize.columns) {
           state.cols = resize.columns;
+          state.sizeFromClient = true;
         }
         if (resize.rows) {
           state.rows = resize.rows;
+          state.sizeFromClient = true;
         }
       } catch (error) {
         // ignore

package/apps/jsgotty/viu.mjs

@@ -27,6 +27,34 @@ function usage(exitCode = 0) {
   process.exitCode = exitCode;
 }
 
+//  A browser terminal only reports its size to the PTY once the page has laid
+//  out, so a window that was just opened, restored, resized or rotated answers
+//  with a couple of columns for a few hundred milliseconds. An image sized
+//  against that is emitted as a one-cell speck — indistinguishable from the
+//  command having printed nothing — while the next run in the same session,
+//  by which time the real size has arrived, comes out correct. Give the size a
+//  short chance to settle when what we read back is too small to be a terminal
+//  anyone could be looking at.
+const MIN_SANE_COLS = 20;
+const MIN_SANE_ROWS = 5;
+const SIZE_SETTLE_TIMEOUT_MS = 400;
+const SIZE_POLL_INTERVAL_MS = 25;
+
+function terminalSizeLooksUnset() {
+  return (process.stdout.columns || 0) < MIN_SANE_COLS
+    || (process.stdout.rows || 0) < MIN_SANE_ROWS;
+}
+
+async function waitForStableTerminalSize() {
+  if (!process.stdout.isTTY) {
+    return;
+  }
+  const deadline = Date.now() + SIZE_SETTLE_TIMEOUT_MS;
+  while (terminalSizeLooksUnset() && Date.now() < deadline) {
+    await new Promise((resolve) => setTimeout(resolve, SIZE_POLL_INTERVAL_MS));
+  }
+}
+
 function fitImageCells(width, height) {
   const terminalCols = Math.max(1, process.stdout.columns || 80);
   const maxCols = Math.max(1, terminalCols - 1);
@@ -384,6 +412,7 @@ async function main() {
   const fullPath = path.resolve(inputPath);
   const buffer = fs.readFileSync(fullPath);
   const image = sniffImage(buffer, fullPath, { compat });
+  await waitForStableTerminalSize();
   writeKittyImage(buffer, image.mime, image.width, image.height, compat);
 }
 

package/apps/musl-la/NOTICE

@@ -1,5 +1,26 @@
 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

package/bin/init.js

@@ -23,26 +23,73 @@ 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
-  --changelog            Render CHANGELOG.md in the terminal and exit
-  --export [output.tgz]  Export this Buninu installation (default: ./buninu.tgz)
-  --export-config [output.json]  Export this package.json (default: ./buninu.json)
-  -i, --install [dir]    Install this package into <dir>/${pkg.name} (default: .)
-  -si, --strip-install [dir]  Install into <dir> directly, without a
-                          top-level directory of its own
-                          (--install --help shows the full install options)
-  --shell <path|name>    Override buninu.shell for this run
-  --command <command>    Override buninu.command for this run
-
-Direct app launch (must be the first argument; skips the shell/command
-startup flow entirely):
-  --jsgotty [args...]    Spawn jsgotty directly, forwarding remaining
-                          arguments, and exit with its exit code
-                          (--jsgotty --help shows jsgotty's own options)
-  --jsmdcui [args...]    Spawn jsmdcui directly, same forwarding behavior
-  --musl-la [args...]    Spawn musl-la directly, same forwarding behavior
+  --local
+    Start Buninu in this terminal
+      instead of a Remote Shell
+      reached from a browser
+      (via jsgotty, the default)
+
+  -h, --help
+    Show this help and exit
+  -V, --version
+    Show version & runtime info, then exit
+
+  --readme
+    Render README.md in the terminal and exit
+  --changelog
+    Render CHANGELOG.md in the terminal and exit
+
+  --readme-tui
+    Open README.md as a Terminal UI
+  --readme-wui
+    Serve README.md as a Web UI
+
+  --export [output.tgz]
+    Export this Buninu installation
+    (default: ./buninu.tgz)
+
+  --export-config [output.json]
+    Export Buninu's package.json
+    (default: ./buninu.json)
+
+Install options:
+  -i, --install [dir]    
+    Install this package into <dir>/${pkg.name}
+    (default: .)
+
+  -si, --strip-install [dir]  
+    Install into <dir> directly
+    Without a top-level directory of its own
+      
+  (--install --help for full options)
+  
+Remote Shell options:
+  --shell <path|name>
+    Override buninu.shell for this run
+  --command <command>
+    Override buninu.command for this run
+
+Direct app launch
+(must be the first argument)
+(skips the shell/command startup flow entirely):
+
+  --jsgotty [args...]    
+    Spawn jsgotty directly,
+      forwarding remaining arguments,
+      and exit with its exit code
+  (--jsgotty --help = jsgotty options)
+  
+  --jsmdcui [args...]
+    Spawn jsmdcui directly, 
+      same forwarding behavior
+      
+  --bunmsh [args...]
+    Spawn bunmsh directly, 
+      same forwarding behavior
+      
+  --musl-la [args...]
+    Spawn musl-la directly,
+      same forwarding behavior
 
 Package configuration:
   package.json contains a buninu section for default and platform settings.
@@ -93,6 +140,16 @@ async function handleInformationArguments(arguments_) {
     return true;
   }
 
+  const markdownUi = arguments_.includes("--readme-tui")
+    ? "--tui"
+    : arguments_.includes("--readme-wui")
+      ? "--wui"
+      : null;
+  if (markdownUi) {
+    await openReadmeMarkdownUi(markdownUi);
+    return true;
+  }
+
   if (arguments_.includes("--changelog")) {
     const changelogPath = resolve(REPO_ROOT, "CHANGELOG.md");
     if (!await pathExists(changelogPath)) fail(`CHANGELOG not found: ${changelogPath}`);
@@ -105,6 +162,47 @@ async function handleInformationArguments(arguments_) {
   return false;
 }
 
+// jsmdcui writes five generated companion files beside the Markdown it opens
+// (`*.md.front.js`, `*.md.back.js`, `*.md.html`, `*.md-rpc.js`,
+// `*.md-server.js`), and needs that directory to be writable. Run it on a copy
+// under TMPDIR rather than on README.md in place: an installation is the
+// user's to keep, `--export` would carry the generated files to another
+// machine, an update never deletes them again, and under `npx` the package
+// directory is a cache that should not be written to at all. Nothing is lost
+// by the move -- the README's only image is a remote URL, and what makes it
+// navigable is same-document `#heading-id` links, which resolve wherever the
+// file sits.
+async function openReadmeMarkdownUi(mode) {
+  const readmePath = resolve(REPO_ROOT, "README.md");
+  if (!await pathExists(readmePath)) fail(`README not found: ${readmePath}`);
+
+  const entry = resolve(rootDir, "apps", "jsmdcui", "src", "index.js");
+  if (!await pathExists(entry)) fail(`jsmdcui not found: ${entry}`);
+
+  const environment = await detectEnvironment();
+  const workDir = resolve(resolveTmpDir(environment), "buninu-readme");
+  // Start from a clean directory so a stale generated file from an older
+  // README can never be served in place of a freshly generated one.
+  rmSync(workDir, { recursive: true, force: true });
+  mkdirSync(workDir, { recursive: true });
+
+  const target = resolve(workDir, "README.md");
+  await Bun.write(target, Bun.file(readmePath));
+
+  // jsmdcui's entry point is a bundled CLI with no exports: it reads
+  // process.argv at the top level and runs. Set the argv it expects and import
+  // it, so this stays one process instead of spawning a second Bun.
+  process.argv = [process.argv[0], entry, mode, target];
+  await import(entry);
+
+  // jsmdcui owns the process from here on: it holds the terminal UI, or the
+  // Web UI server, open. Never resolve -- returning would hand control back to
+  // the caller, whose process.exit(0) would cut the UI off before it draws.
+  // This keeps no handle of its own, so once jsmdcui's are gone the process
+  // still ends on its own.
+  await new Promise(() => {});
+}
+
 function readExportArgument(arguments_) {
   for (let index = 0; index < arguments_.length; index += 1) {
     const argument = arguments_[index];
@@ -418,16 +516,19 @@ function configuredXdgDataHome() {
   return isAbsolute(configured) ? configured : resolve(rootDir, configured);
 }
 
-async function createChildEnvironment(environment) {
-  const packageDir = dirname(rootDir);
-  const androidCacheDir = resolve(packageDir, "cache");
-  const tmpDir = process.env.TMPDIR || (
+function resolveTmpDir(environment) {
+  const androidCacheDir = resolve(dirname(rootDir), "cache");
+  return process.env.TMPDIR || (
     environment.name === "android"
       ? existsSync(androidCacheDir)
         ? androidCacheDir
         : resolve(rootDir, "tmp")
       : systemTmpDir()
   );
+}
+
+async function createChildEnvironment(environment) {
+  const tmpDir = resolveTmpDir(environment);
   const homeDir = process.env.HOME || homedir() || rootDir;
   const envFile = await pathExists(resolve(rootDir, ".bashrc"))
     ? resolve(rootDir, ".bashrc")
@@ -474,6 +575,7 @@ async function createChildEnvironment(environment) {
 const directAppTargets = {
   "--jsgotty": "jsgotty",
   "--jsmdcui": "jsmdcui",
+  "--bunmsh": "bunmsh",
   "--musl-la": "musl-la",
 };
 
@@ -557,10 +659,10 @@ function shellCommandArguments(shell, command, exitAfterCmd) {
   }
 
   const wrapped =
-    `buninu_command=$1; shift; ( eval "$buninu_command" ); status=$?; ` +
-    `if [ "$status" -ne 0 ]; then ` +
-    `echo "buninu: startup command failed with exit $status" >&2; ` +
-    (exitAfterCmd ? `fi; exit "$status"` : `fi; exec "$0"`);
+    `buninu_command=$1; shift; ( eval "$buninu_command" ); _buninu_status=$?; ` +
+    `if [ "$_buninu_status" -ne 0 ]; then ` +
+    `echo "buninu: startup command failed with exit $_buninu_status" >&2; ` +
+    (exitAfterCmd ? `fi; exit "$_buninu_status"` : `fi; exec "$0"`);
   // Pass both the shell and startup command as argv instead of interpolating
   // them into the wrapper. This keeps the wrapper single-line and avoids LF
   // (Ctrl+J) characters in its process-list representation.

package/bin/multicall.sh

@@ -1,10 +1,12 @@
 #!/bin/sh
 
-args=$(tr '\0' '\n' < /proc/$$/cmdline)
-
-caller=$(echo "$args" | head -n 1)
-
-callerb=$(basename "$caller")
+if [ -f /proc/$$/cmdline ] ; then
+  args=$(tr '\0' '\n' < /proc/$$/cmdline)
+  caller=$(echo "$args" | head -n 1)
+  callerb=$(basename "$caller")
+else
+  callerb=$(basename "$0")
+fi
 
 if [ "$callerb" = sh ] ; then
   callerb=$(basename "$0")

package/package.json

@@ -1,10 +1,33 @@
 {
   "name": "buninu",
-  "version": "0.4.5",
+  "version": "0.4.7",
   "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"
   },