flea-qml 0.0.0-stage → 0.2.0

package/src/compare.js

@@ -0,0 +1,74 @@
+// Compare uses the same bunmsh -cc builtin launch convention as Find.
+import {existsSync} from 'node:fs';
+import {open} from 'node:fs/promises';
+import {constants} from 'node:fs';
+import {join,isAbsolute} from 'node:path';
+const LIMIT=1024*1024, PATCH_LIMIT=8*LIMIT;
+export function diffCommands({which=Bun.which,exists=existsSync,beside=join(import.meta.dir,'../../bunmsh/index.js')}={}) {
+ const commands=[];
+ if(exists(beside))commands.push([which('bun')||process.argv0,beside,'-cc','builtin','diff']);
+ const shell=which('bunmsh');if(shell)commands.push([shell,'-cc','builtin','diff']);
+ const diff=which('diff');if(diff)commands.push([diff]);
+ return commands;
+}
+async function read(path) {
+ if(typeof path!=='string'||!isAbsolute(path))throw Error('Not an absolute path');
+ const f=await open(path,constants.O_RDONLY|(constants.O_NONBLOCK||0));
+ try {
+  const stat=await f.stat();if(!stat.isFile())throw Error('Not a regular file');
+  if(stat.size>LIMIT)return {over:true};
+  const data=Buffer.alloc(LIMIT+1);let count=0;
+  while(count<data.length){const r=await f.read(data,count,data.length-count,null);if(!r.bytesRead)break;count+=r.bytesRead;}
+  return {over:count>LIMIT,data:data.subarray(0,count)};
+ }finally{await f.close()}
+}
+async function run(argv,signal,timeout) {
+ let child,reader,timer,stopped=false;
+ // Diff is read-only: cancellation needs no graceful shutdown. Terminate even a
+ // provider that ignores SIGTERM, and release a pipe inherited by descendants.
+ const stop=()=>{
+  if(stopped)return;
+  stopped=true;
+  try{child?.kill('SIGKILL')}catch{}
+  if(reader)void reader.cancel().catch(()=>{});
+ };
+ try {
+  if(signal?.aborted)return null;
+  child=Bun.spawn(argv,{stdin:'ignore',stdout:'pipe',stderr:'ignore',env:{...process.env,NO_COLOR:'1',FORCE_COLOR:'0'}});
+  reader=child.stdout.getReader();
+  signal?.addEventListener('abort',stop,{once:true});
+  if(signal?.aborted)stop();
+  timer=setTimeout(stop,timeout);
+  const chunks=[];let size=0;
+  while(!stopped){
+   const {done,value:chunk}=await reader.read();if(done)break;
+   size+=chunk.length;if(size>PATCH_LIMIT){stop();break;}chunks.push(chunk);
+  }
+  const code=await child.exited;if(stopped)return null;
+  const patch=new TextDecoder('utf-8',{fatal:true}).decode(Buffer.concat(chunks));
+  if(code===0)return {state:'identical',patch:''};
+  if(code===1 && /^--- .*\n\+\+\+ .*\n@@ /s.test(patch))return {state:'diff',patch};
+  return false; // An older bunmsh may not yet support -u: try the next provider.
+ }catch{return stopped?null:false}
+ finally{
+  clearTimeout(timer);signal?.removeEventListener('abort',stop);
+  if(reader){try{await reader.cancel()}catch{}reader.releaseLock();}
+  if(child){try{child.kill('SIGKILL')}catch{}await child.exited.catch(()=>{});}
+ }
+}
+export async function compare(request,{commands=diffCommands(),signal,timeout=10000}={}) {
+ const reply={t:'compare',token:request.token,state:'failed',patch:''};
+ try {
+  const a=await read(request.a),b=await read(request.b);
+  if(a.over||b.over)return {...reply,state:'over'};
+  if(a.data.subarray(0,8192).includes(0)||b.data.subarray(0,8192).includes(0))return {...reply,state:'binary'};
+  const decoder=new TextDecoder('utf-8',{fatal:true});decoder.decode(a.data);decoder.decode(b.data);
+  for(const prefix of commands){
+   if(signal?.aborted)return null;
+   const result=await run([...prefix,'-u','--label',request.a,'--label',request.b,'--',request.a,request.b],signal,timeout);
+   if(result)return {...reply,...result};
+   if(result===null)break;
+  }
+ }catch{}
+ return signal?.aborted?null:reply;
+}

