flea-qml 0.0.0-stage → 0.2.0

package/test/dirsize.test.js

@@ -0,0 +1,138 @@
+import { test, expect, afterAll } from "bun:test";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, chmodSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { dirsize, dirsizeCancel, dirsizeInit, forgetSizes, keptSize } from "../src/dirsize.js";
+import { duCommand } from "../src/find.js";
+import { Listing } from "../src/listing.js";
+
+// Folder sizes only when asked (src/dirsize.js): du streams each folder's size, the answers are
+// kept by path and ride later rows as z, and a change forgets a folder and those above it only.
+const root = mkdtempSync(join(tmpdir(), "flea-dirsize-"));
+afterAll(() => { try { chmodSync(join(root, "w", "c", "locked"), 0o755); } catch {} rmSync(root, { recursive: true, force: true }); });
+const work = join(root, "w");
+mkdirSync(join(work, "a", "deep"), { recursive: true });
+mkdirSync(join(work, "b"));
+mkdirSync(join(work, "-dash"));
+mkdirSync(join(work, "c", "locked"), { recursive: true });
+writeFileSync(join(work, "a", "one"), Buffer.alloc(1000));
+writeFileSync(join(work, "a", "deep", "two"), Buffer.alloc(2500));
+writeFileSync(join(work, "b", "three"), Buffer.alloc(7));
+writeFileSync(join(work, "-dash", "x"), Buffer.alloc(11));
+writeFileSync(join(work, "c", "locked", "hid"), Buffer.alloc(5));
+writeFileSync(join(work, "file.txt"), "not a folder");
+
+let listing = Listing.scan(work, false);
+listing.sort({ by: "name", desc: false, foldersFirst: true, groupByKind: false, hiddenLast: false });
+const messages = [];
+dirsizeInit((m) => messages.push(m), () => listing);
+const until = async (done) => {
+  for (let i = 0; i < 400 && !done(); i++) await Bun.sleep(10);
+  if (!done()) throw Error("timed out: " + JSON.stringify(messages));
+};
+const rowOf = (name) => listing.indexOfName(name);
+const sizes = () => Object.fromEntries(messages.filter((m) => m.t === "dirsized").map((m) => [listing.rows[m.row].name, [m.bytes, m.partial]]));
+
+test("du is looked for in Find's order: bunmsh first", () => {
+  expect(duCommand().slice(-2)).toEqual(["builtin", "du"]);
+});
+
+test("nothing is measured until asked; one row asks for that folder alone", async () => {
+  expect(listing.window(0, 10).rows.some((row) => row.z !== undefined)).toBe(false);
+  dirsize({ rows: [rowOf("a"), rowOf("file.txt")] });
+  await until(() => messages.some((m) => m.t === "dirsizedone"));
+  expect(sizes()).toEqual({ a: [3500, false] });
+  expect(keptSize(join(work, "a"))).toEqual({ bytes: 3500, partial: false });
+});
+
+test("all measures every folder, a name with a leading dash included, and an unreadable one is a floor", async () => {
+  if (process.getuid?.() !== 0 && process.platform !== "win32") chmodSync(join(work, "c", "locked"), 0);
+  messages.length = 0;
+  dirsize({ all: true });
+  await until(() => messages.some((m) => m.t === "dirsizedone"));
+  const got = sizes();
+  expect(got.a).toEqual([3500, false]);
+  expect(got.b).toEqual([7, false]);
+  expect(got["-dash"]).toEqual([11, false]);
+  if (process.getuid?.() !== 0 && process.platform !== "win32") expect(got.c[1]).toBe(true);
+  expect(got["file.txt"]).toBeUndefined();
+  chmodSync(join(work, "c", "locked"), 0o755);
+});
+
+test("kept sizes ride later rows, follow a sort, and a change forgets only its own line upward", () => {
+  listing = Listing.scan(work, false);
+  listing.sort({ by: "name", desc: true, foldersFirst: true, groupByKind: false, hiddenLast: false });
+  const rows = Object.fromEntries(listing.window(0, 10).rows.map((row) => [row.n, row]));
+  expect(rows.a.z).toBe(3500);
+  expect(rows.b.z).toBe(7);
+  expect(rows["file.txt"].z).toBeUndefined();
+  // A write inside a/deep: a (and everything above) is no longer known, b still is.
+  forgetSizes(join(work, "a", "deep"));
+  expect(keptSize(join(work, "a"))).toBeUndefined();
+  expect(keptSize(join(work, "b"))).toEqual({ bytes: 7, partial: false });
+  forgetSizes(join(work, "b", "three-sibling-dir-does-not-exist"));
+  expect(keptSize(join(work, "b"))).toBeUndefined();
+  expect(keptSize(join(work, "-dash"))).toEqual({ bytes: 11, partial: false });
+});
+
+test("a cancel stops the run and says so", async () => {
+  messages.length = 0;
+  dirsize({ all: true });
+  dirsizeCancel();
+  await until(() => messages.some((m) => m.t === "dirsizedone"));
+  expect(messages.find((m) => m.t === "dirsizedone").cancelled).toBe(true);
+});
+
+// The cell side (ui/js/DirSizes.js): ⚖️ until measured, … while a walk is out, then the size.
+async function loadJs(name, names, deps = {}) {
+  const s = (await Bun.file(new URL("../ui/js/" + name + ".js", import.meta.url)).text()).replace(/^\.(?:pragma|import).*$/gm, "");
+  return new Function(...Object.keys(deps), s + ";return {" + names + "};")(...Object.values(deps));
+}
+const Format = { size: (n) => `${n} B` };
+const D = await loadJs("DirSizes", "empty,cellFor,known,folderText,asking,askingAll,remember,settled,UNMEASURED,MEASURING", { Format });
+
+test("a folder's Size cell reads ⚖️, then … while asked, then its size; a row's z stands in after a sort", () => {
+  let state = D.empty();
+  const row = { d: true };
+  expect(D.folderText(D.cellFor(state, 4), row)).toBe("⚖️");
+  state = D.asking(state, [4]);
+  expect(D.folderText(D.cellFor(state, 4), row)).toBe("…");
+  expect(D.folderText(D.cellFor(state, 5), row)).toBe("⚖️");
+  state = D.remember(state, 4, 2048, false, 100);
+  expect(D.folderText(D.cellFor(state, 4), row)).toBe("\u2696\ufe0f 2048 B");
+  expect(D.folderText(D.cellFor(D.empty(), 4), { d: true, z: 9, zp: true })).toBe("\u2696\ufe0f >9 B");
+});
+
+test("the header's ⚖️ makes every folder wait until its answer or the run's end", () => {
+  let state = D.askingAll(D.empty());
+  expect(D.cellFor(state, 900)).toEqual({ waiting: true });
+  state = D.remember(state, 3, 10, false, 100);
+  expect(D.cellFor(state, 3)).toEqual({ bytes: 10, partial: false });
+  expect(D.cellFor(state, 7)).toEqual({ waiting: true });
+  state = D.settled(state);
+  expect(D.cellFor(state, 7)).toBe(null);
+  expect(D.cellFor(state, 3)).toEqual({ bytes: 10, partial: false });
+});
+
+test("a size order uses measured folders' sizes and puts unmeasured folders after them, measuring nothing", () => {
+  // a and b were forgotten above; -dash (11) and c (a floor) are still measured.
+  const fresh = Listing.scan(work, false);
+  fresh.sort({ by: "name", desc: false, foldersFirst: true, groupByKind: false, hiddenLast: false });
+  fresh.sort({ by: "size", desc: true, foldersFirst: true, groupByKind: false, hiddenLast: false });
+  expect(fresh.rows.filter((r) => r.dir).map((r) => r.name)).toEqual(["-dash", "c", "a", "b"]);
+  expect(messages.filter((m) => m.t === "dirsized").length).toBe(0);
+});
+
+test("= measures the selection or the cursor's folder, Alt+= every folder", async () => {
+  // Every Qt.Key_* the table names gets a distinct number; the modifiers are Qt's own.
+  let next = 1000;
+  const named = { AltModifier: 0x08000000, ControlModifier: 0x04000000, ShiftModifier: 0x02000000, MetaModifier: 0x10000000, Key_Equal: 0x3d };
+  const Qt = new Proxy(named, { get: (t, k) => (k in t ? t[k] : (t[k] = next++)) });
+  const Keymap = await loadJs("Keymap", "lookup", { Qt });
+  expect(Keymap.lookup(0x3d, "=", 0)).toBe("measureDirs");
+  expect(Keymap.lookup(0x3d, "=", named.AltModifier)).toBe("measureAllDirs");
+  // Ctrl+= stays the text size.
+  expect(Keymap.lookup(0x3d, "=", named.ControlModifier)).toBe("textSizeUp");
+  const focus = await Bun.file(new URL("../ui/js/Focus.js", import.meta.url)).text();
+  expect(focus).toContain('case "measureDirs": root.measureDirs(root.selectionCount() > 0 ? root.selectedIndices() : [root.cursorIndex])');
+});

