disk-space-saviour 0.15.2 → 0.17.0

package/src/env/cache-roots.js

@@ -0,0 +1,138 @@
+/** Resolve cache configuration once per environment, using only that user's tools. */
+export const CACHE_VARIABLES = [
+  'LOCALAPPDATA',
+  'APPDATA',
+  'TMPDIR',
+  'XDG_CACHE_HOME',
+  'CARGO_HOME',
+  'RUSTUP_HOME',
+  'GRADLE_USER_HOME',
+  'DENO_DIR',
+  'BUN_INSTALL_CACHE_DIR',
+  'GOMODCACHE',
+  'GOCACHE',
+  'GOPATH',
+  'NVM_DIR',
+  'SDKMAN_DIR',
+  'PERLBREW_ROOT',
+  'RBENV_ROOT',
+  'GEM_HOME',
+  'GEM_PATH',
+  'npm_config_cache',
+  'NPM_CONFIG_CACHE',
+  'PIP_CACHE_DIR',
+  'YARN_CACHE_FOLDER',
+  'PNPM_STORE_DIR',
+];
+
+const ROOTS = [
+  ['~/.cargo', 'CARGO_HOME'],
+  ['~/.rustup', 'RUSTUP_HOME'],
+  ['~/.gradle', 'GRADLE_USER_HOME'],
+  ['~/.nvm', 'NVM_DIR'],
+  ['~/.sdkman', 'SDKMAN_DIR'],
+  ['~/.perl5', 'PERLBREW_ROOT'],
+  ['~/perl5/perlbrew', 'PERLBREW_ROOT'],
+  ['~/.rbenv', 'RBENV_ROOT'],
+  ['~/.bun/install/cache', 'BUN_INSTALL_CACHE_DIR'],
+  ['~/.cache/deno', 'DENO_DIR'],
+  ['~/.npm', 'npm_config_cache', 'NPM_CONFIG_CACHE'],
+  ['~/.cache/pip', 'PIP_CACHE_DIR'],
+  ['~/.cache/yarn', 'YARN_CACHE_FOLDER'],
+  ['~/.local/share/pnpm/store', 'PNPM_STORE_DIR'],
+  ['~/go/pkg/mod', 'GOMODCACHE'],
+  ['~/.cache/go-build', 'GOCACHE'],
+  ['~/Library/Caches/go-build', 'GOCACHE'],
+  ['{LOCALAPPDATA}/go-build', 'GOCACHE'],
+  ['~/Library/Caches/deno', 'DENO_DIR'],
+  ['{LOCALAPPDATA}/deno', 'DENO_DIR'],
+  ['{LOCALAPPDATA}/npm-cache', 'npm_config_cache', 'NPM_CONFIG_CACHE'],
+  ['~/Library/Caches/pip', 'PIP_CACHE_DIR'],
+  ['{LOCALAPPDATA}/pip/Cache', 'PIP_CACHE_DIR'],
+  ['~/Library/Caches/Yarn', 'YARN_CACHE_FOLDER'],
+  ['{LOCALAPPDATA}/Yarn/Cache', 'YARN_CACHE_FOLDER'],
+  ['~/Library/pnpm/store', 'PNPM_STORE_DIR'],
+  ['~/.pnpm-store', 'PNPM_STORE_DIR'],
+  ['{LOCALAPPDATA}/pnpm/store', 'PNPM_STORE_DIR'],
+  ['~/.cache', 'XDG_CACHE_HOME'],
+];
+
+export function configuredPattern(env, home, pattern) {
+  if (home !== env.currentHome) {
+    return pattern;
+  }
+  for (const [prefix, ...keys] of ROOTS) {
+    if (pattern !== prefix && !pattern.startsWith(`${prefix}/`)) {
+      continue;
+    }
+    const root = keys
+      .map((key) => env.vars?.[key])
+      .find((value) => value && env.path.isAbsolute(value));
+    if (root) {
+      return env.path.join(root, pattern.slice(prefix.length));
+    }
+  }
+  return pattern;
+}
+
+function applyQuery(vars, keys, values, pathApi) {
+  for (const key of keys) {
+    if (
+      !vars[key] &&
+      typeof values[key] === 'string' &&
+      pathApi.isAbsolute(values[key])
+    ) {
+      vars[key] = values[key];
+    }
+  }
+}
+
+export async function configureCacheRoots(env, homes) {
+  if (env.variables) {
+    Object.assign(env.vars, await env.variables(CACHE_VARIABLES));
+  }
+  if (!homes.includes(env.currentHome)) {
+    return;
+  }
+  const vars = env.vars;
+  if (!vars.GOMODCACHE && vars.GOPATH) {
+    vars.GOMODCACHE = env.path.join(
+      vars.GOPATH.split(env.platform === 'win32' ? ';' : ':')[0],
+      'pkg/mod'
+    );
+  }
+  const queries = [
+    [
+      'go',
+      ['go', 'env', '-json', 'GOMODCACHE', 'GOCACHE'],
+      ['GOMODCACHE', 'GOCACHE'],
+    ],
+    ['npm', ['npm', 'config', 'get', 'cache'], ['npm_config_cache']],
+    ['pip', ['pip', 'cache', 'dir'], ['PIP_CACHE_DIR']],
+    ['yarn', ['yarn', 'cache', 'dir'], ['YARN_CACHE_FOLDER']],
+    ['pnpm', ['pnpm', 'store', 'path'], ['PNPM_STORE_DIR']],
+  ];
+  for (const [tool, argv, keys] of queries) {
+    if (
+      keys.every((key) => vars[key]) ||
+      (tool === 'npm' && vars.NPM_CONFIG_CACHE) ||
+      !(await env.which(tool))
+    ) {
+      continue;
+    }
+    const result = await env.run(argv, { timeoutMs: 5000 });
+    if (result.code !== 0) {
+      continue;
+    }
+    let values;
+    try {
+      values =
+        tool === 'go'
+          ? JSON.parse(result.stdout)
+          : { [keys[0]]: result.stdout.trim().split('\n').at(-1) };
+    } catch {
+      continue;
+    }
+    applyQuery(vars, keys, values, env.path);
+  }
+}

