buninu-linux 0.2.1 → 0.3.1

package/initramfs/bin/reboot

@@ -0,0 +1,10 @@
+#!/bin/bun
+// reboot — thin wrapper over the shared sync-and-reboot implementation.
+
+import { LINUX_REBOOT_CMD_RESTART, runPowerCommand } from "../lib/power.js";
+
+await runPowerCommand({
+  name: "reboot",
+  command: { name: "LINUX_REBOOT_CMD_RESTART", value: LINUX_REBOOT_CMD_RESTART },
+  action: "restarting",
+});

package/initramfs/bin/tar

@@ -0,0 +1,169 @@
+#!/bin/bun
+// tar — a small tar/gzip/zstd CLI over Bun.Archive.
+
+import { lstat, readdir } from "node:fs/promises";
+import { basename, join, resolve } from "node:path";
+import { showDocument } from "../lib/document.js";
+
+const fail = (message) => {
+  console.error(`tar: ${message}`);
+  process.exit(2);
+};
+
+const usage = () => {
+  console.error(`Usage:
+  tar -cf ARCHIVE FILE...
+  tar -xf ARCHIVE [-C DIR] [MEMBER...]
+  tar -tf ARCHIVE [MEMBER...]
+  tar -h | --help
+
+Try 'tar --help' for the full manual.`);
+  process.exit(2);
+};
+
+const options = { operation: null, archive: null, directory: ".", compression: null, verbose: false, operands: [] };
+const argv = process.argv.slice(2);
+if (argv.length === 0) usage();
+const take = (index, option) => {
+  if (index + 1 >= argv.length) fail(`${option} requires an argument`);
+  return argv[index + 1];
+};
+
+for (let index = 0; index < argv.length; index++) {
+  const argument = argv[index];
+  const oldStyleOptions = index === 0 && /^[cxtrvfz]+$/.test(argument)
+    && /[cxtr]/.test(argument);
+  if (argument === "--") { options.operands.push(...argv.slice(index + 1)); break; }
+  if (argument === "-h" || argument === "--help") {
+    await showDocument("tar");
+    process.exit(0);
+  }
+  if (argument === "--zstd") { options.compression = "zstd"; continue; }
+  if (argument === "--gzip") { options.compression = "gzip"; continue; }
+  if (argument === "-C" || argument === "--directory") {
+    options.directory = take(index++, argument);
+    continue;
+  }
+  if (argument.startsWith("--directory=")) {
+    options.directory = argument.slice(12);
+    continue;
+  }
+  if (argument === "-f" || argument === "--file") {
+    options.archive = take(index++, argument);
+    continue;
+  }
+  if (argument.startsWith("--file=")) {
+    options.archive = argument.slice(7);
+    continue;
+  }
+  if ((argument.startsWith("-") && argument !== "-") || oldStyleOptions) {
+    const flags = oldStyleOptions ? argument : argument.slice(1);
+    for (let offset = 0; offset < flags.length; offset++) {
+      const flag = flags[offset];
+      if ("cxt".includes(flag)) {
+        if (options.operation && options.operation !== flag) fail("only one of -c, -x, or -t may be used");
+        options.operation = flag;
+      } else if (flag === "r") {
+        fail("-r append is not supported by Bun.Archive");
+      } else if (flag === "v") options.verbose = true;
+      else if (flag === "z") options.compression = "gzip";
+      else if (flag === "f") {
+        const attached = flags.slice(offset + 1);
+        options.archive = attached || take(index++, "-f");
+        break;
+      } else fail(`unknown option -- ${flag}`);
+    }
+    continue;
+  }
+  options.operands.push(argument);
+}
+
+if (!options.operation) fail("one of -c, -x, or -t is required");
+if (!options.archive) fail("an archive must be specified with -f");
+
+const archiveBytes = async () => {
+  const bytes = options.archive === "-"
+    ? await Bun.stdin.bytes()
+    : await Bun.file(options.archive).bytes();
+  const zstd = options.compression === "zstd" || /\.(?:zst|tzst)$/i.test(options.archive);
+  return zstd ? Bun.zstdDecompressSync(bytes) : bytes;
+};
+
+const patterns = () => options.operands.flatMap((name) => {
+  const clean = name.replace(/^\.\//, "").replace(/\/$/, "");
+  return [clean, `${clean}/**`];
+});
+
+const verboseListing = (name, file) => {
+  const modified = Number.isFinite(file.lastModified) && file.lastModified > 0
+    ? new Date(file.lastModified).toISOString().replace("T", " ").slice(0, 16)
+    : "---- -- -- --:--";
+  return `${String(file.size).padStart(12)} ${modified} ${name}`;
+};
+
+if (options.operation === "x" || options.operation === "t") {
+  let archive;
+  try {
+    archive = new Bun.Archive(await archiveBytes());
+  } catch (error) {
+    fail(error?.message || String(error));
+  }
+
+  if (options.operation === "t") {
+    try {
+      const files = await archive.files(options.operands.length ? patterns() : undefined);
+      for (const [name, file] of files) {
+        console.log(options.verbose ? verboseListing(name, file) : name);
+      }
+    } catch (error) {
+      fail(error?.message || String(error));
+    }
+  } else {
+    try {
+      if (options.verbose) {
+        const files = await archive.files(options.operands.length ? patterns() : undefined);
+        for (const name of files.keys()) console.log(name);
+      }
+      await archive.extract(options.directory, options.operands.length ? { glob: patterns() } : undefined);
+    } catch (error) {
+      fail(error?.message || String(error));
+    }
+  }
+  process.exit(0);
+}
+
+if (options.operands.length === 0) fail("refusing to create an empty archive");
+const root = resolve(options.directory);
+const inputs = {};
+
+const add = async (diskPath, archivePath) => {
+  const info = await lstat(diskPath);
+  if (info.isSymbolicLink()) fail(`${archivePath}: creating symbolic links is not supported by Bun.Archive`);
+  if (info.isDirectory()) {
+    for (const entry of await readdir(diskPath)) await add(join(diskPath, entry), `${archivePath}/${entry}`);
+    return;
+  }
+  if (!info.isFile()) fail(`${archivePath}: unsupported file type`);
+  const name = archivePath.replaceAll("\\", "/").replace(/^\.\//, "").replace(/^\/+/, "");
+  if (!name || name === ".." || name.startsWith("../") || name.includes("/../")) fail(`${archivePath}: unsafe archive path`);
+  // Bun 1.4.3 accepts Blob in ArchiveInput, but a lazy BunFile is currently
+  // archived as zero bytes. Materialise it until Bun.Archive handles BunFile
+  // contents directly.
+  inputs[name] = await Bun.file(diskPath).bytes();
+  if (options.verbose) console.error(name);
+};
+
+try {
+  for (const operand of options.operands) {
+    const diskPath = resolve(root, operand);
+    const name = operand.startsWith("/") ? basename(operand) : operand.replace(/\/$/, "");
+    await add(diskPath, name);
+  }
+  const archive = new Bun.Archive(inputs, options.compression === "gzip" ? { compress: "gzip" } : undefined);
+  const output = options.compression === "zstd"
+    ? Bun.zstdCompressSync(await archive.bytes())
+    : archive;
+  await Bun.write(options.archive === "-" ? Bun.stdout : options.archive, output);
+} catch (error) {
+  fail(error?.message || String(error));
+}

package/initramfs/bin/top

@@ -0,0 +1,129 @@
+#!/bin/bun
+// top — periodically render snapshots and process lines supplied by ps.
+
+import { showDocument } from "../lib/document.js";
+import {
+  CLOCK_TICKS,
+  formatProcessHeader,
+  formatProcessLine,
+  prepareProcessFormat,
+  readProcessSnapshot,
+} from "./ps";
+
+const sleep = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
+const fields = ["pid", "user", "pri", "ni", "vsz", "rss", "state", "%cpu", "%mem", "time", "comm"];
+
+const uptimeText = (seconds) => {
+  const days = Math.floor(seconds / 86400);
+  const hours = Math.floor(seconds % 86400 / 3600);
+  const minutes = Math.floor(seconds % 3600 / 60);
+  return `${days ? `${days} day${days === 1 ? "" : "s"}, ` : ""}${hours}:${String(minutes).padStart(2, "0")}`;
+};
+
+const memoryText = (memory) => {
+  const total = memory.MemTotal ?? 0;
+  const free = memory.MemFree ?? 0;
+  const cache = (memory.Buffers ?? 0) + (memory.Cached ?? 0) + (memory.SReclaimable ?? 0);
+  return `MiB Mem : ${(total / 1024).toFixed(1)} total, ${(free / 1024).toFixed(1)} free, ${((total - free - cache) / 1024).toFixed(1)} used, ${(cache / 1024).toFixed(1)} buff/cache`;
+};
+
+const intervalRows = (snapshot, previous) => {
+  if (!previous) return snapshot.processes;
+  const elapsed = Math.max(0.001, (snapshot.at - previous.at) / 1000);
+  const oldTicks = new Map(previous.processes.map((row) => [row.pid, row.ticks]));
+  return snapshot.processes.map((row) => ({
+    ...row,
+    cpu: Math.max(0, row.ticks - (oldTicks.get(row.pid) ?? row.ticks)) / CLOCK_TICKS / elapsed * 100,
+  }));
+};
+
+const render = (snapshot, previous, sort, batch) => {
+  const rows = intervalRows(snapshot, previous);
+  rows.sort(sort === "memory"
+    ? (a, b) => b.memory - a.memory || a.pid - b.pid
+    : sort === "pid" ? (a, b) => a.pid - b.pid : (a, b) => b.cpu - a.cpu || a.pid - b.pid);
+  const states = { running: 0, sleeping: 0, stopped: 0, zombie: 0 };
+  for (const row of rows) {
+    if (row.state[0] === "R") states.running++;
+    else if (row.state[0] === "T") states.stopped++;
+    else if (row.state[0] === "Z") states.zombie++;
+    else states.sleeping++;
+  }
+  const total = previous ? snapshot.cpu.total - previous.cpu.total : snapshot.cpu.total;
+  const idleTicks = previous ? snapshot.cpu.idle - previous.cpu.idle : snapshot.cpu.idle;
+  const idle = total > 0 ? idleTicks / total * 100 : 0;
+  const clock = new Date().toLocaleTimeString("en-US", { hour12: false });
+  const lines = [
+    `top - ${clock} up ${uptimeText(snapshot.uptime)}, load average: ${snapshot.loadAverage.map((v) => v.toFixed(2)).join(", ")}`,
+    `Tasks: ${rows.length} total, ${states.running} running, ${states.sleeping} sleeping, ${states.stopped} stopped, ${states.zombie} zombie`,
+    `%Cpu(s): ${(100 - idle).toFixed(1)} used, ${idle.toFixed(1)} id`,
+    memoryText(snapshot.memory),
+    "",
+  ];
+  const format = prepareProcessFormat(rows, fields);
+  lines.push(formatProcessHeader(format));
+  // Some early boot consoles report a TTY size of 0x0. Treat that as
+  // unknown; otherwise Math.max(1, 0 - headers) displays only one process
+  // and makes it look as if the snapshot contained only top itself.
+  const terminalRows = Number(process.stdout.rows);
+  const screenRows = Number.isFinite(terminalRows) && terminalRows > lines.length
+    ? terminalRows
+    : 24;
+  const limit = batch ? rows.length : Math.max(1, screenRows - lines.length);
+  for (const row of rows.slice(0, limit)) lines.push(formatProcessLine(row, format));
+  return lines.join("\n");
+};
+
+async function main(argv) {
+  let delay = 3;
+  let iterations = Infinity;
+  let batch = false;
+  for (let index = 0; index < argv.length; index++) {
+    const argument = argv[index];
+    if (argument === "-h" || argument === "--help") return showDocument("top");
+    if (argument === "-b") { batch = true; continue; }
+    if (argument === "-d") { delay = Number(argv[++index]); continue; }
+    if (argument === "-n") { iterations = Number(argv[++index]); continue; }
+    throw new Error(`top: unsupported option '${argument}'`);
+  }
+  if (!(delay > 0) || !(iterations > 0)) throw new Error("top: -d and -n require positive numbers");
+  let quit = false;
+  let sort = "cpu";
+  const interactive = !batch && process.stdin.isTTY && process.stdout.isTTY;
+  const cleanup = () => {
+    if (interactive) {
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+      process.stdout.write("\x1b[?25h\n");
+    }
+  };
+  if (interactive) {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (key) => {
+      if (key === "q" || key === "\u0003") quit = true;
+      else if (key === "P") sort = "cpu";
+      else if (key === "M") sort = "memory";
+      else if (key === "N") sort = "pid";
+    });
+    process.stdout.write("\x1b[?25l");
+    process.on("exit", cleanup);
+  } else if (!batch && iterations === Infinity) iterations = 1;
+
+  let previous = null;
+  try {
+    for (let count = 0; count < iterations && !quit; count++) {
+      const snapshot = readProcessSnapshot();
+      const output = render(snapshot, previous, sort, batch);
+      process.stdout.write(`${interactive ? "\x1b[H\x1b[2J" : ""}${output}\n`);
+      previous = snapshot;
+      if (count + 1 < iterations && !quit) await sleep(delay * 1000);
+    }
+  } finally { cleanup(); }
+}
+
+if (import.meta.main) {
+  try { await main(process.argv.slice(2)); }
+  catch (error) { console.error(error.message); process.exit(1); }
+}

package/initramfs/bin/umount

@@ -0,0 +1,71 @@
+#!/bin/bun
+// umount — unmount a filesystem. `umount --help` renders
+// /usr/share/doc/buninu-linux/umount.md.
+
+import { libc, cString, ptr, errno, strerror, Errno } from "../lib/dlopen.js";
+import { showDocument } from "../lib/document.js";
+
+const MNT = { FORCE: 1, DETACH: 2, EXPIRE: 4, NOFOLLOW: 8 };
+
+const usage = () => {
+  console.error(`Usage:
+  umount [-f] [-l] [-R] [-v] TARGET...
+  umount -h | --help`);
+  process.exit(1);
+};
+
+let flags = 0;
+let recursive = false;
+let verbose = false;
+let help = false;
+const targets = [];
+for (const argument of process.argv.slice(2)) {
+  if (argument === "-h" || argument === "--help") help = true;
+  else if (argument === "-f" || argument === "--force") flags |= MNT.FORCE;
+  else if (argument === "-l" || argument === "--lazy") flags |= MNT.DETACH;
+  else if (argument === "-R" || argument === "--recursive") recursive = true;
+  else if (argument === "-v" || argument === "--verbose") verbose = true;
+  else if (argument === "-n" || argument === "-d" || argument === "--no-mtab" || argument === "--detach-loop") {}
+  else if (argument === "-a" || argument === "--all") { console.error("umount: -a is not supported"); process.exit(1); }
+  else if (argument.startsWith("-") && argument.length > 1) { console.error(`umount: unknown option ${argument}`); usage(); }
+  else targets.push(argument);
+}
+
+if (help) await showDocument("umount");
+else if (targets.length === 0) usage();
+
+const mountPoints = () => {
+  const table = Bun.file("/proc/self/mounts");
+  return table.text().then((text) =>
+    text.split("\n").filter(Boolean).map((line) =>
+      line.split(" ")[1].replace(/\\([0-7]{3})/g, (_, code) => String.fromCharCode(parseInt(code, 8))),
+    ),
+  );
+};
+
+const unmount = (target) => {
+  const result = libc.symbols.umount2(ptr(cString(target)), flags);
+  if (result === 0) {
+    if (verbose) console.log(`${target} unmounted`);
+    return true;
+  }
+  const code = errno();
+  const reason = code === Errno.EBUSY ? "target is busy (try -l for a lazy unmount)"
+    : code === Errno.EINVAL ? "not mounted"
+    : code === Errno.EPERM ? "must be superuser to unmount"
+    : strerror(code);
+  console.error(`umount: ${target}: ${reason}.`);
+  return false;
+};
+
+let status = 0;
+for (const target of targets) {
+  const path = target.length > 1 ? target.replace(/\/+$/, "") : target;
+  // -R takes every mount at or below the target, deepest first, so each
+  // umount2 sees an empty subtree.
+  const list = recursive
+    ? (await mountPoints()).filter((point) => point === path || point.startsWith(`${path}/`)).sort((a, b) => b.length - a.length)
+    : [path];
+  for (const point of list) if (!unmount(point)) status = 32;
+}
+process.exit(status);

package/initramfs/buninu/apps/bunmsh/CHANGELOG.md

@@ -2,6 +2,42 @@
 
 All notable user-visible changes to bunmsh are documented here.
 
+## [0.3.9] - 2026-09-22
+
+### Fixed
+
+- Make pathname expansion follow directory symbolic links used as intermediate
+  path components, matching traditional shell behaviour. `Bun.Glob` disables
+  that traversal by default, so patterns such as `./*/*.js` silently skipped
+  a matching directory symlink, and sysfs patterns such as
+  `/sys/class/net/*/device` failed to pass through class-device links. bunmsh
+  now enables `followSymlinks` while scanning; a symlink matched as the final
+  component is still passed to the command as a symlink.
+
+- Stop the fallback `ls`/`lsfancy` from printing every glob-expanded file as
+  a directory section. `builtin ls L*` previously expanded the glob
+  correctly, but multiple operands unconditionally received `filename:`
+  headings and blank separators. Only directories whose contents are being
+  listed now receive section headings; multiple ordinary files form one
+  continuous listing and retain their full operand paths rather than being
+  reduced to basenames.
+
+- Honor `--` in `ls`/`lsfancy`, so names such as `-odd` after it are operands
+  rather than option clusters. Also follow a command-line symlink to a
+  directory for ordinary and recursive listings, as traditional `ls` does;
+  `-d`, `-l`, and `-F` continue to inspect the symlink itself.
+
+## [0.3.8] - 2026-09-21
+
+### Added
+
+- Make `Ctrl-U` and `Ctrl-K` toggle their edits in the interactive line
+  editor. `Ctrl-U` saves the text removed before the cursor and restores it
+  when pressed again at the beginning of the line; `Ctrl-K` does the same for
+  text after the cursor when pressed again at the end. Each shortcut keeps an
+  independent saved value, and control bytes inside bracketed paste remain
+  literal pasted content rather than triggering either action.
+
 ## [0.3.7] - 2026-09-20
 
 ### Fixed

package/initramfs/buninu/apps/bunmsh/README.md

@@ -476,6 +476,13 @@ Bun.e, Bun.file("/tm     # -> a path, completed inside the string
 
 - `Ctrl-D`: On an empty input line, sends EOF and exits the interactive shell.
 
+- `Ctrl-U`: Removes and saves everything before the cursor. Press it again
+  while the cursor is at the beginning to restore that saved prefix.
+
+- `Ctrl-K`: Removes and saves everything after the cursor. Press it again
+  while the cursor is at the end to restore that saved suffix. Its saved text
+  is independent from `Ctrl-U`.
+
 - `Ctrl-T`: Calls `builtin tab` without adding a command to history. It creates
   a tab when only one exists, or switches to the next tab otherwise. Any
   command text currently being edited is preserved.

package/initramfs/buninu/apps/bunmsh/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunmsh",
-  "version": "0.3.7",
+  "version": "0.3.9",
   "description": "Cross-platform command shell for Bun JavaScript",
   "license": "MIT",
   "type": "module",

package/initramfs/buninu/apps/bunmsh/src/fancy-ls.js

@@ -1,5 +1,5 @@
-import { existsSync, lstatSync, readdirSync, readlinkSync } from "node:fs";
-import { basename, isAbsolute, resolve } from "node:path";
+import { existsSync, lstatSync, readdirSync, readlinkSync, statSync } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
 
 const IMAGE = new Set(["png", "jpg", "jpeg", "gif", "webp", "svg", "bmp", "ico", "avif", "heic"]);
 const MUSIC = new Set(["mp3", "wav", "flac", "ogg", "m4a", "aac", "opus", "mid", "midi"]);
@@ -120,9 +120,11 @@ export function fancyLs(argv, state, terminal = Boolean(process.stdout.isTTY)) {
     recursive: false, time: false, reverse: false, size: false, one: false, classify: false,
   };
   const operands = [];
+  let parseOptions = true;
   for (const argument of argv.slice(1)) {
-    if (argument === "--color=auto" || argument === "--color" || argument === "--") continue;
-    if (/^-[^-]/.test(argument)) {
+    if (parseOptions && argument === "--") { parseOptions = false; continue; }
+    if (parseOptions && (argument === "--color=auto" || argument === "--color")) continue;
+    if (parseOptions && /^-[^-]/.test(argument)) {
       for (const flag of argument.slice(1)) {
         if (flag === "a") options.all = true;
         else if (flag === "A") options.almostAll = true;
@@ -142,15 +144,30 @@ export function fancyLs(argv, state, terminal = Boolean(process.stdout.isTTY)) {
   if (!operands.length) operands.push(".");
   let status = 0, stdout = "", stderr = "";
   const visited = new Set();
-  const show = (operand, heading = operands.length > 1) => {
+  let previousWasDirectory = false;
+  const show = (operand, heading = operands.length > 1, separate = true) => {
     const path = isAbsolute(operand) ? operand : resolve(state.cwd, operand);
     try {
       const stats = lstatSync(path);
+      let listingDirectory = stats.isDirectory() && !options.directory;
+      // GNU/POSIX-style ls follows a command-line symlink to a directory for
+      // an ordinary listing and for -R. -d, -l, and -F request information
+      // about the link itself instead. A broken link simply cannot qualify.
+      if (stats.isSymbolicLink() && !options.directory && !options.long && !options.classify) {
+        try { listingDirectory = statSync(path).isDirectory(); } catch {}
+      }
+      // Multiple file operands are one listing, not a series of directory
+      // sections. Only actual directory contents receive `name:` headings
+      // and blank section separators.
+      if (separate && stdout && (listingDirectory || previousWasDirectory)) stdout += "\n";
       let entries;
-      if (!stats.isDirectory() || options.directory)
-        entries = [{ name: basename(operand) || operand, stats, path }];
+      if (!listingDirectory)
+        // Preserve the operand spelling just like traditional ls. A glob such
+        // as ./*/*.js has already expanded to paths, and reducing each one to
+        // basename would lose the information that distinguishes its parent.
+        entries = [{ name: operand, stats, path }];
       else entries = listDirectory(path, options);
-      if (heading) stdout += `${operand}:\n`;
+      if (heading && listingDirectory) stdout += `${operand}:\n`;
       const rendered = entries.map((entry) => displayEntry(entry, options));
       if (options.long) {
         for (let i = 0; i < entries.length; i++) {
@@ -164,23 +181,21 @@ export function fancyLs(argv, state, terminal = Boolean(process.stdout.isTTY)) {
       } else stdout += terminal && !options.one
         ? columns(rendered, process.stdout.columns ?? 80)
         : `${rendered.join("\n")}${rendered.length ? "\n" : ""}`;
-      if (options.recursive && stats.isDirectory() && !options.directory) {
+      if (options.recursive && listingDirectory) {
         for (const entry of entries) if (entry.stats.isDirectory() && entry.name !== "." && entry.name !== "..") {
           const child = resolve(path, entry.name);
           if (visited.has(child)) continue;
           visited.add(child);
           stdout += "\n";
-          show(`${operand.replace(/\/$/, "")}/${entry.name}`, true);
+          show(`${operand.replace(/\/$/, "")}/${entry.name}`, true, false);
         }
       }
+      previousWasDirectory = listingDirectory;
     } catch (error) {
       status = 1;
       stderr += `bunmsh: ${argv[0]}: ${operand}: ${error.message}\n`;
     }
   };
-  for (let i = 0; i < operands.length; i++) {
-    if (i) stdout += "\n";
-    show(operands[i]);
-  }
+  for (const operand of operands) show(operand);
   return { status, stdout, stderr };
 }

package/initramfs/buninu/apps/bunmsh/src/line-edit.js

@@ -0,0 +1,43 @@
+export function toggleSavedText(line, cursor, saved, side) {
+  line = String(line ?? "");
+  cursor = Math.max(0, Math.min(line.length, Number.isFinite(cursor) ? cursor : line.length));
+  saved = String(saved ?? "");
+
+  if (side === "head") {
+    if (cursor > 0) {
+      return {
+        line: line.slice(cursor),
+        cursor: 0,
+        saved: line.slice(0, cursor),
+        changed: true,
+      };
+    }
+    if (saved) {
+      return {
+        line: saved + line,
+        cursor: saved.length,
+        saved: "",
+        changed: true,
+      };
+    }
+  } else if (side === "tail") {
+    if (cursor < line.length) {
+      return {
+        line: line.slice(0, cursor),
+        cursor,
+        saved: line.slice(cursor),
+        changed: true,
+      };
+    }
+    if (saved) {
+      return {
+        line: line + saved,
+        cursor,
+        saved: "",
+        changed: true,
+      };
+    }
+  }
+
+  return { line, cursor, saved, changed: false };
+}

package/initramfs/buninu/apps/bunmsh/src/main.js

@@ -29,6 +29,7 @@ import { importedHistory, readlineHistory, saveBunmshHistory } from "./history.j
 import pkg from "../package.json" with { type:"json" }
 import { MOUSE_OFF, MOUSE_ON, PASTE_OFF, PASTE_ON, mouseInput } from "./mouse.js";
 import { homeRelativePath } from "./environment.js";
+import { toggleSavedText } from "./line-edit.js";
 
 const VERSION = `
 ${pkg.name}: ${pkg.description}
@@ -223,6 +224,8 @@ async function interactive(state) {
   let lastTabClick = null;
   let mouseCommandRunning = false;
   let foregroundCommand = false;
+  let savedHead = "";
+  let savedTail = "";
   let promptAbort = null;
   // Set by onPaste (below) when a bracketed paste contains a newline, and
   // consumed by the main loop's readline.question() catch block right after
@@ -332,6 +335,17 @@ async function interactive(state) {
     const key = { name: delta > 0 ? "right" : "left" };
     for (let n = 0; n < Math.abs(delta); n++) readline.write(null, key);
   };
+  const toggleLineText = (side) => {
+    if (!readline || foregroundCommand) return;
+    const saved = side === "head" ? savedHead : savedTail;
+    const result = toggleSavedText(readline.line, readline.cursor, saved, side);
+    if (side === "head") savedHead = result.saved;
+    else savedTail = result.saved;
+    if (!result.changed) return;
+    readline.line = result.line;
+    readline.cursor = result.cursor;
+    readline.prompt(true);
+  };
   const filteredInput = terminal ? mouseInput((mouse) => {
     if (!mouse.press || (mouse.button & 3) !== 0 || (mouse.button & 32)) return;
     pendingClick = { ...mouse, at: Date.now() };
@@ -384,7 +398,7 @@ async function interactive(state) {
     else if (shortcut === "lsfancy") runFancyShortcut();
     else if (shortcut === "lsfancy-parent") runFancyShortcut([".."]);
     else if (shortcut === "tab-close") runTabShortcut(["x"]);
-  }, onPaste) : process.stdin;
+  }, onPaste, toggleLineText) : process.stdin;
   const completer = (line) => {
     commandIndex.refreshIfChanged(state);
     if (javascriptLine(line)) {