buninu 0.1.1

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

@@ -0,0 +1,191 @@
+import { join, posix } from "node:path";
+import { REPO_ROOT } from "./compiled.js";
+
+const textDecoder = new TextDecoder();
+const textEncoder = new TextEncoder();
+
+export function hasInternalAssets() {
+  return Boolean(getAssetStore());
+}
+
+export function assetPath(...parts) {
+  return parts
+    .flatMap((part) => String(part).split(/[\\/]+/))
+    .filter(Boolean)
+    .join("/");
+}
+
+export function decodeHtmlAttribute(value) {
+  return String(value ?? "").replace(
+    /&(?:amp|quot|apos|lt|gt|#39|#x27|#\d+|#x[\da-f]+);/gi,
+    (entity) => {
+      const named = {
+        "&": "&",
+        """: "\"",
+        "'": "'",
+        "&lt;": "<",
+        "&gt;": ">",
+        "&#39;": "'",
+        "&#x27;": "'",
+      }[entity.toLowerCase()];
+      if (named != null) return named;
+      const hex = /^&#x([\da-f]+);$/i.exec(entity);
+      const decimal = /^&#(\d+);$/.exec(entity);
+      const codePoint = Number.parseInt(hex?.[1] ?? decimal?.[1] ?? "", hex ? 16 : 10);
+      try {
+        return Number.isInteger(codePoint) ? String.fromCodePoint(codePoint) : entity;
+      } catch {
+        return entity;
+      }
+    },
+  );
+}
+
+export function canonicalHtmlBundleImageHref(input, { htmlAttribute = false } = {}) {
+  let value = String(input ?? "");
+  if (htmlAttribute) value = decodeHtmlAttribute(value);
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+
+export function findHtmlBundleAsset(homepage, publicPath, {
+  contentTypePrefix = "",
+} = {}) {
+  if (!Array.isArray(homepage?.files)) return null;
+  const name = posix.basename(String(publicPath ?? "").replace(/[?#].*$/, ""));
+  for (const file of homepage.files) {
+    if (file?.loader !== "file") continue;
+    const contentType = String(file.headers?.["content-type"] ?? "");
+    if (contentTypePrefix && !contentType.startsWith(contentTypePrefix)) continue;
+    if (posix.basename(String(file.path ?? "")) === name) return file;
+  }
+  return null;
+}
+
+export function findHtmlBundleImageAsset(homepage, publicPath) {
+  return findHtmlBundleAsset(homepage, publicPath, {
+    contentTypePrefix: "image/",
+  });
+}
+
+export function htmlBundleImageAssetPath(homepage, publicPath) {
+  return findHtmlBundleImageAsset(homepage, publicPath)?.path ?? null;
+}
+
+export async function buildHtmlBundleImageMap(
+  homepage,
+  sourceAttribute = "data-mdcui-src",
+) {
+  const images = new Map();
+  if (!homepage?.index || !Array.isArray(homepage.files)) return images;
+  const html = await Bun.file(homepage.index).text();
+  for (const tag of html.match(/<img\b[^>]*>/gi) ?? []) {
+    const rawHref = htmlTagAttribute(tag, sourceAttribute);
+    const publicPath = htmlTagAttribute(tag, "src");
+    if (rawHref == null || publicPath == null) continue;
+    const bundledPath = htmlBundleImageAssetPath(homepage, decodeHtmlAttribute(publicPath));
+    if (!bundledPath) continue;
+    images.set(
+      canonicalHtmlBundleImageHref(rawHref, { htmlAttribute: true }),
+      bundledPath,
+    );
+  }
+  return images;
+}
+
+export function listInternalAssetPaths(prefix = "") {
+  const store = getAssetStore();
+  if (!store) return [];
+
+  const normalizedPrefix = assetPath(prefix);
+  const entries = iterateAssetKeys(store);
+  if (!normalizedPrefix) {
+    return entries.sort();
+  }
+
+  const base = `${normalizedPrefix}/`;
+  return entries.filter((path) => path === normalizedPrefix || path.startsWith(base)).sort();
+}
+
+export function listInternalAssetDirs(prefix = "") {
+  const normalizedPrefix = assetPath(prefix);
+  const base = normalizedPrefix ? `${normalizedPrefix}/` : "";
+  const dirs = new Set();
+
+  for (const path of listInternalAssetPaths(prefix)) {
+    const rest = normalizedPrefix ? path.slice(base.length) : path;
+    const [dir] = rest.split("/");
+    if (dir) dirs.add(dir);
+  }
+
+  return [...dirs].sort();
+}
+
+export function getInternalAsset(path) {
+  const store = getAssetStore();
+  if (!store) return null;
+  const key = assetPath(path);
+  if (store instanceof Map) return store.get(key) ?? null;
+  return store[key] ?? store[path] ?? null;
+}
+
+export function readInternalAssetBytes(path) {
+  const value = getInternalAsset(path);
+  if (value == null) return null;
+  if (value instanceof Uint8Array) return value;
+  if (ArrayBuffer.isView(value)) {
+    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  }
+  if (value instanceof ArrayBuffer) return new Uint8Array(value);
+  if (typeof value === "string") return textEncoder.encode(value);
+  return textEncoder.encode(String(value));
+}
+
+export function readInternalAssetText(path) {
+  const bytes = readInternalAssetBytes(path);
+  if (!bytes) return null;
+  return textDecoder.decode(bytes);
+}
+
+export async function readAssetText(path) {
+  return readInternalAssetText(path)
+    ?? await Bun.file(join(REPO_ROOT, path)).text();
+}
+
+export async function readAssetBytes(path) {
+  const internal = readInternalAssetBytes(path);
+  return internal
+    ?? new Uint8Array(await Bun.file(join(REPO_ROOT, path)).arrayBuffer());
+}
+
+export function internalAssetSource(path) {
+  return {
+    name: path.split("/").pop() ?? path,
+    path,
+    async text() {
+      return readInternalAssetText(path) ?? "";
+    },
+  };
+}
+
+function getAssetStore() {
+  const store = globalThis.internalAssets;
+  if (!store) return null;
+  if (store instanceof Map) return store;
+  if (typeof store === "object") return store;
+  return null;
+}
+
+function iterateAssetKeys(store) {
+  if (store instanceof Map) return [...store.keys()].map(String);
+  return Object.keys(store);
+}
+
+function htmlTagAttribute(tag, name) {
+  const escapedName = String(name).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const match = String(tag).match(new RegExp(`\\b${escapedName}\\s*=\\s*([\"'])(.*?)\\1`, "i"));
+  return match?.[2] ?? null;
+}

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

@@ -0,0 +1,85 @@
+import assets from "./assets.tar" with { type: "file" };
+import { getExeDirname, isCompiledBinary } from "./compiled.js";
+
+const forceExternalAssets = process.argv.includes("--assets-external");
+const debugAssetsLoader = Boolean(process.env.BUNMICRO_DEBUG);
+if (forceExternalAssets) {
+  const flagIndex = process.argv.indexOf("--assets-external");
+  if (flagIndex >= 0) process.argv.splice(flagIndex, 1);
+}
+
+globalThis.internalAssets = forceExternalAssets ? null : Object.create(null);
+globalThis.assetsLoaderPromise = main(process.argv).catch((error) => {
+  console.error("# assets loader failed");
+  console.error(error);
+  return globalThis.internalAssets;
+});
+
+async function main(argv) { 
+
+  if (forceExternalAssets &&
+      !argv.includes("--assets-list") &&
+      !argv.includes("--assets-extract")) {
+    return null;
+  }
+
+  const startedAt = debugAssetsLoader ? Bun.nanoseconds() : 0;
+
+  const tarball = await Bun.file(assets).bytes();
+  const archive = new Bun.Archive(tarball);
+
+  await cliEarlyExit(archive, argv);
+
+  const files = await archive.files();
+  const entries = [...files.entries()];
+  const assetsByPath = Object.create(null);
+  const errors = [];
+
+  for (const [path, file] of entries) {
+    try {
+      assetsByPath[path] = await file.bytes();
+    } catch (reason) {
+      errors.push({ path, reason });
+    }
+  }
+
+  if (errors.length > 0) {
+    console.error(`# Failed to load ${errors.length} bundled asset(s):`);
+    for (const { path, reason } of errors) {
+      console.error(`- ${path}`);
+      if (reason) {
+        console.error(reason);
+      }
+    }
+  }
+  if (debugAssetsLoader) {
+    const elapsedMs = (Bun.nanoseconds() - startedAt) / 1e6;
+    console.error(`Loaded assets: ${elapsedMs.toFixed(3)} ms`);
+  }
+
+  globalThis.internalAssets = assetsByPath;
+  return assetsByPath;
+}
+
+async function cliEarlyExit(archive, argv) {
+  if (argv.includes("--assets-list")) {
+    const files = await archive.files();
+    for (const path of [...files.keys()].sort()) {
+      console.log(path);
+    }
+    process.exit(0);
+  }
+
+  if (argv.includes("--assets-extract")) {
+    if (isCompiledBinary())
+    {
+      const targetDir = getExeDirname();
+      const extracted = await archive.extract(targetDir);
+      console.log(`Extracted ${extracted} asset(s) to ${targetDir}`);
+    }  //  if isCompiled
+    else
+      console.log("Assets extraction should only be used in a Bun compiled single-file executable");
+      
+    process.exit(0);
+  }
+}

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

@@ -0,0 +1,212 @@
+import { basename, dirname, resolve } from "node:path";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import child_process from "node:child_process";
+
+
+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");
+
+
+export function isCompiledBinary(argv = process.argv) {
+  const entry = argv?.[1];
+  return Boolean(
+    entry?.startsWith?.("/$bunfs/") ||
+    entry?.startsWith?.("B:/~BUN")
+  );
+}
+
+export function getExeDirname() {
+  const argv = process.argv
+  const execPath = process.execPath
+  
+  const bn = basename(execPath);
+  if (bn.startsWith("ld") || 
+      bn.startsWith("libld") ||
+      bn.startsWith("linker") ) {
+    const realArgv = readFileSync("/proc/self/cmdline", "utf8").match(/[^\0]+/g);
+    return dirname(realArgv?.[1] ?? execPath);
+  }
+  return dirname(execPath) || process.cwd();
+}
+
+export function getDirnameFromUrl(importMetaUrl) {
+  return dirname(fileURLToPath(importMetaUrl));
+}
+
+export function stringifyNonPrimitiveDefineValues(argv, name) {
+  const definePrefix = `${name}=`;
+  const numberLiteral = /^[+-]?(?:(?:0[xX][\dA-Fa-f](?:_?[\dA-Fa-f])*)|(?:0[bB][01](?:_?[01])*)|(?:0[oO][0-7](?:_?[0-7])*)|(?:(?:\d(?:_?\d)*)(?:\.(?:\d(?:_?\d)*)?)?|\.(?:\d(?:_?\d)*))(?:[eE][+-]?\d(?:_?\d)*)?)$/;
+
+  // Parse scalar literals as data. Never evaluate a user-provided expression.
+  const normalize = (definition) => {
+    if (!definition.startsWith(definePrefix)) return definition;
+    const source = definition.slice(definePrefix.length);
+    const trimmed = source.trim();
+    let value;
+    let parsed = false;
+
+    try {
+      value = JSON.parse(source);
+      parsed = true;
+    } catch {
+      try {
+        if (globalThis.Bun?.JSON5) {
+          value = globalThis.Bun.JSON5.parse(source);
+          parsed = true;
+        }
+      } catch {}
+    }
+
+    if (parsed && typeof value === "string") {
+      return definePrefix + JSON.stringify(value);
+    }
+    if (
+      (parsed && (
+        value === null
+        || typeof value === "number"
+        || typeof value === "boolean"
+      ))
+      || trimmed === "undefined"
+      || numberLiteral.test(trimmed)
+    ) {
+      return definition;
+    }
+    return definePrefix + JSON.stringify(source);
+  };
+
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === "--define" && typeof argv[i + 1] === "string") {
+      argv[i + 1] = normalize(argv[i + 1]);
+    } else if (argv[i]?.startsWith?.("--define=")) {
+      argv[i] = "--define="
+        + normalize(argv[i].slice("--define=".length));
+    }
+  }
+  return argv;
+}
+
+export async function buildExecutable(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;
+  }
+  
+  let bunBin=Bun.which('bun') || process.argv0;
+
+  const steps = [
+    {
+      label: "Pack assets",
+      cwd: SINGLE_EXE_DIR,
+      cmd: bunBin,
+      args: ["./packAssets.sh"],
+    },
+    {
+      label: "Compile executable",
+      cwd: SINGLE_EXE_DIR,
+      cmd: bunBin,
+      args: [
+        "build",
+        "--format=esm",
+        "--compile",
+        "--minify",
+        "--bytecode",
+        "./entry.mjs",
+        `--outfile=${outfile}`,
+        `--metafile-md=${outfile}.meta.md`,
+        ...(normalizedTarget ? [`--target=${normalizedTarget}`] : []),
+        ...extraBunArgs,
+      ],
+    },
+  ];
+
+  for (const step of steps) {
+  
+    console.log('');
+    console.log(Bun?.markdown?.ansi?.('## '+step.label)||step.label); 
+    
+    console.log("Running: ",step.cmd,step.args)
+  
+    const result = child_process.spawnSync(step.cmd, step.args, {
+      cwd: step.cwd,
+      stdio: "inherit",
+      env: process.env,
+    });
+    
+    console.log("");
+    console.log(Bun?.markdown?.ansi?.(
+      '- Status: '+result.status+' for '+step.label
+    )||result.status);
+
+
+
+    if (result.error || result.status !== 0) {
+    
+      if (result.error) {
+        console.error(result.error);
+      }
+      
+      if (step.label == "Pack assets") {
+        console.log("Pack assets failed; continuing with the existing assets.tar if available");
+      }
+      
+    }
+    
+    
+  }  //  for steps of build
+
+  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;
+  }
+  else
+  {
+    console.log(`Error while building executable: ${outfile}`);
+    return 1;
+  }
+}
+
+export const buildExe = buildExecutable;
+
+export async function buildEarlyExit(argv,build_outfile) {
+  argv = argv || process.argv
+
+  const buildExeIndex = argv.indexOf("--build-exe");
+  const buildForIndex = argv.indexOf("--build-for");
+
+  if (buildExeIndex === -1 && buildForIndex === -1) {
+    return false;
+  }
+  
+  if (IS_COMPILED) {
+    console.error("--build-exe & --build-for are only available in the source tree");
+    process.exit(1);
+  }
+
+  if (buildForIndex !== -1) {
+    const target = argv[buildForIndex + 1];
+    if (!target || target.startsWith("-")) {
+      console.error("Missing target value for --build-for");
+      process.exit(2);
+    }
+    process.exit(await buildExe(target, build_outfile, argv.slice(buildForIndex + 2)));
+  }
+
+  process.exit(await buildExe(null, build_outfile, argv.slice(buildExeIndex + 1)));
+}

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

@@ -0,0 +1,10 @@
+#!/usr/bin/env bun
+
+// 1. Injects assets to global.internalAssets
+//   as { "./path/in/tar":file.bytes() }
+// 2. Sets global.assetsLoaderPromise
+// 3. Starts the main program only after the assets are ready
+import "./assetsLoader.mjs";
+
+await globalThis.assetsLoaderPromise;
+await import("../src/index.js");

package/apps/jsmdcui/single-exe/packAssets.sh

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+sd=$(dirname "$0")
+
+cd "$sd"/..
+
+tar -cvf single-exe/assets.tar demos runtime README.md CHANGELOG.md cdp-maze.js src/cui/server.mjs src/cui/rpc.mjs testapp.md

package/apps/jsmdcui/src/buffer/backup.js

@@ -0,0 +1,165 @@
+// Crash recovery backup system compatible with Go micro's internal/buffer/backup.go.
+
+import { join } from "node:path";
+import { existsSync, statSync, unlinkSync } from "node:fs";
+import { mkdir, writeFile, readFile, rename } from "node:fs/promises";
+import { homedir } from "node:os";
+import { createHash } from "node:crypto";
+import { isMdcuiEncoding } from "../runtime/encodings.js";
+
+export const BACKUP_SUFFIX = ".micro-backup";
+
+function isMdcuiBuffer(buf) {
+  return isMdcuiEncoding(buf?.encoding ?? buf?.Settings?.encoding);
+}
+
+export function getBackupDir(buf, configDir) {
+  const raw = String(buf?.Settings?.backupdir ?? "");
+  if (!raw) return join(configDir, "backups");
+  if (raw === "~" || raw.startsWith("~/") || raw.startsWith("~\\")) {
+    return raw.replace(/^~/, homedir());
+  }
+  // Node has no portable equivalent of Go's user.Lookup for ~otheruser.
+  if (raw.startsWith("~")) return join(configDir, "backups");
+  return raw;
+}
+
+function queryEscapePath(path) {
+  return encodeURIComponent(String(path).replaceAll("\\", "/"))
+    .replace(/[!'()*]/g, (ch) => `%${ch.charCodeAt(0).toString(16).toUpperCase()}`)
+    .replace(/%20/g, "+"); 
+} // '
+
+function legacyEscapePath(path) {
+  let escaped = String(path).replaceAll("\\", "/");
+  if (process.platform === "win32") escaped = escaped.replaceAll(":", "%");
+  return escaped.replaceAll("/", "%");
+}
+
+export function determineBackupPath(backupDirPath, absPath) {
+  const urlName = join(backupDirPath, queryEscapePath(absPath));
+  if (existsSync(urlName)) return { name: urlName, resolveName: null };
+
+  const legacyName = join(backupDirPath, legacyEscapePath(absPath));
+  if (existsSync(legacyName)) return { name: legacyName, resolveName: null };
+
+  if (Buffer.byteLength(urlName + BACKUP_SUFFIX) > 255) {
+    const hash = createHash("md5").update(absPath).digest("hex");
+    return {
+      name: join(backupDirPath, hash),
+      resolveName: join(backupDirPath, hash + ".path"),
+    };
+  }
+  return { name: urlName, resolveName: null };
+}
+
+export async function writeBackup(buf, configDir, path = buf?.AbsPath ?? buf?.path, { force = false } = {}) {
+  if (isMdcuiBuffer(buf) || (!force && !buf?.Settings?.backup) || !path || buf.type !== "default") return false;
+  const dir = getBackupDir(buf, configDir);
+  await mkdir(dir, { recursive: true });
+  const { name, resolveName } = determineBackupPath(dir, path);
+  const tmp = name + BACKUP_SUFFIX;
+  try {
+    await writeFile(tmp, buf.lines.join("\n"), "utf8");
+    await rename(tmp, name);
+    if (resolveName) await writeFile(resolveName, path, "utf8");
+    return true;
+  } catch (error) {
+    try { unlinkSync(tmp); } catch {}
+    throw error;
+  }
+}
+
+export function removeBackup(buf, configDir, path = buf?.AbsPath ?? buf?.path) {
+  if (isMdcuiBuffer(buf) || buf?.Settings?.permbackup || buf?._forceKeepBackup) return;
+  if (!path || buf.type !== "default") return;
+  const dir = getBackupDir(buf, configDir);
+  const { name, resolveName } = determineBackupPath(dir, path);
+  try { unlinkSync(name); } catch {}
+  if (resolveName) try { unlinkSync(resolveName); } catch {}
+}
+
+// promptFn(msg) -> Promise<string>
+// Returns { recovered: bool, abort: bool }
+export async function applyBackup(buf, configDir, promptFn) {
+  if (isMdcuiBuffer(buf) || !buf?.Settings?.backup || buf?.Settings?.permbackup) return { recovered: false, abort: false };
+  if (!buf.path || buf.type !== "default") return { recovered: false, abort: false };
+
+  const dir = getBackupDir(buf, configDir);
+  const { name: backupFile, resolveName } = determineBackupPath(dir, buf.AbsPath ?? buf.path);
+  if (!existsSync(backupFile)) return { recovered: false, abort: false };
+
+  let info;
+  try { info = statSync(backupFile); } catch { return { recovered: false, abort: false }; }
+
+  const t = info.mtime;
+  const dateStr =
+    t.toLocaleDateString("en-US", { weekday: "short", month: "short", day: "numeric" }) +
+    " at " +
+    t.toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit", hour12: false }) +
+    ", " + t.getFullYear();
+
+  const ticcc='```';
+
+  const msg = `
+# Backup detected! ⚠️
+- File path/url:
+${ticcc}
+${buf.path}
+${ticcc}
+- either micro crashed
+- or another micro is running
+- or an error occurred while saving
+- The file may be corrupted
+# Date of backup 🕰
+- ${dateStr}
+# Path of backup 
+${ticcc}
+${backupFile}
+${ticcc}
+# Recovery options
+## r = 'recover'
+- Apply the backup 
+- as unsaved changes to the current buffer
+- When the buffer is closed, the backup will be removed.
+## i = 'ignore'
+- Ignore & remove the backup
+## a = 'abort' 
+- Abort the open operation
+- Open an empty buffer
+- Keep the backup
+### Your choice
+- [r]ecover, [i]gnore, [a]bort
+`;
+
+  const options = ["r", "i", "a", "recover", "ignore", "abort"];
+  let choice = -1;
+  let prompt = msg;
+  while (choice === -1) {
+    const resp = await promptFn(prompt);
+    const idx = options.indexOf(resp.trim().toLowerCase());
+    if (idx !== -1) choice = idx % 3;
+    else prompt = "\n#### Invalid choice!";
+  }
+
+  if (choice === 0) {
+    try {
+      const text = await readFile(backupFile, "utf8");
+      buf.lines = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+      if (!buf.lines.length) buf.lines = [""];
+      buf._recovered = true;
+      buf._savedSerial = -1;
+      buf.setModified?.(true);
+      if (!buf.setModified) buf.modified = true;
+      return { recovered: true, abort: false };
+    } catch {
+      return { recovered: false, abort: false };
+    }
+  }
+  if (choice === 1) {
+    try { unlinkSync(backupFile); } catch {}
+    if (resolveName) try { unlinkSync(resolveName); } catch {}
+    return { recovered: false, abort: false };
+  }
+  return { recovered: false, abort: true };
+}