bunmicro 0.9.23 → 0.9.30

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [0.9.30] - 2026-06-13
+- Fixed binary edit hex3 regression
+  * see readme
+- Added crash backup recovery
+
+## [0.9.25] - 2026-06-10
+- Fixed colorscheme: aligned with go
+- Added colorcolumn taberror showchars
+  * e.g. showchars = tab=>,space=.
+- linter underline
+- set hltrailingws on : whitespace
+- Added tests/pty-demo.js
+  * Demo of the whole bunmicro App
+  * bun tests/pty-demo.js
+
 ## [0.9.23] - 2026-06-10
 - Fixed mouse close prompt cursor move
 - Fixed set filetype doesn't apply instantly

package/README.md

@@ -35,6 +35,16 @@
 - Works like bat ccat glow
 - bunmicro -bat file
 - aliases: --cat --bat --ccat --glow
+## Binary edit by hex3
+- Edit binary files like text files
+- bunmicro libc.so.6
+- Ctrl+E reopen hex3
+- Printable chars stay readable
+  * a => a..
+- Non-printable chars become escapes
+  * \xff => \ff
+- Search & Edit by plain text
+- And simply save by Ctrl+S
 ## Preview color schemes(theme)
 - Ctrl-E theme, then press Tab and use arrow keys to preview
 ## Mouse clicks more useful

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunmicro",
-  "version": "0.9.23",
+  "version": "0.9.30",
   "description": "Bun JavaScript rewrite of the micro editor originally in Golang",
   "type": "module",
   "main": "./src/index.js",