package/src/env/inspection.js

@@ -0,0 +1,100 @@
+import { OPEN_PATHS_SCRIPT } from './process-scripts.js';
+import { trace } from '../exec.js';
+
+export function parseProcessProbe(result) {
+  const gids = new Map(
+    result.stderr
+      .split('\n')
+      .filter((line) => line.startsWith('DSS_GID|'))
+      .map((line) => {
+        const [, pid, gid] = line.split('|');
+        return [Number(pid), gid ? Number(gid) : null];
+      })
+  );
+  return {
+    paths: new Set(
+      result.stdout
+        .split('\n')
+        .filter((line) => line.startsWith('/'))
+        .map((line) => line.replace(/ \(deleted\)$/, ''))
+    ),
+    unreadable: result.stderr
+      .split('\n')
+      .filter((line) => line.startsWith('DSS_UNREADABLE|'))
+      .map((line) => {
+        const [, pid, uid, name, ...command] = line.split('|');
+        return {
+          pid: Number(pid),
+          uid: uid ? Number(uid) : null,
+          gid: gids.get(Number(pid)) ?? null,
+          name,
+          command: command.join('|'),
+        };
+      }),
+  };
+}
+
+/** Root without ptrace can often inspect a dumpable process as its own UID/GID. */
+export async function retryProcessOwners(executor, evidence) {
+  const groups = new Map();
+  for (const proc of evidence.unreadable) {
+    if (
+      !Number.isInteger(proc.uid) ||
+      !Number.isInteger(proc.gid) ||
+      proc.uid === 0
+    ) {
+      continue;
+    }
+    const key = `${proc.uid}:${proc.gid}`;
+    groups.set(key, [...(groups.get(key) ?? []), proc]);
+  }
+  const unresolved = new Map(
+    evidence.unreadable.map((proc) => [proc.pid, proc])
+  );
+  for (const [identity, procs] of groups) {
+    const [uid, gid] = identity.split(':');
+    trace(
+      'process inspection as owning uid/gid',
+      identity,
+      procs.map((proc) => proc.pid)
+    );
+    const result = await executor.run([
+      'setpriv',
+      `--reuid=${uid}`,
+      `--regid=${gid}`,
+      '--clear-groups',
+      'sh',
+      '-c',
+      OPEN_PATHS_SCRIPT,
+      'dss',
+      ...procs.map((proc) => `/proc/${proc.pid}`),
+    ]);
+    const retried = parseProcessProbe(result);
+    for (const target of retried.paths) {
+      evidence.paths.add(target);
+    }
+    if (result.code === 0 || retried.unreadable.length) {
+      for (const proc of procs) {
+        unresolved.delete(proc.pid);
+      }
+      for (const proc of retried.unreadable) {
+        unresolved.set(proc.pid, proc);
+      }
+    }
+  }
+  return { paths: evidence.paths, unreadable: [...unresolved.values()] };
+}
+
+export function inspectionHint(unreadable) {
+  if (!unreadable.length) {
+    return null;
+  }
+  const identities = unreadable
+    .slice(0, 5)
+    .map(
+      (proc) =>
+        `${proc.name || 'unknown'} pid ${proc.pid} uid ${proc.uid ?? '?'} gid ${proc.gid ?? '?'}`
+    )
+    .join('; ');
+  return `${unreadable.length} processes are unreadable (${identities}). Activity uncertainty is scoped to daemon storage and accessible paths. Inspect as the owning UID/GID (setpriv), or grant CAP_SYS_PTRACE for read-only inspection; root alone may lack that capability.`;
+}