buninu 0.3.0 → 0.3.1

package/apps/bunmsh/src/completion.js

@@ -0,0 +1,247 @@
+import { readdirSync } from "node:fs";
+import { readdir } from "node:fs/promises";
+import { delimiter, dirname, isAbsolute, resolve } from "node:path";
+import { safeHistoryEntry } from "./history.js";
+import { environmentValue } from "./environment.js";
+
+const WINDOWS_EXECUTABLE_EXTENSIONS = [".exe", ".com", ".cmd", ".bat"];
+
+function commandName(entry, platform) {
+  if (platform !== "win32") return entry.name;
+  const lower = entry.name.toLowerCase();
+  const extension = WINDOWS_EXECUTABLE_EXTENSIONS.find((value) => lower.endsWith(value));
+  return extension ? entry.name.slice(0, -extension.length) : null;
+}
+
+function lowerBound(items, value) {
+  let left = 0;
+  let right = items.length;
+  while (left < right) {
+    const middle = (left + right) >>> 1;
+    if (items[middle] < value) left = middle + 1;
+    else right = middle;
+  }
+  return left;
+}
+
+export function prefixMatches(items, prefix) {
+  if (!prefix) return [];
+  const start = lowerBound(items, prefix);
+  const end = lowerBound(items, `${prefix}\uffff`);
+  return items.slice(start, end);
+}
+
+export function firstPrefixMatch(items, prefix) {
+  if (!prefix) return null;
+  const index = lowerBound(items, prefix);
+  return items[index]?.startsWith(prefix) ? items[index] : null;
+}
+
+export function completionContext(line, cursor = line.length) {
+  const source = line.slice(0, cursor);
+  let command = true;
+  let wordStart = 0;
+  let quote = null;
+  let escaped = false;
+  let token = "";
+
+  const finishWord = () => {
+    if (!token) return;
+    if (command && /^[A-Za-z_][A-Za-z0-9_]*=/.test(token)) {
+      token = "";
+      return;
+    }
+    command = false;
+    token = "";
+  };
+
+  for (let i = 0; i < source.length; i++) {
+    const ch = source[i];
+    if (escaped) {
+      token += ch;
+      escaped = false;
+      continue;
+    }
+    if (ch === "\\" && quote !== "'") {
+      escaped = true;
+      continue;
+    }
+    if (quote) {
+      if (ch === quote) quote = null;
+      else token += ch;
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      quote = ch;
+      continue;
+    }
+    if (ch === ";" || ch === "|" || ch === "&" || ch === "\n") {
+      finishWord();
+      command = true;
+      token = "";
+      wordStart = i + 1;
+      continue;
+    }
+    if (/\s/.test(ch)) {
+      finishWord();
+      wordStart = i + 1;
+      continue;
+    }
+    if (!token) wordStart = i;
+    token += ch;
+  }
+
+  const assignment = command && /^[A-Za-z_][A-Za-z0-9_]*=/.test(token);
+  return {
+    command: command && !assignment && quote === null,
+    prefix: token,
+    start: wordStart,
+  };
+}
+
+export function historyGhost(history, line) {
+  if (!line) return null;
+  for (let i = history.length - 1; i >= 0; i--) {
+    const entry = history[i];
+    if (!safeHistoryEntry(entry)) continue;
+    if (entry !== line && entry.startsWith(line)) return entry.slice(line.length);
+  }
+  return null;
+}
+
+export function nextGhostChunk(ghost) {
+  if (!ghost) return "";
+  let i = 0;
+  while (i < ghost.length && /\s/.test(ghost[i])) i++;
+  while (i < ghost.length && !/\s/.test(ghost[i])) i++;
+  while (i < ghost.length && /\s/.test(ghost[i])) i++;
+  return ghost.slice(0, i || ghost.length);
+}
+
+export function fitGhost(ghost, available) {
+  let output = "", width = 0;
+  for (const character of ghost ?? "") {
+    const characterWidth = Bun.stringWidth(character);
+    if (width + characterWidth > Math.max(0, available)) break;
+    output += character;
+    width += characterWidth;
+  }
+  return { output, width };
+}
+
+export class CommandIndex {
+  constructor(builtins, options = {}) {
+    this.builtins = builtins;
+    this.platform = options.platform ?? process.platform;
+    this.pathDelimiter = options.pathDelimiter ?? delimiter;
+    this.pathNames = [];
+    this.names = [...builtins].sort();
+    this.pathValue = null;
+    this.cwd = null;
+    this.aliasSignature = null;
+    this.refreshing = null;
+  }
+
+  syncShellNames(state) {
+    const aliases = Object.keys(state.aliases).sort();
+    const signature = aliases.join("\0");
+    if (signature === this.aliasSignature) return;
+    this.aliasSignature = signature;
+    this.names = [...new Set([...this.builtins, ...aliases, ...this.pathNames])].sort();
+  }
+
+  async refresh(state) {
+    if (this.refreshing) return this.refreshing;
+    const pathValue = environmentValue(state.env, "PATH", this.platform) ?? "";
+    const cwd = state.cwd;
+    this.refreshing = (async () => {
+      const directories = [...new Set(pathValue.split(this.pathDelimiter).map((directory) => {
+        if (!directory) return cwd;
+        return isAbsolute(directory) ? directory : resolve(cwd, directory);
+      }))];
+      const listings = await Promise.all(directories.map(async (directory) => {
+        try {
+          const entries = await readdir(directory, { withFileTypes: true });
+          return entries
+            .filter((entry) => !entry.isDirectory())
+            .map((entry) => commandName(entry, this.platform))
+            .filter((name) => name !== null);
+        } catch {
+          return [];
+        }
+      }));
+      this.pathNames = listings.flat();
+      this.pathValue = pathValue;
+      this.cwd = cwd;
+      this.aliasSignature = null;
+      this.syncShellNames(state);
+    })().finally(() => {
+      this.refreshing = null;
+    });
+    return this.refreshing;
+  }
+
+  refreshIfChanged(state) {
+    this.syncShellNames(state);
+    const pathValue = environmentValue(state.env, "PATH", this.platform) ?? "";
+    const relativePath = pathValue.split(this.pathDelimiter)
+      .some((directory) => !directory || !isAbsolute(directory));
+    if (this.pathValue !== pathValue || (relativePath && this.cwd !== state.cwd))
+      void this.refresh(state);
+  }
+
+  matches(prefix) {
+    return prefixMatches(this.names, prefix);
+  }
+
+  first(prefix) {
+    return firstPrefixMatch(this.names, prefix);
+  }
+}
+
+export class FileIndex {
+  constructor(ttl = 10_000) {
+    this.ttl = ttl;
+    this.directories = new Map();
+  }
+
+  entries(directory) {
+    const now = Date.now();
+    const cached = this.directories.get(directory);
+    if (cached && now - cached.at < this.ttl) return cached.names;
+    let names = [];
+    try {
+      names = readdirSync(directory, { withFileTypes: true })
+        .map((entry) => entry.name + (entry.isDirectory() ? "/" : ""))
+        .sort();
+    } catch {}
+    this.directories.set(directory, { at: now, names });
+    return names;
+  }
+
+  context(prefix, state) {
+    const slash = prefix.lastIndexOf("/");
+    const directoryPart = slash < 0 ? "" : prefix.slice(0, slash + 1);
+    const basename = prefix.slice(slash + 1);
+    let directory;
+    if (directoryPart.startsWith("~/"))
+      directory = resolve(state.env.HOME ?? state.cwd, directoryPart.slice(2));
+    else if (isAbsolute(directoryPart)) directory = dirname(`${directoryPart}.`);
+    else directory = resolve(state.cwd, directoryPart || ".");
+    return { directoryPart, basename, directory };
+  }
+
+  matches(prefix, state) {
+    const { directoryPart, basename, directory } = this.context(prefix, state);
+    const names = basename
+      ? prefixMatches(this.entries(directory), basename)
+      : this.entries(directory);
+    return names
+      .filter((name) => basename.startsWith(".") || !name.startsWith("."))
+      .map((name) => `${directoryPart}${name}`);
+  }
+
+  first(prefix, state) {
+    return this.matches(prefix, state)[0] ?? null;
+  }
+}

