accrete-kit 0.1.1 → 0.2.0

package/dist/ui/server/readers/objects.mjs

@@ -0,0 +1,261 @@
+// Reads the Workspace for the objects panel. Documents are primary and always list
+// and open. Relation rows come from the index, because it normalizes their shapes.
+import { execFile } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { KINDS, openStore, revisionOf } from '../documents.mjs';
+import { resolveWorkspace } from '../workspace.mjs';
+
+const MAX_PAGE = 1000;
+const SAMPLES = 5;
+
+let store = null;
+let indexRevisions = new Map(); // path -> revision, as of the last read of the index
+let indexPresent = false;
+
+function query(index, sql, attempt = 0) {
+  return new Promise((resolve, reject) => {
+    const args = ['-batch', '-init', '/dev/null', '-readonly', '-json', index, sql];
+    execFile('sqlite3', args, { maxBuffer: 2 ** 28, timeout: 20000 }, (err, stdout, stderr) => {
+      if (err) {
+        const message = stderr.trim() || err.message;
+        if (attempt < 10 && /locked|busy/i.test(message)) {
+          return setTimeout(() => query(index, sql, attempt + 1).then(resolve, reject), 100);
+        }
+        return reject(new Error(message));
+      }
+      try {
+        resolve(stdout.trim() ? JSON.parse(stdout) : []);
+      } catch (parseError) {
+        reject(parseError);
+      }
+    });
+  });
+}
+
+const DOCUMENT_ROWS = ['models', 'iterations', 'tools', 'data_objects', 'results', 'memory_entries']
+  .map((table) => `SELECT path, revision FROM ${table}`)
+  .join(' UNION ALL ');
+
+// What the index holds against what the documents hold, in plain counts and names.
+async function readIndex() {
+  const index = store.workspace.local_state?.index;
+  let state;
+  let rows = [];
+  let failure;
+  if (index && existsSync(index)) {
+    try {
+      [state] = await query(index, 'SELECT refreshed_at, object_count FROM index_state');
+      rows = await query(index, DOCUMENT_ROWS);
+    } catch (err) {
+      // A refresh creates the file a moment before its tables.
+      if (!/no such table/.test(err.message)) failure = err.message;
+    }
+  }
+  indexPresent = Boolean(state) && !failure;
+  indexRevisions = new Map(rows.map((row) => [row.path, row.revision]));
+  if (failure) return { present: true, error: failure };
+  if (!state) return { present: false };
+
+  const changed = [];
+  const missing = [];
+  for (const doc of store.docs.values()) {
+    const revision = indexRevisions.get(doc.path);
+    if (revision === undefined) missing.push(doc.rel);
+    else if (revision !== doc.revision) changed.push(doc.rel);
+  }
+  const gone = rows.filter((row) => !store.docs.has(row.path)).map((row) => store.relToBase(row.path));
+  return {
+    present: true,
+    refreshed_at: state.refreshed_at,
+    object_count: state.object_count,
+    changed: { count: changed.length, sample: changed.slice(0, SAMPLES) },
+    missing: { count: missing.length, sample: missing.slice(0, SAMPLES) },
+    gone: { count: gone.length, sample: gone.slice(0, SAMPLES) },
+  };
+}
+
+function templateVersion(root) {
+  try {
+    return JSON.parse(readFileSync(join(root, '.accrete/release.json'), 'utf8')).template_version ?? 'latest';
+  } catch {
+    return 'latest';
+  }
+}
+
+export async function start({ root, emit }) {
+  store = await openStore(root);
+  const install = store.workspace.kernel ? null : `npx accrete-kit@${templateVersion(root)} install`;
+  // A Kernel that is there but failed is worth naming; one that isn't there is the normal case.
+  const kernelError = install && !/ENOENT/.test(store.workspace.error ?? '') ? store.workspace.error : undefined;
+  let seq = 0;
+
+  async function publish() {
+    const counts = Object.fromEntries(KINDS.map((kind) => [kind, 0]));
+    for (const doc of store.docs.values()) counts[doc.kind] += 1;
+    const index = await readIndex();
+    emit('objects', { seq: ++seq, counts, index, install, kernel_error: kernelError });
+  }
+
+  store.subscribe(publish);
+  await publish();
+}
+
+const timeOf = (doc) => doc.authored_at ?? doc.updated_at ?? doc.created_at ?? '';
+
+function list(kind, offset, limit) {
+  const docs = [...store.docs.values()].filter((doc) => doc.kind === kind);
+  docs.sort((a, b) => timeOf(b).localeCompare(timeOf(a)) || a.rel.localeCompare(b.rel));
+  return {
+    kind,
+    total: docs.length,
+    offset,
+    items: docs.slice(offset, offset + limit).map((doc) => ({
+      id: doc.id,
+      name: doc.name,
+      status: doc.status,
+      rel: doc.rel,
+      time: timeOf(doc) || undefined,
+      problem: doc.problem,
+    })),
+  };
+}
+
+const quote = (value) => `'${value.replaceAll("'", "''")}'`;
+
+// A reference holds whatever its author wrote, and the Kernel accepts a name or alias
+// where an ID goes: `memory append --model NAME` stores NAME. So reverse lookups match
+// those too, and a forward lookup falls back to them.
+function relationSql(id, doc) {
+  const me = quote(id);
+  const us = `(${[id, doc?.name, ...(doc?.aliases ?? [])].filter(Boolean).map(quote).join(',')})`;
+  const dataDoc = '(SELECT document FROM results r WHERE r.id = d.result_id)';
+  const origin = "json_extract(document, '$.origin.result_id')";
+  return [
+    `SELECT 'Models used' section, 'model' kind, model_id target, role, commit_id, NULL revision, document link, NULL result_doc FROM result_models WHERE result_id = ${me}`,
+    `SELECT 'Tools used', 'tool', tool_id, NULL, NULL, revision_used, document, NULL FROM result_tools WHERE result_id = ${me}`,
+    `SELECT 'Data', 'data', data_id, role, NULL, NULL, document, ${dataDoc} FROM result_data d WHERE result_id = ${me}`,
+    `SELECT 'Data from this Result', 'data', id, NULL, NULL, NULL, NULL, NULL FROM data_objects WHERE ${origin} = ${me}`,
+    `SELECT 'Model', 'model', model_id, NULL, NULL, starting_revision, NULL, NULL FROM iterations WHERE id = ${me}`,
+    `SELECT 'Iterations', 'iteration', id, NULL, NULL, starting_revision, NULL, NULL FROM iterations WHERE model_id IN ${us}`,
+    `SELECT 'Results', 'result', result_id, role, commit_id, NULL, document, NULL FROM result_models WHERE model_id IN ${us}`,
+    `SELECT 'Results', 'result', result_id, NULL, NULL, revision_used, document, NULL FROM result_tools WHERE tool_id IN ${us}`,
+    `SELECT 'Results', 'result', result_id, role, NULL, NULL, document, ${dataDoc} FROM result_data d WHERE data_id IN ${us}`,
+    `SELECT 'Origin', 'result', ${origin}, NULL, NULL, NULL, NULL, NULL FROM data_objects WHERE id = ${me} AND ${origin} IS NOT NULL`,
+    `SELECT 'Links', kind, target_id, relation, NULL, NULL, document, NULL FROM memory_links WHERE memory_id = ${me}`,
+    `SELECT 'Linked from Memory', 'memory', memory_id, relation, NULL, NULL, NULL, NULL FROM memory_links WHERE target_id = ${me} OR (target_id IN ${us} AND kind = ${quote(doc?.kind ?? '')})`,
+  ].join(' UNION ALL ');
+}
+
+// The IDs a reference or a list of references names, in any shape the Kernel accepts.
+function referencedIds(value) {
+  if (typeof value === 'string') return [value];
+  if (Array.isArray(value)) return value.flatMap(referencedIds);
+  if (value === null || typeof value !== 'object') return [];
+  const own = value.data_id ?? value.id ?? value.data;
+  return typeof own === 'string' ? [own] : Object.values(value).flatMap(referencedIds);
+}
+
+// result_data.role is the author's role, so "forcing" hides whether it was an input.
+// The Result's own document still says.
+function direction(row) {
+  if (!row.result_doc) return undefined;
+  const link = JSON.parse(row.link);
+  if (link.direction) return link.direction;
+  const result = JSON.parse(row.result_doc);
+  const [named] = referencedIds(link);
+  if (referencedIds(result.inputs).includes(named)) return 'input';
+  if (referencedIds(result.outputs).includes(named)) return 'output';
+  return undefined;
+}
+
+function commitAvailable(checkout, commit) {
+  if (!checkout) return null; // Nothing on this host to look in.
+  if (!/^[0-9a-f]{4,64}$/i.test(commit)) return false;
+  return new Promise((resolve) => {
+    execFile('git', ['--no-optional-locks', '-C', checkout, 'cat-file', '-e', `${commit}^{commit}`], { timeout: 5000 }, (err) => resolve(!err));
+  });
+}
+
+async function relations(id, doc, configuration) {
+  if (!indexPresent) return null;
+  const models = configuration?.models ?? {};
+  const rows = await query(store.workspace.local_state.index, relationSql(id, doc));
+  return Promise.all(
+    rows.map(async (row) => {
+      const target = row.target === null ? null : store.byId.get(row.target) ?? store.byName.get(`${row.kind}:${row.target}`);
+      const flow = direction(row);
+      const relation = {
+        section: row.section === 'Data' && flow ? `${flow[0].toUpperCase()}${flow.slice(1)} Data` : row.section,
+        kind: target?.kind ?? row.kind,
+        id: target?.id ?? row.target,
+        name: target?.name,
+        present: Boolean(target),
+        direction: row.section === 'Results' ? flow : undefined,
+        role: row.role ?? undefined,
+        commit: row.commit_id ?? undefined,
+        revision: row.revision ?? undefined,
+      };
+      if (row.target === null) relation.detail = row.link; // A reference with no ID, such as a bare path.
+      if (row.section === 'Models used' && row.commit_id) {
+        relation.commit_available = await commitAvailable(models[target?.id ?? row.target]?.checkout, row.commit_id);
+      }
+      return relation;
+    }),
+  );
+}
+
+// The local paths this host binds to an object, if any.
+function hostBinding(doc, configuration) {
+  const section = { model: 'models', iteration: 'iterations', tool: 'tools' }[doc?.kind];
+  return section ? configuration?.[section]?.[doc.id] : undefined;
+}
+
+async function object(id) {
+  if (!id || id.length > 1024 || id.includes('\0')) return undefined;
+  const doc = store.byId.get(id);
+  const bytes = doc ? await readFile(doc.path).catch(() => null) : null;
+  // Asked each time, because registering or binding a Model changes the host's bindings.
+  const { configuration } = await resolveWorkspace(store.root);
+  let rows = null;
+  let relationsError;
+  try {
+    rows = await relations(id, doc, configuration);
+  } catch (err) {
+    relationsError = err.message;
+  }
+  const base = { id, relations: rows, relations_error: relationsError };
+  if (!bytes) return { ...base, present: false };
+  const indexRevision = indexRevisions.get(doc.path);
+  return {
+    ...base,
+    present: true,
+    kind: doc.kind,
+    name: doc.name,
+    status: doc.status,
+    rel: doc.rel,
+    problem: doc.problem,
+    created_at: doc.created_at,
+    updated_at: doc.updated_at,
+    authored_at: doc.authored_at,
+    revision: revisionOf(bytes),
+    index_revision: indexRevision,
+    in_index: indexPresent ? indexRevision !== undefined : undefined,
+    binding: hostBinding(doc, configuration),
+    text: bytes.toString('utf8'),
+  };
+}
+
+// rest is untrusted: it selects among scanned documents, and is never used as a path.
+export async function read(rest) {
+  if (!store) return undefined;
+  const [verb, ...tail] = rest.split('/');
+  if (verb === 'object') return object(tail.join('/'));
+  if (verb === 'list' && KINDS.includes(tail[0])) {
+    const offset = Math.max(0, Number.parseInt(tail[1], 10) || 0);
+    const limit = Math.min(MAX_PAGE, Math.max(1, Number.parseInt(tail[2], 10) || 100));
+    return list(tail[0], offset, limit);
+  }
+  return undefined;
+}

