bunmicro 0.8.0

package/src/lua/engine.js

@@ -0,0 +1,38 @@
+export async function createLuaEngine() {
+  const wasmoon = await tryImport("wasmoon");
+  if (!wasmoon?.LuaFactory) {
+    throw new Error("Lua support requires the WASM runtime `wasmoon`. Install it with `bun add wasmoon`.");
+  }
+
+  const factory = new wasmoon.LuaFactory();
+  const lua = await factory.createEngine();
+  return new WasmoonEngine(lua);
+}
+
+async function tryImport(name) {
+  try {
+    return await import(name);
+  } catch (error) {
+    if (error?.code === "ERR_MODULE_NOT_FOUND" || /Cannot find package/.test(String(error?.message))) return null;
+    throw error;
+  }
+}
+
+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/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/src/platform/clipboard.js

@@ -0,0 +1,160 @@
+import { firstCommand, isLinuxLike, platformId, runSync } from "./commands.js";
+
+const CLIPBOARD_TIMEOUT_MS = 2000;
+const internalRegisters = new Map();
+
+export class ClipboardManager {
+  constructor() {
+    this.backend = detectClipboardBackend();
+  }
+
+  methodName() {
+    return this.backend.name;
+  }
+
+  fallbackToInternal() {
+    this.backend = internalClipboard();
+    return this.backend;
+  }
+
+  read(register = "clipboard") {
+    if (register !== "clipboard" && register !== "primary") {
+      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;
+    try {
+      const ok = this.backend.write?.(text, register) ?? true;
+      if (!ok) this.fallbackToInternal();
+      return true;
+    } catch {
+      this.fallbackToInternal();
+      return true;
+    }
+  }
+}
+
+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",
+    read: () => outputOrThrow(runSync([wlPaste, "--no-newline"], { timeout: CLIPBOARD_TIMEOUT_MS })),
+    write: (text) => runSync([wlCopy], { stdin: text, stdout: "ignore", timeout: CLIPBOARD_TIMEOUT_MS }).ok,
+  };
+}
+
+function xclipClipboard(xclip) {
+  return {
+    name: "xclip",
+    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",
+    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",
+    read: () => outputOrThrow(runSync([shell, "-NoProfile", "-Command", "Get-Clipboard -Raw"], { timeout: CLIPBOARD_TIMEOUT_MS })),
+    write: (text) => runSync([shell, "-NoProfile", "-Command", "Set-Clipboard"], { stdin: text, stdout: "ignore", timeout: CLIPBOARD_TIMEOUT_MS }).ok,
+  };
+}
+
+function outputOrThrow(result) {
+  if (!result.ok) throw new Error(result.stderr || result.stdout || "clipboard command failed");
+  return trimOneTrailingNewline(result.stdout);
+}
+
+function trimOneTrailingNewline(text) {
+  return text.replace(/\r?\n$/, "");
+}

package/src/platform/commands.js

@@ -0,0 +1,140 @@
+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) {
+  const b = detectHttpBackend();
+  if (b === "curl") {
+    const r = await runBytes(["curl", "-kL", "--silent", "--fail", url], { allowFailure: true });
+    if (!r.ok) throw new Error(`curl: ${r.stderr.trim() || "failed"} (${url})`);
+    return r.stdout;
+  }
+  if (b === "wget") {
+    const r = await runBytes(["wget", "--no-check-certificate", "-q", "-O", "-", url], { allowFailure: true });
+    if (!r.ok) throw new Error(`wget: ${r.stderr.trim() || "failed"} (${url})`);
+    return r.stdout;
+  }
+  const resp = await fetch(url);
+  if (!resp.ok) throw new Error(`HTTP ${resp.status}: ${url}`);
+  return new Uint8Array(await resp.arrayBuffer());
+}
+
+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 proc = Bun.spawn(command, {
+    stdio: [stdioInput(options.stdin), options.stdout ?? "pipe", options.stderr ?? "pipe"],
+    env: options.env ?? process.env,
+    cwd: options.cwd,
+  });
+  const [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,
+  ]);
+  const stdout = new Uint8Array(stdoutBuf);
+  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) {
+  if (platformId() === "win32") {
+    return runSync(["where.exe", name], { stdout: "ignore", stderr: "ignore" }).ok;
+  }
+  return runSync(["sh", "-c", `command -v ${shellQuote(name)}`], { stdout: "ignore", stderr: "ignore" }).ok;
+}
+
+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;
+}