package/apps/bunmsh/src/environment.js

@@ -0,0 +1,61 @@
+export function environmentValue(env, name, platform = process.platform) {
+  if (Object.hasOwn(env, name)) return env[name];
+  if (platform !== "win32") return undefined;
+  const key = Object.keys(env).find((candidate) => candidate.toLowerCase() === name.toLowerCase());
+  return key === undefined ? undefined : env[key];
+}
+
+export function canonicalEnvironment(env, platform = process.platform) {
+  const output = { ...env };
+  if (platform !== "win32") return output;
+  const canonicalize = (name) => {
+    const keys = Object.keys(output).filter((key) => key.toLowerCase() === name.toLowerCase());
+    if (!keys.length) return undefined;
+    const value = output[keys.at(-1)];
+    for (const key of keys) delete output[key];
+    output[name] = value;
+    return value;
+  };
+  if (canonicalize("PATH") === undefined) delete output.PATH;
+  let home = canonicalize("HOME");
+  if (!home) {
+    home = environmentValue(output, "USERPROFILE", platform);
+    if (!home) {
+      const drive = environmentValue(output, "HOMEDRIVE", platform) ?? "";
+      const path = environmentValue(output, "HOMEPATH", platform) ?? "";
+      home = drive && path ? `${drive}${path}` : "";
+    }
+  }
+  if (home) {
+    output.HOME = String(home).replaceAll("\\", "/");
+  } else {
+    delete output.HOME;
+  }
+  return output;
+}
+
+export function homeRelativePath(cwd, home, platform = process.platform) {
+  if (!home) return null;
+  const trim = (value) => {
+    const normalized = String(value).replaceAll("\\", "/");
+    return normalized === "/" ? "/" : normalized.replace(/\/+$/, "");
+  };
+  // Android exposes app data through both /data/data/PACKAGE and
+  // /data/user/0/PACKAGE. They are the same app sandbox but string comparison
+  // alone cannot recognise HOME when the two spellings are mixed.
+  const comparable = (value) => trim(value).replace(
+    /^\/data\/user\/0\/([^/]+)(?=\/|$)/,
+    "/data/data/$1",
+  );
+  let comparedCwd = comparable(cwd);
+  let comparedHome = comparable(home);
+  if (platform === "win32") {
+    comparedCwd = comparedCwd.toLowerCase();
+    comparedHome = comparedHome.toLowerCase();
+  }
+  if (comparedCwd === comparedHome) return "";
+  if (comparedHome === "/" && comparedCwd.startsWith("/")) return comparedCwd;
+  return comparedCwd.startsWith(`${comparedHome}/`)
+    ? comparable(cwd).slice(comparedHome.length)
+    : null;
+}

