buninu-linux 0.2.0

package/initramfs/buninu/apps/jsmdcui/src/lua/engine.js

@@ -0,0 +1,68 @@
+import { existsSync } from "node:fs";
+import { readInternalAssetBytes } from "../../single-exe/assetsHelper.js";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { REPO_ROOT } from "../../single-exe/compiled.js";
+
+export async function createLuaEngine() {
+  let wasmoon = null;
+  try {
+    wasmoon = await import("wasmoon");
+  } catch (error) {
+    if (
+      error?.code !== "ERR_MODULE_NOT_FOUND" &&
+      !/Cannot find package/.test(String(error?.message))
+    ) {
+      throw error;
+    }
+  }
+  if (!wasmoon?.LuaFactory) {
+    throw new Error("Lua support requires the WASM runtime `wasmoon`. Install it with `bun add wasmoon`.");
+  }
+
+  const wasmLocation = await resolveLuaWasmLocation();
+  const factory = new wasmoon.LuaFactory(wasmLocation);
+  const lua = await factory.createEngine();
+  return new WasmoonEngine(lua);
+}
+
+async function resolveLuaWasmLocation() {
+  const wasmAssetPath = "runtime/wasmoon_glue.wasm";
+  const wasmBytes = readInternalAssetBytes(wasmAssetPath);
+  if (wasmBytes) {
+    const wasmPath = join(tmpdir(), "bunmicro-wasmoon-glue.wasm");
+    try {
+      const existing = await Bun.file(wasmPath).bytes().catch(() => null);
+      if (!existing || existing.byteLength !== wasmBytes.byteLength) {
+        await Bun.write(wasmPath, wasmBytes);
+      }
+      return wasmPath;
+    } catch (error) {
+      console.error("# failed to stage bundled wasmoon wasm");
+      console.error(error);
+    }
+  }
+
+  const fallbackPath = join(REPO_ROOT, wasmAssetPath);
+
+  return existsSync(fallbackPath) ? fallbackPath : undefined;
+}
+
+class WasmoonEngine {
+  constructor(lua) {
+    this.kind = "wasmoon";
+    this.lua = lua;
+  }
+
+  async doString(source, chunkName = "chunk") {
+    return this.lua.doString(source, chunkName);
+  }
+
+  setGlobal(name, value) {
+    this.lua.global.set(name, value);
+  }
+
+  getGlobal(name) {
+    return this.lua.global.get(name);
+  }
+}

package/initramfs/buninu/apps/jsmdcui/src/platform/archive.js

@@ -0,0 +1,50 @@
+import { mkdir, readdir, rename, rm } from "node:fs/promises";
+import { join, dirname } from "node:path";
+import { hasCommand, isLinuxLike, platformId, run } from "./commands.js";
+
+export async function extractZip(zipPath, destDir) {
+  await mkdir(destDir, { recursive: true });
+  const platform = platformId();
+
+  if (platform === "darwin" || platform === "win32") {
+    await run(["tar", "-xf", zipPath, "-C", destDir]);
+    return;
+  }
+
+  if (isLinuxLike()) {
+    if (!hasCommand("unzip")) {
+      throw new Error("Installing zip plugins requires `unzip`. Please install unzip first.");
+    }
+    await run(["unzip", "-q", zipPath, "-d", destDir]);
+    return;
+  }
+
+  if (hasCommand("unzip")) {
+    await run(["unzip", "-q", zipPath, "-d", destDir]);
+    return;
+  }
+
+  throw new Error(`Unsupported platform for zip extraction: ${platform}`);
+}
+
+// Extract zip to destDir, stripping a single top-level prefix directory if present
+// (matches Go micro behavior: zips containing e.g. autoclose-1.0.0/ are stripped).
+export async function extractAndStrip(zipPath, destDir) {
+  const tmpDir = destDir + ".__install_tmp__";
+  await rm(tmpDir, { recursive: true, force: true });
+  await extractZip(zipPath, tmpDir);
+
+  const entries = await readdir(tmpDir, { withFileTypes: true });
+  const subdirs = entries.filter((e) => e.isDirectory());
+  const files = entries.filter((e) => e.isFile());
+
+  await rm(destDir, { recursive: true, force: true });
+  await mkdir(dirname(destDir), { recursive: true });
+
+  if (subdirs.length === 1 && files.length === 0) {
+    await rename(join(tmpDir, subdirs[0].name), destDir);
+    await rm(tmpDir, { recursive: true, force: true });
+  } else {
+    await rename(tmpDir, destDir);
+  }
+}

