flea-qml 0.0.0-stage → 0.1.0

package/src/menu.js

@@ -0,0 +1,180 @@
+// The selected-item menu's `menuaction` requests (docs/protocol.md "menuaction identity and
+// deletion"). Upstream: src/backend/menuaction*.rs.
+//
+// Ported: snapshot, which captures the selection's paths with each one's identity; activate and
+// validate, which check those identities again and hand the paths back; close; and Delete
+// permanently's prepareDelete, checkDelete, refreshDelete and delete, which remove only what the
+// confirmation reviewed. Every other operation answers ok:false, so the menu says so instead of
+// waiting.
+import {trashRecord,forgetTrashRecord} from './trash-record.js';
+import { constants, lstatSync, readdirSync, rmSync } from "node:fs";
+import { dirname, join, resolve, isAbsolute } from "node:path";
+
+const CHANGED = "Selected items changed; reopen the menu.";
+
+// What a name holds: device, inode and file type.
+const identity = (st) => `${st.dev}:${st.ino}:${st.mode & constants.S_IFMT}`;
+
+// id -> { paths, cursor, identities }
+const captured = new Map();
+
+export function capturedPaths(menuId) {
+  const held = captured.get(menuId);
+  return held && unchanged(held) ? held.paths.slice() : null;
+}
+
+export function captureSelection(menuId) {
+  const held = captured.get(menuId);
+  return held && unchanged(held) ? { paths: held.paths.slice(), identities: held.identities.slice() } : null;
+}
+
+export function selectionItemUnchanged(held, index) {
+  try { return identity(lstatSync(held.paths[index])) === held.identities[index]; }
+  catch { return false; }
+}
+
+function unchanged(held) {
+  if (held.cursor) {
+    try { if (identity(lstatSync(held.cursor)) !== held.cursorIdentity) return false; }
+    catch { return false; }
+  }
+  return held.paths.every((path, i) => {
+    try {
+      return identity(lstatSync(path)) === held.identities[i];
+    } catch {
+      return false;
+    }
+  });
+}
+
+export function menuaction(request, send, listing, stamp) {
+  const id = request.id ?? 0,
+    op = request.op ?? "",
+    answer = (fields) => send({ t: "menuaction", id, op, ...fields });
+  if (op === "snapshot") {
+    captured.delete(id);
+    if (request.listing !== undefined && request.listing !== stamp) return answer({ ok: false, error: CHANGED });
+    let paths, cursor;
+    if (Array.isArray(request.paths)) {
+      paths = request.paths.map(String);
+      cursor = typeof request.cursorPath === "string" ? request.cursorPath : (paths[0] ?? "");
+    } else {
+      if (request.listing !== undefined && request.listing !== stamp) return answer({ ok: false, error: CHANGED });
+      const at = (index) => (listing?.rows[index] ? (listing.rows[index].trash?.file ?? join(listing.path || ".", listing.rows[index].name)) : null);
+      paths = (request.rows ?? []).map(at);
+      if (paths.some((p) => p === null)) return answer({ ok: false, error: CHANGED });
+      cursor = at(request.cursor) ?? paths[0] ?? "";
+    }
+    const stats = [];
+    for (const path of paths) {
+      try {
+        stats.push(lstatSync(path));
+      } catch {
+        return answer({ ok: false, error: CHANGED });
+      }
+    }
+    let cursorIdentity;
+    try { cursorIdentity = cursor ? identity(lstatSync(cursor)) : null; }
+    catch { return answer({ ok: false, error: CHANGED }); }
+    captured.set(id, { paths, cursor, cursorIdentity, identities: stats.map(identity) });
+    return answer({ ok: true, count: paths.length, modes: stats.map((s) => s.mode), kinds: stats.map((s) => s.mode & constants.S_IFMT) });
+  }
+  const held = captured.get(id);
+  if (op === "close") {
+    captured.delete(id);
+    return;
+  }
+  if (op === "activate" || op === "validate") {
+    const action = String(request.action ?? "");
+    if (!held || !unchanged(held)) return answer({ action, ok: false, error: CHANGED, paths: [] });
+    const single = action.startsWith("taildrop:") || action === "sharelink";
+    return answer({ action, ok: true, paths: single ? [held.cursor] : held.paths, ...(request.dest === undefined ? {} : { dest: request.dest }) });
+  }
+  if (op === "prepareDelete" || op === "refreshDelete") {
+    if (!held) return answer({ ok: false, error: CHANGED });
+    // A refresh reviews only the paths already captured: missing ones drop out, replaced ones are
+    // captured anew, and nothing outside them can join.
+    held.token = undefined;
+    held.review = undefined;
+    if (op === "refreshDelete") {
+      const kept = [];
+      for (const path of held.paths)
+        try {
+          kept.push([path, identity(lstatSync(path))]);
+        } catch {}
+      held.paths = kept.map(([path]) => path);
+      held.identities = kept.map(([, id]) => id);
+      held.cursor = held.paths[0] ?? "";
+      held.cursorIdentity = held.identities[0];
+    } else if (!unchanged(held)) return answer({ ok: false, error: CHANGED });
+    if (!held.paths.length) return answer({ ok: false, error: "Nothing selected is still there." });
+    try {
+      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 });
+    } catch (error) { return answer({ ok: false, error: error.message }); }
+  }
+  if (op === "checkDelete") {
+    return answer({ ok: true, valid: !!held && held.token !== undefined && held.token === request.token && reviewUnchanged(held) });
+  }
+  if (op === "delete") {
+    // Only the token the confirmation showed deletes, once; a changed selection asks for a fresh review.
+    if (!held || held.token === undefined || held.token !== request.token || !reviewUnchanged(held))
+      return answer({ ok: false, stale: true, error: CHANGED });
+    held.token = undefined;
+    let deleted = 0,
+      firstError = "";
+    const remaining = [],
+      folders = new Set();
+    held.paths.forEach((path, index) => {
+      try {
+        // Checked again just before the removal, so a name swapped since the review is left alone.
+        if (identity(lstatSync(path)) !== held.identities[index]) throw new Error(CHANGED);
+        // A link is removed as a link; rm never follows one into its target.
+        const record=trashRecord(path);
+        rmSync(path, { recursive: true, force: false });
+        forgetTrashRecord(record);
+        deleted++;
+        folders.add(dirname(path));
+      } catch (e) {
+        firstError ||= e.code === "EACCES" || e.code === "EPERM" ? "permission denied" : e.message;
+        try {
+          if (identity(lstatSync(path)) === held.identities[index]) remaining.push(path);
+        } catch {}
+      }
+    });
+    const failed = held.paths.length - deleted;
+    answer({ ok: true, deleted, failed, cancelled: false, error: failed ? firstError : "", remaining });
+    for (const path of folders) send({ t: "changed", path });
+    return;
+  }
+  answer({ ok: false, error: `${op || "That menu action"} is not ported to flea-qml yet.` });
+}
+
+let deleteTokens = 0;
+
+// Bounded, non-following review. A confirmation cannot silently include newly added
+// or replaced descendants. No path-based check makes concurrent filesystem mutation atomic.
+export function reviewTrees(paths) {
+  const rows = [], pending = paths.map(path => ({ path, dev: null }));
+  const deadline = performance.now() + 2000;
+  let bytes = 0;
+  while (pending.length) {
+    if (rows.length >= 100000 || performance.now() > deadline) throw new Error("The selected trees are too large to review safely.");
+    const { path, dev } = pending.pop();
+    if (!isAbsolute(path) || resolve(path) === dirname(resolve(path))) throw new Error("Refusing to delete a filesystem root or relative path.");
+    const st = lstatSync(path);
+    if (dev !== null && st.dev !== dev) throw new Error("Refusing to delete across a mounted filesystem.");
+    rows.push([path, identity(st), st.size, st.mtimeMs, st.ctimeMs]);
+    if (st.isDirectory()) {
+      for (const name of readdirSync(path).sort().reverse()) pending.push({path: join(path, name), dev: st.dev});
+    } else bytes += st.size;
+  }
+  return { rows, bytes };
+}
+function reviewUnchanged(held) {
+  if (!held.review || !unchanged(held)) return false;
+  try { return JSON.stringify(reviewTrees(held.paths).rows) === JSON.stringify(held.review.rows); }
+  catch { return false; }
+}

