buninu-linux 0.3.0 → 0.4.0

package/initramfs/lib/bunterm/images.js

@@ -0,0 +1,225 @@
+// /lib/bunterm/images.js — kitty graphics protocol placements on the cell
+// grid.
+//
+// jsgotty's KittyGraphicsParser has already split the APC packets out of the
+// PTY stream and assembled chunked transfers; this module turns its
+// "placement" / "delete" events into Skia images anchored to terminal lines.
+// A placement is tied to an xterm.js marker, so it scrolls with the text and
+// disappears when its line leaves the scrollback.
+
+const number = (value, fallback = 0) => {
+  const parsed = Number.parseInt(value ?? "", 10);
+  return Number.isFinite(parsed) ? parsed : fallback;
+};
+
+// Decodes a transferred image into a Skia Image. Format 100 is PNG (or any
+// encoded format Skia knows); 24 and 32 are raw RGB / RGBA. Bun.Image, when
+// present, transcodes encodings Skia cannot read on its own.
+export const decodeImage = async (CanvasKit, image) => {
+  const bytes = Buffer.from(image.data, "base64");
+  if (image.format === 24 || image.format === 32) {
+    const { width, height } = image;
+    if (!width || !height) throw new Error("raw image without dimensions");
+    let pixels = bytes;
+    if (image.format === 24) {
+      pixels = Buffer.alloc(width * height * 4, 255);
+      for (let i = 0, o = 0; i < bytes.length; i += 3, o += 4) {
+        pixels[o] = bytes[i];
+        pixels[o + 1] = bytes[i + 1];
+        pixels[o + 2] = bytes[i + 2];
+      }
+    }
+    const decoded = CanvasKit.MakeImage({
+      width, height,
+      colorType: CanvasKit.ColorType.RGBA_8888,
+      alphaType: CanvasKit.AlphaType.Unpremul,
+      colorSpace: CanvasKit.ColorSpace.SRGB,
+    }, pixels, width * 4);
+    if (!decoded) throw new Error("raw image rejected");
+    return decoded;
+  }
+  let decoded = CanvasKit.MakeImageFromEncoded(bytes);
+  if (!decoded && typeof Bun !== "undefined" && Bun.Image) {
+    const png = await new Bun.Image(bytes).png().toBuffer();
+    decoded = CanvasKit.MakeImageFromEncoded(png);
+  }
+  if (!decoded) throw new Error("undecodable image data");
+  return decoded;
+};
+
+export class ImageStore {
+  constructor({ CanvasKit, term, renderer }) {
+    this.CanvasKit = CanvasKit;
+    this.term = term;
+    this.renderer = renderer;
+    this.images = new Map();      // image id → Skia Image
+    this.placements = new Map();  // placement key → placement
+    this.counter = 0;
+    this.coveredKey = "";
+    this.coveredRows = new Set();
+  }
+
+  // Handles one parsed graphic. Returns the control sequence that moves the
+  // cursor past a placement (to be written to the terminal), or "".
+  async handle(graphic) {
+    if (!graphic) return "";
+    if (graphic.kind === "delete") {
+      this.remove(graphic.delete);
+      return "";
+    }
+    if (graphic.kind !== "placement") return "";
+    const { control, image } = graphic;
+    let decoded = this.images.get(image.id);
+    if (!decoded) {
+      try {
+        decoded = await decodeImage(this.CanvasKit, image);
+      } catch (error) {
+        graphic.responseMessage = `EBADPNG:${error.message}`;
+        return "";
+      }
+      this.images.set(image.id, decoded);
+    }
+    const { cellWidth, cellHeight } = this.renderer;
+    const buffer = this.term.buffer.active;
+    const sourceX = number(control.x);
+    const sourceY = number(control.y);
+    const sourceWidth = number(control.w) || decoded.width() - sourceX;
+    const sourceHeight = number(control.h) || decoded.height() - sourceY;
+    const columns = number(control.c) || Math.max(1, Math.ceil(sourceWidth / cellWidth));
+    const rows = number(control.r) || Math.max(1, Math.ceil(sourceHeight / cellHeight));
+    // xterm.js only issues markers in the normal buffer. On the alternate
+    // screen (full-screen programs) there is no scrollback, so the placement
+    // is anchored to a fixed row instead and dropped when that screen ends.
+    const marker = buffer.type === "normal" ? this.term.registerMarker(0) : null;
+    const placementId = control.p ?? null;
+    const key = `${image.id}:${placementId ?? `auto${++this.counter}`}`;
+    const existing = this.placements.get(key);
+    if (existing) this.dispose(existing);
+    const placement = {
+      key,
+      imageId: image.id,
+      placementId,
+      marker,
+      bufferType: buffer.type,
+      fixedLine: buffer.baseY + buffer.cursorY,
+      get line() { return this.marker ? this.marker.line : this.fixedLine; },
+      get isDisposed() {
+        return this.marker ? this.marker.isDisposed : this.bufferType !== this.term.buffer.active.type;
+      },
+      term: this.term,
+      column: buffer.cursorX,
+      columns,
+      rows,
+      offsetX: number(control.X),
+      offsetY: number(control.Y),
+      source: [sourceX, sourceY, sourceX + sourceWidth, sourceY + sourceHeight],
+      zIndex: number(control.z),
+    };
+    this.placements.set(key, placement);
+    this.invalidate(placement);
+    if (control.C === "1") return "";
+    // Move the cursor below the image, the way jsgotty does for its browser
+    // terminal: one line feed per image row (so the screen scrolls when the
+    // image runs past the bottom, and the placement's marker scrolls with
+    // it), then to the column after the image.
+    return `${"\r\n".repeat(rows)}\u001b[${buffer.cursorX + columns + 1}G`;
+  }
+
+  invalidate(placement) {
+    const top = placement.line - this.term.buffer.active.viewportY;
+    this.renderer.invalidateRows(top, top + placement.rows);
+  }
+
+  dispose(placement) {
+    this.invalidate(placement);
+    placement.marker?.dispose();
+    this.placements.delete(placement.key);
+  }
+
+  remove({ scope, imageId, placementId, cursor }) {
+    const wipe = scope === scope.toUpperCase();
+    const targets = [];
+    for (const placement of this.placements.values()) {
+      switch (scope.toLowerCase()) {
+        case "a":
+          targets.push(placement);
+          break;
+        case "i":
+          if (placement.imageId === imageId && (!placementId || placement.placementId === placementId)) {
+            targets.push(placement);
+          }
+          break;
+        case "c": {
+          const row = placement.line - this.term.buffer.active.baseY + 1;
+          const column = placement.column + 1;
+          if (cursor && cursor.row >= row && cursor.row < row + placement.rows
+              && cursor.col >= column && cursor.col < column + placement.columns) {
+            targets.push(placement);
+          }
+          break;
+        }
+        default:
+          break;
+      }
+    }
+    for (const placement of targets) this.dispose(placement);
+    if (wipe) {
+      const used = new Set([...this.placements.values()].map((placement) => placement.imageId));
+      for (const [id, image] of this.images) {
+        if (!used.has(id)) {
+          image.delete();
+          this.images.delete(id);
+        }
+      }
+    }
+  }
+
+  // Placements currently on screen, as { image, source, rect } in pixels.
+  visible() {
+    const { renderer } = this;
+    const { cellWidth, cellHeight, offsetX, offsetY } = renderer;
+    const viewportY = this.term.buffer.active.viewportY;
+    const result = [];
+    for (const placement of [...this.placements.values()]) {
+      if (placement.isDisposed) {
+        this.placements.delete(placement.key);
+        continue;
+      }
+      const top = placement.line - viewportY;
+      if (top + placement.rows <= 0 || top >= renderer.rows) continue;
+      const image = this.images.get(placement.imageId);
+      if (!image) continue;
+      const left = offsetX + placement.column * cellWidth + placement.offsetX;
+      const y = offsetY + top * cellHeight + placement.offsetY;
+      result.push({
+        image,
+        source: placement.source,
+        rect: [left, y, left + placement.columns * cellWidth, y + placement.rows * cellHeight],
+        zIndex: placement.zIndex,
+      });
+    }
+    // The renderer's row hashes only see text, so when placements move or
+    // vanish every row they covered before or cover now is repainted.
+    const covered = new Set();
+    for (const { rect } of result) {
+      const first = Math.floor((rect[1] - offsetY) / cellHeight);
+      const last = Math.ceil((rect[3] - offsetY) / cellHeight);
+      for (let row = first; row < last; row++) covered.add(row);
+    }
+    const key = [...covered].sort((a, b) => a - b).join(",");
+    if (key !== this.coveredKey) {
+      for (const row of this.coveredRows ?? []) renderer.invalidateRows(row, row + 1);
+      for (const row of covered) renderer.invalidateRows(row, row + 1);
+      this.coveredKey = key;
+      this.coveredRows = covered;
+    }
+    return result.sort((a, b) => a.zIndex - b.zIndex);
+  }
+
+  delete() {
+    for (const placement of [...this.placements.values()]) placement.marker?.dispose();
+    this.placements.clear();
+    for (const image of this.images.values()) image.delete();
+    this.images.clear();
+  }
+}

