buninu-linux 0.3.1 → 0.5.1

package/initramfs/lib/bunterm/terminal.js

@@ -0,0 +1,324 @@
+// /lib/bunterm/terminal.js — a graphical terminal on the Linux framebuffer.
+//
+//   Bun.spawn({ terminal })  ──── PTY output ────▶ KittyGraphicsParser
+//      ▲                                            │ plain     │ APC
+//      │ keyboard / replies                         ▼           ▼
+//   jsgotty BunPtyBackend        @xterm/headless Terminal   ImageStore
+//                                              │ buffer        │ placements
+//                                              ▼               ▼
+//                                   Renderer (CanvasKit) ──▶ /dev/fb0
+//
+// The PTY, the terminal emulation and the kitty packet parser are reused
+// from jsgotty and xterm.js; only the cell renderer, the images and the
+// keyboard are Buninu's own.
+
+import { createRequire } from "node:module";
+import { runGraphics } from "../fbdev.js";
+import { loadCanvasKit, openCanvas, loadFontSet } from "../canvas.js";
+import { Terminal } from "../xterm/xterm-headless.mjs";
+import { UnicodeGraphemesAddon } from "../xterm/addon-unicode-graphemes.mjs";
+import { Renderer, defaultTheme } from "./renderer.js";
+import { ImageStore } from "./images.js";
+import { openKeyboard, translateKeys } from "./input.js";
+
+const require = createRequire(import.meta.url);
+
+// jsgotty is CommonJS and guards its server start on require.main, so this
+// only loads the classes.
+export const loadJsgotty = () => {
+  const gotty = require("../../buninu/apps/jsgotty/gotty.js");
+  if (!gotty.BunPtyBackend) {
+    throw new Error("this jsgotty does not export BunPtyBackend; bunterm needs jsgotty ≥ 1.1.12");
+  }
+  return gotty;
+};
+
+const writeTerminal = (term, data) => new Promise((resolve) => term.write(data, resolve));
+
+// One terminal session: a program on a PTY, the emulator fed from it, and a
+// renderer painting onto `screen` (an open canvas from canvas.js). Frames
+// are coalesced, so whatever arrives between two paints is drawn together,
+// at most ~60 times a second. `exited` resolves with the program's status.
+export const createSession = ({
+  CanvasKit,
+  screen,
+  fonts,
+  command = "/bin/sh",
+  argv = [],
+  fontSize = 16,
+  lineHeight = 1,
+  theme = defaultTheme,
+  scrollback = 1000,
+  cursorBlink = true,
+  mouse = true,
+  env = {},
+  onError = (error) => console.error(`bunterm: ${error?.stack ?? error}`),
+}) => {
+  const { BunPtyBackend, KittyGraphicsParser } = loadJsgotty();
+  const renderer = new Renderer({ CanvasKit, screen, fonts, fontSize, lineHeight, theme });
+  const term = new Terminal({
+    cols: renderer.columns,
+    rows: renderer.rows,
+    allowProposedApi: true,
+    scrollback,
+  });
+  term.loadAddon(new UnicodeGraphemesAddon());
+  term.unicode.activeVersion = "15-graphemes";
+  const images = new ImageStore({ CanvasKit, term, renderer });
+  const kitty = new KittyGraphicsParser();
+
+  const backend = new BunPtyBackend({
+    command,
+    argv,
+    width: renderer.columns,
+    height: renderer.rows,
+    closeSignal: "SIGHUP",
+    closeTimeout: -1,
+    // JSMDCUI_KITTY_MODE=extended: jsmdcui sends Markdown images as kitty
+    // placements with the original JPEG/WebP/GIF bytes (jsgotty's U= MIME
+    // extension); Skia decodes those directly, so nothing is transcoded.
+    headerEnv: { COLORTERM: "truecolor", TERM_PROGRAM: "bunterm", JSMDCUI_KITTY_MODE: "extended", ...env },
+  });
+
+  let frameTimer = null;
+  let blinkOn = true;
+  const cursorHidden = () => Boolean(term._core?.coreService?.isCursorHidden);
+  // Only set when a pointer is attached; without one the renderer is called
+  // exactly as before.
+  let pointer = null;
+  const paint = () => {
+    if (frameTimer) clearTimeout(frameTimer);
+    frameTimer = null;
+    const buffer = term.buffer.active;
+    // cursorY counts from the buffer's base, so a scrolled-back viewport
+    // moves the cursor down the screen and eventually off it.
+    const row = buffer.baseY + buffer.cursorY - buffer.viewportY;
+    return renderer.render(term, {
+      cursor: {
+        x: buffer.cursorX,
+        y: row,
+        visible: blinkOn && !cursorHidden() && row >= 0 && row < renderer.rows,
+      },
+      images: images.visible(),
+      pointer,
+    });
+  };
+  const requestFrame = () => {
+    frameTimer ??= setTimeout(paint, 16);
+  };
+  const blinkTimer = cursorBlink
+    ? setInterval(() => { blinkOn = !blinkOn; requestFrame(); }, 500)
+    : null;
+  const resetBlink = () => {
+    blinkOn = true;
+    if (blinkTimer) blinkTimer.refresh();
+  };
+
+  // Output is processed in order: plain text is parsed before the kitty
+  // packet that follows it, so placements see the right cursor position.
+  let queue = Promise.resolve();
+  const pump = (chunk) => {
+    queue = queue.then(async () => {
+      const { events } = kitty.consume(chunk);
+      for (const event of events) {
+        if (event.kind === "plain") {
+          await writeTerminal(term, event.data);
+          continue;
+        }
+        const buffer = term.buffer.active;
+        const graphic = kitty.parsePacket(event.packet, { row: buffer.cursorY + 1, col: buffer.cursorX + 1 });
+        if (!graphic) continue;
+        const motion = await images.handle(graphic);
+        if (motion) await writeTerminal(term, motion);
+        const ack = kitty.acknowledge(graphic);
+        if (ack) backend.write(Buffer.from(ack, "utf8"));
+      }
+      requestFrame();
+    }).catch(onError);
+  };
+
+  let closed = false;
+  const exited = new Promise((resolve) => {
+    backend.onExit(() => { queue.then(() => resolve(backend.proc?.exitCode ?? 0)); });
+  });
+  backend.onData(pump);
+  term.onData((data) => backend.write(Buffer.from(data, "utf8")));
+
+  // Keyboard bytes from the console, rewritten for the program's key mode.
+  const input = (bytes) => {
+    const applicationCursorKeys = Boolean(term._core?.coreService?.decPrivateModes?.applicationCursorKeys);
+    const text = translateKeys(bytes.toString("latin1"), { applicationCursorKeys });
+    backend.write(Buffer.from(text, "latin1"));
+    // Typing returns to the live screen, as every terminal does.
+    if (term.buffer.active.viewportY !== term.buffer.active.baseY) {
+      term.scrollToBottom();
+      renderer.invalidate();
+    }
+    resetBlink();
+    requestFrame();
+  };
+
+  // Turns a pointer report from mouse.js into the mouse sequences the
+  // program asked for. xterm.js's CoreMouseService owns the protocol: it
+  // knows which events the program enabled (DECSET 1000/1002/1003), encodes
+  // them (SGR 1006 or the default form) and sends them through onData, so
+  // nothing here builds an escape sequence. Reports arrive only while a
+  // pointer is open, and this is the only place the terminal sees one.
+  const CoreMouseButton = { LEFT: 0, MIDDLE: 1, RIGHT: 2, NONE: 3, WHEEL: 4 };
+  const CoreMouseAction = { UP: 0, DOWN: 1, LEFT: 2, RIGHT: 3, MOVE: 32 };
+  const heldButton = (buttons) => (buttons.left ? CoreMouseButton.LEFT
+    : buttons.middle ? CoreMouseButton.MIDDLE
+    : buttons.right ? CoreMouseButton.RIGHT
+    : CoreMouseButton.NONE);
+
+  // Scrolls the viewport when the program is not reading the mouse itself:
+  // through the scrollback on the normal screen, and as arrow keys on the
+  // alternate screen, which has no scrollback and is what a pager expects.
+  const wheelScroll = (notches) => {
+    const lines = notches * 3;
+    if (term.buffer.active.type === "alternate") {
+      const application = Boolean(term._core?.coreService?.decPrivateModes?.applicationCursorKeys);
+      const key = `\u001b${application ? "O" : "["}${lines > 0 ? "A" : "B"}`;
+      backend.write(Buffer.from(key.repeat(Math.abs(lines)), "latin1"));
+      return;
+    }
+    const before = term.buffer.active.viewportY;
+    term.scrollLines(-lines);
+    if (term.buffer.active.viewportY !== before) {
+      // Every row on screen is different now, and identical text at the same
+      // row would otherwise hash the same as before.
+      renderer.invalidate();
+      requestFrame();
+    }
+  };
+
+  const reportMouse = (report) => {
+    pointer = { x: report.x, y: report.y };
+    requestFrame();
+    const service = term._core?.coreMouseService;
+    if (!service?.areMouseEventsActive) {
+      if (report.wheel) wheelScroll(report.wheel);
+      return;
+    }
+    const column = Math.floor((report.x - renderer.offsetX) / renderer.cellWidth);
+    const row = Math.floor((report.y - renderer.offsetY) / renderer.cellHeight);
+    const send = (button, action) => {
+      try {
+        service.triggerMouseEvent({ col: column, row, button, action, ctrl: false, alt: false, shift: false });
+      } catch (error) {
+        onError(error);
+      }
+    };
+    for (const name of report.released) {
+      send(CoreMouseButton[name.toUpperCase()], CoreMouseAction.UP);
+    }
+    for (const name of report.pressed) {
+      send(CoreMouseButton[name.toUpperCase()], CoreMouseAction.DOWN);
+    }
+    if (report.moved) send(heldButton(report.buttons), CoreMouseAction.MOVE);
+    for (let notch = 0; notch < Math.abs(report.wheel); notch++) {
+      send(CoreMouseButton.WHEEL, report.wheel > 0 ? CoreMouseAction.UP : CoreMouseAction.DOWN);
+    }
+    for (let notch = 0; notch < Math.abs(report.hwheel); notch++) {
+      send(CoreMouseButton.WHEEL, report.hwheel > 0 ? CoreMouseAction.RIGHT : CoreMouseAction.LEFT);
+    }
+  };
+
+  // The pointer is opened only when asked for, by a module that is imported
+  // only then, so a machine without one — or a broken input layer — cannot
+  // affect a plain session.
+  let pointerDevice = null;
+  const attachPointer = async () => {
+    if (!mouse) return null;
+    const { openPointer, findPointers } = await import("./mouse.js");
+    const devices = findPointers();
+    if (!devices.length) throw new Error("no pointing device in /dev/input (is the evdev module loaded?)");
+    pointerDevice = openPointer({
+      devices,
+      width: screen.width,
+      height: screen.height,
+      onSync: reportMouse,
+      onError,
+    });
+    pointer = { x: pointerDevice.state.x, y: pointerDevice.state.y };
+    paint();
+    return pointerDevice;
+  };
+
+  // Waits until every byte received so far has been parsed, then paints.
+  const settle = async () => {
+    await queue;
+    return paint();
+  };
+
+  const close = () => {
+    if (closed) return;
+    closed = true;
+    if (blinkTimer) clearInterval(blinkTimer);
+    if (frameTimer) clearTimeout(frameTimer);
+    frameTimer = null;
+    backend.close();
+    pointerDevice?.close();
+    pointerDevice = null;
+    images.delete();
+    renderer.delete();
+    term.dispose();
+  };
+
+  paint();
+  return {
+    term, backend, renderer, images, kitty,
+    paint, requestFrame, settle, input, exited, close, attachPointer, reportMouse, wheelScroll,
+  };
+};
+
+// Runs a session on the framebuffer with the console in graphics mode and
+// the keyboard in raw mode, until the program exits. `console` names the
+// virtual console to use (for example /dev/tty1); by default the process's
+// own console and stdin are used.
+export const runTerminal = async ({ console: consoleDevice = null, device = "/dev/fb0", ...options } = {}) => {
+  loadJsgotty();
+  const CanvasKit = await loadCanvasKit();
+  const fonts = loadFontSet(CanvasKit, "terminal");
+  const consolePaths = consoleDevice ? [consoleDevice] : undefined;
+
+  return runGraphics(async (display, { onRestore, onAcquire }) => {
+    const screen = openCanvas(CanvasKit, display);
+    const session = createSession({ CanvasKit, screen, fonts, ...options });
+    // Coming back from another console (Ctrl-Alt-Fn): fbcon has drawn over
+    // the framebuffer, so repaint everything.
+    onAcquire(() => {
+      session.renderer.invalidate();
+      session.paint();
+    });
+    let keyboard = null;
+    try {
+      keyboard = openKeyboard({
+        device: consoleDevice,
+        onData: session.input,
+        onError: (error) => {
+          console.error(`bunterm: keyboard: ${error.message}`);
+          session.backend.close();
+        },
+      });
+      onRestore(() => keyboard.close());
+      if (options.mouse !== false) {
+        // A pointer that cannot be opened is reported and the session
+        // continues as a keyboard-only terminal.
+        try {
+          const attached = await session.attachPointer();
+          if (attached?.devices.length) {
+            console.error(`bunterm: mouse: ${attached.devices.map((device) => device.name).join(", ")}`);
+          }
+        } catch (error) {
+          console.error(`bunterm: mouse: ${error.message}`);
+        }
+      }
+      return await session.exited;
+    } finally {
+      keyboard?.close();
+      session.close();
+      screen.close();
+    }
+  }, { device, console: consolePaths });
+};