package/initramfs/buninu/apps/jsmdcui/src/platform/clipboard.js

@@ -0,0 +1,278 @@
+import { firstCommand, isLinuxLike, platformId, runSync } from "./commands.js";
+
+const CLIPBOARD_TIMEOUT_MS = 2000;
+const internalRegisters = new Map();
+
+export class ClipboardManager {
+  constructor() {
+    this.backend = detectClipboardBackend();
+    this._writeBackend = null;
+    this._altBackend = null;
+    this._readFromInternal = false;
+  }
+
+  methodName() {
+    return (this._writeBackend ?? this.backend).name;
+  }
+
+  readMethodName(register = "clipboard") {
+    if (register !== "clipboard" && register !== "primary") return "internal";
+    if (register === "clipboard" && this._readFromInternal) return "internal";
+    if (register === "primary" && !this.backend.supportsPrimary) return "internal";
+    return this.backend.name;
+  }
+
+  altMethodName() {
+    return this._altBackend?.name ?? null;
+  }
+
+  fallbackToInternal() {
+    this.backend = internalClipboard();
+    this._writeBackend = null;
+    this._altBackend = null;
+    this._readFromInternal = false;
+    return this.backend;
+  }
+
+  read(register = "clipboard") {
+    if (register !== "clipboard" && register !== "primary") {
+      return internalRegisters.get(register) ?? "";
+    }
+    if (register === "primary" && !this.backend.supportsPrimary) {
+      return internalRegisters.get(register) ?? "";
+    }
+    // terminal mode: paste from internal to avoid OSC 52 read issues over SSH
+    if (register === "clipboard" && this._readFromInternal) {
+      return internalRegisters.get(register) ?? "";
+    }
+    try {
+      const text = this.backend.read?.(register);
+      if (text == null) return internalRegisters.get(register) ?? "";
+      return text;
+    } catch {
+      return this.fallbackToInternal().read(register);
+    }
+  }
+
+  write(text, register = "clipboard") {
+    internalRegisters.set(register, text);
+    if (register !== "clipboard" && register !== "primary") return true;
+    const wb = this._writeBackend ?? this.backend;
+    if (register === "primary" && !wb.supportsPrimary) return true;
+    try {
+      const ok = wb.write?.(text, register) ?? true;
+      if (!ok) {
+        if (wb === this._writeBackend) this._writeBackend = null;
+        else this.fallbackToInternal();
+      }
+      return true;
+    } catch {
+      if (wb === this._writeBackend) this._writeBackend = null;
+      else this.fallbackToInternal();
+      return true;
+    }
+  }
+
+  writeAlt(text, register = "clipboard") {
+    if (!this._altBackend) return false;
+    internalRegisters.set(register, text);
+    try {
+      return this._altBackend.write?.(text, register) ?? true;
+    } catch {
+      return false;
+    }
+  }
+
+  async initFromSetting(setting, ttyIn, ttyOut, timeoutMs = 150) {
+    this.backend = detectClipboardBackend();
+    this._writeBackend = null;
+    this._altBackend = null;
+    this._readFromInternal = false;
+    if (setting === "internal") {
+      this.fallbackToInternal();
+      return;
+    }
+    if (setting === "terminal") {
+      // skip probe — directly enable OSC 52 write (handles write-only terminals)
+      if (ttyOut) {
+        this._altBackend = this.backend;   // external as clickable alt
+        this._writeBackend = osc52Clipboard(ttyOut);
+        this._readFromInternal = true;     // paste via internal (SSH-safe)
+      }
+    } else {
+      // "external" (default): probe OSC 52 as optional alt
+      if (ttyIn && ttyOut && process.stdout?.isTTY) {
+        const ok = await probeOSC52(ttyIn, ttyOut, timeoutMs);
+        if (ok) this._altBackend = osc52Clipboard(ttyOut);
+      }
+    }
+  }
+
+  // kept for backward compatibility (--version probe etc.)
+  async probeAndUpgradeOSC52(ttyIn, ttyOut, timeoutMs = 150) {
+    const ok = await probeOSC52(ttyIn, ttyOut, timeoutMs);
+    if (ok) this._writeBackend = osc52Clipboard(ttyOut);
+  }
+}
+
+function detectClipboardBackend() {
+  const platform = platformId();
+
+  if (platform === "android") {
+    const termuxSet = firstCommand(["termux-clipboard-set"]);
+    const termuxGet = firstCommand(["termux-clipboard-get"]);
+    if (termuxSet && termuxGet) return termuxClipboard(termuxSet, termuxGet);
+  }
+
+  if (isLinuxLike()) {
+    const wlCopy = firstCommand(["wl-copy"]);
+    const wlPaste = firstCommand(["wl-paste"]);
+    if (wlCopy && wlPaste) return wlClipboard(wlCopy, wlPaste);
+
+    const xclip = firstCommand(["xclip"]);
+    if (xclip) return xclipClipboard(xclip);
+
+    const xsel = firstCommand(["xsel"]);
+    if (xsel) return xselClipboard(xsel);
+
+    return internalClipboard();
+  }
+
+  if (platform === "darwin") {
+    const pbcopy = firstCommand(["pbcopy"]);
+    const pbpaste = firstCommand(["pbpaste"]);
+    if (pbcopy && pbpaste) return commandClipboard("pbcopy/pbpaste", [pbcopy], [pbpaste]);
+    return internalClipboard();
+  }
+
+  if (platform === "win32") {
+    const shell = firstCommand(["pwsh.exe", "powershell.exe", "pwsh", "powershell"]);
+    if (shell) return powershellClipboard(shell);
+    return internalClipboard();
+  }
+
+  return internalClipboard();
+}
+
+function internalClipboard() {
+  return {
+    name: "internal",
+    read: (register) => internalRegisters.get(register) ?? "",
+    write: (text, register) => {
+      internalRegisters.set(register, text);
+      return true;
+    },
+  };
+}
+
+function commandClipboard(name, writeCommand, readCommand) {
+  return {
+    name,
+    read: () => outputOrThrow(runSync(readCommand, { timeout: CLIPBOARD_TIMEOUT_MS })),
+    write: (text) => runSync(writeCommand, { stdin: text, stdout: "ignore", timeout: CLIPBOARD_TIMEOUT_MS }).ok,
+  };
+}
+
+function termuxClipboard(set, get) {
+  return commandClipboard("termux", [set], [get]);
+}
+
+function wlClipboard(wlCopy, wlPaste) {
+  return {
+    name: "wl-clipboard",
+    supportsPrimary: true,
+    read: (register) => {
+      const args = [wlPaste, "--no-newline"];
+      if (register === "primary") args.push("--primary");
+      return outputOrThrow(runSync(args, { timeout: CLIPBOARD_TIMEOUT_MS }));
+    },
+    write: (text, register) => {
+      const args = [wlCopy];
+      if (register === "primary") args.push("--primary");
+      return runSync(args, { stdin: text, stdout: "ignore", timeout: CLIPBOARD_TIMEOUT_MS }).ok;
+    },
+  };
+}
+
+function xclipClipboard(xclip) {
+  return {
+    name: "xclip",
+    supportsPrimary: true,
+    read: (register) => {
+      const selection = register === "primary" ? "primary" : "clipboard";
+      return outputOrThrow(runSync([xclip, "-selection", selection, "-o"], { timeout: CLIPBOARD_TIMEOUT_MS }));
+    },
+    write: (text, register) => {
+      const selection = register === "primary" ? "primary" : "clipboard";
+      return runSync([xclip, "-selection", selection], { stdin: text, stdout: "ignore", timeout: CLIPBOARD_TIMEOUT_MS }).ok;
+    },
+  };
+}
+
+function xselClipboard(xsel) {
+  return {
+    name: "xsel",
+    supportsPrimary: true,
+    read: (register) => {
+      const selection = register === "primary" ? "--primary" : "--clipboard";
+      return outputOrThrow(runSync([xsel, selection, "--output"], { timeout: CLIPBOARD_TIMEOUT_MS }));
+    },
+    write: (text, register) => {
+      const selection = register === "primary" ? "--primary" : "--clipboard";
+      return runSync([xsel, selection, "--input"], { stdin: text, stdout: "ignore", timeout: CLIPBOARD_TIMEOUT_MS }).ok;
+    },
+  };
+}
+
+function powershellClipboard(shell) {
+  return {
+    name: "powershell",
+    // Get-Clipboard -Raw appends \r\n to stdout; strip exactly one trailing line ending.
+    read: () => outputOrThrow(runSync([shell, "-NoProfile", "-Command", "Get-Clipboard -Raw"], {})).replace(/\r?\n$/, ""),
+    write: (text) => {
+      text=(text+'').replaceAll("'","''") ;
+      return runSync([shell, "-NoProfile", "-Command", `Set-Clipboard '${text}'`], { stdout: "ignore" }).ok ;
+    },
+  };
+}
+
+function outputOrThrow(result) {
+  if (!result.ok) throw new Error(result.stderr || result.stdout || "clipboard command failed");
+  return result.stdout;
+}
+
+export function osc52Clipboard(stdout) {
+  const inTmux = !!process.env.TMUX;
+  return {
+    name: "OSC 52",
+    write(text) {
+      const b64 = Buffer.from(text, "utf-8").toString("base64");
+      stdout.write(inTmux
+        ? `\x1bPtmux;\x1b\x1b]52;c;${b64}\x07\x1b\\`
+        : `\x1b]52;c;${b64}\x07`);
+      return true;
+    },
+  };
+}
+
+export async function probeOSC52(ttyIn, ttyOut, timeoutMs) {
+  return true;
+  // Almost no terminal reliably supports probing OSC 52, so treat it as
+  // available and let the actual write path fail or work on its own.
+  if (process.env.TMUX) return true;
+  return new Promise((resolve) => {
+    let done = false;
+    const timer = setTimeout(() => {
+      if (!done) { done = true; ttyIn.removeListener("data", onData); resolve(false); }
+    }, timeoutMs);
+    function onData(chunk) {
+      if (done) return;
+      const s = Buffer.isBuffer(chunk) ? chunk.toString("latin1") : String(chunk);
+      if (s.includes("\x1b]52;")) {
+        done = true; clearTimeout(timer); ttyIn.removeListener("data", onData); resolve(true);
+      }
+    }
+    ttyIn.on("data", onData);
+    ttyOut.write("\x1b]52;c;?\x07");
+  });
+}

