bunmicro 0.9.25 → 1.0.0

package/runtime/jsplugins/cdp/cdp.js

@@ -0,0 +1,192 @@
+// No imports needed: `micro` is available as a global.
+
+/*
+
+# JS Plugin Documentation
+
+Available hooks (register with micro.on(hookName, fn)):
+
+  Lifecycle (no args):
+    "preinit"           — before plugins load
+    "init"              — main plugin setup, register commands/actions here
+    "postinit"          — after all plugins loaded
+
+  Buffer events:
+    "onBufferOpen"  (buffer)      — buffer opened (raw BufferModel, not pane adapter)
+    "onBufferClose" (buffer)      — buffer closed (raw BufferModel)
+    "onSetActive"   (bp)          — pane became active (tab switch, close, etc.)
+    "onSave"        (bp)          — buffer saved
+
+  Input events:
+    "onRune"           (bp, ch)   — printable character inserted (ch is the string)
+
+  Cancellable hooks (return false to cancel the action):
+    "preBackspace"     (bp)       — before backspace; return false to block
+    "preInsertNewline" (bp)       — before Enter/newline; return false to block
+
+bp is a pane adapter with:
+  bp.Buf.Line(n)  bp.Buf.LinesNum()  bp.Buf.FileType()
+  bp.Buf.Insert(loc, text)  bp.Buf.Replace(s, e, text)
+  bp.Cursor.X  bp.Cursor.Y  bp.Cursor.Loc  bp.Cursor.HasSelection()
+  bp.Save()  bp.Backspace()  bp.CursorLeft/Right()  bp.InsertNewline()
+
+Flat buffer helpers (all 1-based line numbers, omit → cursor line):
+  micro.getLine(n?)            micro.putLine(text, n?)     micro.delLine(n?)
+  micro.getLines(from?, to?)   micro.getLinesCount()
+  micro.getAllText()           — entire buffer as one string (lines joined by "\n")
+  micro.putAllText(text)       — replace entire buffer content; pushes undo
+  micro.getSelection()         micro.putSelection(text)
+
+Other micro APIs:
+  micro.CurPane()              — returns pane adapter for active pane
+  micro.MakeCommand(name, fn)  — register Ctrl+E command; fn(bp, args[])
+                                 args.raw = full original input string (bypass shellSplit)
+                                 e.g. for command "js 1+1": args.raw = "js 1+1", args.raw.slice(3) = "1+1"
+  micro.RegisterAction(name, fn) — register bindable action
+  micro.TermMessage(msg)       — show msg in editor status row
+  micro.alert(msg)             — suspend editor, print msg, wait for Enter
+  micro.Log(...args)           — console.log passthrough
+  micro.GetOption(name)        micro.SetOption(name, value)
+  micro.cmd.save()             — call any editor command via proxy
+  micro.action.CursorUp()      — run any registered action via proxy
+  micro.shell.CMD(...args)     — run CMD interactively (same as Ctrl-B); async
+                                 e.g. await micro.shell.ls('-l')
+                                      await micro.shell.git('diff', '--stat')
+
+*/
+
+micro.on("init", () => {
+  // Register a custom Ctrl+E command
+  micro.MakeCommand("cdp", async (bp, args) =>
+  {
+    const addrFlag = args.find(a => a.startsWith("--address="))?.slice("--address=".length);
+    const isPublic = args.includes("--public");
+    const port = parseInt(args.find(a => /^\d+$/.test(a))) || parseInt(Bun.env.CDP_PORT) || 9222;
+    const hostname = addrFlag ?? (isPublic ? "0.0.0.0" : "127.0.0.1");
+    const path = bp?.Buf?.Path || "(no path)";
+    
+    if(!micro.cdpContext)
+    {
+      micro.cdpContext={
+        title(){
+          return path;
+        },
+        async evaluate(txt){
+          return await eval(txt);
+        },
+        async navigate(url){
+          await micro.cmd.open('-f', url);
+        },
+        async click(x,y,opt){
+          x=x||1 ; y=y||1 ;
+          await micro.cmd.goto(y+':'+x);
+        },
+        async scroll(dx,dy){
+          const pane = micro.CurPane();
+          if (!pane) return;
+
+          dx = toInteger(dx);
+          dy = toInteger(dy);
+
+          const line = Math.max(1, pane.Cursor.Y + dy + 1);
+          const column = Math.max(1, pane.Cursor.X + dx + 1);
+          await micro.cmd.goto(`${line}:${column}`);
+        },
+        async scrollTo(selector){
+          const pattern = selectorToSearchPattern(selector);
+          await micro.cmd.find(pattern);
+        },
+        goBack(){
+          micro.action.PrevTab();
+        },
+        goForward(){
+          micro.action.NextTab();
+        },
+        async type(text){
+          const bp = micro.CurPane();
+          if (!bp) return;
+          bp.Insert(text);
+        },
+        async press(key, options){
+          const bp = micro.CurPane();
+          if (!bp) return;
+
+          // modifiers bitmask: Alt=1, Ctrl=2, Meta=4, Shift=8
+          const mod = options?.modifiers ?? 0;
+          const ctrl  = !!(mod & 2);
+          const shift = !!(mod & 8);
+
+          if (ctrl) {
+            const ctrlMap = {
+              a: () => micro.action.SelectAll(),
+              c: () => micro.action.Copy(),
+              x: () => micro.action.Cut(),
+              v: () => micro.action.Paste(),
+              z: () => micro.action.Undo(),
+              y: () => micro.action.Redo(),
+              s: () => micro.action.Save(),
+            };
+            const h = ctrlMap[key.toLowerCase()];
+            if (h) await h();
+            return;
+          }
+
+          const arrowAction = shift
+            ? { ArrowUp: 'SelectUp', ArrowDown: 'SelectDown', ArrowLeft: 'SelectLeft', ArrowRight: 'SelectRight' }
+            : { ArrowUp: 'CursorUp', ArrowDown: 'CursorDown', ArrowLeft: 'CursorLeft', ArrowRight: 'CursorRight' };
+
+          const keyMap = {
+            ...arrowAction,
+            Enter:     () => micro.action.InsertNewline(),
+            Backspace: () => micro.action.Backspace(),
+            Delete:    () => micro.action.Delete(),
+            Tab:       () => micro.action.InsertTab(),
+            Escape:    () => micro.action.Escape(),
+            Home:      () => shift ? micro.action.SelectToStartOfLine() : micro.action.StartOfLine(),
+            End:       () => shift ? micro.action.SelectToEndOfLine()   : micro.action.EndOfLine(),
+            PageUp:    () => shift ? micro.action.SelectPageUp()        : micro.action.CursorPageUp(),
+            PageDown:  () => shift ? micro.action.SelectPageDown()      : micro.action.CursorPageDown(),
+          };
+
+          const entry = keyMap[key];
+          if (typeof entry === 'string') {
+            await micro.action[entry]();
+          } else if (typeof entry === 'function') {
+            await entry();
+          } else if (key.length === 1) {
+            bp.Insert(key);
+          }
+        },
+      }
+    
+      let {CdpServer}=await import('./cdp-server.js');
+      
+      micro.cdpPort = port;
+      CdpServer
+        .create(micro.cdpContext)
+        .listen(port, hostname);
+
+      const addr = isPublic ? `0.0.0.0:${port}` : `127.0.0.1:${port}`;
+      micro.TermMessage(`CDP@${addr} server running 伺服器啟動了`)
+
+      //await micro.alert(CdpServer)
+    }  //  server not running
+    else
+    {
+      micro.TermMessage(`CDP@${micro.cdpPort} already running a server 已有伺服器啟動`)
+    }
+
+    
+  });
+  
+})
+
+function selectorToSearchPattern(selector) {
+  const value = String(selector ?? "");
+  return value.startsWith("#") ? value.slice(1) : value;
+}
+
+function toInteger(value) {
+  const number = Number(value);
+  return Number.isFinite(number) ? Math.trunc(number) : 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 };
+}