package/src/create.js

@@ -0,0 +1,128 @@
+// Making things: `mkdir`, the menu's `newfile` and `duplicate` (docs/protocol.md "mkdir",
+// "duplicate"). Upstream: src/backend/opsdispatch.rs, menu_actions.rs `create_file`, ops.rs.
+// Not yet: the undo journal, so nothing made here can be undone.
+import { lstatSync, mkdirSync, openSync, closeSync } from "node:fs";
+import { basename, dirname, join, isAbsolute } from "node:path";
+import { capturedPaths } from "./menu.js";
+import { copyName, copyTree, reason } from "./transfer.js";
+
+const NAME_TRIES = 1000;
+const slash = (path) => (process.platform === "win32" ? path.replaceAll("\\", "/") : path);
+
+/** A bare name in one folder: not empty, not `.` or `..`, no separator and no NUL. */
+export function validName(name) {
+  return typeof name === "string" && name !== "" && name !== "." && name !== ".." && !/[/\0]/.test(name)
+    && !(process.platform === "win32" && name.includes("\\"));
+}
+
+const exists = (path) => {
+  try {
+    lstatSync(path);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+// The mkdir sentences of src/error.rs, which the client words as they come.
+const mkdirReason = (e) =>
+  ({
+    EEXIST: "a folder or file with that name already exists",
+    ENOENT: "item not found",
+    ENOTDIR: "item not found",
+    EACCES: "permission denied",
+    EPERM: "permission denied",
+    EROFS: "the drive is read-only",
+    ENAMETOOLONG: "that name is too long",
+    ENOSPC: "the drive is full",
+  })[e?.code] ?? String(e?.message ?? e);
+
+// An opted-in `request` adds itself to the success line and sends the creation receipt after it.
+function receipt(send, request, kind, fields) {
+  const id = request.request;
+  if (!Number.isSafeInteger(id) || id <= 0) return;
+  send({ t: "menuaction", op: "creation", id, kind, ...fields });
+}
+
+export function mkdir(request, send) {
+  const parent = request.path;
+  const fail = (msg) => {
+    send({ t: "error", where: "mkdir", path: String(parent ?? ""), msg });
+    receipt(send, request, "made", { ok: false, error: msg });
+  };
+  if (typeof parent !== "string" || !isAbsolute(parent)) return fail("the folder is not an absolute path");
+  const typed = typeof request.name === "string" && request.name !== "";
+  if (typed && !validName(request.name)) return fail("that name is not allowed");
+  // A typed name is never renumbered; no name takes the first free New Folder.
+  for (let n = 1; n <= (typed ? 1 : NAME_TRIES); n++) {
+    const name = typed ? request.name : n === 1 ? "New Folder" : `New Folder ${n}`,
+      path = join(parent, name);
+    try {
+      mkdirSync(path);
+    } catch (e) {
+      if (e?.code === "EEXIST" && !typed) continue;
+      return fail(mkdirReason(e));
+    }
+    const id = request.request;
+    send({ t: "made", ok: true, path: slash(path), ...(Number.isSafeInteger(id) && id > 0 ? { request: id } : {}) });
+    receipt(send, request, "made", { ok: true, path: slash(path) });
+    send({ t: "changed", path: slash(parent) });
+    return;
+  }
+  fail("every New Folder name is already taken");
+}
+
+// The New file card: one empty file, created exclusively, so neither a file nor a dangling link
+// already at that name is ever opened.
+export function newfile(request, send) {
+  const answer = (fields) => send({ t: "menuaction", id: request.id ?? 0, op: "newFile", ...fields });
+  const parent = request.path,
+    name = request.name;
+  if (typeof parent !== "string" || !isAbsolute(parent) || !validName(name))
+    return answer({ ok: false, error: "New File requires an absolute folder and one non-empty filename." });
+  const path = join(parent, name);
+  try {
+    closeSync(openSync(path, "wx", 0o666));
+  } catch (e) {
+    return answer({ ok: false, error: `Could not create ${path}: ${reason(e)}.` });
+  }
+  answer({ ok: true, path: slash(path) });
+  send({ t: "changed", path: slash(parent) });
+}
+
+// Copies one path to its first free " copy" sibling; a folder duplicates its whole tree.
+let duplicating = Promise.resolve();
+export function duplicate(request, send) {
+  const run = () => duplicateOne(request, send);
+  duplicating = duplicating.then(run, run);
+}
+
+async function duplicateOne(request, send) {
+  const source = request.path;
+  const fail = (msg) => {
+    send({ t: "error", where: "duplicate", path: String(source ?? ""), msg });
+    receipt(send, request, "duplicated", { ok: false, error: msg });
+  };
+  if (typeof source !== "string" || !isAbsolute(source)) return fail("the path is not absolute");
+  if (request.menuId && !capturedPaths(request.menuId)?.includes(source)) return fail("Selected item changed; reopen the menu.");
+  if (!exists(source)) return fail("it no longer exists");
+  const folder = dirname(source),
+    name = basename(source);
+  let target = null;
+  for (let n = 1; n <= NAME_TRIES && !target; n++) {
+    const candidate = join(folder, copyName(name, n));
+    if (!exists(candidate)) target = candidate;
+  }
+  if (!target) return fail("every copy name for this item is already taken");
+  try {
+    await copyTree(source, target);
+  } catch (e) {
+    // A copy that failed partway leaves its partial sibling, as upstream does, and the folder shows it.
+    send({ t: "changed", path: slash(folder) });
+    return fail(e?.sentence ?? reason(e));
+  }
+  const id = request.request;
+  send({ t: "duplicated", ok: true, path: slash(target), ...(Number.isSafeInteger(id) && id > 0 ? { request: id } : {}) });
+  receipt(send, request, "duplicated", { ok: true, path: slash(target) });
+  send({ t: "changed", path: slash(folder) });
+}

package/src/dirsize.js

@@ -0,0 +1,147 @@
+// Folder sizes, only when the user asks (docs/protocol.md "dirsize"): a click on a folder's ⚖️ Size
+// cell asks for that row, the ⚖️ on the Size header asks for every folder in the listing. Nothing
+// here ever starts a walk on its own: no viewport sweep, no size sort, no refresh.
+//
+// The walk is `du -s -b -x -0`, streamed: bunmsh's du beside this repository or on PATH, else the
+// system's (src/find.js duCommand). -b is apparent bytes, the unit file rows already show; -x stays
+// on the folder's own filesystem as upstream's walker does; each folder's line arrives as soon as
+// it is finished, so sizes land one by one. One du runs at a time; rows asked while it runs wait
+// for the next one. Several folders share one run, so a file hard-linked into two of them counts
+// in the first only, as `du -s a b` counts it.
+//
+// Answers are kept by full path and handed out again on later rows (`z`, and `zp` when partial)
+// after a sort, a refresh or a return to the folder, never recomputed. A `changed` line for a
+// folder forgets that folder and every folder above it, whose totals it is part of, and nothing
+// else: a busy folder never touches the sizes of its siblings. A change deep inside a measured
+// folder that no watch sees leaves its size as it was until the user measures it again.
+import { resolve, dirname } from "node:path";
+import { duCommand } from "./find.js";
+
+const known = new Map(),
+  waiting = new Set();
+let job = null,
+  send = () => {},
+  current = () => null;
+
+export function dirsizeInit(sender, listingOf) {
+  send = sender;
+  current = listingOf;
+}
+
+/** The kept size of the folder at `path`, or undefined. */
+export const keptSize = (path) => known.get(resolve(path));
+
+/** A folder changed: its own size and every one above it are no longer known. */
+export function forgetSizes(path) {
+  if (!known.size || typeof path !== "string") return;
+  let at = resolve(path);
+  for (;;) {
+    known.delete(at);
+    const up = dirname(at);
+    if (up === at) break;
+    at = up;
+  }
+}
+
+// The row a measured path holds in the listing now, which a sort since the ask may have moved.
+function rowOf(full) {
+  const listing = current();
+  if (!listing || listing.trash) return -1;
+  const base = resolve(listing.path || ".");
+  return listing.rows.findIndex((row) => row.dir && resolve(base, row.name) === full);
+}
+
+/** `dirsize`: { rows: [...] } or { all: true }; answers dirsized per folder, then one dirsizedone. */
+export function dirsize(request) {
+  const listing = current();
+  if (listing && !listing.trash) {
+    const base = resolve(listing.path || ".");
+    const indices = request.all === true ? listing.rows.map((_, i) => i)
+      : Array.isArray(request.rows) ? request.rows.filter(Number.isInteger) : [];
+    for (const i of indices) {
+      const row = listing.rows[i];
+      if (row?.dir) waiting.add(resolve(base, row.name));
+    }
+  }
+  if (!job) run();
+}
+
+/** `dirsizecancel`: the run in flight stops and nothing waits any more. */
+export function dirsizeCancel() {
+  waiting.clear();
+  if (!job) return send({ t: "dirsizedone", cancelled: true });
+  job.cancelled = true;
+  job.child?.kill();
+}
+
+const quotedNames = (errors) => {
+  // GNU and bunmsh both quote the path: "du: cannot read directory './photos/2019': Permission denied".
+  const names = new Set();
+  for (const match of errors.matchAll(/'\.[\\/]([^\\/']+)/g)) names.add(match[1]);
+  return names;
+};
+
+// The waiting folders that share the first one's parent: du runs there with "./name" operands, so a
+// name starting with "-" stays a name and each printed name maps straight back.
+function run() {
+  if (!waiting.size) return send({ t: "dirsizedone", cancelled: false });
+  const command = duCommand();
+  if (!command) {
+    waiting.clear();
+    send({ t: "error", where: "dirsize", path: "", msg: "no du could be found to measure folders" });
+    return send({ t: "dirsizedone", cancelled: false });
+  }
+  const parent = dirname(waiting.values().next().value);
+  const here = [...waiting].filter((full) => dirname(full) === parent);
+  for (const full of here) waiting.delete(full);
+  const names = here.map((full) => "./" + full.slice(parent.length).replace(/^[\\/]+/, ""));
+  const started = performance.now();
+  const mine = (job = { cancelled: false, child: null });
+  let child;
+  try {
+    child = Bun.spawn([...command, "-s", "-b", "-x", "-0", "--", ...names], { cwd: parent, stdin: "ignore", stdout: "pipe", stderr: "pipe" });
+  } catch (e) {
+    job = null;
+    send({ t: "error", where: "dirsize", path: parent, msg: String(e?.message ?? e) });
+    return run();
+  }
+  mine.child = child;
+  let errors = "";
+  const answered = new Map();
+  const answer = (name, bytes, partial) => {
+    const full = resolve(parent, name);
+    known.set(full, { bytes, partial });
+    answered.set(name, bytes);
+    if (mine.cancelled) return;
+    const row = rowOf(full);
+    if (row >= 0) send({ t: "dirsized", row, bytes, partial, ms: Number((performance.now() - started).toFixed(3)) });
+  };
+  const errorsDone = (async () => {
+    for await (const chunk of child.stderr) errors += Buffer.from(chunk).toString();
+  })();
+  const stdoutDone = (async () => {
+    let rest = "";
+    const decoder = new TextDecoder();
+    for await (const chunk of child.stdout) {
+      rest += decoder.decode(chunk, { stream: true });
+      let at;
+      while ((at = rest.indexOf("\0")) >= 0) {
+        const line = rest.slice(0, at);
+        rest = rest.slice(at + 1);
+        const tab = line.indexOf("\t");
+        const bytes = Number(line.slice(0, tab));
+        if (tab < 0 || !Number.isFinite(bytes)) continue;
+        const name = line.slice(tab + 1).replace(/^\.[\\/]/, "");
+        answer(name, bytes, quotedNames(errors).has(name));
+      }
+    }
+  })();
+  Promise.all([stdoutDone, errorsDone, child.exited]).then(() => {
+    // A message that reached stderr after its folder's line still makes that folder a floor.
+    const short = quotedNames(errors);
+    for (const [name, bytes] of answered) if (short.has(name) && !known.get(resolve(parent, name))?.partial) answer(name, bytes, true);
+    job = null;
+    if (mine.cancelled) return send({ t: "dirsizedone", cancelled: true });
+    run();
+  });
+}