buninu 0.4.12 → 0.4.13

package/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/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/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/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/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/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)) {

package/apps/bunmsh/src/mouse.js

@@ -21,7 +21,13 @@ function partialMarkerSuffixLength(text, marker) {
   return 0;
 }
 
-export function mouseInput(onMouse, onCursorPosition, onShortcut = () => {}, onPaste = () => {}) {
+export function mouseInput(
+  onMouse,
+  onCursorPosition,
+  onShortcut = () => {},
+  onPaste = () => {},
+  onEditShortcut = () => {},
+) {
   const decoder = new StringDecoder("utf8");
   let pending = "";
   // Bracketed paste (\x1b[200~ ... \x1b[201~): everything between the
@@ -48,6 +54,25 @@ export function mouseInput(onMouse, onCursorPosition, onShortcut = () => {}, onP
         source = source.replace(/\x1bc/g, () => { onShortcut("tab-close"); return ""; });
       }
       let output = "";
+      const flushOutput = () => {
+        if (!output) return;
+        this.push(output);
+        output = "";
+      };
+      const appendPlainText = (text) => {
+        let start = 0;
+        for (let index = 0; index < text.length; index++) {
+          const side = text[index] === "\x15" ? "head"
+            : text[index] === "\x0b" ? "tail"
+            : null;
+          if (!side) continue;
+          output += text.slice(start, index);
+          flushOutput();
+          onEditShortcut(side);
+          start = index + 1;
+        }
+        output += text.slice(start);
+      };
       while (source) {
         if (pasting) {
           const end = source.indexOf(PASTE_END);
@@ -66,8 +91,8 @@ export function mouseInput(onMouse, onCursorPosition, onShortcut = () => {}, onP
           continue;
         }
         const escape = source.indexOf("\x1b[");
-        if (escape < 0) { output += source; break; }
-        output += source.slice(0, escape);
+        if (escape < 0) { appendPlainText(source); break; }
+        appendPlainText(source.slice(0, escape));
         source = source.slice(escape);
         if (source.startsWith(PASTE_START)) {
           pasting = true;
@@ -93,7 +118,7 @@ export function mouseInput(onMouse, onCursorPosition, onShortcut = () => {}, onP
         output += source.slice(0, 2);
         source = source.slice(2);
       }
-      if (output) this.push(output);
+      flushOutput();
       done();
     },
   });

package/apps/bunmsh/src/shell.js

@@ -787,7 +787,15 @@ async function pathnameFields(field, state) {
     return ch;
   }).join("");
   const glob = new Bun.Glob(pattern);
-  const matches = [...glob.scanSync({ cwd: state.cwd, dot: false, onlyFiles: false })].sort();
+  // Shell pathname expansion follows a directory symlink used as an
+  // intermediate path component. Bun.Glob defaults this off, which makes
+  // patterns such as /sys/class/*/device silently miss sysfs class links.
+  const matches = [...glob.scanSync({
+    cwd: state.cwd,
+    dot: false,
+    onlyFiles: false,
+    followSymlinks: true,
+  })].sort();
   return matches.length ? matches : [value];
 }
 

package/apps/bunmsh/test/shell1.test.js

@@ -53,6 +53,7 @@ import { fancyLs } from "../src/fancy-ls.js";
 import { MOUSE_OFF, MOUSE_ON, mouseInput } from "../src/mouse.js";
 import { canonicalEnvironment, environmentValue, homeRelativePath } from "../src/environment.js";
 import { findIsRegularBuiltin } from "../src/find.js";
+import { toggleSavedText } from "../src/line-edit.js";
 
 async function run(source, options = {}) {
   const state = createState({
@@ -181,6 +182,36 @@ describe("completion", () => {
     ]);
   });
 
+  test("toggles independently saved Ctrl-U heads and Ctrl-K tails", () => {
+    const cutHead = toggleSavedText("headtail", 4, "", "head");
+    expect(cutHead).toEqual({ line: "tail", cursor: 0, saved: "head", changed: true });
+    expect(toggleSavedText(cutHead.line, cutHead.cursor, cutHead.saved, "head"))
+      .toEqual({ line: "headtail", cursor: 4, saved: "", changed: true });
+
+    const cutTail = toggleSavedText("headtail", 4, "", "tail");
+    expect(cutTail).toEqual({ line: "head", cursor: 4, saved: "tail", changed: true });
+    expect(toggleSavedText(cutTail.line, cutTail.cursor, cutTail.saved, "tail"))
+      .toEqual({ line: "headtail", cursor: 4, saved: "", changed: true });
+  });
+
+  test("intercepts Ctrl-U and Ctrl-K outside bracketed paste", async () => {
+    const edits = [];
+    const pasted = [];
+    let forwarded = "";
+    const input = mouseInput(() => {}, () => {}, () => {},
+      (text) => pasted.push(text),
+      (side) => edits.push({ side, forwarded }));
+    input.on("data", (chunk) => { forwarded += chunk.toString(); });
+    input.end("abc\x15def\x0b\x1b[200~x\x15y\x0bz\x1b[201~");
+    await new Promise((resolve) => input.once("end", resolve));
+    expect(edits).toEqual([
+      { side: "head", forwarded: "abc" },
+      { side: "tail", forwarded: "abcdef" },
+    ]);
+    expect(forwarded).toBe("abcdef");
+    expect(pasted).toEqual(["x\x15y\x0bz"]);
+  });
+
   test("imports Bash and Fish history by default and can be disabled", async () => {
     expect(parseBashHistory("#1720000000\necho bash\n\nshared\n"))
       .toEqual(["echo bash", "shared"]);
@@ -575,6 +606,7 @@ describe("execution", () => {
       mkdirSync(join(cwd, "targetdir"));
       symlinkSync("target.txt", join(cwd, "link_ok"));
       symlinkSync("targetdir", join(cwd, "link_dir"));
+      await Bun.write(join(cwd, "targetdir", "inside.js"), "export {};\n");
       symlinkSync("/nonexistent/path", join(cwd, "link_broken"));
       symlinkSync("loop_b", join(cwd, "loop_a"));
       symlinkSync("loop_a", join(cwd, "loop_b"));
@@ -597,6 +629,15 @@ describe("execution", () => {
       const plain = await run("builtin lsfancy", { cwd });
       expect(plain.stdout).toContain("🔗 link_ok");
       expect(plain.stdout).toContain("🚫 link_broken");
+
+      // A command-line link to a directory is followed for an ordinary
+      // listing, but -l, -d, and -F inspect/classify the link itself.
+      const followed = await run("builtin lsfancy link_dir", { cwd });
+      expect(followed.stdout).toContain("inside.js");
+      const linkLong = await run("builtin lsfancy -l link_dir", { cwd });
+      expect(linkLong.stdout).toContain("link_dir -> targetdir");
+      expect((await run("builtin lsfancy -d link_dir", { cwd })).stdout).toContain("🔗 link_dir");
+      expect((await run("builtin lsfancy -F link_dir", { cwd })).stdout).toContain("link_dir@");
     } finally { rmSync(cwd, { recursive: true, force: true }); }
   });
 
@@ -624,6 +665,35 @@ describe("execution", () => {
     } finally { rmSync(cwd, { recursive: true, force: true }); }
   });
 
+  test("builtin ls lists glob-expanded files as files, not directory sections", async () => {
+    const cwd = mkdtempSync(join(tmpdir(), "bunmsh-ls-glob-"));
+    try {
+      await Bun.write(join(cwd, "first.sh"), "#!/bin/sh\n");
+      await Bun.write(join(cwd, "final.sh"), "#!/bin/sh\n");
+      await Bun.write(join(cwd, "other.txt"), "other\n");
+      const output = await run("builtin ls f*.sh", { cwd });
+      expect(output).toMatchObject({ status: 0, stderr: "" });
+      expect(output.stdout).toContain("first.sh");
+      expect(output.stdout).toContain("final.sh");
+      expect(output.stdout).not.toContain("other.txt");
+      expect(output.stdout).not.toContain("first.sh:");
+      expect(output.stdout).not.toContain("final.sh:");
+      expect(output.stdout).not.toContain("\n\n");
+
+      await Bun.write(join(cwd, "-odd"), "odd\n");
+      const afterDoubleDash = await run("builtin ls -- -odd", { cwd });
+      expect(afterDoubleDash).toMatchObject({ status: 0, stderr: "" });
+      expect(afterDoubleDash.stdout).toContain("-odd");
+
+      mkdirSync(join(cwd, ".hidden-target"));
+      await Bun.write(join(cwd, ".hidden-target", "through-link.js"), "export {};\n");
+      symlinkSync(".hidden-target", join(cwd, "class-link"));
+      const throughLink = await run("builtin ls ./*/*.js", { cwd });
+      expect(throughLink).toMatchObject({ status: 0, stderr: "" });
+      expect(throughLink.stdout).toContain("./class-link/through-link.js");
+    } finally { rmSync(cwd, { recursive: true, force: true }); }
+  });
+
   test("fallback find filters paths and supports both -exec modes", async () => {
     const cwd = mkdtempSync(join(tmpdir(), "bunmsh-find-"));
     try {

package/apps/jsmdcui/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable user-visible changes to jsmdcui are documented here.
 
+## [0.19.2] - 2026-09-21
+
+### Added
+
+- Quickly pressing `Ctrl-W` twice now switches to the next tab like `Alt-T`
+  from either an editor or terminal pane. A single press retains its existing
+  next-pane behavior. At the rightmost tab, when every tab contains only
+  terminal panes, the double press creates a new editor tab instead of cycling
+  back, ensuring keyboard-only access to editing and other non-terminal work.
+
 ## [0.19.0] - 2026-08-24
 
 ### Fixed

package/apps/jsmdcui/README.md

@@ -793,6 +793,8 @@ selection, search, and copy remain available.
 | `Ctrl-F` | Search; use `Ctrl-N` and `Ctrl-P` for the next and previous match. |
 | `Ctrl-G` | Open the editor help. |
 | `Alt-G` | Show or hide the shortcut bar. |
+| `Ctrl-W` | Switch to the next pane in the current tab. |
+| `Ctrl-W` twice quickly | Switch to the next tab like `Alt-T`. At the rightmost tab, if every tab contains only terminal panes, create a new editor tab instead of cycling back. |
 | `Ctrl-Q` or `Alt-Q` | Close the current UI. |
 
 To preview another color theme, press `Ctrl-E` or click on `€`, type `theme `, then use `Tab`

package/apps/jsmdcui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsmdcui",
-  "version": "0.19.1",
+  "version": "0.19.2",
   "description": "Markdown as a Common UI for Terminals and Web Browsers",
   "type": "module",
   "main": "./src/index.js",

package/apps/jsmdcui/runtime/help/commands.md

@@ -151,7 +151,10 @@ quotes here but these are not necessary when entering the command in micro.
 
 * `term ['exec']`: Open a terminal emulator running the given executable. If no
    executable is given, this will open the default shell in the terminal
-   emulator.
+   emulator. `Ctrl-W` switches panes in both editor and terminal panes. Press
+   it twice quickly to cycle to the next tab like `Alt-T`; at the rightmost
+   tab, if every tab is a terminal, this creates a new editor tab instead of
+   cycling back.
 
 ---
 

package/apps/jsmdcui/runtime/help/help.md

@@ -793,6 +793,8 @@ selection, search, and copy remain available.
 | `Ctrl-F` | Search; use `Ctrl-N` and `Ctrl-P` for the next and previous match. |
 | `Ctrl-G` | Open the editor help. |
 | `Alt-G` | Show or hide the shortcut bar. |
+| `Ctrl-W` | Switch to the next pane in the current tab. |
+| `Ctrl-W` twice quickly | Switch to the next tab like `Alt-T`. At the rightmost tab, if every tab contains only terminal panes, create a new editor tab instead of cycling back. |
 | `Ctrl-Q` or `Alt-Q` | Close the current UI. |
 
 To preview another color theme, press `Ctrl-E` or click on `€`, type `theme `, then use `Tab`

package/apps/jsmdcui/src/index.js

@@ -2796,6 +2796,8 @@ class App {
     this.tabRects = [];
     this._escBuf = null;   // pending lone ESC bytes waiting for alt-key combo
     this._escTimer = null;
+    this._ctrlWTime = 0;
+    this._ctrlWTimer = null;
     this._suggestionsRow = null;
     this._suggestionRects = [];
     this._acHScroll = 0;
@@ -3790,7 +3792,7 @@ class App {
     const titleStyle = { ...defaultStyle, reverse: true };
     const scrollMsg = vt && vt.scrollOffset > 0
       ? ` -- SCROLLBACK (${vt.scrollOffset}/${vt.scrollback.length}) wheel↑↓ to browse, any key to return`
-      : (isActive ? " [Esc: close  Ctrl-W: switch pane]" : "");
+      : (isActive ? " [Esc=close,Ctrl-W/*2=Next Pane/Tab]" : "");
     putText(this.screen, pane.x, pane.y, ` Terminal${scrollMsg}`.padEnd(pane.w), titleStyle, pane.w);
     if (!vt) return;
     const renderRows = pane.h - 1;
@@ -4228,14 +4230,12 @@ class App {
         this.render();
         return;
       }
-      // Ctrl-W: switch pane focus without closing
+      // Ctrl-W: switch pane focus without closing. A quick second Ctrl-W
+      // cycles tabs, with an editor-tab escape hatch when every tab is a
+      // terminal and the current one is already the rightmost tab.
       if (text === "\x17") {
-        const panes = this.tab.panes();
-        if (panes.length > 1) {
-          const idx = panes.indexOf(this.tab.activePane);
-          this.tab.activePane = panes[(idx + 1) % panes.length];
-          this.render();
-        }
+        await this.handleCtrlW();
+        this.render();
         return;
       }
 
@@ -4525,11 +4525,7 @@ class App {
         await runAction("AddTab", this);
         break;
       case "ctrl-w": { //switchPane
-        const panes = this.tab.panes();
-        if (panes.length > 1) {
-          const idx = panes.indexOf(this.tab.activePane);
-          this.tab.activePane = panes[(idx + 1) % panes.length];
-        }
+        await this.handleCtrlW();
         break;
       }
       case "ctrl-y": //redo
@@ -5403,6 +5399,37 @@ class App {
     return this.setActiveTab((this.activeTabIdx + 1) % this.tabs.length);
   }
 
+  _clearCtrlW() {
+    if (this._ctrlWTimer) clearTimeout(this._ctrlWTimer);
+    this._ctrlWTimer = null;
+    this._ctrlWTime = 0;
+  }
+
+  async handleCtrlW() {
+    const now = Date.now();
+    const isDouble = this._ctrlWTime > 0 && now - this._ctrlWTime < 400;
+    this._clearCtrlW();
+
+    if (isDouble) {
+      const atRightmostTab = this.activeTabIdx === this.tabs.length - 1;
+      const allTabsAreTerminal = this.tabs.every((tab) =>
+        tab.panes().length > 0 && tab.panes().every((pane) => pane.type === "term")
+      );
+      if (atRightmostTab && allTabsAreTerminal) await this.addTab();
+      else this.nextTab();
+      return;
+    }
+
+    this._ctrlWTime = now;
+    this._ctrlWTimer = setTimeout(() => this._clearCtrlW(), 400);
+
+    const panes = this.tab.panes();
+    if (panes.length > 1) {
+      const idx = panes.indexOf(this.tab.activePane);
+      this.tab.activePane = panes[(idx + 1) % panes.length];
+    }
+  }
+
   async handlePrompt(text) {
     const key = parseKey(text);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buninu",
-  "version": "0.4.12",
+  "version": "0.4.13",
   "description": "Buninu is a portable, self-bootstrapping Unix-like userspace built on Bun that runs across operating systems",
   "type": "module",
   "main": "./bin/init.js",