buninu 0.1.1

package/apps/jsgotty/rz.js

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+const {
+  basenameSafe,
+  loadZmodem,
+  restoreStdin,
+  setRawStdin,
+  stderr,
+  appendDebugLog,
+  writeOctets,
+} = require("./zmodem-node");
+const {
+  BridgeInputParser,
+  emitBridgeMessage,
+} = require("./windows-bridge-node");
+
+async function main() {
+  if (process.argv.includes("-h") || process.argv.includes("--help")) {
+    stderr("usage: node rz.js [target-dir]");
+    process.exitCode = 0;
+    return;
+  }
+
+  const targetDir = process.argv[2] ? path.resolve(process.argv[2]) : process.cwd();
+  fs.mkdirSync(targetDir, { recursive: true });
+
+  if (process.platform === "win32") {
+    await runWindowsBridge(targetDir);
+    return;
+  }
+
+  const Zmodem = await loadZmodem();
+  const session = new Zmodem.Session.Receive();
+  let ending = false;
+  const completedUploads = [];
+
+  const finish = (code, error) => {
+    if (ending) {
+      return;
+    }
+    ending = true;
+    restoreStdin();
+    if (error) {
+      stderr(String(error && error.stack ? error.stack : error));
+    } else if (code === 0) {
+      for (const file of completedUploads) {
+        stderr(`uploaded ${file.path} (${formatByteCount(file.size)})`);
+      }
+    }
+    process.exitCode = code;
+  };
+
+  process.on("SIGINT", () => {
+    try {
+      if (!session.has_ended()) {
+        session.abort();
+      }
+    } catch {}
+    finish(130);
+  });
+
+  session.set_sender((octets) => {
+    void writeOctets(octets).catch((error) => finish(1, error));
+  });
+
+  session.on("offer", (offer) => {
+    void receiveOffer(offer, targetDir, completedUploads).catch((error) => {
+      try {
+        session.abort();
+      } catch {}
+      finish(1, error);
+    });
+  });
+
+  session.on("session_end", () => {
+    finish(0);
+  });
+
+  process.stdin.on("data", (chunk) => {
+    try {
+      session.consume(Array.from(chunk));
+    } catch (error) {
+      finish(1, error);
+    }
+  });
+
+  process.stdin.on("end", () => {
+    if (!ending) {
+      finish(session.has_ended() ? 0 : 1, session.has_ended() ? null : new Error("stdin ended before ZMODEM session completed"));
+    }
+  });
+
+  setRawStdin();
+  stderr(`rz ready: waiting for sender, target dir ${targetDir}`);
+  session.start();
+}
+
+async function runWindowsBridge(targetDir) {
+  const requestId = `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  let finished = false;
+
+  const finish = (code, error) => {
+    if (finished) {
+      return;
+    }
+    finished = true;
+    if (error) {
+      stderr(String(error && error.stack ? error.stack : error));
+    }
+    restoreStdin();
+    process.exitCode = code;
+  };
+
+  const parser = new BridgeInputParser((message) => {
+    try {
+      if (!message || message.requestId !== requestId) {
+        return;
+      }
+
+      if (message.op === "upload_cancel") {
+        finish(1, new Error("upload canceled"));
+        return;
+      }
+
+      if (message.op === "upload_error") {
+        finish(1, new Error(String(message.message || "upload failed")));
+        return;
+      }
+
+      if (message.op === "upload_finish") {
+        finish(0);
+      }
+    } catch (error) {
+      finish(1, error);
+    }
+  });
+
+  process.on("SIGINT", () => finish(130));
+  process.stdin.on("data", (chunk) => parser.consume(chunk));
+  process.stdin.on("end", () => {
+    if (!finished) {
+      finish(1, new Error("stdin ended before upload completed"));
+    }
+  });
+
+  setRawStdin();
+  stderr(`rz ready: waiting for sender, target dir ${targetDir}`);
+  emitBridgeMessage({
+    op: "upload_request",
+    requestId,
+    targetDir,
+  });
+}
+
+async function receiveOffer(offer, targetDir, completedUploads) {
+  const details = offer.get_details();
+  const originalName = details.name;
+  const localName = basenameSafe(originalName);
+  const outputPath = path.join(targetDir, localName);
+  const fd = fs.openSync(outputPath, "w", details.mode ? details.mode & 0o777 : 0o644);
+  let receivedBytes = 0;
+
+  debug(`receiving ${originalName} -> ${outputPath}`);
+
+  try {
+    await offer.accept({
+      on_input: (payload) => {
+        const buffer = Buffer.from(payload);
+        fs.writeSync(fd, buffer);
+        receivedBytes += buffer.length;
+      },
+    });
+  } finally {
+    fs.closeSync(fd);
+  }
+
+  if (details.mtime instanceof Date && !Number.isNaN(details.mtime.valueOf())) {
+    fs.utimesSync(outputPath, new Date(), details.mtime);
+  }
+
+  completedUploads.push({ path: outputPath, size: receivedBytes });
+  debug(`received ${outputPath}`);
+}
+
+function debug(message) {
+  appendDebugLog(message);
+}
+
+function formatByteCount(bytes) {
+  return `${Number(bytes || 0).toLocaleString()} bytes`;
+}
+
+main().catch((error) => {
+  restoreStdin();
+  stderr(String(error && error.stack ? error.stack : error));
+  process.exitCode = 1;
+});

package/apps/jsgotty/single-exe/README.md

@@ -0,0 +1,80 @@
+# This is completely optional
+- I still recommend using the methods in the root README.md
+- Bun's Android build is currently not supported
+
+# Usage
+- First run `bun ./packAssets.sh` to bundle the assets into `assets.tar`
+- Then run the build script like this
+
+  ```shell
+  bun build --compile --bytecode --minify ./entry.mjs --outfile=binname
+  ```
+
+- You'll get a binname executable
+
+# Single Executable Intro
+
+This folder contains the Bun single-exe bootstrap used by the project.
+
+## Entry Flow
+
+- `entry.mjs` imports `assetsLoader.mjs` first
+- `assetsLoader.mjs` loads `assets.tar` with `Bun.Archive` and mounts it as `globalThis.internalAssets`
+- `assetsLoaderPromise` is exposed on `globalThis`
+- The main program waits for `assetsLoaderPromise` if it exists
+
+That keeps the main program bootable even if asset loading reports errors.
+
+## Assets Loading
+
+- Bundled assets are loaded sequentially with `await file.bytes()`
+- Load failures are collected and printed to `stderr`
+- Asset loading never rejects the bootstrap promise
+- When loading succeeds, the archive is available through `globalThis.internalAssets`
+
+## CLI Flags
+
+- `--assets-list`
+  - Lists all entries inside bundled `assets.tar`
+  - Exits early before the main program starts
+
+- `--assets-extract`
+  - Extracts bundled assets to the same directory as the executable
+  - Exits early before the main program starts
+
+- `--assets-external`
+  - Skips loading bundled assets into `globalThis.internalAssets`
+  - Forces the main program and runtime helpers to use the external file tree
+  - Keeps the bootstrap alive while leaving `internalAssets` falsy
+
+## Adapting this folder
+
+This single-exe folder is intended for reuse by other projects. Usually you
+only need to edit these project-specific files first:
+
+- `entry.mjs`
+- `packAssets.sh`
+
+Then the main program can import `buildEarlyExit` from `compiled.js` and call
+it before normal CLI parsing. `--build-exe` and `--build-for <target>` will run
+`packAssets.sh` first, so `assets.tar` is generated as part of the build flow.
+
+```js
+const compiledHelper = await import("./single-exe/compiled.js").catch(() => null);
+await compiledHelper?.buildEarlyExit?.(process.argv, "my-bin");
+```
+
+- `--build-exe` builds with no Bun target.
+- `--build-for <target>` passes `<target>` to `bun build --target=<target>`.
+- The second argument is the output filename. If omitted, it defaults to `single.exe`.
+
+The main program should also switch its repo/resource root when running as a
+compiled binary. Use `IS_COMPILED` and `REPO_ROOT` from
+`compiled.js`; when compiled, treat the executable directory as the repo root
+used for external fallback files such as `static/`, `README.md`, or other files
+packed by `packAssets.sh`.
+
+```js
+const compiledHelper = await import("./single-exe/compiled.js").catch(() => null);
+const repoRoot = compiledHelper?.REPO_ROOT
+```

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

@@ -0,0 +1,90 @@
+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 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 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);
+}

package/apps/jsgotty/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/jsgotty/single-exe/compiled.js

@@ -0,0 +1,138 @@
+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() {
+  const argv = process.argv
+  return Boolean(argv?.[1]?.startsWith?.("/$bunfs/"));
+}
+
+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 async function buildExecutable(target = "",build_outfile="single.exe") {
+ 
+  const outfile = resolve(process.cwd(), build_outfile);
+  const normalizedTarget = String(target || "").trim();
+  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: process.cwd(),
+      cmd: bunBin,
+      args: [
+        "build",
+        "--compile",
+        "--bytecode",
+        "--minify",
+        SINGLE_EXE_ENTRY,
+        `--outfile=${build_outfile}`,
+        ...(normalizedTarget ? [`--target=${normalizedTarget}`] : []),
+      ],
+    },
+  ];
+
+  for (const step of steps) {
+  
+    console.log('');
+    console.log(Bun?.markdown?.ansi?.('## '+step.label)||step.label);
+  
+    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
+
+  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 = process.argv,build_outfile) {
+  const buildExeIndex = argv.indexOf("--build-exe");
+  const buildForIndex = argv.indexOf("--build-for");
+
+  if (buildExeIndex === -1 && buildForIndex === -1) {
+    return false;
+  }
+
+  if (buildForIndex !== -1) {
+    const target = argv[buildForIndex + 1];
+    if (!target || target.startsWith("-")) {
+      console.error("Missing value for --build-for");
+      process.exit(2);
+    }
+    process.exit(await buildExe(target,build_outfile));
+  }
+
+  process.exit(await buildExe(null,build_outfile));
+}

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

@@ -0,0 +1,9 @@
+#!/usr/bin/env bun
+
+// 1. Injects assets to global.internalAssets
+//   as { "./path/in/tar":file.bytes() }
+// 2. Sets global.assetsLoaderPromise
+import "./assetsLoader.mjs"
+
+import "../gotty.js"
+

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

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+sd=$(dirname "$0")
+
+cd "$sd"/..
+
+tar -cvf single-exe/assets.tar static README.md README.en.md

package/apps/jsgotty/static/css/index.css

@@ -0,0 +1,13 @@
+html, body, #terminal {
+    background: black;
+    height: 100%;
+    width: 100%;
+    padding: 0%;
+    margin: 0%;
+}
+
+.progress .progress-bar {
+  transition: unset;
+  transition-duration: 0.1s;
+  transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
+}

package/apps/jsgotty/static/css/kitty.css

@@ -0,0 +1,61 @@
+#terminal {
+  position: relative;
+}
+
+#kitty-overlay {
+  position: absolute;
+  inset: 0;
+  pointer-events: none;
+  overflow: hidden;
+  z-index: 3;
+}
+
+#kitty-overlay .kitty-image {
+  position: absolute;
+  display: block;
+  overflow: hidden;
+  pointer-events: none;
+}
+
+#kitty-overlay .kitty-image__content {
+  position: absolute;
+  display: block;
+  max-width: none;
+  max-height: none;
+  image-rendering: auto;
+  pointer-events: none;
+}
+
+.kitty-context-menu {
+  position: fixed;
+  z-index: 1000;
+  min-width: 144px;
+  padding: 6px;
+  border: 1px solid rgba(255, 255, 255, 0.18);
+  border-radius: 10px;
+  background: rgba(24, 28, 34, 0.96);
+  box-shadow: 0 10px 28px rgba(0, 0, 0, 0.35);
+  backdrop-filter: blur(10px);
+}
+
+.kitty-context-menu[hidden] {
+  display: none;
+}
+
+.kitty-context-menu__item {
+  display: block;
+  width: 100%;
+  margin: 0;
+  padding: 9px 12px;
+  border: 0;
+  border-radius: 7px;
+  background: transparent;
+  color: #f3f5f7;
+  font: inherit;
+  text-align: left;
+  cursor: pointer;
+}
+
+.kitty-context-menu__item:hover {
+  background: rgba(255, 255, 255, 0.08);
+}