buninu-linux 0.2.0

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

@@ -0,0 +1,61 @@
+export function environmentValue(env, name, platform = process.platform) {
+  if (Object.hasOwn(env, name)) return env[name];
+  if (platform !== "win32") return undefined;
+  const key = Object.keys(env).find((candidate) => candidate.toLowerCase() === name.toLowerCase());
+  return key === undefined ? undefined : env[key];
+}
+
+export function canonicalEnvironment(env, platform = process.platform) {
+  const output = { ...env };
+  if (platform !== "win32") return output;
+  const canonicalize = (name) => {
+    const keys = Object.keys(output).filter((key) => key.toLowerCase() === name.toLowerCase());
+    if (!keys.length) return undefined;
+    const value = output[keys.at(-1)];
+    for (const key of keys) delete output[key];
+    output[name] = value;
+    return value;
+  };
+  if (canonicalize("PATH") === undefined) delete output.PATH;
+  let home = canonicalize("HOME");
+  if (!home) {
+    home = environmentValue(output, "USERPROFILE", platform);
+    if (!home) {
+      const drive = environmentValue(output, "HOMEDRIVE", platform) ?? "";
+      const path = environmentValue(output, "HOMEPATH", platform) ?? "";
+      home = drive && path ? `${drive}${path}` : "";
+    }
+  }
+  if (home) {
+    output.HOME = String(home).replaceAll("\\", "/");
+  } else {
+    delete output.HOME;
+  }
+  return output;
+}
+
+export function homeRelativePath(cwd, home, platform = process.platform) {
+  if (!home) return null;
+  const trim = (value) => {
+    const normalized = String(value).replaceAll("\\", "/");
+    return normalized === "/" ? "/" : normalized.replace(/\/+$/, "");
+  };
+  // Android exposes app data through both /data/data/PACKAGE and
+  // /data/user/0/PACKAGE. They are the same app sandbox but string comparison
+  // alone cannot recognise HOME when the two spellings are mixed.
+  const comparable = (value) => trim(value).replace(
+    /^\/data\/user\/0\/([^/]+)(?=\/|$)/,
+    "/data/data/$1",
+  );
+  let comparedCwd = comparable(cwd);
+  let comparedHome = comparable(home);
+  if (platform === "win32") {
+    comparedCwd = comparedCwd.toLowerCase();
+    comparedHome = comparedHome.toLowerCase();
+  }
+  if (comparedCwd === comparedHome) return "";
+  if (comparedHome === "/" && comparedCwd.startsWith("/")) return comparedCwd;
+  return comparedCwd.startsWith(`${comparedHome}/`)
+    ? comparable(cwd).slice(comparedHome.length)
+    : null;
+}

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

