disk-space-saviour 0.0.0-stage → 0.12.0

package/src/scanners/rust.js

@@ -0,0 +1,404 @@
+/**
+ * Superseded Rust build artifacts inside a cargo `target` directory.
+ *
+ * Every compilation unit leaves entries named `<crate>-<16 hex hash>` in
+ * `<profile>/deps`, `<profile>/build` and `<profile>/.fingerprint`, and
+ * incremental state in `<profile>/incremental/<crate>-<hash>`. Changing
+ * features, flags, the toolchain or dependency versions creates a new hash
+ * next to the old one, so old hashes pile up.
+ *
+ * The result has two parts:
+ *
+ * - **library**: `.rlib`, `.rmeta`, `.so`/`.dylib`/`.a`, `.d`, `build/*`
+ *   and `.fingerprint` entries. A unit's identity is read from its
+ *   fingerprint (`<kind>-<target>.json` with the `target` and `profile`
+ *   hashes, which separate lib/bin/test and check/build units). Units
+ *   without a fingerprint fall back to crate name, artifact kind and crate
+ *   root source (first entry of the `.d` file). For each identity the
+ *   newest hash is kept, together with every hash built within the same
+ *   generation window (one build); older hashes are reported only when all
+ *   of their files are outside the activity window. A running cargo may
+ *   already have judged these fresh, so callers must not touch this part
+ *   while cargo or rustc runs in the project.
+ * - **leaf**: nothing links against these, so they stay removable while
+ *   cargo runs (callers still skip files a process has open):
+ *   - incremental session directories whose newest file is older than
+ *     `leafIdleMs` and that hold no `-working` session. Each directory is
+ *     judged by its own age: lib, test and bin sessions of one crate live
+ *     side by side and never supersede each other;
+ *   - extension-less (or `.exe`) executables `<name>-<hash>` in `deps` and
+ *     `examples` (test and example binaries) older than `leafIdleMs` when a
+ *     newer build of the same unit exists.
+ */
+
+import { listMany } from './common.js';
+
+const HASHED = /^(.+)-([0-9a-f]{16})(\..*)?$/;
+const INCREMENTAL = /^(.+)-([0-9a-z]{8,20})$/;
+const LIB_PREFIXED = new Set(['.rlib', '.rmeta', '.so', '.dylib', '.a']);
+const KIND_ORDER = ['lib', 'dylib', 'staticlib', 'bin', 'rmeta', 'other'];
+const NON_PROFILES = new Set(['doc', 'package', 'tmp', 'flycheck0']);
+const EXECUTABLE = new Set(['', '.exe']);
+export const DEFAULT_GENERATION_MS = 10 * 60 * 1000;
+export const DEFAULT_LEAF_IDLE_MS = 3 * 60 * 60 * 1000;
+
+function fileKind(extension) {
+  const kinds = {
+    '.rlib': 'lib',
+    '.rmeta': 'rmeta',
+    '.so': 'dylib',
+    '.dylib': 'dylib',
+    '.dll': 'dylib',
+    '.a': 'staticlib',
+    '.lib': 'staticlib',
+    '': 'bin',
+    '.exe': 'bin',
+  };
+  return kinds[extension] ?? 'other';
+}
+
+/**
+ * Splits `libfoo_bar-0123456789abcdef.rlib` into crate, hash, extension.
+ * @returns {{crate: string, hash: string, extension: string}|null}
+ */
+export function parseArtifactName(name) {
+  const match = HASHED.exec(name);
+  if (!match) {
+    return null;
+  }
+  const extension = match[3] ?? '';
+  let crate = match[1];
+  if (LIB_PREFIXED.has(extension) && crate.startsWith('lib')) {
+    crate = crate.slice(3);
+  }
+  return { crate, hash: match[2], extension };
+}
+
+/**
+ * First dependency of a Makefile-style `.d` file: the crate root source.
+ */
+export function rootSourceOf(depInfo) {
+  const line = (depInfo ?? '').split('\n')[0];
+  const separator = line.search(/:\s/);
+  if (separator === -1) {
+    return '';
+  }
+  const deps = line
+    .slice(separator + 1)
+    .trim()
+    .split(/(?<!\\)\s+/);
+  return deps[0] ?? '';
+}
+
+/**
+ * Unit identity from a fingerprint JSON file name and its beginning.
+ */
+export function fingerprintIdentity(jsonName, head) {
+  const target = /"target":(\d+)/.exec(head ?? '');
+  const profile = /"profile":(\d+)/.exec(head ?? '');
+  return `${jsonName}:${target?.[1] ?? '?'}:${profile?.[1] ?? '?'}`;
+}
+
+/**
+ * Profile directories (`target/debug`, `target/<triple>/release`, ...)
+ * identified by their `deps` subdirectory.
+ * @returns {Promise<string[]>}
+ */
+export async function findRustProfiles(env, targetDir) {
+  const top = (await env.list(targetDir)).filter(
+    (entry) => entry.type === 'dir' && !NON_PROFILES.has(entry.name)
+  );
+  const hasDeps = (entries) => entries.some((entry) => entry.name === 'deps');
+  const listings = await listMany(
+    env,
+    top.map((entry) => entry.path)
+  );
+  const profiles = [];
+  const nested = [];
+  for (const entry of top) {
+    const children = listings.get(entry.path) ?? [];
+    if (hasDeps(children)) {
+      profiles.push(entry.path);
+      continue;
+    }
+    for (const child of children) {
+      if (child.type === 'dir' && !NON_PROFILES.has(child.name)) {
+        nested.push(env.path.join(entry.path, child.name));
+      }
+    }
+  }
+  const nestedListings = await listMany(env, nested);
+  profiles.push(...nested.filter((dir) => hasDeps(nestedListings.get(dir))));
+  return profiles.sort();
+}
+
+async function withDirUsage(env, entries) {
+  const dirs = entries.filter((entry) => entry.type === 'dir');
+  if (dirs.length === 0) {
+    return entries;
+  }
+  const usages = await env.usageMany(dirs.map((entry) => entry.path));
+  return entries.map((entry) => {
+    const usage = entry.type === 'dir' ? usages.get(entry.path) : null;
+    return usage
+      ? {
+          ...entry,
+          bytes: usage.bytes,
+          mtimeMs: Math.max(entry.mtimeMs, usage.newestMtimeMs ?? 0),
+        }
+      : entry;
+  });
+}
+
+function hashedEntries(entries) {
+  return (entries ?? []).filter((entry) => parseArtifactName(entry.name));
+}
+
+function isExecutable(entry) {
+  return (
+    entry.type !== 'dir' &&
+    EXECUTABLE.has(parseArtifactName(entry.name).extension)
+  );
+}
+
+function summarize(stale, kept) {
+  const entries = stale
+    .flatMap((unit) => unit.entries)
+    .map(({ path, bytes, mtimeMs }) => ({ path, bytes, mtimeMs }));
+  return {
+    entries,
+    bytes: entries.reduce((sum, entry) => sum + entry.bytes, 0),
+    kept,
+    removed: stale.length,
+  };
+}
+
+class UnitSet {
+  constructor() {
+    this.units = new Map();
+  }
+
+  add(key, hash, entry) {
+    if (!this.units.has(key)) {
+      this.units.set(key, new Map());
+    }
+    const hashes = this.units.get(key);
+    if (!hashes.has(hash)) {
+      hashes.set(hash, { hash, entries: [], mtimeMs: 0 });
+    }
+    const unit = hashes.get(hash);
+    unit.entries.push(entry);
+    unit.mtimeMs = Math.max(unit.mtimeMs, entry.mtimeMs);
+  }
+
+  superseded({ staleAgeMs, now, generationMs }) {
+    const stale = [];
+    let kept = 0;
+    for (const hashes of this.units.values()) {
+      const ordered = [...hashes.values()].sort(
+        (a, b) => b.mtimeMs - a.mtimeMs
+      );
+      const newest = ordered[0].mtimeMs;
+      for (const unit of ordered) {
+        const sameGeneration = newest - unit.mtimeMs <= generationMs;
+        const idle = now - unit.mtimeMs >= staleAgeMs;
+        if (sameGeneration || !idle) {
+          kept++;
+        } else {
+          stale.push(unit);
+        }
+      }
+    }
+    return { stale, kept };
+  }
+}
+
+async function fingerprintKeys(env, fingerprints) {
+  const listings = await listMany(
+    env,
+    fingerprints.map((entry) => entry.path)
+  );
+  const jsonFiles = new Map();
+  for (const entry of fingerprints) {
+    const json = (listings.get(entry.path) ?? []).find(
+      (child) => child.name.endsWith('.json') && !child.name.startsWith('dep-')
+    );
+    if (json) {
+      jsonFiles.set(entry, json);
+    }
+  }
+  const heads = await env.readHeads(
+    [...jsonFiles.values()].map((json) => json.path),
+    8192
+  );
+  const keys = new Map();
+  for (const [entry, json] of jsonFiles) {
+    const { crate, hash } = parseArtifactName(entry.name);
+    keys.set(
+      hash,
+      `fp:${crate}:${fingerprintIdentity(json.name, heads.get(json.path))}`
+    );
+  }
+  return keys;
+}
+
+async function fallbackDepsKeys(env, depsDir, entries, known) {
+  const groups = new Map();
+  for (const entry of entries) {
+    const parsed = parseArtifactName(entry.name);
+    if (known.has(parsed.hash)) {
+      continue;
+    }
+    if (!groups.has(parsed.hash)) {
+      groups.set(parsed.hash, { crate: parsed.crate, kinds: new Set() });
+    }
+    groups.get(parsed.hash).kinds.add(fileKind(parsed.extension));
+  }
+  const depFile = (hash, crate) => env.path.join(depsDir, `${crate}-${hash}.d`);
+  const heads = await env.readHeads(
+    [...groups].map(([hash, group]) => depFile(hash, group.crate)),
+    4096
+  );
+  const keys = new Map();
+  for (const [hash, group] of groups) {
+    const kind = KIND_ORDER.find((k) => group.kinds.has(k)) ?? 'other';
+    const root = rootSourceOf(heads.get(depFile(hash, group.crate)));
+    keys.set(hash, `deps:${group.crate}:${kind}:${root}`);
+  }
+  return keys;
+}
+
+function buildRole(listing) {
+  return (listing ?? []).some((c) => c.name.startsWith('build-script-'))
+    ? 'script'
+    : 'run';
+}
+
+function libraryPart(settings, keys, fallback, buildListings, entries) {
+  const units = new UnitSet();
+  for (const entry of entries) {
+    const { crate, hash } = parseArtifactName(entry.name);
+    const key =
+      keys.get(hash) ??
+      fallback.get(hash) ??
+      `build:${crate}:${buildRole(buildListings.get(entry.path))}`;
+    units.add(key, hash, entry);
+  }
+  const { stale, kept } = units.superseded(settings);
+  return summarize(stale, kept);
+}
+
+function executablePart(settings, keys, executables) {
+  const units = new UnitSet();
+  for (const { dir, entry } of executables) {
+    const { crate, hash } = parseArtifactName(entry.name);
+    units.add(`${dir}:${keys.get(hash) ?? crate}`, hash, entry);
+  }
+  return units.superseded({ ...settings, staleAgeMs: settings.leafIdleMs });
+}
+
+async function incrementalPart(env, settings, listing) {
+  const dirs = await withDirUsage(
+    env,
+    (listing ?? []).filter(
+      (entry) => entry.type === 'dir' && INCREMENTAL.test(entry.name)
+    )
+  );
+  const sessions = await listMany(
+    env,
+    dirs.map((entry) => entry.path)
+  );
+  const stale = [];
+  let kept = 0;
+  for (const entry of dirs) {
+    const working = (sessions.get(entry.path) ?? []).some((child) =>
+      child.name.endsWith('-working')
+    );
+    if (working || settings.now - entry.mtimeMs < settings.leafIdleMs) {
+      kept++;
+    } else {
+      stale.push({ entries: [entry] });
+    }
+  }
+  return { stale, kept };
+}
+
+/**
+ * Superseded artifacts of one profile directory.
+ * @param {object} env
+ * @param {string} profileDir
+ * @param {{staleAgeMs: number, now: number, generationMs?: number,
+ *   leafIdleMs?: number}} options `leafIdleMs` defaults to the larger of
+ *   3 hours and `staleAgeMs`
+ * @returns {Promise<{entries: Array<{path: string, bytes: number,
+ *   mtimeMs: number}>, bytes: number, kept: number, removed: number,
+ *   library: object, leaf: object}>} both parts together plus `library`
+ *   and `leaf` with the same shape
+ */
+export async function analyzeRustProfile(env, profileDir, options) {
+  const settings = {
+    generationMs: DEFAULT_GENERATION_MS,
+    ...options,
+    leafIdleMs:
+      options.leafIdleMs ??
+      Math.max(DEFAULT_LEAF_IDLE_MS, options.staleAgeMs ?? 0),
+  };
+  const sub = (name) => env.path.join(profileDir, name);
+  const listings = await listMany(env, [
+    sub('deps'),
+    sub('build'),
+    sub('incremental'),
+    sub('.fingerprint'),
+    sub('examples'),
+  ]);
+  const fingerprints = await withDirUsage(
+    env,
+    hashedEntries(listings.get(sub('.fingerprint')))
+  );
+  const deps = await withDirUsage(
+    env,
+    hashedEntries(listings.get(sub('deps')))
+  );
+  const builds = await withDirUsage(
+    env,
+    hashedEntries(listings.get(sub('build')))
+  );
+  const keys = await fingerprintKeys(env, fingerprints);
+  const fallback = await fallbackDepsKeys(env, sub('deps'), deps, keys);
+  const buildListings = await listMany(
+    env,
+    builds
+      .filter((entry) => !keys.has(parseArtifactName(entry.name).hash))
+      .map((entry) => entry.path)
+  );
+
+  const library = libraryPart(settings, keys, fallback, buildListings, [
+    ...deps.filter((entry) => !isExecutable(entry)),
+    ...builds,
+    ...fingerprints,
+  ]);
+  const executables = executablePart(settings, keys, [
+    ...deps.filter(isExecutable).map((entry) => ({ dir: 'deps', entry })),
+    ...hashedEntries(listings.get(sub('examples')))
+      .filter(isExecutable)
+      .map((entry) => ({ dir: 'examples', entry })),
+  ]);
+  const incremental = await incrementalPart(
+    env,
+    settings,
+    listings.get(sub('incremental'))
+  );
+  const leaf = summarize(
+    [...incremental.stale, ...executables.stale],
+    incremental.kept + executables.kept
+  );
+  const entries = [...library.entries, ...leaf.entries];
+  return {
+    entries,
+    bytes: library.bytes + leaf.bytes,
+    kept: library.kept + leaf.kept,
+    removed: library.removed + leaf.removed,
+    library,
+    leaf,
+  };
+}