package/initramfs/lib/bunterm/input.js

@@ -0,0 +1,140 @@
+// /lib/bunterm/input.js — keyboard bytes from a Linux virtual console.
+//
+// The console is read in raw mode so every key reaches the terminal
+// emulator unchanged (Ctrl-C included; the program in the PTY decides what
+// it means). The kernel keeps translating keys to bytes (K_XLATE), and its
+// "linux" console sequences for a few keys are rewritten into the xterm
+// forms that programs seeing TERM=xterm-256color expect.
+
+import { closeSync, openSync, read } from "node:fs";
+import { libc, ptr, errno, strerror } from "../dlopen.js";
+
+const TCGETS = 0x5401;
+const TCSETS = 0x5402;
+// struct termios (kernel ABI): 4 x u32 flags, c_line, c_cc[19].
+const TERMIOS_LENGTH = 36;
+const IFLAG = 0;
+const OFLAG = 4;
+const CFLAG = 8;
+const LFLAG = 12;
+const CC = 17;
+const VTIME = 5;
+const VMIN = 6;
+
+const IGNBRK = 0o1, BRKINT = 0o2, PARMRK = 0o10, ISTRIP = 0o40, INLCR = 0o100,
+  IGNCR = 0o200, ICRNL = 0o400, IXON = 0o2000;
+const OPOST = 0o1;
+const CSIZE = 0o60, CS8 = 0o60, PARENB = 0o400;
+const ISIG = 0o1, ICANON = 0o2, ECHO = 0o10, ECHONL = 0o100, IEXTEN = 0o100000;
+
+const fail = (operation) => {
+  const code = errno();
+  throw new Error(`${operation}: ${strerror(code)}`);
+};
+
+const getTermios = (fd) => {
+  const buffer = new Uint8Array(TERMIOS_LENGTH);
+  if (libc.symbols.ioctl(fd, TCGETS, ptr(buffer)) === -1) fail("TCGETS");
+  return buffer;
+};
+
+const setTermios = (fd, buffer) => {
+  if (libc.symbols.ioctl(fd, TCSETS, ptr(buffer)) === -1) fail("TCSETS");
+};
+
+// cfmakeraw() on a copy of the current settings.
+const rawTermios = (current) => {
+  const raw = new Uint8Array(current);
+  const view = new DataView(raw.buffer);
+  const clear = (offset, mask) => view.setUint32(offset, view.getUint32(offset, true) & ~mask, true);
+  clear(IFLAG, IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IXON);
+  clear(OFLAG, OPOST);
+  clear(LFLAG, ECHO | ECHONL | ICANON | ISIG | IEXTEN);
+  clear(CFLAG, CSIZE | PARENB);
+  view.setUint32(CFLAG, view.getUint32(CFLAG, true) | CS8, true);
+  raw[CC + VMIN] = 1;
+  raw[CC + VTIME] = 0;
+  return raw;
+};
+
+// Linux console sequences → xterm sequences (keys programs commonly bind).
+const consoleToXterm = new Map([
+  ["\u001b[[A", "\u001bOP"], ["\u001b[[B", "\u001bOQ"], ["\u001b[[C", "\u001bOR"],
+  ["\u001b[[D", "\u001bOS"], ["\u001b[[E", "\u001b[15~"],
+  ["\u001b[1~", "\u001b[H"], ["\u001b[4~", "\u001b[F"],
+]);
+
+const cursorKeys = new Map([
+  ["\u001b[A", "\u001bOA"], ["\u001b[B", "\u001bOB"], ["\u001b[C", "\u001bOC"], ["\u001b[D", "\u001bOD"],
+  ["\u001b[H", "\u001bOH"], ["\u001b[F", "\u001bOF"],
+]);
+
+// Rewrites console key sequences in `text`. With `applicationCursorKeys`
+// (DECCKM set by the program) the arrow keys use the SS3 forms.
+export const translateKeys = (text, { applicationCursorKeys = false } = {}) => {
+  let output = "";
+  let index = 0;
+  while (index < text.length) {
+    if (text[index] !== "\u001b") {
+      output += text[index++];
+      continue;
+    }
+    let matched = false;
+    for (const [from, to] of consoleToXterm) {
+      if (text.startsWith(from, index)) {
+        output += applicationCursorKeys ? (cursorKeys.get(to) ?? to) : to;
+        index += from.length;
+        matched = true;
+        break;
+      }
+    }
+    if (matched) continue;
+    if (applicationCursorKeys) {
+      for (const [from, to] of cursorKeys) {
+        if (text.startsWith(from, index)) {
+          output += to;
+          index += from.length;
+          matched = true;
+          break;
+        }
+      }
+      if (matched) continue;
+    }
+    output += text[index++];
+  }
+  return output;
+};
+
+// Opens the keyboard: `device` names a console such as /dev/tty1; without
+// it the process's own stdin is used (it must be a terminal). `onData`
+// receives Buffers. close() restores the previous terminal settings.
+export const openKeyboard = ({ device = null, onData, onError = () => {} }) => {
+  const fd = device ? openSync(device, "r+") : 0;
+  const saved = getTermios(fd);
+  setTermios(fd, rawTermios(saved));
+  let open = true;
+  const chunk = Buffer.alloc(4096);
+  const pump = () => {
+    if (!open) return;
+    read(fd, chunk, 0, chunk.length, null, (error, count) => {
+      if (!open) return;
+      if (error) {
+        if (error.code === "EAGAIN") { setTimeout(pump, 10); return; }
+        onError(error);
+        return;
+      }
+      if (count > 0) onData(Buffer.from(chunk.subarray(0, count)));
+      pump();
+    });
+  };
+  pump();
+  return {
+    fd,
+    close() {
+      if (!open) return;
+      open = false;
+      try { setTermios(fd, saved); } catch {}
+      if (device) closeSync(fd);
+    },
+  };
+};