flea-qml 0.1.0 → 0.2.0

package/README.md

@@ -9,16 +9,32 @@ Flea QML is a cross-platform file manager written in Bun JavaScript & QML. It's
 - **Extend the capabilities**: run across platforms, on Windows, Linux and
   Android, wherever a QML runtime and a JS engine do, including [buninu-browser](https://github.com/jjtseng93/buninu-browser)'s QML frontend.
 
+> [!WARNING]
+> Flea QML is still in early development. Features and APIs may be unstable and may change without notice.
+
 ## Running it
 
-Install Bun first, then check that it is available on PATH:
+1. Install Bun first, then check that it is available on PATH:
 
 ```sh
 npm i -g bun
 bun --version
 ```
 
-Start Flea QML with:
+2. Enter the [Buninu userspace](https://github.com/jjtseng93/buninu)
+
+```sh
+# Run a server & open in a browser
+bunx buninu
+
+# Open in the current terminal
+# Kitty graphics support is required if you want to show Flea QML inside it directly
+bunx buninu --local
+
+# Or do nothing in a @drxiaozhi/minapk Android App
+```
+
+3. Start Flea QML with npx or bunx:
 
 ```sh
 npx flea-qml
@@ -123,6 +139,11 @@ frontend may intercept a shortcut before Flea receives it.
 | `,`, Ctrl+, | Open settings |
 | `?` | Open the searchable keymap |
 
+Enter on an ordinary file invokes `xdg-open` from PATH on every platform,
+including Windows. Install or provide an `xdg-open` command there; Flea does not
+substitute a platform-specific opener. Folders navigate inside Flea and archives
+open the built-in preview (except AppImage). Space uses the built-in preview.
+
 ### Selection and file operations
 
 | Keys | Action |
@@ -188,6 +209,18 @@ Esc acts on that query rather than the other one.
 | `e` in PDF Quick Look | Toggle expanded view |
 | `y` in Compare Quick Look | Copy the diff patch |
 
+### Extracting archives
+
+Both Quick Look and the right preview column offer **Extract to Folder** and
+**Extract here** for ZIP, TAR, TAR.GZ/TGZ and TAR.ZST/TZST archives. Extract to
+Folder uses the archive name without its extension; existing destinations get
+` copy`, ` copy 2`, and so on. Extract here places the contents beside the archive
+and asks for confirmation when the archive contains more than five top-level items
+(files and directories; nested contents count only toward their top-level folder). Cancel is the default.
+Existing items are kept: colliding names get a copy suffix, and existing folders
+are not merged. Work is prepared under a hidden unique name at the destination,
+not in the system temporary directory, so publication stays on the same filesystem.
+
 ### Menus and dialogs
 
 Use Up/Down (or `k`/`j`) to choose a menu row, Right/`l` to enter a submenu,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flea-qml",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Flea QML is a cross-platform file manager written in Bun JavaScript & QML. It's an unofficial fork of Flea, the fast GUI file manager for Omarchy",
   "type": "module",
   "main": "./index.js",
@@ -31,6 +31,6 @@
   "scripts": {
     "start": "bun index.js",
     "test": "bun test",
-    "browser": "bunx buninu-browser@0.10.4"
+    "browser": "bunx buninu-browser@0.10.5"
   }
 }

package/src/archive.js

@@ -400,3 +400,8 @@ export function openZip(path) {
 // The pieces src/archiveops.js reads member data with: extraction needs the type, mode, link and
 // bytes of every member, which the listing above never keeps.
 export { BLOCK, MAX_RECORD, checkedSize, checksumMatches, fileReader, kindOf, octal, paxRecords, scanZip, text };
+
+// Extraction normalizes both separators and ignores empty/dot path components.
+export function topLevelArchiveName(name) {
+  return String(name).replaceAll("\\", "/").split("/").find(part => part && part !== ".") || "";
+}

package/src/archiveops.js

@@ -15,7 +15,7 @@ import { basename, dirname, join, isAbsolute, resolve, sep } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { crc32, createDeflateRaw, createGunzip, createGzip, createInflateRaw, createZstdCompress, createZstdDecompress } from "node:zlib";
-import { BLOCK, MAX_RECORD, checkedSize, checksumMatches, fileReader, octal, paxRecords, scanZip, text } from "./archive.js";
+import { BLOCK, MAX_RECORD, listArchive, topLevelArchiveName, checkedSize, checksumMatches, fileReader, octal, paxRecords, scanZip, text } from "./archive.js";
 import { capturedPaths } from "./menu.js";
 import { copyName, nextJobId, reason } from "./transfer.js";
 
@@ -439,25 +439,56 @@ function extract(request, send, id, refuse) {
   send({ t: "archivestarted", id });
   send({ t: "extractstarted", id });
   send({ t: "transferprogress", id, index: 0, name: basename(path), bytes: 0, total: 0, scanned: 0 });
-  const staged = stagingName(dest, "ext", id);
+  const here = request.here === true;
+  const staged = stagingName(here ? join(dest, "contents") : dest, "ext", id);
+  let ownsStaged = false;
   (async () => {
+    if (here) {
+      if (!lstatOrNull(dest)?.isDirectory()) throw Error("Extract here needs an existing real folder");
+      if (request.confirmed !== true) {
+        const entries = new Set();
+        await listArchive(path, path, member => {
+          check(job);
+          const root = topLevelArchiveName(member.name);
+          if (root) entries.add(root);
+          if (entries.size > 5) throw Error("Extract here needs confirmation for more than 5 top-level items");
+        });
+      }
+    }
     await fsp.mkdir(staged, { mode: 0o700 });
+    ownsStaged = true;
     const out = new Extractor(staged, job);
     if (kind === "zip") await readZip(path, out, job);
     else await readTar(path, kind, out, job);
     await out.finish();
     check(job);
-    const written = await publish(staged, dest, null);
+    let written = dest;
+    if (here) {
+      // Publish complete top-level items without merging existing folders. Roll back our
+      // moves if publishing fails; cancellation is checked before this short commit phase.
+      const moved = [];
+      try {
+        for (const name of await fsp.readdir(staged)) {
+          const source = join(staged, name);
+          const target = await publish(source, join(dest, name), lstatOrNull(source)?.isDirectory() ? null : "");
+          moved.push([source, target]);
+        }
+      } catch (error) {
+        for (const [source, target] of moved.reverse()) await fsp.rename(target, source);
+        throw error;
+      }
+      await fsp.rmdir(staged);
+    } else written = await publish(staged, dest, null);
     send({ t: "archivedone", id, ok: true, verified: true, err: "", path: slash(path), dest: slash(written) });
   })()
     .catch(async (e) => {
-      await fsp.rm(staged, { recursive: true, force: true }).catch(() => {});
+      if (ownsStaged) await fsp.rm(staged, { recursive: true, force: true }).catch(() => {});
       send({ t: "archivedone", id, ok: false, verified: true, path: slash(path), dest: slash(dest),
         err: e instanceof Cancelled ? "cancelled" : e?.sentence ?? reason(e) });
     })
     .finally(() => {
       jobs.delete(id);
-      send({ t: "changed", path: slash(dirname(dest)) });
+      send({ t: "changed", path: slash(here ? dest : dirname(dest)) });
     });
 }
 

package/src/menu.js

@@ -8,7 +8,7 @@
 // waiting.
 import {trashRecord,forgetTrashRecord} from './trash-record.js';
 import { constants, lstatSync, readdirSync, rmSync } from "node:fs";
-import { dirname, join, resolve, isAbsolute } from "node:path";
+import { basename, dirname, join, resolve, isAbsolute } from "node:path";
 
 const CHANGED = "Selected items changed; reopen the menu.";
 
@@ -112,7 +112,7 @@ export function menuaction(request, send, listing, stamp) {
       held.review = reviewTrees(held.paths);
       if (!unchanged(held)) throw new Error(CHANGED);
       held.token = ++deleteTokens;
-      return answer({ ok: true, token: held.token, count: held.paths.length, bytes: held.review.bytes, partial: false });
+      return answer({ ok: true, token: held.token, count: held.paths.length, name: held.paths.length === 1 ? basename(held.paths[0]) : "", bytes: held.review.bytes, partial: false });
     } catch (error) { return answer({ ok: false, error: error.message }); }
   }
   if (op === "checkDelete") {

package/src/meta.js

@@ -4,7 +4,7 @@
 // Not read yet: media duration and rate, EXIF orientation and camera facts, RAW previews, owners.
 import { closeSync, fstatSync, lstatSync, openSync, readSync, readlinkSync, statSync, constants } from "node:fs";
 import { join } from "node:path";
-import { listArchive } from "./archive.js";
+import { listArchive, topLevelArchiveName } from "./archive.js";
 import { officeKind, officePreview } from "./office.js";
 
 // A line count stops here and says it is a floor (`partial`).
@@ -98,10 +98,16 @@ function addEntry(meta, name, isDir, size) {
 // Every member through src/archive.js, which reads a zip's directory and a tar's headers only.
 async function listMembers(path, name, meta) {
   try {
-    await listArchive(path, name, (member) => addEntry(meta, member.name, member.dir, member.size));
+    const roots = new Set();
+    await listArchive(path, name, member => {
+      addEntry(meta, member.name, member.dir, member.size);
+      const root = topLevelArchiveName(member.name);
+      if (root) roots.add(root);
+    });
+    meta.topEntries = roots.size;
   } catch {
     // A failed read carries nothing, so a partial count never reads as a total.
-    Object.assign(meta, { entries: 0, unpacked: 0, names: [], afailed: true });
+    Object.assign(meta, { entries: 0, topEntries: -1, unpacked: 0, names: [], afailed: true });
   }
 }
 

package/src/terminal-server.js

@@ -0,0 +1,95 @@
+// A shared, loopback-only server. Each tab owns a reconnect token, not a server.
+// stdin is the GUI's lifetime lease; EOF also closes all PTYs after a GUI crash.
+import {existsSync} from 'node:fs';
+import {resolve, join, isAbsolute} from 'node:path';
+import {spawn} from 'node:child_process';
+import {createInterface} from 'node:readline';
+export const RANDOM_URL_LENGTH = 48;
+export function terminalCommand(which = Bun.which, exists = existsSync, repo = resolve(import.meta.dir, '..')) {
+  const sibling = join(repo, '..', 'jsgotty', 'gotty.js');
+  if (exists(sibling)) return [which('bun') || process.execPath, sibling];
+  const executable = which('jsgotty');
+  return executable ? [executable] : null;
+}
+export function terminalArguments() {
+  return ['--address','127.0.0.1','--port','0','--permit-write','--random-url',
+    '--random-url-length',String(RANDOM_URL_LENGTH),'--session','--permit-arguments',
+    '--close-signal','SIGTERM','--close-timeout','1',
+    // QtWebEngine's isolated iframe sends Origin:null. No arbitrary site origins.
+    '--ws-origin','^(|null|http://127\\.0\\.0\\.1:[0-9]+)$',
+    Bun.which('bun') || process.execPath, join(import.meta.dir,'terminal-shell.js')];
+}
+// Use jsgotty's existing WebTTY session protocol rather than scraping a session list.
+export function sessionRequest(base, init, type) {
+  return new Promise((resolveRequest,reject) => {
+    const ws = new WebSocket(base.replace(/^http/,'ws')+'ws','webtty');
+    let done=false;
+    const timer=setTimeout(()=>finish(Error('Terminal session request timed out')),15000);
+    function finish(error,value){if(done)return;done=true;clearTimeout(timer);ws.close();error?reject(error):resolveRequest(value);}
+    ws.onopen=()=>ws.send(JSON.stringify({AuthToken:'',ReadOnly:true,...init}));
+    ws.onmessage=event=>{
+      const text=String(event.data);
+      if(text[0]!==type)return;
+      try {const result=JSON.parse(text.slice(1)); if(result.ok===false)throw Error(result.message);finish(null,result);} catch(e){finish(e);}
+    };
+    ws.onerror=()=>finish(Error('Terminal session connection failed'));
+    ws.onclose=()=>finish(Error('Terminal session connection closed'));
+  });
+}
+export async function runTerminalServer() {
+  const send=value=>{try{process.stdout.write(JSON.stringify(value)+'\n');}catch{}};
+  const command=terminalCommand();
+  if(!command){send({error:'jsgotty was not found. Install it on PATH (npm i -g jsgotty).'});return 1;}
+  let child,stopping=false,killer,buffer='',base='';
+  const tabs=new Map();
+  let readyResolve,readyReject;
+  const ready=new Promise((res,rej)=>{readyResolve=res;readyReject=rej;});ready.catch(()=>{});
+  const stop=()=>{
+    if(stopping)return;stopping=true;readyReject(Error('Terminal server stopped'));
+    child?.kill('SIGTERM');killer=setTimeout(()=>child?.kill('SIGKILL'),7000);killer.unref();
+  };
+  const closeSession=async token=>{if(base&&token&&!stopping)await sessionRequest(base,{ReconnectToken:token,TerminateSession:true},'b');};
+  const lines=createInterface({input:process.stdin,crlfDelay:Infinity});
+  lines.on('line',async line=>{
+    let request;
+    try {
+      request=JSON.parse(line);
+      if(request.shutdown===true){stop();return;}
+      if(typeof request.id!=='string'||request.id.length>128)throw Error('Invalid terminal tab id');
+      if(request.close){const record=tabs.get(request.id);tabs.delete(request.id);if(record)await closeSession(record.token);return;}
+      if(typeof request.path!=='string'||!isAbsolute(request.path))throw Error('An absolute terminal directory is required');
+      if(tabs.has(request.id))return;
+      const record={token:''};tabs.set(request.id,record);
+      await ready;
+      if(tabs.get(request.id)!==record||stopping)return;
+      const args=new URLSearchParams({arg:request.path});
+      const session=await sessionRequest(base,{Arguments:'?'+args},'5');
+      record.token=session.token;
+      if(tabs.get(request.id)!==record||stopping){await closeSession(record.token);return;}
+      send({id:request.id,url:base+'?reconnect-token='+encodeURIComponent(record.token),pid:session.pid});
+    } catch(error){send({id:request?.id,error:error.message});}
+  });
+  lines.on('close',stop);process.on('SIGTERM',stop);process.on('SIGINT',stop);
+  try {
+    child=spawn(command[0],[...command.slice(1),...terminalArguments()],{stdio:['pipe','pipe','pipe'],windowsHide:true});
+    const read=chunk=>{
+      buffer=(buffer+chunk.toString()).slice(-16384);
+      if(base)return;
+      const match=buffer.match(/http:\/\/127\.0\.0\.1:(\d+)\/([A-Za-z0-9]{48})\//);
+      if(match&&+match[1]>0&&+match[1]<=65535){base=match[0];readyResolve();send({ready:true});}
+    };
+    child.stdout.on('data',read);child.stderr.on('data',read);
+    return await new Promise(resolveExit=>{
+      child.on('error',error=>{readyReject(error);send({error:error.message});resolveExit(1);});
+      child.on('close',code=>{
+        readyReject(Error('Terminal server exited'));
+        if(!stopping)send({error:base?'Terminal server exited.':'jsgotty failed to start: '+buffer.slice(-2000)});
+        resolveExit(stopping?0:code||1);
+      });
+    });
+  } finally {
+    clearTimeout(killer);lines.removeAllListeners();lines.close();process.stdin.pause();
+    process.removeListener('SIGTERM',stop);process.removeListener('SIGINT',stop);
+  }
+}
+if(import.meta.main)process.exit(await runTerminalServer());

package/src/terminal-shell.js

@@ -0,0 +1,26 @@
+// jsgotty appends the requested tab directory as one argv entry, never shell text.
+import {spawn} from 'node:child_process';
+import {existsSync} from 'node:fs';
+import {join, isAbsolute} from 'node:path';
+export function shellCommand(which = Bun.which, exists = existsSync, platform = process.platform) {
+  const sibling = join(import.meta.dir, '../../bunmsh/index.js');
+  if (exists(sibling)) return [which('bun') || process.execPath, sibling];
+  const bunmsh = which('bunmsh');
+  if (bunmsh) return [bunmsh];
+  if (platform !== 'win32') return ['/bin/sh'];
+  for (const name of ['powershell', 'pwsh']) {
+    const path = which(name);
+    if (path) return [path];
+  }
+  throw Error('No shell was found on PATH. Install bunmsh, PowerShell or pwsh.');
+}
+if (import.meta.main) {
+  const cwd = process.argv[2];
+  if (!cwd || !isAbsolute(cwd)) throw Error('An absolute terminal directory is required');
+  process.chdir(cwd);
+  const command = shellCommand();
+  const child = spawn(command[0], command.slice(1), {stdio:'inherit', windowsHide:true});
+  for (const signal of ['SIGTERM','SIGINT','SIGHUP']) process.on(signal, () => child.kill(signal));
+  child.on('error', error => { console.error(error.message); process.exitCode = 1; });
+  child.on('exit', code => process.exit(code || 0));
+}

package/src/trashbrowse.js

@@ -280,6 +280,7 @@ function handleTrashBrowse(request, send) {
       token: review.token,
       all: request.emptyTrash === true || request.all === true,
       count: review.items.length,
+      name: review.items.length === 1 ? (review.items[0].original.split(/[\\/]/).pop() || review.items[0].name) : "",
       bytes: tree.bytes,
       partial: false,
     });

package/test/delete-trash.test.js

@@ -1,7 +1,7 @@
 import {test,expect,afterAll} from 'bun:test';
 import {mkdtempSync,mkdirSync,writeFileSync,readFileSync,existsSync,renameSync,symlinkSync,lstatSync,rmSync,readdirSync} from 'node:fs';
 import {tmpdir} from 'node:os';
-import {join} from 'node:path';
+import {join,basename} from 'node:path';
 import {menuaction} from '../src/menu.js';
 import {trashOne,trash} from '../src/trash.js';
 const root=mkdtempSync(join(tmpdir(),'flea-mutations-'));
@@ -17,7 +17,7 @@ function fixture() {
 }
 test('permanent delete requires a prepared token and deletes reviewed tree once',()=>{
  const {path,call}=fixture();expect(call('checkDelete').valid).toBe(false);expect(call('delete').ok).toBe(false);
- const {token}=call('prepareDelete');expect(call('checkDelete',{token}).valid).toBe(true);
+ const prepared=call('prepareDelete');expect(prepared.name).toBe(basename(path));const {token}=prepared;expect(call('checkDelete',{token}).valid).toBe(true);
  call('delete',{token});expect(existsSync(path)).toBe(false);expect(call('delete',{token}).ok).toBe(false);
 });
 test('new descendants invalidate confirmation before any removal',()=>{

package/test/file-ops.test.js

@@ -217,6 +217,11 @@ test('an archive that names a path outside its folder extracts nothing', async (
   expect(done.err).toMatch(/outside its folder/);
   expect(readdirSync(dir).sort()).toEqual(['evil.tar']);
   expect(existsSync(join(root, 'escape'))).toBe(false);
+  const here = collector();
+  archive({ op: 'extract', path: join(dir, 'evil.tar'), dest: dir, here: true, confirmed: true }, here.send);
+  expect((await until(here.lines, l => l.t === 'archivedone')).ok).toBe(false);
+  expect(readdirSync(dir)).toEqual(['evil.tar']);
+  expect(existsSync(join(root, 'escape'))).toBe(false);
 });
 
 test('a password, a format it cannot read and a disk image are refused without starting', () => {
@@ -239,3 +244,64 @@ test('cancelling a compress removes its staging file', async () => {
   expect(done).toMatchObject({ ok: false, err: 'cancelled' });
   expect(readdirSync(dir)).toEqual(['big']);
 });
+
+for (const count of [5, 6]) test(`extract here ${count} items requires confirmation only above five`, async () => {
+  const dir = fresh(), input = join(dir, 'input'), dest = join(dir, 'destination');
+  mkdirSync(input); mkdirSync(dest);
+  const paths = Array.from({ length: count }, (_, i) => {
+    const path = join(input, `item${i}.txt`); writeFileSync(path, `content ${i}`); return path;
+  });
+  const pack = collector();
+  archive({ op: 'compress', paths, dest: join(dir, 'pack.zip'), format: 'zip' }, pack.send);
+  const packed = await until(pack.lines, l => l.t === 'archivedone');
+  expect(packed.ok).toBe(true);
+  writeFileSync(join(dest, 'item0.txt'), 'keep');
+  const run = async confirmed => {
+    const c = collector();
+    archive({ op: 'extract', path: packed.path, dest, here: true, confirmed }, c.send);
+    return await until(c.lines, l => l.t === 'archivedone');
+  };
+  const first = await run(false);
+  expect(first.ok).toBe(count <= 5);
+  if (count > 5) {
+    expect(first.err).toContain('confirmation');
+    expect(readdirSync(dest)).toEqual(['item0.txt']);
+    expect((await run(true)).ok).toBe(true);
+  }
+  expect(readFileSync(join(dest, 'item0.txt'), 'utf8')).toBe('keep');
+  expect(readdirSync(dest).length).toBe(count + 1);
+  expect(readdirSync(dest).some(n => n.startsWith('.flea-work'))).toBe(false);
+  expect(readdirSync(dest).filter(n => n !== 'item0.txt').map(n => readFileSync(join(dest, n), 'utf8')).sort()).toEqual(paths.map((_, i) => `content ${i}`).sort());
+});
+
+test('extract here never merges an existing folder; folder extraction keeps copy naming', async () => {
+  const dir = fresh(), input = join(dir, 'folder'), dest = join(dir, 'out');
+  mkdirSync(input); writeFileSync(join(input, 'new.txt'), 'new');
+  mkdirSync(dest); mkdirSync(join(dest, 'folder')); writeFileSync(join(dest, 'folder', 'old.txt'), 'old');
+  const c = collector();
+  archive({ op: 'compress', paths: [input], dest: join(dir, 'pack.tar'), format: 'tar' }, c.send);
+  const packed = await until(c.lines, l => l.t === 'archivedone');
+  for (const here of [true, false]) {
+    const result = collector();
+    archive({ op: 'extract', path: packed.path, dest, here, confirmed: true }, result.send);
+    expect((await until(result.lines, l => l.t === 'archivedone')).ok).toBe(true);
+  }
+  expect(readFileSync(join(dest, 'folder', 'old.txt'), 'utf8')).toBe('old');
+  expect(existsSync(join(dest, 'folder', 'new.txt'))).toBe(false);
+  expect(readFileSync(join(dest, 'folder copy', 'new.txt'), 'utf8')).toBe('new');
+  expect(readFileSync(join(dir, 'out copy', 'folder', 'new.txt'), 'utf8')).toBe('new');
+});
+
+for (const format of ['zip','tar']) test(`extract here counts top-level names, not nested members (${format})`, async () => {
+  const dir=fresh(), input=join(dir,'one-folder'), dest=join(dir,'destination');
+  mkdirSync(input);mkdirSync(dest);
+  for(let i=0;i<8;i++)writeFileSync(join(input,`item${i}.txt`),`content ${i}`);
+  const pack=collector();
+  archive({op:'compress',paths:[input],dest:join(dir,'pack.'+format),format},pack.send);
+  const packed=await until(pack.lines,l=>l.t==='archivedone');expect(packed.ok).toBe(true);
+  const result=collector();
+  archive({op:'extract',path:packed.path,dest,here:true,confirmed:false},result.send);
+  expect((await until(result.lines,l=>l.t==='archivedone')).ok).toBe(true);
+  expect(readdirSync(dest)).toEqual(['one-folder']);
+  expect(readdirSync(join(dest,'one-folder')).length).toBe(8);
+});

package/test/file-url.test.js

@@ -0,0 +1,24 @@
+import {test,expect} from 'bun:test';
+import {readFileSync} from 'node:fs';
+
+function loadFunction(file,name,scope={}) {
+ const source=readFileSync(new URL(file,import.meta.url),'utf8');
+ const match=source.match(new RegExp('^( *)function '+name+'\\(path\\) \\{([\\s\\S]*?)^\\1\\}', 'm'));
+ if(!match)throw Error('Missing '+name);
+ return new Function(...Object.keys(scope),`return (${match[0].trim()})`)(...Object.values(scope));
+}
+const format=loadFunction('../ui/js/Format.js','fileUri');
+const boot=loadFunction('../ui/boot/shell.qml','fileUrl');
+const drag=loadFunction('../ui/js/Drag.js','uriFor',{Format:{fileUri:format}});
+const cases=[
+ ['C:\\Users\\wxk\\AppData\\Local\\Temp\\flea\\ui\\boot/../WindowBody.qml','file:///C:/Users/wxk/AppData/Local/Temp/flea/ui/boot/../WindowBody.qml'],
+ ['C:/Users/a b/中文#?%.qml','file:///C:/Users/a%20b/%E4%B8%AD%E6%96%87%23%3F%25.qml'],
+ ['\\\\server\\share\\a b.png','file://server/share/a%20b.png'],
+ ['/home/a b/#?%.png','file:///home/a%20b/%23%3F%25.png'],
+ ['/home/a\\b.png','file:///home/a%5Cb.png'],
+];
+for(const [name,convert] of [['boot',boot],['preview',format],['drag',drag]]) {
+ test(name+' file URLs preserve Windows drives, UNC and POSIX path bytes',()=>{
+  for(const [path,url] of cases){expect(convert(path)).toBe(url);expect(new URL(convert(path)).protocol).toBe('file:');}
+ });
+}

package/test/manual-archive-here-ui.mjs

@@ -0,0 +1,47 @@
+// bun test/manual-archive-here-ui.mjs (requires the sibling buninu-browser checkout).
+import {mkdtempSync,mkdirSync,rmSync,existsSync} from 'node:fs';
+import {join} from 'node:path';
+import {tmpdir} from 'node:os';
+import assert from 'node:assert/strict';
+const repo=Bun.fileURLToPath(new URL('../',import.meta.url));
+const dir=mkdtempSync(join(tmpdir(),'flea-terminal-ui-'));
+process.env.XDG_DATA_HOME=join(dir,'data');process.env.XDG_CONFIG_HOME=join(dir,'config');process.env.XDG_CACHE_HOME=join(dir,'cache');process.env.FLEA_PATH=dir;process.env.BUNINU_BUN=process.execPath;
+for(const p of ['data','config','cache'])mkdirSync(join(dir,p));
+await Bun.write(join(dir,'notes.txt'),'line of preview text\n'.repeat(200));
+const {createBrowser}=await import('../../buninu-browser/lib/headless-shell.js');
+const file=join(repo,'ui/boot/.terminal-check-'+process.pid+'.qml');
+await Bun.write(file,`import QtQuick\nimport Quickshell\nimport ".." as Flea\nimport "../js/Tabs.js" as Tabs\nFloatingWindow { id: win; width:900; height:600; Loader {anchors.fill:parent; source:"../WindowBody.qml";onLoaded:{item.host=win;globalThis.testTabs=Tabs;globalThis.testBody=item;globalThis.terminalService=Flea.TerminalService}} }`);
+const browser=await createBrowser({spareRenderer:false});
+const run=s=>browser.context.evaluate(s);
+const until=async(s)=>{for(let i=0;i<200;i++){if(await run(s))return;await Bun.sleep(100);}throw Error('UI timeout '+s+' '+await run('document.body.innerText.slice(-2500)'));};
+try {
+ const {archive}=await import('../src/archiveops.js');
+ const source=join(dir,'source');mkdirSync(source);
+ for(let i=0;i<8;i++)await Bun.write(join(source,`file${i}.txt`),'test');
+ await new Promise((resolve,reject)=>archive({op:'compress',paths:[source],dest:join(dir,'sample.zip'),format:'zip'},m=>{if(m.t==='archivedone')m.ok?resolve():reject(Error(m.err))}));
+ await browser.context.navigate(Bun.pathToFileURL(file).href);
+ await until('!!globalThis.testBody && !testBody.currentPane.listInFlight');
+ await run('for(let i=0;i<testBody.currentPane.total;i++)if(testBody.currentPane.rowFor(i)?.n==="sample.zip")testBody.currentPane.selectOnly(i,0)');
+ await until('testBody.currentPane.previewColumnItem?.meta?.topEntries===1');
+ assert.equal(await run('testBody.currentPane.previewColumnItem.meta.entries'),9);
+ console.log('PASS right preview carries 9 members / 1 top-level item');
+ await run('testBody.currentPane.act("preview")');
+ await until('testBody.currentPane.quickLook().archiveMeta?.topEntries===1');
+ assert.equal(await run('testBody.currentPane.quickLook().archiveMeta.entries'),9);
+ console.log('PASS Quick Look carries 9 members / 1 top-level item');
+ const button=await run('(()=>{const e=[...document.querySelectorAll("[data-qml-type=Text]")].filter(e=>e.textContent==="Extract here"&&e.getBoundingClientRect().width>0).at(-1);const r=e.getBoundingClientRect();return {x:r.x+r.width/2,y:r.y+r.height/2}})()');
+ await browser.context.click(button.x,button.y);
+ for(let i=0;i<100&&!existsSync(join(dir,'source copy'));i++)await Bun.sleep(100);
+ assert(existsSync(join(dir,'source copy')),'Extract here should run without confirmation');
+ console.log('PASS clicking Quick Look Extract here extracts without a confirmation dialog');
+ await run('testBody.currentPane.quickLook().close()');
+ await until('!testBody.currentPane.listInFlight');
+ await run('for(let i=0;i<testBody.currentPane.total;i++)if(testBody.currentPane.rowFor(i)?.n==="sample.zip")testBody.currentPane.selectOnly(i,0)');
+ await until('testBody.currentPane.previewColumnItem?.meta?.topEntries===1');
+ const right=await run('(()=>{const e=[...document.querySelectorAll("[data-qml-type=Text]")].find(e=>e.textContent==="Extract here"&&e.getBoundingClientRect().width>0);const r=e.getBoundingClientRect();return {x:r.x+r.width/2,y:r.y+r.height/2}})()');
+ await browser.context.click(right.x,right.y);
+ for(let i=0;i<100&&!existsSync(join(dir,'source copy 2'));i++)await Bun.sleep(100);
+ assert(existsSync(join(dir,'source copy 2')),'right preview Extract here should run without confirmation');
+ console.log('PASS clicking right preview Extract here extracts without confirmation');
+
+}finally{await browser.close();rmSync(file,{force:true});rmSync(dir,{recursive:true,force:true});}

package/test/manual-folder-focus.mjs

@@ -0,0 +1,63 @@
+// bun test/manual-terminal-ui.mjs (requires the sibling buninu-browser checkout).
+import {mkdtempSync,mkdirSync,rmSync} from 'node:fs';
+import {join} from 'node:path';
+import {tmpdir} from 'node:os';
+import assert from 'node:assert/strict';
+const repo=Bun.fileURLToPath(new URL('../',import.meta.url));
+const dir=mkdtempSync(join(tmpdir(),'flea-terminal-ui-'));
+process.env.XDG_DATA_HOME=join(dir,'data');process.env.XDG_CONFIG_HOME=join(dir,'config');process.env.XDG_CACHE_HOME=join(dir,'cache');process.env.FLEA_PATH=dir;process.env.BUNINU_BUN=process.execPath;
+for(const p of ['data','config','cache'])mkdirSync(join(dir,p));
+await Bun.write(join(dir,'notes.txt'),'line of preview text\n'.repeat(200));
+const {createBrowser}=await import('../../buninu-browser/lib/headless-shell.js');
+const file=join(repo,'ui/boot/.terminal-check-'+process.pid+'.qml');
+await Bun.write(file,`import QtQuick\nimport Quickshell\nimport ".." as Flea\nimport "../js/Tabs.js" as Tabs\nFloatingWindow { id: win; width:900; height:600; Loader {anchors.fill:parent; source:"../WindowBody.qml";onLoaded:{item.host=win;globalThis.testTabs=Tabs;globalThis.testBody=item;globalThis.terminalService=Flea.TerminalService}} }`);
+const browser=await createBrowser({spareRenderer:false});
+const run=s=>browser.context.evaluate(s);
+const until=async(s)=>{for(let i=0;i<200;i++){if(await run(s))return;await Bun.sleep(100);}throw Error('UI timeout '+s+' '+await run('document.body.innerText.slice(-2500)'));};
+try {
+ await browser.context.navigate(Bun.pathToFileURL(file).href);
+ await until('!!globalThis.testBody && !testBody.currentPane.listInFlight');
+
+ await run('testBody.currentPane.act("newFolder")');
+ await until('testBody.currentPane.renamingIndex>=0 && document.activeElement.tagName==="INPUT"');
+ await browser.context.type('Created Folder');
+ await browser.context.press('Enter');
+ await until('testBody.currentPane.renamingIndex<0 && !testBody.currentPane.listInFlight');
+ await until('testBody.currentPane.activeFocus');
+ await Bun.sleep(300);
+ const before=await run('testBody.currentPane.cursorIndex');
+ await browser.context.press(before>0?'ArrowUp':'ArrowDown');
+ assert.equal(await run('testBody.currentPane.cursorIndex'),before>0?before-1:before+1);
+ console.log('PASS mkdir + rename + ArrowDown');
+ await run('document.activeElement.blur()');
+ const pos=await run('(()=>{const r=__qmlRuntime.element(testBody.currentPane.visibleItemFor(Array.from({length:testBody.currentPane.total},(_,i)=>i).find(i=>testBody.currentPane.rowFor(i)?.n==="notes.txt"))).getBoundingClientRect();return {x:r.x+40,y:r.y+r.height/2}})()');
+ await browser.context.click(pos.x,pos.y);
+ await until('testBody.currentPane.activeFocus');
+ const clicked=await run('testBody.currentPane.cursorIndex');
+ await browser.context.press('ArrowUp');
+ assert.equal(await run('testBody.currentPane.cursorIndex'),clicked-1);
+ console.log('PASS clicking row recovers list focus from BODY');
+ // Empty list space also takes focus, independently of a row TapHandler.
+ const point=async expr=>run(`(()=>{const r=__qmlRuntime.element(${expr}).getBoundingClientRect();return {x:r.x+r.width/2,y:r.bottom-15}})()`);
+ await run('document.activeElement.blur()');
+ const ground=await point('testBody.currentPane.listArea');
+ await browser.context.click(ground.x,ground.y);
+ await until('testBody.currentPane.listArea.activeFocus');
+ console.log('PASS empty listing ground takes focus');
+ await run('document.activeElement.blur()');
+ const rail=await point('testBody.currentPane.sidebar');
+ await browser.context.click(rail.x,rail.y);
+ await until('testBody.currentPane.sidebar.activeFocus');
+ const railIndex=await run('testBody.currentPane.sidebar.cursorIndex');
+ await browser.context.press('ArrowDown');
+ assert.equal(await run('testBody.currentPane.sidebar.cursorIndex'),railIndex+1);
+ console.log('PASS Places empty ground takes focus and arrow keys');
+ await run('testBody.currentPane.focusView="list";for(let i=0;i<testBody.currentPane.total;i++)if(testBody.currentPane.rowFor(i)?.n==="notes.txt")testBody.currentPane.selectOnly(i,0)');
+ await until('!!testBody.currentPane.previewColumnItem?.visible');
+ const preview=await point('testBody.currentPane.previewColumnItem');
+ await run('document.activeElement.blur()');
+ await browser.context.click(preview.x,preview.y);
+ await until('testBody.currentPane.previewColumnItem.activeFocus');
+ console.log('PASS preview ground takes keyboard focus');
+
+}finally{await browser.close();rmSync(file,{force:true});rmSync(dir,{recursive:true,force:true});}

package/test/manual-terminal-lifecycle.mjs

@@ -0,0 +1,42 @@
+// bun test/manual-terminal-ui.mjs (requires the sibling buninu-browser checkout).
+import {mkdtempSync,mkdirSync,rmSync} from 'node:fs';
+import {join} from 'node:path';
+import {tmpdir} from 'node:os';
+import assert from 'node:assert/strict';
+const repo=Bun.fileURLToPath(new URL('../',import.meta.url));
+const dir=mkdtempSync(join(tmpdir(),'flea-terminal-ui-'));
+process.env.XDG_DATA_HOME=join(dir,'data');process.env.XDG_CONFIG_HOME=join(dir,'config');process.env.XDG_CACHE_HOME=join(dir,'cache');process.env.FLEA_PATH=dir;process.env.BUNINU_BUN=process.execPath;
+for(const p of ['data','config','cache'])mkdirSync(join(dir,p));
+const {createBrowser}=await import('../../buninu-browser/lib/headless-shell.js');
+const file=join(repo,'ui/boot/.terminal-check-'+process.pid+'.qml');
+await Bun.write(file,`import QtQuick\nimport Quickshell\nimport ".." as Flea\nFloatingWindow { id: win; width:900; height:600; Loader {anchors.fill:parent; source:"../WindowBody.qml";onLoaded:{item.host=win;globalThis.testBody=item;globalThis.terminalService=Flea.TerminalService}} }`);
+const browser=await createBrowser({spareRenderer:false});
+const run=s=>browser.context.evaluate(s);
+const until=async(s)=>{for(let i=0;i<200;i++){if(await run(s))return;await Bun.sleep(100);}throw Error('UI timeout '+s+' '+await run('document.body.innerText.slice(-2500)'));};
+try {
+ await browser.context.navigate(Bun.pathToFileURL(file).href);
+ await until('!!globalThis.testBody && !testBody.currentPane.listInFlight');
+ await run('testBody.currentPane.openTerminal()');
+ await until('!!testBody.currentPane.terminalId');
+ await until('Object.values(terminalService.tabs).some(t=>t.url?.includes("reconnect-token"))');
+ const one=await run('Object.values(terminalService.tabs)[0].url');
+ await run('testBody.currentPane.openTerminal()');
+ await until('Object.values(terminalService.tabs).length===2 && Object.values(terminalService.tabs).every(t=>t.url?.includes("reconnect-token"))');
+ const urls=await run('Object.values(terminalService.tabs).map(t=>t.url)');
+ assert.equal(new URL(urls[0]).host,new URL(urls[1]).host);assert.notEqual(urls[0],urls[1]);
+ assert.equal(await run('testBody.currentPane.tabs.items.length'),3);
+ console.log('PASS two terminal tabs, shared listener, distinct sessions',new URL(one).port);
+ await run('for (const id of Object.keys(terminalService.tabs)) terminalService.release(id)');
+ await until('!terminalService.stopping && !terminalService.process.running');
+ let closed=false;try{await fetch(one)}catch{closed=true}assert(closed);
+ console.log('PASS final terminal closes shared listener');
+ await run('terminalService.acquire(testBody.currentPane.path)');
+ await until('Object.values(terminalService.tabs).some(t=>t.url)');
+ const restarted=await run('Object.values(terminalService.tabs)[0].url');
+ assert.equal((await fetch(restarted)).status,200);
+ await run('for (const id of Object.keys(terminalService.tabs)) terminalService.release(id); terminalService.acquire(testBody.currentPane.path)');
+ await until('!terminalService.stopping && Object.values(terminalService.tabs).some(t=>t.url)');
+ console.log('PASS reopen during shutdown starts a fresh listener');
+ await run('for (const id of Object.keys(terminalService.tabs)) terminalService.release(id)');
+ await until('!terminalService.stopping && !terminalService.process.running');
+}finally{await browser.close();rmSync(file,{force:true});rmSync(dir,{recursive:true,force:true});}