bunmicro 0.9.10 → 0.9.19

package/src/platform/clipboard.js

@@ -6,14 +6,31 @@ const internalRegisters = new Map();
 export class ClipboardManager {
   constructor() {
     this.backend = detectClipboardBackend();
+    this._writeBackend = null;
+    this._altBackend = null;
+    this._readFromInternal = false;
   }
 
   methodName() {
+    return (this._writeBackend ?? this.backend).name;
+  }
+
+  readMethodName(register = "clipboard") {
+    if (register !== "clipboard" && register !== "primary") return "internal";
+    if (register === "clipboard" && this._readFromInternal) return "internal";
+    if (register === "primary" && !this.backend.supportsPrimary) return "internal";
     return this.backend.name;
   }
 
+  altMethodName() {
+    return this._altBackend?.name ?? null;
+  }
+
   fallbackToInternal() {
     this.backend = internalClipboard();
+    this._writeBackend = null;
+    this._altBackend = null;
+    this._readFromInternal = false;
     return this.backend;
   }
 
@@ -21,6 +38,13 @@ export class ClipboardManager {
     if (register !== "clipboard" && register !== "primary") {
       return internalRegisters.get(register) ?? "";
     }
+    if (register === "primary" && !this.backend.supportsPrimary) {
+      return internalRegisters.get(register) ?? "";
+    }
+    // terminal mode: paste from internal to avoid OSC 52 read issues over SSH
+    if (register === "clipboard" && this._readFromInternal) {
+      return internalRegisters.get(register) ?? "";
+    }
     try {
       const text = this.backend.read?.(register);
       if (text == null) return internalRegisters.get(register) ?? "";
@@ -33,15 +57,62 @@ export class ClipboardManager {
   write(text, register = "clipboard") {
     internalRegisters.set(register, text);
     if (register !== "clipboard" && register !== "primary") return true;
+    const wb = this._writeBackend ?? this.backend;
+    if (register === "primary" && !wb.supportsPrimary) return true;
     try {
-      const ok = this.backend.write?.(text, register) ?? true;
-      if (!ok) this.fallbackToInternal();
+      const ok = wb.write?.(text, register) ?? true;
+      if (!ok) {
+        if (wb === this._writeBackend) this._writeBackend = null;
+        else this.fallbackToInternal();
+      }
       return true;
     } catch {
-      this.fallbackToInternal();
+      if (wb === this._writeBackend) this._writeBackend = null;
+      else this.fallbackToInternal();
       return true;
     }
   }
+
+  writeAlt(text, register = "clipboard") {
+    if (!this._altBackend) return false;
+    internalRegisters.set(register, text);
+    try {
+      return this._altBackend.write?.(text, register) ?? true;
+    } catch {
+      return false;
+    }
+  }
+
+  async initFromSetting(setting, ttyIn, ttyOut, timeoutMs = 150) {
+    this.backend = detectClipboardBackend();
+    this._writeBackend = null;
+    this._altBackend = null;
+    this._readFromInternal = false;
+    if (setting === "internal") {
+      this.fallbackToInternal();
+      return;
+    }
+    if (setting === "terminal") {
+      // skip probe — directly enable OSC 52 write (handles write-only terminals)
+      if (ttyOut) {
+        this._altBackend = this.backend;   // external as clickable alt
+        this._writeBackend = osc52Clipboard(ttyOut);
+        this._readFromInternal = true;     // paste via internal (SSH-safe)
+      }
+    } else {
+      // "external" (default): probe OSC 52 as optional alt
+      if (ttyIn && ttyOut && process.stdout?.isTTY) {
+        const ok = await probeOSC52(ttyIn, ttyOut, timeoutMs);
+        if (ok) this._altBackend = osc52Clipboard(ttyOut);
+      }
+    }
+  }
+
+  // kept for backward compatibility (--version probe etc.)
+  async probeAndUpgradeOSC52(ttyIn, ttyOut, timeoutMs = 150) {
+    const ok = await probeOSC52(ttyIn, ttyOut, timeoutMs);
+    if (ok) this._writeBackend = osc52Clipboard(ttyOut);
+  }
 }
 
 function detectClipboardBackend() {
@@ -109,14 +180,24 @@ function termuxClipboard(set, get) {
 function wlClipboard(wlCopy, wlPaste) {
   return {
     name: "wl-clipboard",
-    read: () => outputOrThrow(runSync([wlPaste, "--no-newline"], { timeout: CLIPBOARD_TIMEOUT_MS })),
-    write: (text) => runSync([wlCopy], { stdin: text, stdout: "ignore", timeout: CLIPBOARD_TIMEOUT_MS }).ok,
+    supportsPrimary: true,
+    read: (register) => {
+      const args = [wlPaste, "--no-newline"];
+      if (register === "primary") args.push("--primary");
+      return outputOrThrow(runSync(args, { timeout: CLIPBOARD_TIMEOUT_MS }));
+    },
+    write: (text, register) => {
+      const args = [wlCopy];
+      if (register === "primary") args.push("--primary");
+      return runSync(args, { stdin: text, stdout: "ignore", timeout: CLIPBOARD_TIMEOUT_MS }).ok;
+    },
   };
 }
 
 function xclipClipboard(xclip) {
   return {
     name: "xclip",
+    supportsPrimary: true,
     read: (register) => {
       const selection = register === "primary" ? "primary" : "clipboard";
       return outputOrThrow(runSync([xclip, "-selection", selection, "-o"], { timeout: CLIPBOARD_TIMEOUT_MS }));
@@ -131,6 +212,7 @@ function xclipClipboard(xclip) {
 function xselClipboard(xsel) {
   return {
     name: "xsel",
+    supportsPrimary: true,
     read: (register) => {
       const selection = register === "primary" ? "--primary" : "--clipboard";
       return outputOrThrow(runSync([xsel, selection, "--output"], { timeout: CLIPBOARD_TIMEOUT_MS }));
@@ -146,8 +228,11 @@ function powershellClipboard(shell) {
   return {
     name: "powershell",
     // Get-Clipboard -Raw appends \r\n to stdout; strip exactly one trailing line ending.
-    read: () => outputOrThrow(runSync([shell, "-NoProfile", "-Command", "Get-Clipboard -Raw"], { timeout: CLIPBOARD_TIMEOUT_MS })).replace(/\r?\n$/, ""),
-    write: (text) => runSync([shell, "-NoProfile", "-Command", "Set-Clipboard"], { stdin: text, stdout: "ignore", timeout: CLIPBOARD_TIMEOUT_MS }).ok,
+    read: () => outputOrThrow(runSync([shell, "-NoProfile", "-Command", "Get-Clipboard -Raw"], {})).replace(/\r?\n$/, ""),
+    write: (text) => {
+      text=(text+'').replaceAll("'","''") ;
+      return runSync([shell, "-NoProfile", "-Command", `Set-Clipboard '${text}'`], { stdout: "ignore" }).ok ;
+    },
   };
 }
 
@@ -155,3 +240,36 @@ function outputOrThrow(result) {
   if (!result.ok) throw new Error(result.stderr || result.stdout || "clipboard command failed");
   return result.stdout;
 }
+
+export function osc52Clipboard(stdout) {
+  const inTmux = !!process.env.TMUX;
+  return {
+    name: "OSC 52",
+    write(text) {
+      const b64 = Buffer.from(text, "utf-8").toString("base64");
+      stdout.write(inTmux
+        ? `\x1bPtmux;\x1b\x1b]52;c;${b64}\x07\x1b\\`
+        : `\x1b]52;c;${b64}\x07`);
+      return true;
+    },
+  };
+}
+
+export async function probeOSC52(ttyIn, ttyOut, timeoutMs) {
+  if (process.env.TMUX) return true;
+  return new Promise((resolve) => {
+    let done = false;
+    const timer = setTimeout(() => {
+      if (!done) { done = true; ttyIn.removeListener("data", onData); resolve(false); }
+    }, timeoutMs);
+    function onData(chunk) {
+      if (done) return;
+      const s = Buffer.isBuffer(chunk) ? chunk.toString("latin1") : String(chunk);
+      if (s.includes("\x1b]52;")) {
+        done = true; clearTimeout(timer); ttyIn.removeListener("data", onData); resolve(true);
+      }
+    }
+    ttyIn.on("data", onData);
+    ttyOut.write("\x1b]52;c;?\x07");
+  });
+}

package/src/plugins/js-bridge.js

@@ -51,8 +51,8 @@ function registerBuiltinActions() {
   reg("CursorEnd",             (app) => { app.pane && (app.pane.selection = null); app.buffer?.moveEndOfBuffer();   app.scrollCursorToBoundary?.(app.pane, "end");   });
   reg("ParagraphPrevious",     (app) => { app.pane && (app.pane.selection = null); app.buffer?.paragraphPrevious(); });
   reg("ParagraphNext",         (app) => { app.pane && (app.pane.selection = null); app.buffer?.paragraphNext(); });
-  reg("PageUp",                (app) => { app.pane && (app.pane.selection = null); app.buffer?.page(-1, app.pane?.h ?? 24); });
-  reg("PageDown",              (app) => { app.pane && (app.pane.selection = null); app.buffer?.page(1,  app.pane?.h ?? 24); });
+  reg("PageUp",                (app) => { app.pane && (app.pane.selection = null); app.pageScroll?.(app.pane, -1); });
+  reg("PageDown",              (app) => { app.pane && (app.pane.selection = null); app.pageScroll?.(app.pane, 1); });
 
   // Selection — extend
   reg("SelectUp",              (app) => _actExtendSel(app, (buf) => buf._moveUpVisual?.() ?? buf.moveUp?.()));
@@ -67,8 +67,8 @@ function registerBuiltinActions() {
   reg("SelectToEndOfLine",     (app) => _actExtendSel(app, (buf) => buf.moveEnd?.()));
   reg("SelectToStart",         (app) => _actExtendSel(app, (buf) => buf.moveStartOfBuffer?.()));
   reg("SelectToEnd",           (app) => _actExtendSel(app, (buf) => buf.moveEndOfBuffer?.()));
-  reg("SelectPageUp",          (app) => _actExtendSel(app, (buf) => buf.page?.(-1, app.pane?.h ?? 24)));
-  reg("SelectPageDown",        (app) => _actExtendSel(app, (buf) => buf.page?.(1, app.pane?.h ?? 24)));
+  reg("SelectPageUp",          (app) => app.cursorPage?.(app.pane, -1, { select: true }));
+  reg("SelectPageDown",        (app) => app.cursorPage?.(app.pane, 1, { select: true }));
   reg("SelectToParagraphPrevious", (app) => _actExtendSel(app, (buf) => buf.paragraphPrevious?.()));
   reg("SelectToParagraphNext",     (app) => _actExtendSel(app, (buf) => buf.paragraphNext?.()));
 
@@ -298,10 +298,10 @@ function registerBuiltinActions() {
   reg("End",   (app) => { app.pane && (app.pane.selection = null); app.buffer?._lastVisX != null && (app.buffer._lastVisX = null); app.buffer?.moveEndOfBuffer();   app.scrollCursorToBoundary?.(app.pane, "end");   });
 
   // Page aliases
-  reg("CursorPageUp",    (app) => { app.pane && (app.pane.selection = null); app.buffer?.page?.(-1, app.pane?.h ?? 24); });
-  reg("CursorPageDown",  (app) => { app.pane && (app.pane.selection = null); app.buffer?.page?.(1,  app.pane?.h ?? 24); });
-  reg("HalfPageUp",      (app) => { app.pane && (app.pane.selection = null); app.buffer?.page?.(-1, Math.max(1, Math.floor((app.pane?.h ?? 24) / 2))); });
-  reg("HalfPageDown",    (app) => { app.pane && (app.pane.selection = null); app.buffer?.page?.(1,  Math.max(1, Math.floor((app.pane?.h ?? 24) / 2))); });
+  reg("CursorPageUp",    (app) => app.cursorPage?.(app.pane, -1));
+  reg("CursorPageDown",  (app) => app.cursorPage?.(app.pane, 1));
+  reg("HalfPageUp",      (app) => app.cursorPage?.(app.pane, -1, { amount: Math.max(1, Math.floor((app.pane?.h ?? 24) / 2)) }));
+  reg("HalfPageDown",    (app) => app.cursorPage?.(app.pane, 1, { amount: Math.max(1, Math.floor((app.pane?.h ?? 24) / 2)) }));
 
   // Cursor-to-view-boundary
   reg("CursorToViewTop", (app) => {
@@ -857,6 +857,8 @@ function _makePaneAPI(buffer, app) {
   return {
     get Buf()    { return _makeBufAPI(buffer); },
     get Cursor() { return _makeCursorAPI(buffer); },
+    CursorLocation: () => app?.formatCursorLocation?.(buffer) ?? "+1.0:1",
+    AbsoluteCursorLocation: () => app?.formatAbsoluteCursorLocation?.(buffer) ?? "+1:1",
 
     Save:        async () => app?.save?.(),
     Quit:        async () => app?.quit?.(),

package/todo.txt

@@ -283,11 +283,15 @@ Clipboard / platform integration
     Remaining: real platform verification for wl-copy/wl-paste, xclip, xsel.
 [ ] Verify Android behavior only when process.platform reports android; Linux must not use Termux clipboard commands.
 [ ] Verify macOS pbcopy/pbpaste and Windows PowerShell Set-Clipboard/Get-Clipboard.
-[ ] Implement terminal OSC 52 clipboard method.
-[ ] Implement primary selection behavior for Linux where applicable.
+[~] Implement terminal OSC 52 clipboard method.
+    Done: osc52Clipboard backend + probeOSC52 exported from clipboard.js; App.start() probes on startup (150ms, before main data handler), upgrades _writeBackend if supported; tmux $TMUX env skips probe and uses DCS passthrough format; --version probes last and prints Clipboard: result after other fields.
+    Remaining: OSC 52 read (async response handling for Ctrl+V from system clipboard via escape sequence).
+[~] Implement primary selection behavior for Linux where applicable.
+    Done: wlClipboard read/write now pass --primary flag when register==="primary"; _syncPrimarySelection() called at end of every _dispatchInput event loop (keyboard+shift+arrows+alt-s+ctrl-a+mouse drag/double-click/gutter); middle mouse button click moves cursor to click position and pastes primary register.
+    Remaining: real platform testing; primary selection for macOS (no direct equivalent); wl-clipboard backend primary verification.
 [~] Implement internal multi-register clipboard and multi-cursor clipboard parity.
     Done: internal register map exists and is used as fallback; Ctrl-C/Ctrl-X/Ctrl-V/Ctrl-Y handle current selection and line copy/cut/paste.
-    Remaining: Go micro multi-register semantics, primary selection parity, multi-cursor clipboard behavior.
+    Remaining: Go micro multi-register semantics, multi-cursor clipboard behavior.
 
 Shell / jobs / terminal pane
 ----------------------------