package/dist/ui/server/readers/running.mjs

@@ -0,0 +1,245 @@
+// What is running under this Workspace, from ps and lsof, and the files it is writing.
+// Only what the process table and the files show; no opinion on whether it is healthy.
+import { open, stat } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { extname, join } from 'node:path';
+import { listProcesses, openFiles, workingDirectories } from '../processes.mjs';
+import { inScope, readScope } from '../scope.mjs';
+
+const POLL_MS = 4000;
+const SCOPE_MS = 30000;
+const CWD_REFRESH_MS = 30000; // a shell can cd; a new pid is looked up as soon as it appears
+const TAIL_BYTES = 16 * 1024;
+const TAIL_LINES = 5;
+const LINE_CHARS = 400;
+const MAX_FILES_PER_PROCESS = 8;
+const GROWTH_WINDOW_MS = 60000;
+const NOT_WORK = /^(?:\/System\/|\/usr\/libexec\/|\/usr\/sbin\/)/;
+const SHELL = /^-?(?:\S*\/)?(?:zsh|bash|sh|dash|fish|ksh|tcsh|csh)$/;
+const TMUX = /^(?:\S*\/)?tmux(?::|\s|$)/;
+const UI_SERVER = /\bbin\/accrete-ui\.mjs(?:\s|$)/;
+const BINARY_EXTENSIONS = new Set(['.nc', '.nc4', '.h5', '.hdf5', '.npy', '.npz', '.grib', '.grb', '.zarr', '.parquet', '.bin', '.dat', '.pkl', '.pt', '.ckpt', '.sqlite', '.db', '.png', '.jpg', '.pdf', '.gz', '.zip', '.tar', '.zst']);
+
+function isShell(command) {
+  return SHELL.test(command.split(/\s+/, 1)[0]);
+}
+
+// A shell sitting at its prompt: no script and no -c, just options.
+function isLoginShellForm(command) {
+  const [program, ...args] = command.split(/\s+/);
+  return SHELL.test(program) && args.every((arg) => arg.startsWith('-') && !/^-[a-z]*c[a-z]*$/.test(arg));
+}
+
+// The tree of processes to show, from ps rows and pid -> cwd. A process's parent in
+// the tree is its nearest ancestor that is itself shown.
+export function selectProcesses(rows, cwds, scope, selfPid = process.pid) {
+  const byPid = new Map(rows.map((row) => [row.pid, row]));
+  const servers = new Set(rows.filter((row) => row.pid === selfPid || UI_SERVER.test(row.command)).map((row) => row.pid));
+  const isOurs = (row) =>
+    servers.has(row.pid) || TMUX.test(row.command) || (servers.has(row.ppid) && !isShell(row.command)); // ps, lsof and the Kernel, run by a reader
+
+  const nodes = new Map();
+  for (const row of rows) {
+    if (inScope(scope, cwds.get(row.pid)) && !isOurs(row)) nodes.set(row.pid, { ...row, cwd: cwds.get(row.pid), children: [] });
+  }
+
+  const roots = [];
+  for (const node of nodes.values()) {
+    let up = byPid.get(node.ppid);
+    while (up && !nodes.has(up.pid)) up = byPid.get(up.ppid);
+    (up ? nodes.get(up.pid).children : roots).push(node);
+  }
+
+  const keep = (node) => {
+    node.children = node.children.filter(keep).sort((a, b) => a.startedAt - b.startedAt);
+    return node.children.length > 0 || !isLoginShellForm(node.command) || node.cpu >= 1;
+  };
+  return roots.filter(keep).sort((a, b) => a.startedAt - b.startedAt);
+}
+
+export function writtenFiles(files, home = homedir()) {
+  const agentState = [join(home, '.claude/'), join(home, '.codex/')];
+  return files.filter(
+    (file) =>
+      /^\d+$/.test(file.fd) &&
+      (file.access === 'w' || file.access === 'u') &&
+      file.type === 'REG' &&
+      file.name?.startsWith('/') &&
+      !agentState.some((dir) => file.name.startsWith(dir)),
+  );
+}
+
+// Terminal control sequences go, and a line rewritten with \r shows its last state.
+function cleanLine(line) {
+  const text = line
+    .replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, '')
+    .split('\r')
+    .filter(Boolean)
+    .pop() ?? '';
+  const plain = text.replace(/[\x00-\x08\x0b-\x1f\x7f]/g, '');
+  return plain.length > LINE_CHARS ? `${plain.slice(0, LINE_CHARS)}...` : plain;
+}
+
+// The last lines of a file if its end looks like text, or { binary: true }.
+export async function readLogTail(path, size) {
+  if (BINARY_EXTENSIONS.has(extname(path).toLowerCase())) return { binary: true };
+  const length = Math.min(size, TAIL_BYTES);
+  const file = await open(path, 'r');
+  let buffer;
+  try {
+    buffer = Buffer.alloc(length);
+    const { bytesRead } = await file.read(buffer, 0, length, size - length);
+    buffer = buffer.subarray(0, bytesRead);
+  } finally {
+    await file.close();
+  }
+  if (buffer.includes(0)) return { binary: true };
+  const text = buffer.toString('utf8');
+  const odd = text.match(/[�\x01-\x08\x0e-\x1a\x1c-\x1f]/g)?.length ?? 0;
+  if (odd > Math.max(4, text.length / 100)) return { binary: true };
+  const lines = text.split('\n');
+  if (size > length) lines.shift(); // cut at the start
+  while (lines.length > 0 && !lines.at(-1).trim()) lines.pop();
+  return { lines: lines.slice(-TAIL_LINES).map(cleanLine) };
+}
+
+const quiet = (node) => node.cpu < 1 && node.writes.length === 0 && node.children.every(quiet);
+
+// An agent can keep dozens of the same idle helper here, one set per thread. Three or
+// more identical quiet siblings read as one line, so a lone stuck program never folds.
+export function foldIdentical(nodes) {
+  const same = new Map();
+  for (const node of nodes) {
+    if (!quiet(node)) continue;
+    if (!same.has(node.command)) same.set(node.command, []);
+    same.get(node.command).push(node);
+  }
+  const folded = [];
+  for (const node of nodes) {
+    const peers = same.get(node.command);
+    if (!quiet(node) || !peers || peers.length < 3) folded.push({ ...node, children: foldIdentical(node.children) });
+    else if (peers[0] === node) folded.push({ ...node, children: [], pids: peers.map((peer) => peer.pid), rss: peers.reduce((sum, peer) => sum + peer.rss, 0) });
+  }
+  return folded;
+}
+
+function present(node) {
+  return {
+    pid: node.pid,
+    pids: node.pids,
+    startedAt: node.startedAt,
+    cpu: Math.round(node.cpu),
+    rssMb: Math.round(node.rss / 1048576),
+    cwd: node.cwd,
+    command: node.command,
+    writes: node.writes,
+    children: node.children.map(present),
+  };
+}
+
+export function createRunning({ selfPid = process.pid, uid = process.getuid(), home = homedir() } = {}) {
+  const cwdCache = new Map(); // pid -> { startedAt, cwd }
+  const fileCache = new Map(); // path -> { size, mtimeMs, samples, tail }
+  let cwdsAt = 0;
+
+  async function refreshCwds(rows, now) {
+    const candidates = rows.filter((row) => row.uid === uid && !NOT_WORK.test(row.command));
+    const stale = now - cwdsAt >= CWD_REFRESH_MS;
+    const lookup = stale ? candidates : candidates.filter((row) => cwdCache.get(row.pid)?.startedAt !== row.startedAt);
+    if (stale) cwdsAt = now;
+    const found = await workingDirectories(lookup.map((row) => row.pid));
+    for (const row of lookup) cwdCache.set(row.pid, { startedAt: row.startedAt, cwd: found.get(row.pid) ?? null });
+    const alive = new Set(rows.map((row) => row.pid));
+    for (const pid of cwdCache.keys()) if (!alive.has(pid)) cwdCache.delete(pid);
+    return new Map(candidates.map((row) => [row.pid, cwdCache.get(row.pid)?.cwd]));
+  }
+
+  async function describeFile(path, now) {
+    let info;
+    try {
+      info = await stat(path);
+    } catch {
+      return null; // deleted while still open, or out of reach
+    }
+    if (!info.isFile()) return null;
+    let known = fileCache.get(path);
+    if (!known) fileCache.set(path, (known = { samples: [], tail: null }));
+    if (known.size !== info.size || known.mtimeMs !== info.mtimeMs || !known.tail) {
+      known.size = info.size;
+      known.mtimeMs = info.mtimeMs;
+      known.tail = await readLogTail(path, info.size).catch(() => ({ unknown: true }));
+    }
+    known.seen = now;
+    known.samples.push({ at: now, size: info.size });
+    while (known.samples.length > 2 && now - known.samples[1].at >= GROWTH_WINDOW_MS) known.samples.shift();
+    const first = known.samples[0];
+    return {
+      path,
+      size: info.size,
+      mtimeMs: info.mtimeMs,
+      ...known.tail,
+      grew: info.size - first.size,
+      overSeconds: Math.round((now - first.at) / 5000) * 5,
+    };
+  }
+
+  async function poll(scope) {
+    const now = Date.now();
+    const rows = await listProcesses();
+    const cwds = await refreshCwds(rows, now);
+    const roots = selectProcesses(rows, cwds, scope, selfPid);
+
+    const shown = [];
+    const walk = (node) => {
+      shown.push(node);
+      node.children.forEach(walk);
+    };
+    roots.forEach(walk);
+
+    const opened = await openFiles(shown.map((node) => node.pid));
+    const files = {};
+    for (const node of shown) {
+      const written = writtenFiles(opened.get(node.pid) ?? [], home);
+      const paths = [...new Set(written.map((file) => file.name))];
+      for (const path of paths) {
+        if (!(path in files)) files[path] = await describeFile(path, now);
+      }
+      node.writes = paths
+        .filter((path) => files[path])
+        .sort((a, b) => files[b].mtimeMs - files[a].mtimeMs)
+        .slice(0, MAX_FILES_PER_PROCESS);
+    }
+    for (const [path, known] of fileCache) if (known.seen !== now) fileCache.delete(path);
+    for (const path of Object.keys(files)) if (!files[path]) delete files[path];
+
+    return { scope, home, roots: foldIdentical(roots).map(present), files };
+  }
+
+  return { poll };
+}
+
+export function start({ root, emit }) {
+  emit('running', { scope: [root], home: homedir(), roots: [], files: {}, loading: true });
+  const running = createRunning();
+  let scope = [root];
+  let scopeAt = 0;
+  let last = null;
+
+  async function poll() {
+    try {
+      if (Date.now() - scopeAt > SCOPE_MS) {
+        scope = await readScope(root);
+        scopeAt = Date.now();
+      }
+      const state = JSON.stringify(await running.poll(scope));
+      if (state !== last) {
+        last = state;
+        emit('running', JSON.parse(state));
+      }
+    } catch (err) {
+      console.error(`accrete-ui: running poll failed: ${err.message}`);
+    }
+    setTimeout(poll, POLL_MS).unref();
+  }
+  poll();
+}