package/apps/bunmsh/src/fancy-ls.js

@@ -0,0 +1,186 @@
+import { existsSync, lstatSync, readdirSync, readlinkSync } from "node:fs";
+import { basename, isAbsolute, resolve } from "node:path";
+
+const IMAGE = new Set(["png", "jpg", "jpeg", "gif", "webp", "svg", "bmp", "ico", "avif", "heic"]);
+const MUSIC = new Set(["mp3", "wav", "flac", "ogg", "m4a", "aac", "opus", "mid", "midi"]);
+const VIDEO = new Set(["mp4", "mkv", "webm", "mov", "avi", "m4v", "mpeg", "mpg"]);
+const ICONS = new Map([
+  ["js", "🟨"], ["mjs", "🟨"], ["cjs", "🟨"],
+  ["ts", "🟦"], ["mts", "🟦"], ["cts", "🟦"],
+  ["py", "🐍"], ["c", "🔧"], ["h", "🧩"], ["rs", "🦀"],
+  ["html", "🌐"], ["htm", "🌐"], ["css", "🎨"],
+]);
+
+function extension(name) {
+  const index = name.lastIndexOf(".");
+  return index > 0 ? name.slice(index + 1).toLowerCase() : "";
+}
+
+export function iconFor(name, stats, path = null) {
+  if (stats.isDirectory()) return "📦";
+  if (stats.isSymbolicLink()) return path !== null && !existsSync(path) ? "🚫" : "🔗";
+  const ext = extension(name);
+  if (IMAGE.has(ext)) return "🖼️";
+  if (MUSIC.has(ext)) return "🎵";
+  if (VIDEO.has(ext)) return "🎬";
+  if (ICONS.has(ext)) return ICONS.get(ext);
+  if (stats.mode & 0o111) return "⚙️";
+  return "📄";
+}
+
+// Only touches cross-platform-safe fs.Stats methods (isDirectory/
+// isSymbolicLink/isSocket/isFIFO always return a real boolean on Windows
+// too, just typically false for socket/FIFO since NTFS directory entries
+// aren't reported as those) and the same mode-bit check iconFor already
+// uses elsewhere in this file, so this needs no platform-specific handling.
+function classifySuffix(stats) {
+  if (stats.isDirectory()) return "/";
+  if (stats.isSymbolicLink()) return "@";
+  if (stats.isSocket()) return "=";
+  if (stats.isFIFO()) return "|";
+  if (stats.mode & 0o111) return "*";
+  return "";
+}
+
+function displayEntry(entry, options) {
+  const suffix = options.classify ? classifySuffix(entry.stats) : entry.stats.isDirectory() ? "/" : "";
+  return `${iconFor(entry.name, entry.stats, entry.path)} ${entry.name}${suffix}`;
+}
+
+function columns(items, width) {
+  if (!items.length) return "";
+  const widest = Math.max(...items.map((item) => Bun.stringWidth(item))) + 2;
+  const count = Math.max(1, Math.floor(width / widest));
+  let output = "";
+  for (let index = 0; index < items.length; index++) {
+    const last = index % count === count - 1 || index === items.length - 1;
+    output += items[index];
+    output += last ? "\n" : " ".repeat(widest - Bun.stringWidth(items[index]));
+  }
+  return output;
+}
+
+function modeString(mode) {
+  const kinds = [[0o400, "r"], [0o200, "w"], [0o100, "x"], [0o040, "r"], [0o020, "w"], [0o010, "x"], [0o004, "r"], [0o002, "w"], [0o001, "x"]];
+  return kinds.map(([bit, letter]) => mode & bit ? letter : "-").join("");
+}
+
+function linkTarget(path) {
+  try {
+    // Node/Bun read the reparse point's stored target on Windows the same
+    // way as a POSIX symlink; only the separator needs normalizing to match
+    // the forward-slash paths the rest of the shell displays.
+    const target = readlinkSync(path);
+    return process.platform === "win32" ? target.replaceAll("\\", "/") : target;
+  } catch {
+    return null;
+  }
+}
+
+function localDateTime(ms) {
+  const date = new Date(ms);
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} `
+    + `${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}
+
+function humanSize(bytes) {
+  if (bytes < 1024) return String(bytes);
+  const units = ["K", "M", "G", "T", "P"];
+  let value = bytes;
+  let unit = -1;
+  do { value /= 1024; unit++; } while (value >= 1024 && unit < units.length - 1);
+  return `${value >= 10 ? value.toFixed(0) : value.toFixed(1).replace(/\.0$/, "")}${units[unit]}`;
+}
+
+function listDirectory(path, options) {
+  let entries = readdirSync(path, { withFileTypes: true })
+    .filter((entry) => options.all || options.almostAll || !entry.name.startsWith("."))
+    .map((entry) => {
+      const entryPath = resolve(path, entry.name);
+      return { name: entry.name, stats: lstatSync(entryPath), path: entryPath };
+    });
+  if (options.all) entries = [
+    { name: ".", stats: lstatSync(path), path },
+    { name: "..", stats: lstatSync(resolve(path, "..")), path: resolve(path, "..") },
+    ...entries,
+  ];
+  entries.sort(options.size
+    ? (a, b) => b.stats.size - a.stats.size || a.name.localeCompare(b.name)
+    : options.time
+    ? (a, b) => b.stats.mtimeMs - a.stats.mtimeMs || a.name.localeCompare(b.name)
+    : (a, b) => a.name.localeCompare(b.name));
+  if (options.reverse) entries.reverse();
+  return entries;
+}
+
+export function fancyLs(argv, state, terminal = Boolean(process.stdout.isTTY)) {
+  const options = {
+    all: false, almostAll: false, directory: false, long: false, human: false,
+    recursive: false, time: false, reverse: false, size: false, one: false, classify: false,
+  };
+  const operands = [];
+  for (const argument of argv.slice(1)) {
+    if (argument === "--color=auto" || argument === "--color" || argument === "--") continue;
+    if (/^-[^-]/.test(argument)) {
+      for (const flag of argument.slice(1)) {
+        if (flag === "a") options.all = true;
+        else if (flag === "A") options.almostAll = true;
+        else if (flag === "d") options.directory = true;
+        else if (flag === "l") options.long = true;
+        else if (flag === "h") options.human = true;
+        else if (flag === "R") options.recursive = true;
+        else if (flag === "t") options.time = true;
+        else if (flag === "r") options.reverse = true;
+        else if (flag === "S") options.size = true;
+        else if (flag === "1") options.one = true;
+        else if (flag === "F") options.classify = true;
+        else return { status: 2, stdout: "", stderr: `bunmsh: ${argv[0]}: unsupported option: -${flag}\n` };
+      }
+    } else operands.push(argument);
+  }
+  if (!operands.length) operands.push(".");
+  let status = 0, stdout = "", stderr = "";
+  const visited = new Set();
+  const show = (operand, heading = operands.length > 1) => {
+    const path = isAbsolute(operand) ? operand : resolve(state.cwd, operand);
+    try {
+      const stats = lstatSync(path);
+      let entries;
+      if (!stats.isDirectory() || options.directory)
+        entries = [{ name: basename(operand) || operand, stats, path }];
+      else entries = listDirectory(path, options);
+      if (heading) stdout += `${operand}:\n`;
+      const rendered = entries.map((entry) => displayEntry(entry, options));
+      if (options.long) {
+        for (let i = 0; i < entries.length; i++) {
+          const item = entries[i];
+          const date = localDateTime(item.stats.mtimeMs);
+          const size = options.human ? humanSize(item.stats.size) : String(item.stats.size);
+          const target = item.stats.isSymbolicLink() ? linkTarget(item.path) : null;
+          const suffix = target === null ? "" : ` -> ${target}`;
+          stdout += `${item.stats.isDirectory() ? "d" : item.stats.isSymbolicLink() ? "l" : "-"}${modeString(item.stats.mode)} ${size.padStart(8)} ${date} ${rendered[i]}${suffix}\n`;
+        }
+      } else stdout += terminal && !options.one
+        ? columns(rendered, process.stdout.columns ?? 80)
+        : `${rendered.join("\n")}${rendered.length ? "\n" : ""}`;
+      if (options.recursive && stats.isDirectory() && !options.directory) {
+        for (const entry of entries) if (entry.stats.isDirectory() && entry.name !== "." && entry.name !== "..") {
+          const child = resolve(path, entry.name);
+          if (visited.has(child)) continue;
+          visited.add(child);
+          stdout += "\n";
+          show(`${operand.replace(/\/$/, "")}/${entry.name}`, true);
+        }
+      }
+    } catch (error) {
+      status = 1;
+      stderr += `bunmsh: ${argv[0]}: ${operand}: ${error.message}\n`;
+    }
+  };
+  for (let i = 0; i < operands.length; i++) {
+    if (i) stdout += "\n";
+    show(operands[i]);
+  }
+  return { status, stdout, stderr };
+}