@@ -0,0 +1,186 @@
+import { existsSync, lstatSync, readdirSync, readlinkSync } from "node:fs";
+import { basename, 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"]);
+const VIDEO = new Set(["mp4", "mkv", "webm", "mov", "avi", "m4v", "mpeg", "mpg"]);
+const ICONS = new Map([
+  ["js", "🟨"], ["mjs", "🟨"], ["cjs", "🟨"],
+  ["ts", "🟦"], ["mts", "🟦"], ["cts", "🟦"],
+  ["py", "🐍"], ["c", "🔧"], ["h", "🧩"], ["rs", "🦀"],
+  ["html", "🌐"], ["htm", "🌐"], ["css", "🎨"],
+]);
+
+function extension(name) {
+  const index = name.lastIndexOf(".");
+  return index > 0 ? name.slice(index + 1).toLowerCase() : "";
+}
+
+export function iconFor(name, stats, path = null) {
+  if (stats.isDirectory()) return "📦";
+  if (stats.isSymbolicLink()) return path !== null && !existsSync(path) ? "🚫" : "🔗";
+  const ext = extension(name);
+  if (IMAGE.has(ext)) return "🖼️";
+  if (MUSIC.has(ext)) return "🎵";
+  if (VIDEO.has(ext)) return "🎬";
+  if (ICONS.has(ext)) return ICONS.get(ext);
+  if (stats.mode & 0o111) return "⚙️";
+  return "📄";
+}
+
+// Only touches cross-platform-safe fs.Stats methods (isDirectory/
+// isSymbolicLink/isSocket/isFIFO always return a real boolean on Windows
+// too, just typically false for socket/FIFO since NTFS directory entries
+// aren't reported as those) and the same mode-bit check iconFor already
+// uses elsewhere in this file, so this needs no platform-specific handling.
+function classifySuffix(stats) {
+  if (stats.isDirectory()) return "/";
+  if (stats.isSymbolicLink()) return "@";
+  if (stats.isSocket()) return "=";
+  if (stats.isFIFO()) return "|";
+  if (stats.mode & 0o111) return "*";
+  return "";
+}
+
+function displayEntry(entry, options) {
+  const suffix = options.classify ? classifySuffix(entry.stats) : entry.stats.isDirectory() ? "/" : "";
+  return `${iconFor(entry.name, entry.stats, entry.path)} ${entry.name}${suffix}`;
+}
+
+function columns(items, width) {
+  if (!items.length) return "";
+  const widest = Math.max(...items.map((item) => Bun.stringWidth(item))) + 2;
+  const count = Math.max(1, Math.floor(width / widest));
+  let output = "";
+  for (let index = 0; index < items.length; index++) {
+    const last = index % count === count - 1 || index === items.length - 1;
+    output += items[index];
+    output += last ? "\n" : " ".repeat(widest - Bun.stringWidth(items[index]));
+  }
+  return output;
+}
+
+function modeString(mode) {
+  const kinds = [[0o400, "r"], [0o200, "w"], [0o100, "x"], [0o040, "r"], [0o020, "w"], [0o010, "x"], [0o004, "r"], [0o002, "w"], [0o001, "x"]];
+  return kinds.map(([bit, letter]) => mode & bit ? letter : "-").join("");
+}
+
+function linkTarget(path) {
+  try {
+    // Node/Bun read the reparse point's stored target on Windows the same
+    // way as a POSIX symlink; only the separator needs normalizing to match
+    // the forward-slash paths the rest of the shell displays.
+    const target = readlinkSync(path);
+    return process.platform === "win32" ? target.replaceAll("\\", "/") : target;
+  } catch {
+    return null;
+  }
+}
+
+function localDateTime(ms) {
+  const date = new Date(ms);
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} `
+    + `${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}
+
+function humanSize(bytes) {
+  if (bytes < 1024) return String(bytes);
+  const units = ["K", "M", "G", "T", "P"];
+  let value = bytes;
+  let unit = -1;
+  do { value /= 1024; unit++; } while (value >= 1024 && unit < units.length - 1);
+  return `${value >= 10 ? value.toFixed(0) : value.toFixed(1).replace(/\.0$/, "")}${units[unit]}`;
+}
+
+function listDirectory(path, options) {
+  let entries = readdirSync(path, { withFileTypes: true })
+    .filter((entry) => options.all || options.almostAll || !entry.name.startsWith("."))
+    .map((entry) => {
+      const entryPath = resolve(path, entry.name);
+      return { name: entry.name, stats: lstatSync(entryPath), path: entryPath };
+    });
+  if (options.all) entries = [
+    { name: ".", stats: lstatSync(path), path },
+    { name: "..", stats: lstatSync(resolve(path, "..")), path: resolve(path, "..") },
+    ...entries,
+  ];
+  entries.sort(options.size
+    ? (a, b) => b.stats.size - a.stats.size || a.name.localeCompare(b.name)
+    : options.time
+    ? (a, b) => b.stats.mtimeMs - a.stats.mtimeMs || a.name.localeCompare(b.name)
+    : (a, b) => a.name.localeCompare(b.name));
+  if (options.reverse) entries.reverse();
+  return entries;
+}
+
+export function fancyLs(argv, state, terminal = Boolean(process.stdout.isTTY)) {
+  const options = {
+    all: false, almostAll: false, directory: false, long: false, human: false,
+    recursive: false, time: false, reverse: false, size: false, one: false, classify: false,
+  };
+  const operands = [];
+  for (const argument of argv.slice(1)) {
+    if (argument === "--color=auto" || argument === "--color" || argument === "--") continue;
+    if (/^-[^-]/.test(argument)) {
+      for (const flag of argument.slice(1)) {
+        if (flag === "a") options.all = true;
+        else if (flag === "A") options.almostAll = true;
+        else if (flag === "d") options.directory = true;
+        else if (flag === "l") options.long = true;
+        else if (flag === "h") options.human = true;
+        else if (flag === "R") options.recursive = true;
+        else if (flag === "t") options.time = true;
+        else if (flag === "r") options.reverse = true;
+        else if (flag === "S") options.size = true;
+        else if (flag === "1") options.one = true;
+        else if (flag === "F") options.classify = true;
+        else return { status: 2, stdout: "", stderr: `bunmsh: ${argv[0]}: unsupported option: -${flag}\n` };
+      }
+    } else operands.push(argument);
+  }
+  if (!operands.length) operands.push(".");
+  let status = 0, stdout = "", stderr = "";
+  const visited = new Set();
+  const show = (operand, heading = operands.length > 1) => {
+    const path = isAbsolute(operand) ? operand : resolve(state.cwd, operand);
+    try {
+      const stats = lstatSync(path);
+      let entries;
+      if (!stats.isDirectory() || options.directory)
+        entries = [{ name: basename(operand) || operand, stats, path }];
+      else entries = listDirectory(path, options);
+      if (heading) stdout += `${operand}:\n`;
+      const rendered = entries.map((entry) => displayEntry(entry, options));
+      if (options.long) {
+        for (let i = 0; i < entries.length; i++) {
+          const item = entries[i];
+          const date = localDateTime(item.stats.mtimeMs);
+          const size = options.human ? humanSize(item.stats.size) : String(item.stats.size);
+          const target = item.stats.isSymbolicLink() ? linkTarget(item.path) : null;
+          const suffix = target === null ? "" : ` -> ${target}`;
+          stdout += `${item.stats.isDirectory() ? "d" : item.stats.isSymbolicLink() ? "l" : "-"}${modeString(item.stats.mode)} ${size.padStart(8)} ${date} ${rendered[i]}${suffix}\n`;
+        }
+      } else stdout += terminal && !options.one
+        ? columns(rendered, process.stdout.columns ?? 80)
+        : `${rendered.join("\n")}${rendered.length ? "\n" : ""}`;
+      if (options.recursive && stats.isDirectory() && !options.directory) {
+        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);
+        }
+      }
+    } 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]);
+  }
+  return { status, stdout, stderr };
+}

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

