buninu 0.2.5 → 0.3.1

package/apps/bunmsh/test/t.sh

@@ -0,0 +1,12 @@
+#!/bin/sh
+
+echo shell-before
+Bun.version
+Bun.e, Math.cos(1)
+
+Bun.sha.var = { message: "shared", count: 1 }
+Bun.sha.var.count += 1
+Bun.sha.var
+echo "from command substitution: $(Bun.sha.var.message)"
+
+echo shell-after

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

@@ -101,6 +101,51 @@ export const tts = ttsStatus
 // 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

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

@@ -7,9 +7,74 @@
 // 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 } from "../native-bridge/native-bridge.js"
+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
@@ -46,7 +111,14 @@ let ok = false
 try {
   if (process.platform === "android") {
     if (available()) {
-      ok = await bridgeOpen(target)
+      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

package/bin/init.js

@@ -546,7 +546,11 @@ function shellCommandArguments(shell, command, exitAfterCmd) {
   return [shell, "-c", wrapped, shell, command];
 }
 
-const startScript = pkg.scripts?.start;
+let startScript = pkg.scripts?.start;
+
+if(process.argv.includes('--local'))
+  startScript = pkg.scripts?.local ;
+
 if (typeof startScript !== "string" || !startScript.trim()) {
   fail("package.json does not define scripts.start");
 }
@@ -606,9 +610,13 @@ const hasExplicitPort = forwardedArguments.some((argument) =>
 const portArguments = hasExplicitPort ? [] : ["-p", String(getFreePort())];
 const childEnvironment = await createChildEnvironment(environment);
 
+const infoSuffix = 
+  process.argv.includes('--local') ? 
+  'bunmsh' :
+  `port=${portArguments[1] || "user-defined"}, shell=${environment.shell}` ;
+
 console.error(
-  `${pkg.name}@${pkg.version}: ${environment.name}/${process.arch}, ` +
-  `port=${portArguments[1] || "user-defined"}, shell=${environment.shell}`,
+  `${pkg.name}@${pkg.version}: ${environment.name}/${process.arch}, ` + infoSuffix
 );
 
 const child = Bun.spawn(

package/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buninu",
-  "version": "0.2.5",
+  "version": "0.3.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",
@@ -23,10 +23,12 @@
       "macos": null,
       "windows": null
     },
-    "exitAfterCmd": false
+    "exitAfterCmd": false,
+    "backToConsole": true
   },
   "scripts": {
     "start": "bun ./apps/jsgotty/gotty.js --reconnect -r -w --webgl -a 127.0.0.1",
+    "local": "bun ./apps/bunmsh/bunmsh -c 'exec bunmsh'",
     "check": "node --check ./bin/init.js"
   }
 }