package/initramfs/buninu/apps/jsmdcui/src/platform/commands.js

@@ -0,0 +1,221 @@
+import process from "node:process";
+
+const decoder = new TextDecoder();
+
+let _httpBackend = null;
+
+export function detectHttpBackend() {
+  if (_httpBackend !== null) return _httpBackend;
+  if (Bun.which("curl")) { _httpBackend = "curl"; return _httpBackend; }
+  if (Bun.which("wget")) { _httpBackend = "wget"; return _httpBackend; }
+  _httpBackend = "fetch";
+  return _httpBackend;
+}
+
+export async function fetchHttp(url) {
+  return decoder.decode(await fetchHttpBytes(url));
+}
+
+export async function fetchHttpBytes(url, options = {}) {
+  const b = detectHttpBackend();
+  const timeoutMs = Number.isFinite(options.timeoutMs)
+    ? Math.max(1, Math.trunc(options.timeoutMs))
+    : null;
+  const timeoutSeconds = timeoutMs == null
+    ? null
+    : String(Math.max(1, Math.ceil(timeoutMs / 1000)));
+  if (b === "curl") {
+    const command = ["curl", "-kL", "--silent", "--fail"];
+    if (timeoutSeconds != null)
+      command.push("--connect-timeout", timeoutSeconds, "--max-time", timeoutSeconds);
+    command.push(url);
+    const r = await runBytes(command, {
+      allowFailure: true,
+      timeout: timeoutMs,
+      signal: options.signal,
+    });
+    if (!r.ok) throw new Error(`curl: ${r.stderr.trim() || "failed"} (${url})`);
+    return r.stdout;
+  }
+  if (b === "wget") {
+    const command = ["wget", "--no-check-certificate", "-q", "-O", "-"];
+    if (timeoutSeconds != null)
+      command.push(`--timeout=${timeoutSeconds}`, "--tries=1");
+    command.push(url);
+    const r = await runBytes(command, {
+      allowFailure: true,
+      timeout: timeoutMs,
+      signal: options.signal,
+    });
+    if (!r.ok) throw new Error(`wget: ${r.stderr.trim() || "failed"} (${url})`);
+    return r.stdout;
+  }
+  const controller = timeoutMs == null && !options.signal
+    ? null
+    : new AbortController();
+  const abort = () => controller?.abort(options.signal?.reason);
+  if (options.signal?.aborted) abort();
+  else options.signal?.addEventListener("abort", abort, { once: true });
+  const timeout = timeoutMs != null
+    ? setTimeout(() => controller.abort(), timeoutMs)
+    : null;
+  try {
+    const resp = await fetch(
+      url,
+      controller ? { signal: controller.signal } : undefined,
+    );
+    if (!resp.ok) throw new Error(`HTTP ${resp.status}: ${url}`);
+    return new Uint8Array(await resp.arrayBuffer());
+  } finally {
+    if (timeout != null) clearTimeout(timeout);
+    options.signal?.removeEventListener("abort", abort);
+  }
+}
+
+export async function downloadFile(url, outPath) {
+  const b = detectHttpBackend();
+  if (b === "curl") {
+    await run(["curl", "-kL", "--silent", "--fail", "-o", outPath, url]);
+    return;
+  }
+  if (b === "wget") {
+    await run(["wget", "--no-check-certificate", "-q", "-O", outPath, url]);
+    return;
+  }
+  const resp = await fetch(url);
+  if (!resp.ok) throw new Error(`HTTP ${resp.status}: ${url}`);
+  await Bun.write(outPath, resp);
+}
+
+export function platformId() {
+  return process.platform;
+}
+
+export function isLinuxLike() {
+  const platform = platformId();
+  return platform === "linux" || platform === "android";
+}
+
+export function runSync(command, options = {}) {
+  try {
+    const spawnOpts = {
+      stdio: [stdioInput(options.stdin), options.stdout ?? "pipe", options.stderr ?? "pipe"],
+      env: options.env ?? process.env,
+      cwd: options.cwd,
+    };
+    if (options.timeout != null) spawnOpts.timeout = options.timeout;
+    const proc = Bun.spawnSync(command, spawnOpts);
+    return {
+      ok: proc.success,
+      code: proc.exitCode,
+      stdout: proc.stdout ? decoder.decode(proc.stdout) : "",
+      stderr: proc.stderr ? decoder.decode(proc.stderr) : "",
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      code: -1,
+      stdout: "",
+      stderr: String(error?.message || error),
+    };
+  }
+}
+
+export async function run(command, options = {}) {
+  const proc = Bun.spawn(command, {
+    stdio: [stdioInput(options.stdin), options.stdout ?? "pipe", options.stderr ?? "pipe"],
+    env: options.env ?? process.env,
+    cwd: options.cwd,
+  });
+  const [stdout, stderr, code] = await Promise.all([
+    proc.stdout ? new Response(proc.stdout).text() : Promise.resolve(""),
+    proc.stderr ? new Response(proc.stderr).text() : Promise.resolve(""),
+    proc.exited,
+  ]);
+  if (code !== 0 && !options.allowFailure) {
+    throw new Error(`${command[0]} exited with ${code}: ${stderr || stdout}`);
+  }
+  return { ok: code === 0, code, stdout, stderr };
+}
+
+export async function runBytes(command, options = {}) {
+  const failure = (message, code = -1) => {
+    const result = {
+      ok: false,
+      code,
+      stdout: new Uint8Array(),
+      stderr: message,
+    };
+    if (!options.allowFailure) throw new Error(message);
+    return result;
+  };
+  if (options.signal?.aborted)
+    return failure(`${command[0]} aborted`);
+
+  const proc = Bun.spawn(command, {
+    stdio: [stdioInput(options.stdin), options.stdout ?? "pipe", options.stderr ?? "pipe"],
+    env: options.env ?? process.env,
+    cwd: options.cwd,
+  });
+  const timeoutMs = Number.isFinite(options.timeout)
+    ? Math.max(1, Math.trunc(options.timeout))
+    : null;
+  let interrupted = "";
+  const interrupt = message => {
+    if (interrupted) return;
+    interrupted = message;
+    try { proc.kill(); } catch {}
+  };
+  const abort = () => interrupt(`${command[0]} aborted`);
+  options.signal?.addEventListener("abort", abort, { once: true });
+  const timeout = timeoutMs == null
+    ? null
+    : setTimeout(
+      () => interrupt(`${command[0]} timed out after ${timeoutMs}ms`),
+      timeoutMs,
+    );
+  let stdoutBuf;
+  let stderr;
+  let code;
+  try {
+    [stdoutBuf, stderr, code] = await Promise.all([
+      proc.stdout ? new Response(proc.stdout).arrayBuffer() : Promise.resolve(new ArrayBuffer(0)),
+      proc.stderr ? new Response(proc.stderr).text() : Promise.resolve(""),
+      proc.exited,
+    ]);
+  } finally {
+    if (timeout != null) clearTimeout(timeout);
+    options.signal?.removeEventListener("abort", abort);
+  }
+  const stdout = new Uint8Array(stdoutBuf);
+  if (interrupted) {
+    const message = stderr.trim()
+      ? `${interrupted}: ${stderr.trim()}`
+      : interrupted;
+    if (!options.allowFailure) throw new Error(message);
+    return { ok: false, code, stdout, stderr: message };
+  }
+  if (code !== 0 && !options.allowFailure) {
+    throw new Error(`${command[0]} exited with ${code}: ${stderr || decoder.decode(stdout)}`);
+  }
+  return { ok: code === 0, code, stdout, stderr };
+}
+
+export function hasCommand(name) {
+  return Bun.which(name);
+}
+
+export function firstCommand(names) {
+  return names.find((name) => hasCommand(name)) ?? null;
+}
+
+export function shellQuote(value) {
+  return `'${String(value).replaceAll("'", "'\\''")}'`;
+}
+
+function stdioInput(input) {
+  if (input == null) return "ignore";
+  if (input === "pipe" || input === "inherit" || input === "ignore") return input;
+  if (typeof input === "string" || input instanceof Uint8Array || input instanceof ArrayBuffer) return new Blob([input]);
+  return input;
+}

package/initramfs/buninu/apps/jsmdcui/src/platform/terminal.js

@@ -0,0 +1,5 @@
+import process from "node:process";
+
+export function controllingTerminalInputPath(platform = process.platform) {
+  return platform === "win32" ? "CONIN$" : "/dev/tty";
+}