package/initramfs/lib/canvas.js

@@ -0,0 +1,181 @@
+// /lib/canvas.js — CanvasKit (Skia in WebAssembly) on the Linux framebuffer.
+//
+// Skia draws into a buffer inside the wasm heap that already has the
+// framebuffer's own pixel layout, so a frame reaches /dev/fb0 with a single
+// copy: exactly what /lib/fbdev.js does with its JavaScript back buffer. The
+// Framebuffer's `pixels` view is pointed at that heap buffer while a canvas is
+// open, so the fbdev.js drawing calls and flush() keep working on the same
+// frame and Skia and JavaScript drawing can be mixed freely.
+
+import { readFileSync } from "node:fs";
+import CanvasKitInit from "./canvaskit/canvaskit.js";
+import { flush as flushFramebuffer } from "./fbdev.js";
+
+export const canvasKitDirectory = `${import.meta.dir}/canvaskit`;
+export const fontDirectory = `${import.meta.dir}/../usr/share/fonts`;
+
+let canvasKitPromise = null;
+
+// One CanvasKit instance per process; the wasm heap starts at 128 MiB.
+export const loadCanvasKit = () => {
+  canvasKitPromise ??= CanvasKitInit({
+    wasmBinary: readFileSync(`${canvasKitDirectory}/canvaskit.wasm`),
+  });
+  return canvasKitPromise;
+};
+
+const fieldIs = (field, offset, length) =>
+  field.offset === offset && field.length === length;
+
+// Maps the kernel's bitfield description to a Skia ColorType with the same
+// byte order in memory. The fields are little-endian bit offsets, so 32-bit
+// red@16 green@8 blue@0 is B,G,R,X in memory: Skia's BGRA_8888. Only formats
+// Skia can rasterize into directly are accepted; others must go through
+// blitImageData() in fbdev.js.
+export const pickColorType = (CanvasKit, display) => {
+  const { red, green, blue } = display.fields;
+  if (display.bitsPerPixel === 32) {
+    if (fieldIs(red, 16, 8) && fieldIs(green, 8, 8) && fieldIs(blue, 0, 8)) {
+      return CanvasKit.ColorType.BGRA_8888;
+    }
+    if (fieldIs(red, 0, 8) && fieldIs(green, 8, 8) && fieldIs(blue, 16, 8)) {
+      return CanvasKit.ColorType.RGBA_8888;
+    }
+  }
+  if (display.bitsPerPixel === 16
+      && fieldIs(red, 11, 5) && fieldIs(green, 5, 6) && fieldIs(blue, 0, 5)) {
+    return CanvasKit.ColorType.RGB_565;
+  }
+  return null;
+};
+
+const describeFields = ({ red, green, blue }) =>
+  `red@${red.offset}/${red.length} green@${green.offset}/${green.length} blue@${blue.offset}/${blue.length}`;
+
+// Binds a Skia raster surface to an open Framebuffer. `display` only needs
+// the fields fbdev.js's Framebuffer exposes (width, height, stride,
+// bitsPerPixel, fields, pixels), so a plain object backed by memory works for
+// tests and off-screen rendering.
+export const openCanvas = (CanvasKit, display) => {
+  const colorType = pickColorType(CanvasKit, display);
+  if (colorType === null) {
+    throw new Error(`no Skia color type for a ${display.bitsPerPixel} bpp framebuffer `
+      + `(${describeFields(display.fields)}); use blitImageData() instead`);
+  }
+  const length = display.stride * display.height;
+  const memory = CanvasKit.Malloc(Uint8Array, length);
+  const surface = CanvasKit.MakeRasterDirectSurface({
+    width: display.width,
+    height: display.height,
+    colorType,
+    alphaType: CanvasKit.AlphaType.Opaque,
+    colorSpace: CanvasKit.ColorSpace.SRGB,
+  }, memory, display.stride);
+  if (!surface) {
+    CanvasKit.Free(memory);
+    throw new Error("MakeRasterDirectSurface failed");
+  }
+  const previousPixels = display.pixels;
+  // Start from whatever the JavaScript back buffer held (usually zeros).
+  memory.toTypedArray().set(previousPixels.subarray(0, length));
+  display.pixels = memory.toTypedArray();
+  let open = true;
+  return {
+    CanvasKit,
+    display,
+    surface,
+    canvas: surface.getCanvas(),
+    colorType,
+    width: display.width,
+    height: display.height,
+    // Finishes pending Skia work and copies the frame to the framebuffer.
+    // toTypedArray() is re-read because wasm heap growth detaches old views.
+    flush() {
+      if (!open) throw new Error("canvas is closed");
+      surface.flush();
+      display.pixels = memory.toTypedArray();
+      flushFramebuffer(display);
+    },
+    // Releases the Skia surface and heap buffer; the Framebuffer stays open
+    // and gets its own back buffer back, holding the last frame.
+    close() {
+      if (!open) return;
+      open = false;
+      previousPixels.set(memory.toTypedArray().subarray(0, previousPixels.length));
+      display.pixels = previousPixels;
+      surface.delete();
+      CanvasKit.Free(memory);
+    },
+  };
+};
+
+// Font catalogue: /usr/share/fonts/fonts.json names every bundled file and
+// the family sets built from them. Files load lazily, since the CJK
+// collection alone is 32 MiB and is copied into the wasm heap.
+let catalogue = null;
+
+export const fontCatalogue = () => {
+  catalogue ??= JSON.parse(readFileSync(`${fontDirectory}/fonts.json`, "utf8"));
+  return catalogue;
+};
+
+export const fontPath = (name) => {
+  const entry = fontCatalogue().fonts[name];
+  if (!entry) throw new Error(`unknown font ${JSON.stringify(name)}`);
+  return `${fontDirectory}/${entry.file}`;
+};
+
+const fontData = new Map();
+
+export const loadFontData = (name) => {
+  let data = fontData.get(name);
+  if (!data) {
+    const bytes = readFileSync(fontPath(name));
+    data = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+    fontData.set(name, data);
+  }
+  return data;
+};
+
+// A named font set from fonts.json as CanvasKit objects:
+//   typefaces  the "regular", "bold" and each fallback font as a Typeface
+//              (a collection such as Noto Sans CJK yields its preferred face)
+//   fontMgr    every file of the set registered by family name, for the
+//              Paragraph API; a collection registers all of its families
+//   families   family names for ParagraphStyle.textStyle.fontFamilies, in
+//              lookup order
+export const loadFontSet = (CanvasKit, setName = "terminal") => {
+  const { sets, fonts } = fontCatalogue();
+  const set = sets[setName];
+  if (!set) throw new Error(`unknown font set ${JSON.stringify(setName)}`);
+  const names = [set.regular, set.bold, ...(set.fallback ?? [])].filter(Boolean);
+  const buffers = names.map(loadFontData);
+  const fontMgr = CanvasKit.FontMgr.FromData(...buffers);
+  if (!fontMgr) throw new Error("FontMgr.FromData failed");
+  const typefaces = {};
+  names.forEach((name, index) => {
+    // A collection's "preferred" family picks the face (Noto Sans CJK TC for
+    // Taiwanese glyph forms); a single-face file loads directly.
+    const preferred = fonts[name].preferred;
+    const typeface = preferred
+      ? fontMgr.matchFamilyStyle(preferred, {})
+      : CanvasKit.Typeface.MakeFreeTypeFaceFromData(buffers[index]);
+    if (!typeface) throw new Error(`cannot load font ${name} (${fonts[name].file})`);
+    typefaces[name] = typeface;
+  });
+  const families = names.flatMap((name) => fonts[name].families ?? [name]);
+  return {
+    set,
+    names,
+    typefaces,
+    regular: typefaces[set.regular],
+    bold: set.bold ? typefaces[set.bold] : null,
+    fallback: (set.fallback ?? []).map((name) => typefaces[name]),
+    fontMgr,
+    families,
+    delete() {
+      for (const typeface of Object.values(typefaces)) typeface.delete();
+      fontMgr.delete();
+    },
+  };
+};

package/initramfs/lib/canvaskit/LICENSE

@@ -0,0 +1,29 @@
+// Copyright (c) 2011 Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+--------------------------------------------------------------------------------