buninu 0.3.0 → 0.4.0

package/apps/jsmdcui/single-exe/compiled.js

@@ -1,15 +1,19 @@
 import { basename, dirname, resolve } from "node:path";
-import { readFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import child_process from "node:child_process";
+import { ASSETS_ROOT } from "./assetsPacker.js";
 
 
 export const IS_COMPILED = isCompiledBinary();
 export const REPO_ROOT = IS_COMPILED
   ? getExeDirname()
-  : resolve(import.meta.dirname, "..");
-const SINGLE_EXE_DIR = resolve(REPO_ROOT, "single-exe");
-const SINGLE_EXE_ENTRY = resolve(SINGLE_EXE_DIR, "entry.mjs");
+  : resolve(import.meta.dirname, ASSETS_ROOT);
+//  This file's own directory. Not derived from REPO_ROOT: the only user
+//  is buildExecutable(), which already refuses to run when IS_COMPILED,
+//  so REPO_ROOT there is always the source tree, and going back down
+//  through it would hard-code this folder name.
+const SINGLE_EXE_DIR = import.meta.dirname;
 
 
 export function isCompiledBinary(argv = process.argv) {
@@ -182,7 +186,7 @@ export async function buildExecutable(target = "",build_outfile="single.exe", bu
   }
 }
 
-export const buildExe = buildExecutable;
+export const buildExe = buildExeAssets;
 
 export async function buildEarlyExit(argv,build_outfile) {
   argv = argv || process.argv
@@ -210,3 +214,285 @@ export async function buildEarlyExit(argv,build_outfile) {
 
   process.exit(await buildExe(null, build_outfile, argv.slice(buildExeIndex + 1)));
 }
+
+
+//  Multi-package variant of buildExecutable().
+//
+//  Every package that ships assets vendors its own single-exe/, and its
+//  assetsHelper imports its assetsPacker, so a packer shows up in the
+//  bundle's module graph exactly when that package is actually reachable
+//  from this entry point. A scan build writes that graph to a metafile,
+//  and each packer found there appends its own namespaced members to one
+//  shared assets.tar before the real compile runs.
+export async function buildExeAssets(target = "", build_outfile = "single.exe", bunArgs = []) {
+  let outfile = resolve(process.cwd(), build_outfile);
+  const normalizedTarget = String(target || "").trim();
+  const extraBunArgs = Array.from(bunArgs ?? [], String);
+
+  if (!globalThis.Bun || IS_COMPILED) {
+    console.log("Build exe can only be run by Bun in the source tree");
+    return 1;
+  }
+
+  const bunBin = Bun.which("bun") || process.argv0;
+  const ownPacker = resolve(SINGLE_EXE_DIR, "assetsPacker.js");
+  const archive = resolve(SINGLE_EXE_DIR, "assets.tar");
+  const metafile = `${outfile}.meta.json`;
+  const scanDir = `${outfile}.scan`;
+
+  //  ASSETS_BUNFS swaps the tar for `--compile --asset`: every packer
+  //  copies into one fixed build/assets, and --asset keeps only that
+  //  folder's basename, so the members land at assets/<name>@<version>/
+  //  exactly as the tar back end writes them.
+  const bunfs = Boolean(process.env.ASSETS_BUNFS);
+  const staging = resolve(REPO_ROOT, "build", "assets");
+
+  //  Nothing loads a tar in bunfs mode, so the asset loader — and the
+  //  `assets.tar` it imports — cannot be in the graph. Everything else in
+  //  entry.mjs still has to run, so the compile entry is a generated copy
+  //  of it with that one import removed.
+  //
+  //  Handing the main program to `bun build` directly would be simpler and
+  //  breaks two ways. Whatever entry.mjs does after the import is lost, and
+  //  a CommonJS program relying on a `require.main` guard the bundler
+  //  inlines to false would never start. Worse, `--bytecode` only marks the
+  //  chunk as an async module when a top-level await appears in an
+  //  unwrapped part's own source; a main program that reaches top-level
+  //  await only through `__esm`-wrapped dependencies is then evaluated on
+  //  the sync path, its suspended generator is dropped, and the binary
+  //  exits 0 having run nothing. entry.mjs awaits in its own source, so the
+  //  copy carries that flag the way the tar build always has.
+  const bunfsEntry = resolve(SINGLE_EXE_DIR, ".bunfs-entry.mjs");
+  const dropBunfsEntry = () => bunfs && rmSync(bunfsEntry, { force: true });
+
+  if (bunfs && !writeBunfsEntry(resolve(SINGLE_EXE_DIR, "entry.mjs"), bunfsEntry)) {
+    return 1;
+  }
+
+  const compileEntry = bunfs ? bunfsEntry : "./entry.mjs";
+
+  const step = (label, args, cwd) => {
+    console.log("");
+    console.log(Bun?.markdown?.ansi?.("## " + label) || label);
+    console.log("Running: ", bunBin, args);
+
+    const result = child_process.spawnSync(bunBin, args, {
+      cwd,
+      stdio: "inherit",
+      env: process.env,
+    });
+
+    console.log("");
+    console.log(Bun?.markdown?.ansi?.("- Status: " + result.status + " for " + label) || result.status);
+
+    if (result.error) console.error(result.error);
+    return result.status ?? 1;
+  };
+
+  //  What each packer is told to write into, and in which mode.
+  const packInto = bunfs ? ["-f", staging] : ["-f", archive, "-p"];
+
+  if (bunfs) {
+    mkdirSync(staging, { recursive: true });
+    console.log("");
+    console.log(`Staging assets into ${staging}`);
+  } else if (step("Pack own assets", [ownPacker, ...packInto], SINGLE_EXE_DIR) !== 0) {
+    //  Tar mode packs first: the scan below has to resolve entry.mjs's
+    //  `with { type: "file" }` import of the archive.
+    console.error("Own assets failed to pack");
+    return 1;
+  }
+
+  //  Bundle only. The binary is thrown away, so skip --compile, --minify
+  //  and --bytecode; the module graph is the same and it is much faster.
+  if (step("Scan module graph", ["build", compileEntry, "--target=bun", `--metafile=${metafile}`, `--outdir=${scanDir}`], SINGLE_EXE_DIR) !== 0) {
+    console.error("Scan build failed");
+    dropBunfsEntry();
+    return 1;
+  }
+
+  const packers = findAssetPackers(metafile, SINGLE_EXE_DIR, bunfs ? "" : ownPacker);
+  rmSync(scanDir, { recursive: true, force: true });
+
+  console.log("");
+  console.log(`Found ${packers.length} asset packer(s) to run`);
+
+  for (const packer of packers) {
+    const name = dirname(dirname(packer)).split("/").pop();
+
+    //  Tar mode appends to a shared archive; folder mode needs no -r
+    //  because each package owns its own <name>@<version> subtree.
+    const args = bunfs ? [packer, ...packInto] : [packer, ...packInto, "-r"];
+
+    if (step(`Pack ${name}`, args, dirname(packer)) !== 0) {
+      console.error(`Failed to pack assets from ${packer}`);
+      dropBunfsEntry();
+      return 1;
+    }
+  }
+
+  //  Compress last. Every packer above reads the archive and writes it
+  //  back uncompressed, so this has to happen after the final append.
+  //  libarchive sniffs the format on read, so assetsLoader needs no
+  //  change to consume it. Nothing to compress in bunfs mode.
+  if (bunfs) {
+    // no archive in this mode
+  } else if (process.env.ASSETS_NO_GZIP) {
+    console.log("");
+    console.log("ASSETS_NO_GZIP is set, leaving the archive uncompressed");
+  } else {
+    console.log("");
+    console.log(Bun?.markdown?.ansi?.("## Compress assets") || "Compress assets");
+
+    try {
+      const raw = await Bun.file(archive).bytes();
+      const gzipped = Bun.gzipSync(raw, { level: 9 });
+
+      await Bun.write(archive, gzipped);
+
+      const pct = raw.byteLength ? Math.round((1 - gzipped.byteLength / raw.byteLength) * 100) : 0;
+      console.log(`${raw.byteLength} -> ${gzipped.byteLength} bytes (-${pct}%)`);
+    } catch (e) {
+      console.error("Could not compress the archive; continuing uncompressed");
+      console.error(e);
+    }
+  }
+
+  if (step("Compile executable", [
+    "build",
+    "--format=esm",
+    "--compile",
+    "--minify",
+    "--bytecode",
+    compileEntry,
+    ...(bunfs ? ["--asset", staging] : []),
+    `--outfile=${outfile}`,
+    `--metafile-md=${outfile}.meta.md`,
+    ...(normalizedTarget ? [`--target=${normalizedTarget}`] : []),
+    ...extraBunArgs,
+  ], SINGLE_EXE_DIR) !== 0) {
+    console.error("Compile failed");
+  }
+
+  dropBunfsEntry();
+
+  const isWindows = normalizedTarget ? normalizedTarget.toLowerCase().includes("windows") : process.platform === "win32";
+  if (isWindows && !outfile.toLowerCase().endsWith(".exe")) {
+    outfile += ".exe";
+  }
+
+  if (await Bun.file(outfile).exists()) {
+    console.log(`Built executable: ${outfile}`);
+    return 0;
+  }
+
+  console.log(`Error while building executable: ${outfile}`);
+  return 1;
+}
+
+
+//  entry.mjs, minus the import of the asset loader, written to `outFile`
+//  as the compile entry for bunfs builds. Returns whether it was written.
+//
+//  A textual copy, not a generated stub: entry.mjs may do more than import
+//  the main program, and all of it has to survive.
+export function writeBunfsEntry(entryFile, outFile) {
+  let src;
+
+  try {
+    src = readFileSync(entryFile, "utf8");
+  } catch (e) {
+    console.error(`Could not read ${entryFile}`);
+    console.error(e);
+    return false;
+  }
+
+  //  Whole-line side-effect import of the loader, in any of the shapes a
+  //  project might have written it. Nothing else may reference it: the
+  //  loader is what pulls in `assets.tar`, which no bunfs build produces.
+  const loaderImport = /^[ \t]*import\s+(?:[^"'\n]*\bfrom\s+)?["'][^"'\n]*assetsLoader\.mjs["'][ \t]*;?[ \t]*$/gm; // "
+  const stripped = src.replace(loaderImport, "");
+
+  if (stripped === src) {
+    console.log("");
+    console.log(`No assetsLoader import found in ${entryFile}; compiling it as is`);
+  }
+
+  const header =
+    "//  Generated by single-exe/compiled.js for ASSETS_BUNFS=1 builds.\n"
+    + "//  A copy of entry.mjs without the asset loader; edit entry.mjs.\n";
+
+  //  A hashbang is only a hashbang on the first line; anywhere else it is
+  //  a syntax error. Keep it there and put the header underneath, unless
+  //  the file is nothing but a hashbang and there is no underneath.
+  const firstBreak = stripped.indexOf("\n");
+  const hasHashbang = stripped.startsWith("#!");
+  const hashbang = hasHashbang && firstBreak !== -1 ? stripped.slice(0, firstBreak + 1) : "";
+
+  try {
+    writeFileSync(
+      outFile,
+      hasHashbang && !hashbang
+        ? stripped
+        : hashbang + header + stripped.slice(hashbang.length),
+    );
+  } catch (e) {
+    console.error(`Could not write ${outFile}`);
+    console.error(e);
+    return false;
+  }
+
+  return true;
+}
+
+
+//  The main program, as declared by the last import of entry.mjs. That
+//  file is already the one place an adopting project edits.
+export function lastEntryImport(entryFile) {
+  let src;
+
+  try {
+    src = readFileSync(entryFile, "utf8");
+  } catch {
+    return "";
+  }
+
+  //  Drop comments first, or a commented-out import would win.
+  src = src.replace(/\/\*[\s\S]*?\*\//g, "").replace(/^[ \t]*\/\/.*$/gm, "");
+
+  const re = /\bimport\b[^"'\n]*["']([^"']+)["']/g; // "
+  let last = "";
+
+  for (let m; (m = re.exec(src)) !== null; ) last = m[1];
+
+  return last;
+}
+
+
+//  Absolute, de-duplicated paths of every assetsPacker.js in the metafile,
+//  minus `own`. Metafile input keys are relative to the build's cwd.
+export function findAssetPackers(metafilePath, baseDir, own = "") {
+  if (!existsSync(metafilePath)) return [];
+
+  let meta;
+  try {
+    meta = JSON.parse(readFileSync(metafilePath, "utf8"));
+  } catch (e) {
+    console.error(`Could not read metafile ${metafilePath}`);
+    console.error(e);
+    return [];
+  }
+
+  const found = new Set();
+
+  for (const key of Object.keys(meta?.inputs ?? {})) {
+    if (basename(key) !== "assetsPacker.js") continue;
+
+    const abs = resolve(baseDir, key);
+    if (abs === own || !existsSync(abs)) continue;
+
+    found.add(abs);
+  }
+
+  return [...found].sort();
+}

package/apps/jsmdcui/single-exe/entry.mjs

@@ -6,5 +6,12 @@
 // 3. Starts the main program only after the assets are ready
 import "./assetsLoader.mjs";
 
+//  Keep these as `await`, not `.then()`. Besides the sequencing, they are
+//  the only top-level await this program writes anywhere, and `--bytecode`
+//  reads exactly that to decide the program starts asynchronously. With
+//  none written, the executable is evaluated synchronously, its suspended
+//  startup is dropped, and it exits 0 having run nothing — no error, at any
+//  size. Awaits the bundler generates for us do not count; see the README's
+//  "The await in entry.mjs is load-bearing".
 await globalThis.assetsLoaderPromise;
 await import("../src/index.js");

package/apps/jsmdcui/src/index.js

@@ -117,7 +117,7 @@ import { Config } from "./config/config.js";
 import { defaultAllSettings, OPTION_CHOICES, LOCAL_SETTINGS } from "./config/defaults.js";
 import { cleanConfig } from "./config/clean.js";
 import { RuntimeRegistry, RTColorscheme, RTHelp } from "./runtime/registry.js";
-import { assetPath, buildHtmlBundleImageMap, hasInternalAssets, listInternalAssetDirs, listInternalAssetPaths, readInternalAssetText } from "../single-exe/assetsHelper.js";
+import { assetDiskPath, assetPath, buildHtmlBundleImageMap, hasInternalAssets, listInternalAssetDirs, listInternalAssetPaths, readAssetText, readInternalAssetText } from "../single-exe/assetsHelper.js";
 //import { PluginManager } from "./plugins/manager.js";
 import { JsPluginManager, buildMicroGlobal, buildTuiBlockIndex, captureTuiRerenderState, clearTuiSourceDependentState, findTuiBlockInIndex, indexTuiHeadingRows, insertTuiTextareaNewline, markTuiTableCellDirtyAtPosition, mergeTuiTextareaBackward, mergeTuiTextareaForward, navigateTuiHeadingFragment, restoreTuiHiddenHeadings, restoreTuiRerenderState, toggleTuiHeadingAt, tuiCheckboxRerenderMismatchMessage, tuiTableCellAtPosition, runAction, listActions } from "./plugins/js-bridge.js";
 import { Colorscheme } from "./config/colorscheme.js";
@@ -8466,7 +8466,7 @@ async function printReadmeDocs() {
 }
 
 async function bundledReadmeSource() {
-  return readInternalAssetText("README.md") ?? await Bun.file(join(REPO_ROOT, "README.md")).text();
+  return readAssetText("README.md");
 }
 
 async function exportReadme() {
@@ -8482,7 +8482,7 @@ async function exportCdpMaze() {
 }
 
 async function printChangelogDocs() {
-  const changelog = readInternalAssetText("CHANGELOG.md") ?? await Bun.file(join(REPO_ROOT, "CHANGELOG.md")).text();
+  const changelog = await readAssetText("CHANGELOG.md");
   process.stdout.write(Bun.markdown.ansi(changelog, { hyperlinks: true }));
 }
 
@@ -8491,7 +8491,7 @@ async function printTestappSource() {
 }
 
 async function bundledMarkdownSource(filename) {
-  return readInternalAssetText(filename) ?? await Bun.file(join(REPO_ROOT, filename)).text();
+  return readAssetText(filename);
 }
 
 function availableDemoAssets() {
@@ -8500,7 +8500,7 @@ function availableDemoAssets() {
     paths = listInternalAssetPaths("demos");
   } else {
     try {
-      paths = readdirSync(join(REPO_ROOT, "demos"), { withFileTypes: true })
+      paths = readdirSync(assetDiskPath("demos"), { withFileTypes: true })
         .filter((entry) => entry.isFile())
         .map((entry) => assetPath("demos", entry.name));
     } catch {
@@ -8853,7 +8853,10 @@ async function main() {
   syncEditorSettings(config);
 
   addCheckpoint("Runtime Registry Init");
-  const runtime = new RuntimeRegistry({ repoRoot: REPO_ROOT, configDir: config.configDir });
+  //  Not REPO_ROOT: --assets-extract writes the tree under its own
+  //  assets/<name>@<version>/ namespace, and --assets-external then reads
+  //  from there. assetDiskPath("") is that root, or REPO_ROOT in a checkout.
+  const runtime = new RuntimeRegistry({ repoRoot: assetDiskPath(""), configDir: config.configDir });
   await runtime.init({ user: true });
 
   addCheckpoint("Colorscheme & Syntax Load");
@@ -8887,7 +8890,7 @@ async function main() {
         jsItems.push({ name, builtin: true });
       }
     } else {
-      const builtinJsDir = join(REPO_ROOT, "runtime", "jsplugins");
+      const builtinJsDir = assetDiskPath("runtime/jsplugins");
       if (existsSync(builtinJsDir)) {
         for (const entry of readdirSync(builtinJsDir, { withFileTypes: true })) {
           if (!entry.isDirectory()) continue;
@@ -8961,7 +8964,7 @@ async function main() {
   const jsPromise = (async () => {
     const start = Bun.nanoseconds();
     const jsDirs = [
-      { dir: join(REPO_ROOT, "runtime", "jsplugins"), builtin: true },
+      { dir: assetDiskPath("runtime/jsplugins"), builtin: true },
       { dir: join(config.configDir, "jsplug"),        builtin: false },
     ];
     await jsPlugins.loadFrom(jsDirs);

package/apps/jsmdcui/tests/jmigt.js

@@ -0,0 +1,16 @@
+#!/bin/sh
+
+':' //; sd=$(dirname "$(realpath "$0")")
+
+':' //; exec bun "$sd"/src/index.js "$@"
+
+console.log(Bun.argv)
+
+if(Bun.argv[2]=='--jsgotty')
+{
+  Bun.argv.splice(2,1);
+  let m=await import('../../wgotty/gotty.js');
+  m.bootstrap()
+}
+else
+  await import('../src/index.js');

package/bin/bunmsh.bat

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

package/bin/bunmsh.sh

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

package/bin/init.js

@@ -2,7 +2,7 @@
 
 import pkg from "../package.json" with { type: "json" };
 import { existsSync, lstatSync, mkdirSync, mkdtempSync, rmSync, symlinkSync, unlinkSync } from "node:fs";
-import { tmpdir as systemTmpDir } from "node:os";
+import { homedir, tmpdir as systemTmpDir } from "node:os";
 import { basename, delimiter, dirname, isAbsolute, resolve } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { fileURLToPath } from "node:url";
@@ -29,6 +29,10 @@ Init options:
   --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
 
@@ -401,6 +405,19 @@ function getFreePort() {
   return port;
 }
 
+// buninu.xdgDataHome moves the data directory XDG-aware programs write to,
+// bunmsh's command history among them, without touching HOME: a shell started
+// here still finds the SSH keys and Git configuration in the user's own home.
+// `true` puts it inside the installation so it travels with a copied tree; a
+// string names a directory, resolved from the package.json directory when it
+// is relative, the way buninu.shell already resolves one.
+function configuredXdgDataHome() {
+  const configured = pkg.buninu?.xdgDataHome;
+  if (configured === true) return resolve(rootDir, ".local", "share");
+  if (typeof configured !== "string" || !configured.trim()) return null;
+  return isAbsolute(configured) ? configured : resolve(rootDir, configured);
+}
+
 async function createChildEnvironment(environment) {
   const packageDir = dirname(rootDir);
   const androidCacheDir = resolve(packageDir, "cache");
@@ -411,14 +428,17 @@ async function createChildEnvironment(environment) {
         : resolve(rootDir, "tmp")
       : systemTmpDir()
   );
-  const homeDir = process.env.HOME || rootDir;
+  const homeDir = process.env.HOME || homedir() || rootDir;
   const envFile = await pathExists(resolve(rootDir, ".bashrc"))
     ? resolve(rootDir, ".bashrc")
     : await pathExists(resolve(homeDir, ".bashrc"))
       ? resolve(homeDir, ".bashrc")
       : null;
 
+  const xdgDataHome = configuredXdgDataHome();
+
   mkdirSync(tmpDir, { recursive: true });
+  if (xdgDataHome) mkdirSync(xdgDataHome, { recursive: true });
 
   const inheritedPath = process.env.PATH || "";
   const hasTermuxExecPreload =
@@ -443,6 +463,7 @@ async function createChildEnvironment(environment) {
     TMPDIR: tmpDir,
     SHELL: process.env.SHELL || environment.shell,
     BUNINU_HOME: rootDir,
+    ...(xdgDataHome ? { XDG_DATA_HOME: xdgDataHome } : {}),
     ...(envFile ? { ENV: envFile } : {}),
     TERM: process.env.TERM || "xterm-256color",
     COLORTERM: process.env.COLORTERM || "truecolor",
@@ -546,7 +567,25 @@ function shellCommandArguments(shell, command, exitAfterCmd) {
   return [shell, "-c", wrapped, shell, command];
 }
 
-const startScript = pkg.scripts?.start;
+// Install is a mode of its own rather than a startup option, so it follows the
+// same "must be the first argument" rule as the direct app launches above and
+// never competes with an argument being forwarded to jsgotty.
+function isInstallArgument(argument = "") {
+  return argument === "-i" || argument === "--install" ||
+    argument === "-si" || argument === "--strip-install" ||
+    argument.startsWith("--install=") || argument.startsWith("--strip-install=");
+}
+
+if (isInstallArgument(process.argv[2])) {
+  const { runInstall } = await import("./install.js");
+  process.exit(await runInstall(process.argv.slice(2)));
+}
+
+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 +645,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(