package/apps/bunmsh/src/find.js

@@ -0,0 +1,119 @@
+import { lstatSync, readdirSync } from "node:fs";
+import { basename, isAbsolute, resolve } from "node:path";
+
+const shellPath = (value) => value.replaceAll("\\", "/");
+const nativePath = (value, platform) => platform === "win32" ? value.replaceAll("/", "\\") : value;
+
+function globRegex(pattern, insensitive = false) {
+  let source = "^";
+  for (let i = 0; i < pattern.length; i++) {
+    const ch = pattern[i];
+    if (ch === "*") source += ".*";
+    else if (ch === "?") source += ".";
+    else if (ch === "[") {
+      const end = pattern.indexOf("]", i + 1);
+      if (end < 0) source += "\\[";
+      else { source += pattern.slice(i, end + 1); i = end; }
+    } else source += ch.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+  }
+  return new RegExp(`${source}$`, insensitive ? "i" : "");
+}
+
+export function findIsRegularBuiltin(platform = process.platform) {
+  return platform === "win32";
+}
+
+export async function runFind(argv, state, platform = process.platform, execute = null) {
+  let index = 1;
+  const roots = [];
+  while (index < argv.length && argv[index] !== "!" && argv[index] !== "-not" &&
+      !argv[index].startsWith("-")) roots.push(argv[index++]);
+  if (!roots.length) roots.push(".");
+  let minDepth = 0, maxDepth = Infinity, print0 = false, negate = false, explicitPrint = false;
+  const predicates = [];
+  const actions = [];
+  while (index < argv.length) {
+    const option = argv[index++];
+    if (option === "!" || option === "-not") { negate = !negate; continue; }
+    if (option === "-print") { explicitPrint = true; continue; }
+    if (option === "-print0") { explicitPrint = true; print0 = true; continue; }
+    if (option === "-exec") {
+      const command = [];
+      while (index < argv.length && argv[index] !== ";" && argv[index] !== "+")
+        command.push(argv[index++]);
+      const terminator = argv[index++];
+      if (!command.length || (terminator !== ";" && terminator !== "+"))
+        return { status: 2, stdout: "", stderr: "bunmsh: find: -exec: missing command or terminator\n" };
+      if (!command.includes("{}"))
+        return { status: 2, stdout: "", stderr: "bunmsh: find: -exec: command must contain {}\n" };
+      actions.push({ command, mode: terminator });
+      continue;
+    }
+    const argument = argv[index++];
+    if (argument === undefined)
+      return { status: 2, stdout: "", stderr: `bunmsh: find: ${option}: missing argument\n` };
+    let predicate;
+    if (option === "-name" || option === "-iname") {
+      const regex = globRegex(argument, option === "-iname");
+      predicate = (entry) => regex.test(basename(entry.shown));
+    } else if (option === "-path" || option === "-ipath") {
+      const regex = globRegex(argument, option === "-ipath");
+      predicate = (entry) => regex.test(entry.shown);
+    } else if (option === "-type") {
+      if (!/^[fdl]$/.test(argument))
+        return { status: 2, stdout: "", stderr: `bunmsh: find: unsupported type: ${argument}\n` };
+      predicate = (entry) => argument === "f" ? entry.stats.isFile() :
+        argument === "d" ? entry.stats.isDirectory() : entry.stats.isSymbolicLink();
+    } else if (option === "-mindepth" || option === "-maxdepth") {
+      if (!/^\d+$/.test(argument))
+        return { status: 2, stdout: "", stderr: `bunmsh: find: ${option}: invalid depth: ${argument}\n` };
+      if (option === "-mindepth") minDepth = Number(argument); else maxDepth = Number(argument);
+      continue;
+    } else return { status: 2, stdout: "", stderr: `bunmsh: find: unsupported option: ${option}\n` };
+    predicates.push(negate ? (entry) => !predicate(entry) : predicate);
+    negate = false;
+  }
+  if (negate) return { status: 2, stdout: "", stderr: "bunmsh: find: expected expression after !\n" };
+  let status = 0, stdout = "", stderr = "";
+  const decoder = new TextDecoder();
+  const appendExecution = (execution) => {
+    stdout += typeof execution.stdout === "string" ? execution.stdout : decoder.decode(execution.stdout);
+    stderr += typeof execution.stderr === "string" ? execution.stderr : decoder.decode(execution.stderr);
+  };
+  const matches = [];
+  const emit = (shown) => { stdout += shown + (print0 ? "\0" : "\n"); };
+  const visit = async (native, shown, depth) => {
+    let stats;
+    try { stats = lstatSync(native); }
+    catch (error) { status = 1; stderr += `bunmsh: find: ${shown}: ${error.message}\n`; return; }
+    const entry = { shown, stats };
+    if (depth >= minDepth && predicates.every((predicate) => predicate(entry))) {
+      matches.push(shown);
+      if (!actions.length || explicitPrint) emit(shown);
+      for (const action of actions) if (action.mode === ";") {
+        if (!execute) return;
+        const command = action.command.map((argument) => argument === "{}" ? shown : argument);
+        appendExecution(await execute(command));
+      }
+    }
+    if (!stats.isDirectory() || depth >= maxDepth) return;
+    let children;
+    try { children = readdirSync(native).sort(); }
+    catch (error) { status = 1; stderr += `bunmsh: find: ${shown}: ${error.message}\n`; return; }
+    for (const child of children)
+      await visit(resolve(native, child), shown === "." ? `./${child}` : `${shown.replace(/\/$/, "")}/${child}`, depth + 1);
+  };
+  for (const root of roots) {
+    const native = isAbsolute(nativePath(root, platform))
+      ? nativePath(root, platform) : resolve(nativePath(state.cwd, platform), nativePath(root, platform));
+    await visit(native, shellPath(root), 0);
+  }
+  for (const action of actions) if (action.mode === "+" && matches.length) {
+    if (!execute) continue;
+    const command = action.command.flatMap((argument) => argument === "{}" ? matches : [argument]);
+    const execution = await execute(command);
+    appendExecution(execution);
+    if (execution.status !== 0) status = 1;
+  }
+  return { status, stdout, stderr };
+}