@@ -0,0 +1,119 @@
+import { lstatSync, readdirSync } from "node:fs";
+import { basename, isAbsolute, resolve } from "node:path";
+
+const shellPath = (value) => value.replaceAll("\\", "/");
+const nativePath = (value, platform) => platform === "win32" ? value.replaceAll("/", "\\") : value;
+
+function globRegex(pattern, insensitive = false) {
+  let source = "^";
+  for (let i = 0; i < pattern.length; i++) {
+    const ch = pattern[i];
+    if (ch === "*") source += ".*";
+    else if (ch === "?") source += ".";
+    else if (ch === "[") {
+      const end = pattern.indexOf("]", i + 1);
+      if (end < 0) source += "\\[";
+      else { source += pattern.slice(i, end + 1); i = end; }
+    } else source += ch.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+  }
+  return new RegExp(`${source}$`, insensitive ? "i" : "");
+}
+
+export function findIsRegularBuiltin(platform = process.platform) {
+  return platform === "win32";
+}
+
+export async function runFind(argv, state, platform = process.platform, execute = null) {
+  let index = 1;
+  const roots = [];
+  while (index < argv.length && argv[index] !== "!" && argv[index] !== "-not" &&
+      !argv[index].startsWith("-")) roots.push(argv[index++]);
+  if (!roots.length) roots.push(".");
+  let minDepth = 0, maxDepth = Infinity, print0 = false, negate = false, explicitPrint = false;
+  const predicates = [];
+  const actions = [];
+  while (index < argv.length) {
+    const option = argv[index++];
+    if (option === "!" || option === "-not") { negate = !negate; continue; }
+    if (option === "-print") { explicitPrint = true; continue; }
+    if (option === "-print0") { explicitPrint = true; print0 = true; continue; }
+    if (option === "-exec") {
+      const command = [];
+      while (index < argv.length && argv[index] !== ";" && argv[index] !== "+")
+        command.push(argv[index++]);
+      const terminator = argv[index++];
+      if (!command.length || (terminator !== ";" && terminator !== "+"))
+        return { status: 2, stdout: "", stderr: "bunmsh: find: -exec: missing command or terminator\n" };
+      if (!command.includes("{}"))
+        return { status: 2, stdout: "", stderr: "bunmsh: find: -exec: command must contain {}\n" };
+      actions.push({ command, mode: terminator });
+      continue;
+    }
+    const argument = argv[index++];
+    if (argument === undefined)
+      return { status: 2, stdout: "", stderr: `bunmsh: find: ${option}: missing argument\n` };
+    let predicate;
+    if (option === "-name" || option === "-iname") {
+      const regex = globRegex(argument, option === "-iname");
+      predicate = (entry) => regex.test(basename(entry.shown));
+    } else if (option === "-path" || option === "-ipath") {
+      const regex = globRegex(argument, option === "-ipath");
+      predicate = (entry) => regex.test(entry.shown);
+    } else if (option === "-type") {
+      if (!/^[fdl]$/.test(argument))
+        return { status: 2, stdout: "", stderr: `bunmsh: find: unsupported type: ${argument}\n` };
+      predicate = (entry) => argument === "f" ? entry.stats.isFile() :
+        argument === "d" ? entry.stats.isDirectory() : entry.stats.isSymbolicLink();
+    } else if (option === "-mindepth" || option === "-maxdepth") {
+      if (!/^\d+$/.test(argument))
+        return { status: 2, stdout: "", stderr: `bunmsh: find: ${option}: invalid depth: ${argument}\n` };
+      if (option === "-mindepth") minDepth = Number(argument); else maxDepth = Number(argument);
+      continue;
+    } else return { status: 2, stdout: "", stderr: `bunmsh: find: unsupported option: ${option}\n` };
+    predicates.push(negate ? (entry) => !predicate(entry) : predicate);
+    negate = false;
+  }
+  if (negate) return { status: 2, stdout: "", stderr: "bunmsh: find: expected expression after !\n" };
+  let status = 0, stdout = "", stderr = "";
+  const decoder = new TextDecoder();
+  const appendExecution = (execution) => {
+    stdout += typeof execution.stdout === "string" ? execution.stdout : decoder.decode(execution.stdout);
+    stderr += typeof execution.stderr === "string" ? execution.stderr : decoder.decode(execution.stderr);
+  };
+  const matches = [];
+  const emit = (shown) => { stdout += shown + (print0 ? "\0" : "\n"); };
+  const visit = async (native, shown, depth) => {
+    let stats;
+    try { stats = lstatSync(native); }
+    catch (error) { status = 1; stderr += `bunmsh: find: ${shown}: ${error.message}\n`; return; }
+    const entry = { shown, stats };
+    if (depth >= minDepth && predicates.every((predicate) => predicate(entry))) {
+      matches.push(shown);
+      if (!actions.length || explicitPrint) emit(shown);
+      for (const action of actions) if (action.mode === ";") {
+        if (!execute) return;
+        const command = action.command.map((argument) => argument === "{}" ? shown : argument);
+        appendExecution(await execute(command));
+      }
+    }
+    if (!stats.isDirectory() || depth >= maxDepth) return;
+    let children;
+    try { children = readdirSync(native).sort(); }
+    catch (error) { status = 1; stderr += `bunmsh: find: ${shown}: ${error.message}\n`; return; }
+    for (const child of children)
+      await visit(resolve(native, child), shown === "." ? `./${child}` : `${shown.replace(/\/$/, "")}/${child}`, depth + 1);
+  };
+  for (const root of roots) {
+    const native = isAbsolute(nativePath(root, platform))
+      ? nativePath(root, platform) : resolve(nativePath(state.cwd, platform), nativePath(root, platform));
+    await visit(native, shellPath(root), 0);
+  }
+  for (const action of actions) if (action.mode === "+" && matches.length) {
+    if (!execute) continue;
+    const command = action.command.flatMap((argument) => argument === "{}" ? matches : [argument]);
+    const execution = await execute(command);
+    appendExecution(execution);
+    if (execution.status !== 0) status = 1;
+  }
+  return { status, stdout, stderr };
+}

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