package/dist/ui/server/scope.mjs

@@ -0,0 +1,36 @@
+// Which directories count as "this Workspace": its root, bound Model checkouts,
+// and Iteration worktrees. The Kernel keeps worktree bindings in local configuration,
+// so `config resolve` reports them; an Iteration document may also name one.
+import { readdir, readFile, realpath } from 'node:fs/promises';
+import { join } from 'node:path';
+import { resolveWorkspace } from './workspace.mjs';
+
+export async function readScope(root) {
+  const workspace = await resolveWorkspace(root);
+  const { configuration: config, paths } = workspace;
+  const found = [workspace.project_root ?? root];
+  for (const model of Object.values(config?.models ?? {})) found.push(model?.checkout);
+  for (const iteration of Object.values(config?.iterations ?? {})) found.push(iteration?.worktree);
+
+  const iterations = join(paths?.metadata ?? join(root, '.accrete/objects'), 'iterations');
+  const names = await readdir(iterations).catch(() => []);
+  for (const name of names.filter((n) => n.endsWith('.json'))) {
+    try {
+      found.push(JSON.parse(await readFile(join(iterations, name), 'utf8')).worktree);
+    } catch {
+      // A document being replaced or not valid JSON names no worktree for now.
+    }
+  }
+
+  const scope = new Set();
+  for (const path of found) {
+    if (typeof path !== 'string' || !path.startsWith('/')) continue;
+    scope.add(path.replace(/\/+$/, ''));
+    scope.add(await realpath(path).catch(() => path));
+  }
+  return [...scope];
+}
+
+export function inScope(scope, path) {
+  return typeof path === 'string' && scope.some((dir) => path === dir || path.startsWith(`${dir}/`));
+}