@@ -10,7 +10,8 @@
   },
   "scripts": {
     "start": "bun ./src/index.js",
-    "check": "node --check ./src/index.js"
+    "check": "node --check ./src/index.js",
+    "demo:pty": "bun ./tests/pty-demo.js"
   },
   "dependencies": {
     "wasmoon": "^1.16.0"

package/src/buffer/backup.js

@@ -0,0 +1,160 @@
+// Crash recovery backup system compatible with Go micro's internal/buffer/backup.go.
+
+import { join } from "node:path";
+import { existsSync, statSync, unlinkSync } from "node:fs";
+import { mkdir, writeFile, readFile, rename } from "node:fs/promises";
+import { homedir } from "node:os";
+import { createHash } from "node:crypto";
+
+export const BACKUP_SUFFIX = ".micro-backup";
+
+export function getBackupDir(buf, configDir) {
+  const raw = String(buf?.Settings?.backupdir ?? "");
+  if (!raw) return join(configDir, "backups");
+  if (raw === "~" || raw.startsWith("~/") || raw.startsWith("~\\")) {
+    return raw.replace(/^~/, homedir());
+  }
+  // Node has no portable equivalent of Go's user.Lookup for ~otheruser.
+  if (raw.startsWith("~")) return join(configDir, "backups");
+  return raw;
+}
+
+function queryEscapePath(path) {
+  return encodeURIComponent(String(path).replaceAll("\\", "/"))
+    .replace(/[!'()*]/g, (ch) => `%${ch.charCodeAt(0).toString(16).toUpperCase()}`)
+    .replace(/%20/g, "+"); 
+} // '
+
+function legacyEscapePath(path) {
+  let escaped = String(path).replaceAll("\\", "/");
+  if (process.platform === "win32") escaped = escaped.replaceAll(":", "%");
+  return escaped.replaceAll("/", "%");
+}
+
+export function determineBackupPath(backupDirPath, absPath) {
+  const urlName = join(backupDirPath, queryEscapePath(absPath));
+  if (existsSync(urlName)) return { name: urlName, resolveName: null };
+
+  const legacyName = join(backupDirPath, legacyEscapePath(absPath));
+  if (existsSync(legacyName)) return { name: legacyName, resolveName: null };
+
+  if (Buffer.byteLength(urlName + BACKUP_SUFFIX) > 255) {
+    const hash = createHash("md5").update(absPath).digest("hex");
+    return {
+      name: join(backupDirPath, hash),
+      resolveName: join(backupDirPath, hash + ".path"),
+    };
+  }
+  return { name: urlName, resolveName: null };
+}
+
+export async function writeBackup(buf, configDir, path = buf?.AbsPath ?? buf?.path, { force = false } = {}) {
+  if ((!force && !buf?.Settings?.backup) || !path || buf.type !== "default") return false;
+  const dir = getBackupDir(buf, configDir);
+  await mkdir(dir, { recursive: true });
+  const { name, resolveName } = determineBackupPath(dir, path);
+  const tmp = name + BACKUP_SUFFIX;
+  try {
+    await writeFile(tmp, buf.lines.join("\n"), "utf8");
+    await rename(tmp, name);
+    if (resolveName) await writeFile(resolveName, path, "utf8");
+    return true;
+  } catch (error) {
+    try { unlinkSync(tmp); } catch {}
+    throw error;
+  }
+}
+
+export function removeBackup(buf, configDir, path = buf?.AbsPath ?? buf?.path) {
+  if (buf?.Settings?.permbackup || buf?._forceKeepBackup) return;
+  if (!path || buf.type !== "default") return;
+  const dir = getBackupDir(buf, configDir);
+  const { name, resolveName } = determineBackupPath(dir, path);
+  try { unlinkSync(name); } catch {}
+  if (resolveName) try { unlinkSync(resolveName); } catch {}
+}
+
+// promptFn(msg) -> Promise<string>
+// Returns { recovered: bool, abort: bool }
+export async function applyBackup(buf, configDir, promptFn) {
+  if (!buf?.Settings?.backup || buf?.Settings?.permbackup) return { recovered: false, abort: false };
+  if (!buf.path || buf.type !== "default") return { recovered: false, abort: false };
+
+  const dir = getBackupDir(buf, configDir);
+  const { name: backupFile, resolveName } = determineBackupPath(dir, buf.AbsPath ?? buf.path);
+  if (!existsSync(backupFile)) return { recovered: false, abort: false };
+
+  let info;
+  try { info = statSync(backupFile); } catch { return { recovered: false, abort: false }; }
+
+  const t = info.mtime;
+  const dateStr =
+    t.toLocaleDateString("en-US", { weekday: "short", month: "short", day: "numeric" }) +
+    " at " +
+    t.toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit", hour12: false }) +
+    ", " + t.getFullYear();
+
+  const ticcc='```';
+
+  const msg = `
+# Backup detected! ⚠️
+- File path/url:
+${ticcc}
+${buf.path}
+${ticcc}
+- either micro crashed
+- or another micro is running
+- or an error occurred while saving
+- The file may be corrupted
+# Date of backup 🕰
+- ${dateStr}
+# Path of backup 
+${ticcc}
+${backupFile}
+${ticcc}
+# Recovery options
+## r = 'recover'
+- Apply the backup 
+- as unsaved changes to the current buffer
+- When the buffer is closed, the backup will be removed.
+## i = 'ignore'
+- Ignore & remove the backup
+## a = 'abort' 
+- Abort the open operation
+- Open an empty buffer
+- Keep the backup
+### Your choice
+- [r]ecover, [i]gnore, [a]bort
+`;
+
+  const options = ["r", "i", "a", "recover", "ignore", "abort"];
+  let choice = -1;
+  let prompt = msg;
+  while (choice === -1) {
+    const resp = await promptFn(prompt);
+    const idx = options.indexOf(resp.trim().toLowerCase());
+    if (idx !== -1) choice = idx % 3;
+    else prompt = "\n#### Invalid choice!";
+  }
+
+  if (choice === 0) {
+    try {
+      const text = await readFile(backupFile, "utf8");
+      buf.lines = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+      if (!buf.lines.length) buf.lines = [""];
+      buf._recovered = true;
+      buf._savedSerial = -1;
+      buf.setModified?.(true);
+      if (!buf.setModified) buf.modified = true;
+      return { recovered: true, abort: false };
+    } catch {
+      return { recovered: false, abort: false };
+    }
+  }
+  if (choice === 1) {
+    try { unlinkSync(backupFile); } catch {}
+    if (resolveName) try { unlinkSync(resolveName); } catch {}
+    return { recovered: false, abort: false };
+  }
+  return { recovered: false, abort: true };
+}

package/src/config/colorscheme.js

@@ -7,17 +7,6 @@ export const DEFAULT_STYLE = {
   underline: false,
 };
 
-// Built-in fallback styles for color groups not defined in a colorscheme.
-// Matches Go micro's default group colours.
-const BUILTIN_GROUPS = {
-  "diff-added":    { ...DEFAULT_STYLE, fg: "green" },
-  "diff-modified": { ...DEFAULT_STYLE, fg: "yellow" },
-  "diff-deleted":  { ...DEFAULT_STYLE, fg: "red" },
-  "gutter-error":  { ...DEFAULT_STYLE, fg: "red" },
-  "gutter-warning":{ ...DEFAULT_STYLE, fg: "yellow" },
-  "gutter-info":   { ...DEFAULT_STYLE, fg: "brightblue" },
-};
-
 const COLOR_LINK = /color-link\s+(\S*)\s+"(.*)"/;
 const INCLUDE = /include\s+"(.*)"/;
 
@@ -47,10 +36,11 @@ export class Colorscheme {
       if (include) {
         const includeName = include[1];
         if (!parsed.has(includeName)) {
-          const child = new Colorscheme(this.runtime);
-          await child.load(includeName, parsed);
-          for (const [key, value] of child.styles) styles.set(key, value);
-          if (child.styles.has("default")) this.defaultStyle = child.styles.get("default");
+          const file = this.runtime.find(0, includeName);
+          if (!file) throw new Error(`${includeName} is not a valid colorscheme`);
+          parsed.add(includeName);
+          const includedStyles = await this.parse(includeName, await file.text(), parsed);
+          for (const [key, value] of includedStyles) styles.set(key, value);
         }
         continue;
       }
@@ -76,7 +66,7 @@ export class Colorscheme {
         if (this.styles.has(cur)) style = this.styles.get(cur);
       }
     }
-    return style ?? BUILTIN_GROUPS[group] ?? stringToStyle(group, this.defaultStyle);
+    return style ?? stringToStyle(group, this.defaultStyle);
   }
 }
 
@@ -87,10 +77,10 @@ export function stringToStyle(input, base = DEFAULT_STYLE) {
   return {
     fg: stringToColor(fgRaw.trim(), base.fg),
     bg: stringToColor(bgRaw.trim(), base.bg),
-    bold: text.includes("bold"),
-    italic: text.includes("italic"),
-    reverse: text.includes("reverse"),
-    underline: text.includes("underline"),
+    bold: base.bold || text.includes("bold"),
+    italic: base.italic || text.includes("italic"),
+    reverse: base.reverse || text.includes("reverse"),
+    underline: base.underline || text.includes("underline"),
   };
 }