package/src/scanners/system.js

@@ -0,0 +1,171 @@
+/**
+ * System reclaimers that only the owning tool can clean correctly:
+ * journald archives (`journalctl --vacuum-size`), disabled snap revisions
+ * (`snap remove --revision`) and Homebrew's old versions and downloads
+ * (`brew cleanup`). Plain cache directories live in ../rules/other.js.
+ */
+
+import { block, makeItem } from '../items.js';
+import { parseSize } from '../units.js';
+import { scanTimeBusy } from './common.js';
+
+export const DEFAULT_JOURNAL_KEEP = 512 * 1024 ** 2;
+
+/**
+ * Bytes reported by `journalctl --disk-usage`.
+ * @returns {number|null}
+ */
+export function parseJournalUsage(output) {
+  const match = /take up ([\d.]+\s*[A-Za-z]*) in the file system/.exec(
+    output ?? ''
+  );
+  return match ? parseSize(match[1]) : null;
+}
+
+/**
+ * Disabled revisions from `snap list --all`.
+ * @returns {Array<{name: string, revision: string}>}
+ */
+export function parseDisabledSnaps(output) {
+  const lines = (output ?? '').split('\n').filter(Boolean);
+  const header = lines.shift() ?? '';
+  if (!/^Name\s+Version\s+Rev\b/.test(header)) {
+    return [];
+  }
+  return lines
+    .map((line) => line.trim().split(/\s+/))
+    .filter((cols) => cols.length >= 6 && /\bdisabled\b/.test(cols.at(-1)))
+    .map((cols) => ({ name: cols[0], revision: cols[2] }));
+}
+
+/**
+ * Size freed according to `brew cleanup --dry-run`.
+ * @returns {number}
+ */
+export function parseBrewCleanup(output) {
+  const total = /would free approximately ([\d.]+\s*[A-Za-z]+)/.exec(
+    output ?? ''
+  );
+  if (total) {
+    return parseSize(total[1]);
+  }
+  return [...(output ?? '').matchAll(/,\s*([\d.]+\s*[KMGT]?B)\)$/gm)].reduce(
+    (sum, match) => sum + parseSize(match[1]),
+    0
+  );
+}
+
+function withBusy(context, item) {
+  const busy = scanTimeBusy(context, item);
+  if (busy) {
+    block(item, `busy: ${busy}`);
+  }
+  return item;
+}
+
+async function journalItems(context, isRoot) {
+  const { env, options } = context;
+  if (!(await env.which('journalctl'))) {
+    return [];
+  }
+  const result = await env.run(['journalctl', '--disk-usage']);
+  const total = parseJournalUsage(`${result.stdout}\n${result.stderr}`);
+  const keep = options.journalKeepBytes ?? DEFAULT_JOURNAL_KEEP;
+  if (total === null || total <= keep) {
+    return [];
+  }
+  const item = makeItem(env, {
+    rule: 'journald-archives',
+    kind: 'logs',
+    ecosystem: 'system',
+    description: 'systemd journal archives above the kept size',
+    path: '/var/log/journal',
+    bytes: total - keep,
+    tier: 'moderate',
+    reason: `journals take ${total} bytes, vacuuming keeps the newest ${keep}`,
+    action: {
+      type: 'command',
+      argv: ['journalctl', `--vacuum-size=${keep}`],
+      measure: ['/var/log/journal', '/run/log/journal'],
+    },
+    checks: { busy: [], cwd: null, mtime: false },
+  });
+  if (!isRoot) {
+    block(item, 'system location, run as root to clean it');
+  }
+  return [item];
+}
+
+async function snapItems(context, isRoot) {
+  const { env } = context;
+  if (!(await env.which('snap'))) {
+    return [];
+  }
+  const result = await env.run(['snap', 'list', '--all']);
+  const items = [];
+  for (const { name, revision } of parseDisabledSnaps(result.stdout)) {
+    const file = `/var/lib/snapd/snaps/${name}_${revision}.snap`;
+    const stat = await env.stat(file);
+    const item = makeItem(env, {
+      rule: 'snap-disabled-revision',
+      kind: 'package',
+      ecosystem: 'system',
+      description: `disabled snap revision ${name} ${revision}`,
+      path: file,
+      bytes: stat?.bytes ?? 0,
+      newestMtimeMs: stat?.mtimeMs ?? 0,
+      tier: 'safe',
+      reason: 'superseded revision kept only for rollback',
+      action: {
+        type: 'command',
+        argv: ['snap', 'remove', name, `--revision=${revision}`],
+        measure: [file],
+      },
+      checks: { busy: ['snap', 'snapd'], cwd: null, mtime: false },
+    });
+    if (!isRoot) {
+      block(item, 'system location, run as root to clean it');
+    }
+    items.push(withBusy(context, item));
+  }
+  return items;
+}
+
+async function brewItems(context, isRoot) {
+  const { env } = context;
+  if (isRoot || !(await env.which('brew'))) {
+    return [];
+  }
+  const result = await env.run(['brew', 'cleanup', '--dry-run']);
+  const bytes = result.code === 0 ? parseBrewCleanup(result.stdout) : 0;
+  if (bytes === 0) {
+    return [];
+  }
+  const prefix = (await env.run(['brew', '--prefix'])).stdout.trim();
+  const item = makeItem(env, {
+    rule: 'brew-cleanup',
+    kind: 'package',
+    ecosystem: 'system',
+    description: 'Homebrew outdated versions and stale downloads',
+    path: prefix || 'brew',
+    bytes,
+    tier: 'moderate',
+    reason: 'Homebrew may remove old kegs and unneeded dependencies',
+    action: { type: 'command', argv: ['brew', 'cleanup'], measure: [] },
+    checks: { busy: ['brew'], cwd: null, mtime: false },
+  });
+  return [withBusy(context, item)];
+}
+
+/**
+ * Scans journald, snap and Homebrew.
+ * @returns {Promise<object[]>} report items
+ */
+export async function scanSystem(context) {
+  const isRoot = await context.env.isRoot();
+  return [
+    ...(await journalItems(context, isRoot)),
+    ...(await snapItems(context, isRoot)),
+    ...(await brewItems(context, isRoot)),
+  ];
+}