@@ -0,0 +1,198 @@
+import { mkdirSync } from "node:fs";
+import { appendFile, rename, stat } from "node:fs/promises";
+import { dirname } from "node:path";
+
+function importEnabled(env) {
+  return !/^(?:0|false|off|no)$/i.test(env.BUNMSH_IMPORT_HISTORY ?? "");
+}
+
+// History is rendered directly beside the prompt. Reject the entire entry
+// instead of stripping bytes and accidentally turning it into another command.
+export function safeHistoryEntry(entry) {
+  return typeof entry === "string" && entry.length > 0 &&
+    !/[\u0000-\u001f\u007f-\u009f\u200b-\u200f\u2028-\u202e\u2066-\u2069\ufeff]/u.test(entry);
+}
+
+// node:readline stores its history newest-first, while bunmsh keeps history in
+// chronological order for saving and ghost completion.
+export function readlineHistory(history) {
+  return history.filter(safeHistoryEntry).toReversed();
+}
+
+export function bunmshHistoryPath(env = process.env, platform = process.platform) {
+  const trim = (value) => value?.replace(/[\\/]+$/, "");
+  if (platform === "win32") {
+    const base = trim(env.LOCALAPPDATA || env.APPDATA ||
+      (env.USERPROFILE ? `${trim(env.USERPROFILE)}/AppData/Local` : ""));
+    return base ? `${base}/bunmsh/history` : null;
+  }
+  const base = trim(env.XDG_DATA_HOME || (env.HOME ? `${trim(env.HOME)}/.local/share` : ""));
+  return base ? `${base}/bunmsh/history` : null;
+}
+
+async function readableText(path) {
+  const file = Bun.file(path);
+  return await file.exists() ? file.text() : null;
+}
+
+async function statSafe(path) {
+  try { return await stat(path); } catch { return null; }
+}
+
+export function parseBashHistory(source) {
+  return source
+    .split(/\r?\n/)
+    .filter((line) => !/^#[0-9]+$/.test(line) && safeHistoryEntry(line));
+}
+
+export function parseFishHistory(source) {
+  const records = source.split(/\r?\n/)
+    .map((line) => /^- cmd:\s?(.*)$/.exec(line)?.[1] ?? null)
+    .filter((entry) => entry !== null);
+  // Fish documents this as "YAML-style", not YAML. Command scalars use Fish's
+  // own escaping and can be rejected or only partially consumed by YAML
+  // parsers. The stable record boundary is the unindented `- cmd:` prefix.
+  return records
+    .map((entry) => entry.replace(/\\(\\|n)/g, (_match, escaped) => escaped === "n" ? "\n" : "\\"))
+    .filter(safeHistoryEntry);
+}
+
+// bunmsh saved its own history as a single JSON array before switching to
+// one-JSON-value-per-line (JSONL). Detecting and reading that old format
+// keeps existing history files working; see saveBunmshHistory for where the
+// on-disk file actually gets converted.
+function isLegacyArrayFormat(source) {
+  return source.trimStart().startsWith("[");
+}
+
+function parseLegacyArrayFormat(source) {
+  const parsed = JSON.parse(source);
+  return Array.isArray(parsed) ? parsed.filter(safeHistoryEntry) : [];
+}
+
+// Bun.JSONL.parse stops at the first line it can't parse instead of skipping
+// it, which would silently discard every entry after one corrupted line (for
+// example from a write torn by a crash). Detect that by comparing against the
+// non-empty line count, and fall back to a per-line parse that only skips the
+// bad lines when it looks like that happened.
+function parseJsonlFormat(source) {
+  const lines = source.split(/\r?\n/).filter((line) => line.trim() !== "");
+  let parsed;
+  try { parsed = Bun.JSONL.parse(source); } catch { parsed = []; }
+  if (parsed.length < lines.length) {
+    parsed = [];
+    for (const line of lines) {
+      try { parsed.push(JSON.parse(line)); } catch {}
+    }
+  }
+  return parsed.filter(safeHistoryEntry);
+}
+
+function parseBunmshHistoryContent(source) {
+  if (source.trim() === "") return [];
+  return isLegacyArrayFormat(source) ? parseLegacyArrayFormat(source) : parseJsonlFormat(source);
+}
+
+function encodeJsonlLines(entries) {
+  return entries.map((entry) => `${JSON.stringify(entry)}\n`).join("");
+}
+
+// Writes the whole file in one shot via a temp file plus atomic rename, so a
+// crash or interruption mid-write can never leave a half-written, unreadable
+// history file behind — only ever the old content or the new content.
+async function writeHistoryFileAtomic(path, entries) {
+  const tmpPath = `${path}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  await Bun.write(tmpPath, encodeJsonlLines(entries));
+  await rename(tmpPath, path);
+}
+
+function dedupeEntries(entries) {
+  const seen = new Set();
+  const unique = [];
+  for (let index = entries.length - 1; index >= 0; index--) {
+    const entry = entries[index];
+    if (!safeHistoryEntry(entry) || seen.has(entry)) continue;
+    seen.add(entry);
+    unique.push(entry);
+  }
+  return unique.reverse();
+}
+
+// The routine, frequent save path (manual `tab s`/`tab save`, the periodic
+// autosave, and the on-exit flush all call this). It only appends the
+// entries this session hasn't persisted yet — tracked on `state` via
+// historySaved, a count into state.history — instead of rewriting the whole
+// file, so it stays safe to call from multiple bunmsh sessions at once:
+// each one only ever adds its own new lines to the end, never touching (or
+// needing to know about) what any other session already wrote.
+export async function saveBunmshHistory(state, env = process.env, platform = process.platform) {
+  const path = bunmshHistoryPath(env, platform);
+  if (!path) throw new Error("cannot determine bunmsh history path");
+  mkdirSync(dirname(path), { recursive: true });
+  if (!state.historyMigrated) {
+    // One-time upgrade for a pre-existing legacy (JSON-array) file. Like the
+    // explicit dedupe below, this rewrites the whole file, so it carries the
+    // same small risk of racing another session's concurrent write — but it
+    // happens at most once per history file, ever.
+    const source = await readableText(path);
+    if (source !== null && isLegacyArrayFormat(source))
+      await writeHistoryFileAtomic(path, parseLegacyArrayFormat(source));
+    state.historyMigrated = true;
+  }
+  const saved = state.historySaved ?? 0;
+  const pending = (state.history ?? []).slice(saved).filter(safeHistoryEntry);
+  if (pending.length) await appendFile(path, encodeJsonlLines(pending));
+  state.historySaved = (state.history ?? []).length;
+  return path;
+}
+
+// The explicit, occasional maintenance path (`tab s d` / `tab save dedupe`):
+// rewrites the whole file with only the most recent occurrence of each
+// command kept. Unlike saveBunmshHistory, this can race a concurrent save
+// from another session — that's the trade-off for being able to shrink the
+// file at all, since dropping duplicates means looking at (and replacing)
+// entries this session didn't itself write. `raced` reports whether the
+// file's mtime/size changed while this ran, as a best-effort heads-up (not a
+// guarantee) that another session's write may have been overwritten by it.
+export async function dedupeBunmshHistory(state, env = process.env, platform = process.platform) {
+  // Flush this session's own pending entries through the safe path first, so
+  // the dedupe/rewrite below is never the reason they'd be lost.
+  const path = await saveBunmshHistory(state, env, platform);
+  const before = await statSafe(path);
+  const source = await readableText(path);
+  const deduped = dedupeEntries(source === null ? [] : parseBunmshHistoryContent(source));
+  const after = await statSafe(path);
+  const raced = Boolean(before && after &&
+    (before.mtimeMs !== after.mtimeMs || before.size !== after.size));
+  await writeHistoryFileAtomic(path, deduped);
+  return { path, raced, count: deduped.length };
+}
+
+export async function importedHistory(env = process.env, platform = process.platform) {
+  const home = env.HOME?.replace(/\/+$/, "");
+  const paths = [];
+  if (importEnabled(env) && home) paths.push(
+    { type: "bash", path: env.HISTFILE || `${home}/.bash_history` },
+    { type: "fish", path: `${home}/.local/share/fish/fish_history` },
+  );
+  const ownPath = bunmshHistoryPath(env, platform);
+  if (ownPath) paths.push({ type: "bunmsh", path: ownPath });
+  const history = [];
+  for (const item of paths) {
+    try {
+      const source = await readableText(item.path);
+      if (source === null) continue;
+      history.push(...(item.type === "fish" ? parseFishHistory(source) :
+        item.type === "bunmsh" ? parseBunmshHistoryContent(source) : parseBashHistory(source)));
+    } catch {}
+  }
+  // Keep the most recent occurrence, matching historyGhost's reverse lookup.
+  const seen = new Set();
+  const unique = [];
+  for (let index = history.length - 1; index >= 0; index--) {
+    if (seen.has(history[index])) continue;
+    seen.add(history[index]);
+    unique.push(history[index]);
+  }
+  return unique.reverse();
+}