package/test/file-ops.test.js

@@ -0,0 +1,307 @@
+import { test, expect, afterAll } from 'bun:test';
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, rmSync, readdirSync, lstatSync, readlinkSync, symlinkSync, statSync, chmodSync, existsSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { mkdir, newfile, duplicate } from '../src/create.js';
+import { bulkrename } from '../src/bulkrename.js';
+import { permissions, permissionsBatch, parseMode } from '../src/permissions.js';
+import { archive, archiveCancel, formats, freeName } from '../src/archiveops.js';
+import { listArchive } from '../src/archive.js';
+import { openSync, closeSync } from 'node:fs';
+
+const root = mkdtempSync(join(tmpdir(), 'flea-ops-'));
+afterAll(() => rmSync(root, { recursive: true, force: true }));
+let n = 0;
+const fresh = () => { const dir = join(root, `case-${++n}`); mkdirSync(dir); return dir; };
+// PRoot resolves links itself, so an exclusive create there follows a dangling link; the kernel never does.
+const exclusiveRefusesLinks = (() => {
+  const dir = mkdtempSync(join(tmpdir(), 'flea-excl-'));
+  try {
+    symlinkSync(join(dir, 'absent'), join(dir, 'link'));
+    try { closeSync(openSync(join(dir, 'link'), 'wx')); return false; } catch { return true; }
+  } finally { rmSync(dir, { recursive: true, force: true }); }
+})();
+const umask = process.umask();
+const collector = () => { const lines = []; const send = (line) => lines.push(line); return { lines, send }; };
+// Resolves with the first line `pick` accepts, waiting for the asynchronous operations.
+async function until(lines, pick, ms = 10000) {
+  const end = Date.now() + ms;
+  for (;;) {
+    const found = lines.find(pick);
+    if (found) return found;
+    if (Date.now() > end) throw Error(`no line arrived: ${JSON.stringify(lines)}`);
+    await Bun.sleep(10);
+  }
+}
+
+test('mkdir takes the first free New Folder and refuses a typed name already taken', () => {
+  const dir = fresh(), { lines, send } = collector();
+  mkdir({ path: dir }, send);
+  mkdir({ path: dir }, send);
+  expect(lines.filter((l) => l.t === 'made').map((l) => l.path)).toEqual([join(dir, 'New Folder'), join(dir, 'New Folder 2')]);
+  writeFileSync(join(dir, '報告'), '');
+  mkdir({ path: dir, name: '報告' }, send);
+  expect(lines.at(-1)).toMatchObject({ t: 'error', where: 'mkdir', msg: 'a folder or file with that name already exists' });
+  mkdir({ path: dir, name: '../x' }, send);
+  expect(lines.at(-1)).toMatchObject({ t: 'error', where: 'mkdir' });
+  mkdir({ path: 'relative' }, send);
+  expect(lines.at(-1).t).toBe('error');
+});
+
+test('mkdir with a request id adds the creation receipt', () => {
+  const dir = fresh(), { lines, send } = collector();
+  mkdir({ path: dir, name: 'a', request: 4 }, send);
+  expect(lines[0]).toMatchObject({ t: 'made', ok: true, request: 4 });
+  expect(lines[1]).toEqual({ t: 'menuaction', op: 'creation', id: 4, kind: 'made', ok: true, path: join(dir, 'a') });
+});
+
+test('newfile creates an empty file exclusively and never follows a dangling link', () => {
+  const dir = fresh(), { lines, send } = collector();
+  newfile({ id: 3, path: dir, name: 'New File 🙂' }, send);
+  expect(lines[0]).toEqual({ t: 'menuaction', id: 3, op: 'newFile', ok: true, path: join(dir, 'New File 🙂') });
+  expect(statSync(join(dir, 'New File 🙂')).size).toBe(0);
+  newfile({ id: 3, path: dir, name: 'New File 🙂' }, send);
+  expect(lines.at(-1)).toMatchObject({ op: 'newFile', ok: false });
+  if (exclusiveRefusesLinks) {
+    symlinkSync(join(dir, 'absent'), join(dir, 'link'));
+    newfile({ id: 3, path: dir, name: 'link' }, send);
+    expect(lines.at(-1).ok).toBe(false);
+    expect(existsSync(join(dir, 'absent'))).toBe(false);
+  }
+  newfile({ id: 3, path: dir, name: 'a/b' }, send);
+  expect(lines.at(-1).ok).toBe(false);
+});
+
+test('duplicate copies a file and a tree to free copy names', async () => {
+  const dir = fresh(), { lines, send } = collector();
+  writeFileSync(join(dir, 'backup.tar.zst'), 'x');
+  mkdirSync(join(dir, 'tree/inner'), { recursive: true });
+  writeFileSync(join(dir, 'tree/inner/f'), 'deep');
+  duplicate({ path: join(dir, 'backup.tar.zst') }, send);
+  duplicate({ path: join(dir, 'backup.tar.zst') }, send);
+  duplicate({ path: join(dir, 'tree') }, send);
+  await until(lines, (l) => l.t === 'duplicated' && l.path.endsWith('tree copy'));
+  expect(lines.filter((l) => l.t === 'duplicated').map((l) => l.path)).toEqual(
+    [join(dir, 'backup.tar copy.zst'), join(dir, 'backup.tar copy 2.zst'), join(dir, 'tree copy')]);
+  expect(readFileSync(join(dir, 'tree copy/inner/f'), 'utf8')).toBe('deep');
+});
+
+test('bulkrename swaps names through temporary names and refuses a bad batch whole', () => {
+  const dir = fresh(), { lines, send } = collector();
+  writeFileSync(join(dir, 'a'), 'A');
+  writeFileSync(join(dir, 'b'), 'B');
+  writeFileSync(join(dir, 'c'), 'C');
+  bulkrename({ paths: [join(dir, 'a'), join(dir, 'b'), join(dir, 'c')], names: ['b', 'a', 'c'] }, send);
+  expect(lines[0]).toEqual({ t: 'bulkrenamed', ok: 2, unchanged: 1 });
+  expect(readFileSync(join(dir, 'a'), 'utf8')).toBe('B');
+  expect(readFileSync(join(dir, 'b'), 'utf8')).toBe('A');
+  for (const names of [['x', 'x', 'y'], ['c', 'q'], ['ok', 'a/b', 'z'], ['', 'm', 'n']]) {
+    bulkrename({ paths: [join(dir, 'a'), join(dir, 'b'), join(dir, 'c')].slice(0, names.length), names }, send);
+    expect(lines.at(-1)).toMatchObject({ t: 'error', where: 'bulkrename' });
+  }
+  expect(readdirSync(dir).sort()).toEqual(['a', 'b', 'c']);
+});
+
+test('permissions inspects, applies and refuses a replaced item', () => {
+  if (process.platform === 'win32') return;
+  const dir = fresh(), path = join(dir, 'f'), { lines, send } = collector();
+  writeFileSync(path, '');
+  chmodSync(path, 0o644);
+  permissions({ op: 'inspect', id: 1, path }, send);
+  expect(lines[0]).toMatchObject({ t: 'permissions', id: 1, op: 'inspect', ok: true, mode: '0644', directory: false, reason: '' });
+  permissions({ op: 'apply', id: 1, mode: '600' }, send);
+  expect(lines.at(-1)).toEqual({ t: 'permissions', id: 1, op: 'apply', ok: true, mode: '0600' });
+  expect(statSync(path).mode & 0o777).toBe(0o600);
+  permissions({ op: 'apply', id: 1, mode: '9' }, send);
+  expect(lines.at(-1).error).toMatch(/octal/);
+  rmSync(path);
+  writeFileSync(path, '');
+  permissions({ op: 'apply', id: 1, mode: '644' }, send);
+  expect(lines.at(-1)).toMatchObject({ ok: false, error: 'Selected item changed; reopen Permissions.' });
+  expect(() => parseMode('1644')).toThrow();
+  expect(parseMode('0755')).toBe(0o755);
+});
+
+test('permissionsBatch changes every item or none, and u+x adds the owner execute bit', () => {
+  if (process.platform === 'win32') return;
+  const dir = fresh(), a = join(dir, 'a'), b = join(dir, 'b'), { lines, send } = collector();
+  writeFileSync(a, '');
+  writeFileSync(b, '');
+  chmodSync(a, 0o644);
+  chmodSync(b, 0o640);
+  permissionsBatch({ id: 7, paths: [a, b], modes: ['u+x', 'u+x'] }, send);
+  expect(lines.at(-1)).toMatchObject({ op: 'applyMany', ok: true });
+  expect([statSync(a).mode & 0o777, statSync(b).mode & 0o777]).toEqual([0o744, 0o740]);
+  permissionsBatch({ id: 8, paths: [a, join(dir, 'gone')], modes: ['600', '600'] }, send);
+  expect(lines.at(-1)).toMatchObject({ op: 'applyMany', ok: false });
+  expect(statSync(a).mode & 0o777).toBe(0o744);
+});
+
+test('formats names what this port writes and reads, and no password', () => {
+  const { lines, send } = collector();
+  formats({ id: 2 }, send);
+  expect(lines[0]).toMatchObject({ t: 'formats', archive: ['zip', 'tar', 'tar.gz', 'tar.zst'], convert: false,
+    extract: { archive: true, sevenZip: false, zip: true } });
+});
+
+test('free archive names keep the format tail', () => {
+  expect(freeName('/a/pack.tar.gz', 'tar.gz', 1)).toBe('/a/pack copy.tar.gz');
+  expect(freeName('/a/pack.tar.gz', 'tar.gz', 2)).toBe('/a/pack copy 2.tar.gz');
+  expect(freeName('/a/folder', null, 1)).toBe('/a/folder copy');
+});
+
+// A tree with Chinese and emoji names, a long path, a symlink, an empty folder and a non-default mode.
+function sampleTree(dir) {
+  const top = join(dir, '專案 📦');
+  const long = join(top, 'd'.repeat(60), 'e'.repeat(60));
+  mkdirSync(long, { recursive: true });
+  mkdirSync(join(top, 'empty'));
+  writeFileSync(join(top, '說明.txt'), '你好 👋\n');
+  writeFileSync(join(long, 'f'.repeat(90) + '.bin'), Buffer.alloc(300000, 7));
+  writeFileSync(join(top, 'run.sh'), '#!/bin/sh\n');
+  chmodSync(join(top, 'run.sh'), 0o755);
+  symlinkSync('說明.txt', join(top, 'readme'));
+  return top;
+}
+// Extracted modes pass through the umask, as bsdtar's do for anyone but root.
+function expectSameTree(a, b) {
+  const walk = (base, rel = '', mask = 0) => readdirSync(join(base, rel)).sort().flatMap((name) => {
+    const path = join(base, rel, name), st = lstatSync(path), key = join(rel, name);
+    if (st.isSymbolicLink()) return [[key, 'link', readlinkSync(path)]];
+    if (st.isDirectory()) return [[key, 'dir'], ...walk(base, key, mask)];
+    return [[key, (st.mode & 0o777 & ~mask).toString(8), readFileSync(path).toString('base64')]];
+  });
+  expect(walk(b)).toEqual(walk(a, '', umask));
+}
+
+for (const format of ['zip', 'tar', 'tar.gz', 'tar.zst']) {
+  test(`compress to .${format} and extract it back to the same tree`, async () => {
+    const dir = fresh(), top = sampleTree(dir), { lines, send } = collector();
+    archive({ op: 'compress', paths: [top], dest: join(dir, `專案 📦.${format}`), format }, send);
+    const done = await until(lines, (l) => l.t === 'archivedone');
+    expect(done).toMatchObject({ ok: true, err: '', path: join(dir, `專案 📦.${format}`) });
+    // The preview's own reader lists what was written.
+    const names = [];
+    await listArchive(done.path, done.path, (entry) => names.push(entry.name));
+    expect(names).toContain('專案 📦/說明.txt');
+    expect(names.some((name) => name.endsWith('f'.repeat(90) + '.bin'))).toBe(true);
+    const out = join(dir, 'out');
+    archive({ op: 'extract', path: done.path, dest: out }, send);
+    const extracted = await until(lines, (l) => l.t === 'archivedone' && l.dest);
+    expect(extracted).toMatchObject({ ok: true, dest: out });
+    expect(lines.some((l) => l.t === 'extractstarted')).toBe(true);
+    expectSameTree(top, join(out, '專案 📦'));
+    // A second compress of the same name lands under its copy name.
+    archive({ op: 'compress', paths: [top], dest: join(dir, `專案 📦.${format}`), format }, send);
+    const again = await until(lines, (l) => l.t === 'archivedone' && l.path?.includes('copy'));
+    expect(again.path).toBe(join(dir, `專案 📦 copy.${format}`));
+    expect(readdirSync(dir).filter((name) => name.startsWith('.flea-work'))).toEqual([]);
+  });
+}
+
+test('an archive that names a path outside its folder extracts nothing', async () => {
+  const dir = fresh(), { lines, send } = collector();
+  // A tar whose only member is ../escape.
+  const header = Buffer.alloc(512);
+  header.write('../escape', 0);
+  header.write('0000644\0', 100); header.write('0000000\0', 108); header.write('0000000\0', 116);
+  header.write('00000000003\0', 124); header.write('00000000000\0', 136);
+  header.fill(0x20, 148, 156); header[156] = 0x30; header.write('ustar\0', 257); header.write('00', 263);
+  let sum = 0; for (const byte of header) sum += byte;
+  header.write(sum.toString(8).padStart(6, '0') + '\0 ', 148);
+  const data = Buffer.alloc(512); data.write('bad');
+  writeFileSync(join(dir, 'evil.tar'), Buffer.concat([header, data, Buffer.alloc(1024)]));
+  archive({ op: 'extract', path: join(dir, 'evil.tar'), dest: join(dir, 'evil') }, send);
+  const done = await until(lines, (l) => l.t === 'archivedone');
+  expect(done.ok).toBe(false);
+  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', () => {
+  const { lines, send } = collector();
+  archive({ op: 'extract', path: '/x/a.zip', dest: '/x/a', password: 'p' }, send);
+  archive({ op: 'extract', path: '/x/a.7z', dest: '/x/a' }, send);
+  archive({ op: 'extract', path: '/x/a.iso', dest: '/x/a' }, send);
+  expect(lines.every((l) => l.t === 'archivedone' && l.ok === false)).toBe(true);
+  expect(lines.length).toBe(3);
+});
+
+test('cancelling a compress removes its staging file', async () => {
+  const dir = fresh(), { lines, send } = collector();
+  mkdirSync(join(dir, 'big'));
+  for (let i = 0; i < 20; i++) writeFileSync(join(dir, 'big', `f${i}`), Buffer.alloc(2 << 20, i));
+  archive({ op: 'compress', paths: [join(dir, 'big')], dest: join(dir, 'big.zip'), format: 'zip' }, send);
+  const started = await until(lines, (l) => l.t === 'archivestarted');
+  expect(archiveCancel(started.id)).toBe(true);
+  const done = await until(lines, (l) => l.t === 'archivedone');
+  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/find-contents.test.js

@@ -0,0 +1,161 @@
+import { test, expect, afterAll } from "bun:test";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { grepCommand } from "../src/find.js";
+import { matchOf, MATCH_TEXT_LIMIT } from "../src/backend.js";
+import { Listing } from "../src/listing.js";
+
+// Ctrl+G's content search: ui/js/Find.js builds grep's arguments and reads its lines, ui/js/Search.js
+// opens and turns the mode, and the backend carries each row's matched line as `g`.
+async function load(name, names, deps = {}) {
+  const s = (await Bun.file(new URL("../ui/js/" + name + ".js", import.meta.url)).text()).replace(/^\.(?:pragma|import).*$/gm, "");
+  return new Function(...Object.keys(deps), s + ";return {" + names + "};")(...Object.values(deps));
+}
+const Find = await load("Find", "grepArguments,grepLine,snippet,CONTEXT,SNIPPET_LIMIT");
+const Qt = { Key_Return: 16777220, Key_Enter: 16777221, Key_Escape: 16777216, Key_Backspace: 16777219,
+  Key_Tab: 16777217, Key_Backtab: 16777218, Key_G: 71, ControlModifier: 0x04000000, AltModifier: 0x08000000, MetaModifier: 0x10000000 };
+const Search = await load("Search", "start,contents,commit,rescope,abort,typeKey,placeholder,sendQuery,TYPING,RESULTS",
+  { Qt, Input: { isPasteKey: () => false }, Format: {} });
+
+const root = mkdtempSync(join(tmpdir(), "flea-grep-"));
+afterAll(() => rmSync(root, { recursive: true, force: true }));
+
+test("grep runs over the scope with the query as literal text, hidden names skipped unless shown", () => {
+  const off = Find.grepArguments("a.b*(c)", false);
+  expect(off).toEqual(["-r", "-n", "-o", "-a", "-i", "-m", "1", "-Z", "--line-buffered", "-E",
+    "--exclude=.*", "--exclude-dir=.*", "-e", ".{0,80}a\\.b\\*\\(c\\).{0,80}"]);
+  // No path operand: grep walks "." and the bare "." is never excluded.
+  expect(off.some((arg) => arg === "." || arg === "./")).toBe(false);
+  expect(Find.grepArguments("x", true)).not.toContain("--exclude=.*");
+});
+
+test("a grep line parses into its file, line number and a clean bounded snippet", () => {
+  expect(Find.grepLine("dir/a: b.txt\u000012:  let x\t= 1")).toEqual({ path: "dir/a: b.txt", line: 12, text: "let x = 1" });
+  // A binary's control bytes become dots; the text is cut at SNIPPET_LIMIT.
+  expect(Find.grepLine("bin.dat\u00003:ab\u0000\u0001cd").text).toBe("ab··cd");
+  expect(Find.grepLine("long\u00001:" + "y".repeat(5000)).text.length).toBe(Find.SNIPPET_LIMIT);
+  for (const junk of ["", "no separator", "\u00001:starts with nul", "a\u0000not a number"]) expect(Find.grepLine(junk)).toBe(null);
+});
+
+for (const [label, argv] of [["bunmsh's grep", grepCommand()], ["the system grep", Bun.which("grep") ? [Bun.which("grep")] : null]]) {
+  test(`${label} answers the arguments: binary files match, hidden ones follow the setting, long lines stay short`, async () => {
+    if (!argv) return;
+    const scope = mkdtempSync(join(root, "scope-"));
+    mkdirSync(join(scope, "sub"));
+    mkdirSync(join(scope, ".hid"));
+    writeFileSync(join(scope, "sub", "notes:1.txt"), "first\nSecond Needle here\nneedle again\n");
+    writeFileSync(join(scope, "image.bin"), Buffer.from([0, 1, 2, ...Buffer.from("xxNEEDLExx"), 0, 255]));
+    writeFileSync(join(scope, "min.js"), "a".repeat(200000) + "needle" + "b".repeat(200000));
+    writeFileSync(join(scope, ".hidden.txt"), "needle\n");
+    writeFileSync(join(scope, ".hid", "in.txt"), "needle\n");
+    writeFileSync(join(scope, "none.txt"), "nothing\n");
+    const run = async (hidden) => {
+      const child = Bun.spawn([...argv, ...Find.grepArguments("needle", hidden)], { cwd: scope, stdout: "pipe", stderr: "pipe" });
+      const out = await new Response(child.stdout).text();
+      await child.exited;
+      const rows = new Map();
+      for (const line of out.split("\n")) {
+        if (line.length > 2 * Find.CONTEXT + "needle".length + 400) throw new Error(`an output line of ${line.length} characters`);
+        const hit = Find.grepLine(line);
+        if (hit && !rows.has(hit.path)) rows.set(hit.path, hit);
+      }
+      return rows;
+    };
+    const shown = await run(false);
+    expect([...shown.keys()].sort()).toEqual(["image.bin", "min.js", "sub/notes:1.txt"]);
+    expect(shown.get("sub/notes:1.txt")).toMatchObject({ line: 2, text: "Second Needle here" });
+    expect(shown.get("image.bin").text).toContain("NEEDLE");
+    expect(shown.get("min.js").text).toBe("a".repeat(Find.CONTEXT) + "needle" + "b".repeat(Find.CONTEXT));
+    expect([...(await run(true)).keys()].sort()).toEqual([".hid/in.txt", ".hidden.txt", "image.bin", "min.js", "sub/notes:1.txt"]);
+  }, 30000);
+}
+
+test("the backend keeps a checked, bounded match and hands it out as the row's g", () => {
+  expect(matchOf({ l: 4, t: "x" })).toEqual({ l: 4, t: "x" });
+  expect(matchOf({ l: 2, t: "z".repeat(MATCH_TEXT_LIMIT + 50) }).t.length).toBe(MATCH_TEXT_LIMIT);
+  for (const bad of [null, "x", { l: 0, t: "x" }, { l: 1.5, t: "x" }, { l: 3 }]) expect(matchOf(bad)).toBe(null);
+  const dir = mkdtempSync(join(root, "rows-"));
+  writeFileSync(join(dir, "a.txt"), "x");
+  writeFileSync(join(dir, "b.txt"), "x");
+  const listing = new Listing(dir, [{ name: "a.txt", dir: false, link: false, match: { l: 3, t: "hit" } }, { name: "b.txt", dir: false, link: false }]);
+  const { rows } = listing.window(0, 2);
+  expect(rows[0].g).toEqual({ l: 3, t: "hit" });
+  expect(rows[1].g).toBeUndefined();
+});
+
+// A pane as Search.js reads it, recording what it asks the backend.
+function pane(extra = {}) {
+  const calls = [];
+  const root = {
+    calls, recentMode: "", searchMode: "", searchQuery: "", searchSent: "", searchGen: 0, searchStep: 0,
+    path: "/work", home: "/home/u", showHidden: false, windowSize: 40, sizeWish: false, cursorIndex: 0,
+    rowFor: () => null, join: (a, b) => a + "/" + b,
+    backend: {
+      searchOpen: (scope, folder, hidden) => calls.push(["open", scope]),
+      searchQuery: (query, gen, count, sizes, contents) => calls.push(["query", query, contents]),
+      searchCancel: () => calls.push(["cancel"]), searchClose: () => calls.push(["close"]),
+    },
+    openWithoutHistory: (path) => calls.push(["relist", path]),
+    ...extra,
+  };
+  return root;
+}
+const key = (code, modifiers = 0) => ({ key: code, modifiers, text: "" });
+
+test("Ctrl+G opens a content search that waits for Enter, as f opens a name search", () => {
+  const root = pane();
+  Search.contents(root);
+  expect(root.searchMode).toBe(Search.TYPING);
+  expect(root.searchContents).toBe(true);
+  expect(root.calls).toEqual([["open", "/work"]]);
+  expect(Search.placeholder(root.path, root.home, root.searchStep, true)).toBe("grep -ri ");
+  root.searchQuery = "needle";
+  Search.typeKey(key(Qt.Key_Return), root);
+  expect(root.calls.at(-1)).toEqual(["query", "needle", true]);
+  expect(root.searchMode).toBe(Search.RESULTS);
+  // f starts a name search afresh.
+  const named = pane();
+  Search.start(named);
+  expect(named.searchContents).toBe(false);
+  expect(Search.placeholder(named.path, named.home, 0, false)).toBe("find . -iname ");
+});
+
+test("Ctrl+G inside Find only turns the mode; the query runs at the next Enter", () => {
+  const root = pane();
+  Search.start(root);
+  root.searchQuery = "draft";
+  Search.typeKey(key(Qt.Key_G, Qt.ControlModifier), root);
+  expect(root.searchContents).toBe(true);
+  expect(root.calls.filter((c) => c[0] === "query")).toEqual([]);
+  Search.typeKey(key(Qt.Key_Return), root);
+  expect(root.calls.at(-1)).toEqual(["query", "draft", true]);
+  expect(root.searchMode).toBe(Search.RESULTS);
+  // From the results (a query already run) it still waits, back on the query line.
+  const sent = root.calls.length;
+  Search.contents(root);
+  expect(root.searchContents).toBe(false);
+  expect(root.searchMode).toBe(Search.TYPING);
+  expect(root.calls.length).toBe(sent);
+  root.searchEnterAt = 0;
+  Search.typeKey(key(Qt.Key_Return), root);
+  expect(root.calls.at(-1)).toEqual(["query", "draft", false]);
+});
+
+test("Tab, Enter and Esc keep their meanings in a content search", () => {
+  const root = pane();
+  Search.contents(root);
+  root.searchQuery = "needle";
+  Search.typeKey(key(Qt.Key_Return), root);
+  // Tab turns the scope and reruns, still over contents.
+  Search.typeKey(key(Qt.Key_Tab), root);
+  expect(root.calls.slice(-2)).toEqual([["open", "/home/u"], ["query", "needle", true]]);
+  // Esc while the walk runs stops it and keeps the results; the next Esc leaves.
+  root.searchRunning = true;
+  Search.typeKey(key(Qt.Key_Escape), root);
+  expect(root.calls.at(-1)).toEqual(["cancel"]);
+  expect(root.searchMode).not.toBe("");
+  root.searchRunning = false;
+  Search.typeKey(key(Qt.Key_Escape), root);
+  expect(root.calls.slice(-2)).toEqual([["close"], ["relist", "/work"]]);
+});