package/src/meta.js

@@ -0,0 +1,129 @@
+// The `meta` line: the facts one row's preview asks for and a listing row does not carry
+// (docs/protocol.md "meta"). Everything here is read by this process from the file itself; no tool
+// is run. Upstream: src/backend/meta.rs, metareq.rs, archivelist.rs.
+// 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 { officeKind, officePreview } from "./office.js";
+
+// A line count stops here and says it is a floor (`partial`).
+const LINE_BUDGET = 1 << 20;
+// A tile lists this many archive names and states the rest as "+ N more".
+const ARCHIVE_NAME_CAP = 64;
+
+const blank = () => ({
+  w: 0, h: 0, orient: 1, ms: 0, rate: 0,
+  entries: 0, unpacked: 0, afailed: false, names: [],
+  lines: 0, partial: false, lfailed: false, frames: 0,
+  photo: null, target: "", targetdir: false, raw: null, owner: "",
+});
+
+// Reads up to `length` bytes from the start of a regular file; null for anything else. The open is
+// non-blocking and re-checked on the descriptor, so a FIFO swapped in after the stat is never waited on.
+function head(path, length) {
+  let fd;
+  try {
+    if (!statSync(path).isFile()) return null;
+    fd = openSync(path, constants.O_RDONLY | (constants.O_NONBLOCK ?? 0));
+    const st = fstatSync(fd);
+    if (!st.isFile()) return null;
+    const buffer = Buffer.alloc(Math.min(length, st.size));
+    const read = readSync(fd, buffer, 0, buffer.length, 0);
+    return { bytes: buffer.subarray(0, read), size: st.size };
+  } catch {
+    return null;
+  } finally {
+    if (fd !== undefined) closeSync(fd);
+  }
+}
+
+// Stored pixel size from the header of a PNG, GIF, BMP, WebP or JPEG; null for anything else.
+function imageSize(b) {
+  if (b.length >= 24 && b.readUInt32BE(0) === 0x89504e47) return [b.readUInt32BE(16), b.readUInt32BE(20)];
+  if (b.length >= 10 && b.toString("latin1", 0, 4) === "GIF8") return [b.readUInt16LE(6), b.readUInt16LE(8)];
+  if (b.length >= 26 && b.toString("latin1", 0, 2) === "BM") return [b.readInt32LE(18), Math.abs(b.readInt32LE(22))];
+  if (b.length >= 30 && b.toString("latin1", 0, 4) === "RIFF" && b.toString("latin1", 8, 12) === "WEBP") {
+    const chunk = b.toString("latin1", 12, 16);
+    if (chunk === "VP8 ") return [b.readUInt16LE(26) & 0x3fff, b.readUInt16LE(28) & 0x3fff];
+    if (chunk === "VP8L") {
+      const bits = b.readUInt32LE(21);
+      return [(bits & 0x3fff) + 1, ((bits >> 14) & 0x3fff) + 1];
+    }
+    if (chunk === "VP8X") return [b.readUIntLE(24, 3) + 1, b.readUIntLE(27, 3) + 1];
+  }
+  if (b.length >= 4 && b[0] === 0xff && b[1] === 0xd8) {
+    for (let at = 2; at + 9 < b.length; ) {
+      if (b[at] !== 0xff) return null;
+      const marker = b[at + 1];
+      // Start of frame: every SOFn but DHT (C4), JPG (C8) and DAC (CC).
+      if (marker >= 0xc0 && marker <= 0xcf && ![0xc4, 0xc8, 0xcc].includes(marker))
+        return [b.readUInt16BE(at + 7), b.readUInt16BE(at + 5)];
+      at += 2 + b.readUInt16BE(at + 2);
+    }
+  }
+  return null;
+}
+
+function countLines(path, meta) {
+  // An office document counts the lines its preview shows, not the newlines in its zip.
+  if (officeKind(path)) {
+    try {
+      const text = officePreview(path).text;
+      for (let at = text.indexOf("\n"); at !== -1; at = text.indexOf("\n", at + 1)) meta.lines++;
+    } catch {
+      meta.lfailed = true;
+    }
+    return;
+  }
+  const file = head(path, LINE_BUDGET);
+  if (!file) {
+    meta.lfailed = true;
+    return;
+  }
+  // The newlines in a bitmap are a number nothing should be shown.
+  if (imageSize(file.bytes)) return;
+  let lines = 0;
+  for (const byte of file.bytes) if (byte === 10) lines++;
+  meta.lines = lines;
+  meta.partial = file.size > file.bytes.length;
+}
+
+function addEntry(meta, name, isDir, size) {
+  meta.entries++;
+  meta.unpacked += size;
+  if (meta.names.length < ARCHIVE_NAME_CAP) meta.names.push({ n: name, d: isDir });
+}
+
+// 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));
+  } 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 });
+  }
+}
+
+/** The facts for row `row` of `listing`, or null for a row the listing no longer holds. Async,
+ * because a compressed tar's listing streams. */
+export async function meta(listing, request) {
+  const row = listing?.rows[request.row];
+  if (!row) return null;
+  const path = join(listing.path, row.name),
+    out = blank();
+  try {
+    if (lstatSync(path).isSymbolicLink()) {
+      out.target = readlinkSync(path);
+      try {
+        out.targetdir = statSync(path).isDirectory();
+      } catch {}
+    }
+  } catch {}
+  const file = head(path, 65536);
+  const size = file && imageSize(file.bytes);
+  if (size) [out.w, out.h] = size;
+  if (request.text) countLines(path, out);
+  if (request.archive) await listMembers(path, row.name, out);
+  return { t: "meta", row: request.row, ...out, token: request.token ?? 0 };
+}