disk-space-saviour 0.13.0 → 0.15.1

package/src/rules/other.js

@@ -18,6 +18,7 @@
 export const OTHER_RULES = [
   {
     id: 'playwright-browsers',
+    protectProfiles: true,
     ecosystem: 'browsers',
     description: 'old Playwright browser revisions',
     paths: [
@@ -27,7 +28,7 @@ export const OTHER_RULES = [
     ],
     versionPattern: /^(?<family>[a-z_]+)-(?<version>\d+)$/,
     minAge: 'inactive',
-    tier: 'moderate',
+    tier: 'safe',
     busy: [
       'playwright',
       'playwright-mcp',
@@ -49,7 +50,7 @@ export const OTHER_RULES = [
     ],
     versionPattern: /^(?<version>\d+(?:\.\d+){1,3})$/,
     minAge: 'inactive',
-    tier: 'moderate',
+    tier: 'safe',
     busy: ['playwright'],
   },
   {
@@ -59,7 +60,7 @@ export const OTHER_RULES = [
     paths: ['~/.cache/puppeteer/*/*'],
     versionPattern: /^(?<family>[a-z0-9_-]+)-(?<version>\d[\d.]*)$/,
     minAge: 'inactive',
-    tier: 'moderate',
+    tier: 'safe',
     busy: ['puppeteer', 'chrome', 'chromium', 'headless_shell'],
   },
   {
@@ -69,7 +70,7 @@ export const OTHER_RULES = [
     paths: ['~/.cache/Cypress/*', '~/Library/Caches/Cypress/*'],
     versionPattern: /^(?<version>\d+(?:\.\d+){1,3})$/,
     minAge: 'inactive',
-    tier: 'moderate',
+    tier: 'safe',
     busy: ['Cypress', 'cypress'],
   },
   {
@@ -79,7 +80,7 @@ export const OTHER_RULES = [
     paths: ['~/.cache/selenium/*/*/*'],
     versionPattern: /^(?<version>\d+(?:\.\d+){1,3})$/,
     minAge: 'inactive',
-    tier: 'moderate',
+    tier: 'safe',
     busy: ['chromedriver', 'geckodriver'],
   },
   {
@@ -464,6 +465,29 @@ export const OTHER_RULES = [
     aggregate: true,
     paths: ['/var/lib/systemd/coredump/*', '/var/crash/*', '/cores/*'],
   },
+  {
+    id: 'start-command-isolation-logs',
+    ecosystem: 'agents',
+    scope: 'tmp',
+    description: 'old start-command Docker isolation logs',
+    tier: 'moderate',
+    paths: ['{TMP}/start-command/logs/isolation/docker/*.log'],
+    minAge: 'stale',
+    busy: [],
+  },
+  {
+    id: 'sanitized-upload-staging',
+    ecosystem: 'agents',
+    scope: 'tmp',
+    description: 'old sanitized log upload staging data',
+    tier: 'moderate',
+    paths: [
+      '{TMP}/log-tmp-hive-mind-log-upload-*-sanitized-*',
+      '{TMP}/log-home-box-hive-telegram-bot-*',
+    ],
+    minAge: 'stale',
+    busy: [],
+  },
   {
     id: 'gh-issue-solver-workdirs',
     ecosystem: 'tmp',

package/src/rules/versions.js

@@ -101,6 +101,29 @@ export function compareVersions(left, right) {
 }
 
 export const VERSION_RULES = [
+  {
+    id: 'claude-code-versions',
+    ecosystem: 'agents',
+    manager: 'Claude Code',
+    description: 'Claude Code binary',
+    dirs: ['~/.local/share/claude/versions/*'],
+    installTypes: ['file'],
+    defaultLinks: ['~/.local/bin/claude'],
+    busy: ['claude'],
+    recheck: true,
+  },
+  {
+    id: 'copilot-cli-versions',
+    ecosystem: 'agents',
+    manager: 'Copilot CLI',
+    description: 'Copilot CLI package',
+    dirs: ['~/.cache/copilot/pkg/*/*'],
+    defaultLinks: ['~/.local/bin/copilot'],
+    linkVersion: (target) => /\/pkg\/[^/]+\/([^/]+)/.exec(target ?? '')?.[1],
+    busy: ['copilot'],
+    recheck: true,
+  },
+
   {
     id: 'nvm-node',
     ecosystem: 'javascript',

package/src/scan.js

@@ -3,14 +3,19 @@
  * Docker, inside running containers and nested daemons. Never deletes.
  */
 
+import {
+  configureContainerHost,
+  resetWritableLayers,
+} from './docker/writable.js';
 import { scanDocker } from './docker/scan.js';
 import { LocalEnv } from './env/local.js';
+import { configureScanPolicy } from './env/policy.js';
 import { block, tierTotals } from './items.js';
 import { hostExecutor, trace } from './exec.js';
 import { GitInspector } from './git.js';
 import { LivenessProbe } from './liveness.js';
 import { resolveOptions } from './options.js';
-import { existingPaths, isWithin, matchesGlob } from './paths.js';
+import { existingPaths, isWithin, matchesExcluded } from './paths.js';
 import { scanAgents } from './scanners/agents.js';
 import { scanGlobal } from './scanners/global.js';
 import { scanProjects } from './scanners/projects.js';
@@ -27,6 +32,8 @@ export const SCANNERS = {
 
 export const REPORT_SCHEMA = 1;
 const trustedReports = new WeakMap();
+const reportEnvironments = new WeakMap();
+export const scannedEnvironment = (report) => reportEnvironments.get(report);
 const RESCAN_OPTIONS = new Set([
   'roots',
   'scanners',
@@ -43,6 +50,7 @@ const RESCAN_OPTIONS = new Set([
   'exclude',
   'includeVolumes',
   'removeStoppedContainers',
+  'investigationMaxAge',
   'removeContainers',
   'removeImages',
   'allowDirtyRepos',
@@ -115,6 +123,10 @@ async function defaultRoots(env, homes, tmpDirs) {
  * @param {{roots?: string[]|null}} [overrides]
  */
 export async function environmentContext(env, options, overrides = {}) {
+  await configureScanPolicy(env, {
+    ...options,
+    roots: overrides.roots ?? options.roots,
+  });
   const liveness = new LivenessProbe(env, {
     staleAgeMs: options.staleAgeMs,
     now: options.now,
@@ -164,16 +176,56 @@ export async function scanEnvironment(env, options, extra = {}) {
     }
     trace('scanner', name, 'in', env.id, `${Date.now() - started}ms`);
   }
+  await attributeStorage(env, items);
+  for (const item of items) {
+    for (const target of item.paths) {
+      block(item, env.scanPolicy.removalReason(target));
+    }
+  }
+  for (const message of env.accessErrors?.values() ?? []) {
+    errors.push({ env: env.id, scanner: 'filesystem', message });
+  }
   return items;
 }
 
+async function attributeStorage(env, items) {
+  if (env.writableLayer) {
+    const usages = await env.usageMany([
+      ...new Set(items.flatMap((item) => item.paths)),
+    ]);
+    for (const item of items.filter((entry) => entry.paths.length > 0)) {
+      const measured = item.paths
+        .map((target) => usages.get(target))
+        .filter(Boolean);
+      item.bytes = measured.reduce((sum, usage) => sum + usage.bytes, 0);
+      item.totalBytes = measured.reduce(
+        (sum, usage) => sum + (usage.totalBytes ?? usage.bytes),
+        0
+      );
+      item.imageBytes = measured.reduce(
+        (sum, usage) => sum + (usage.imageBytes ?? 0),
+        0
+      );
+      item.imageRef =
+        measured.find((usage) => usage.imageRef)?.imageRef ?? null;
+      item.sizeUnknown = measured.some((usage) => usage.sizeUnknown);
+      if (!item.sizeUnknown && item.bytes === 0 && item.imageBytes > 0) {
+        block(
+          item,
+          'all bytes are in the image layer; remove the stopped container and its unused image after the task completes, or rebuild without caches'
+        );
+      }
+    }
+  }
+}
+
 /**
  * Container ids of the container dss itself runs in (from mount sources
  * such as `/var/lib/docker/containers/<id>/hostname`).
  * @returns {Promise<string[]>}
  */
 export async function selfContainerIds(env) {
-  if (env.platform !== 'linux') {
+  if (env.platform !== 'linux' || typeof env.readText !== 'function') {
     return [];
   }
   const ids = new Set();
@@ -210,13 +262,13 @@ function matchesOnly(item, only) {
 }
 
 function excluded(item, exclude, pathApi) {
-  return item.paths.some((target) =>
-    exclude.some(
-      (pattern) =>
-        isWithin(target, pattern, pathApi) ||
-        isWithin(pattern, target, pathApi) ||
-        matchesGlob(pathApi.basename(target), pattern)
-    )
+  return item.paths.some(
+    (target) =>
+      matchesExcluded(target, exclude, pathApi) ||
+      exclude.some(
+        (pattern) =>
+          !/[*?[]/.test(pattern) && isWithin(pattern, target, pathApi)
+      )
   );
 }
 
@@ -237,7 +289,10 @@ function underDaemonRoot(item, daemons, pathApi) {
 export function filterItems(items, options, daemons = [], pathApi) {
   return items.filter(
     (item) =>
-      item.bytes >= options.minSizeBytes &&
+      (item.bytes >= options.minSizeBytes ||
+        item.sizeUnknown ||
+        item.imageBytes >= options.minSizeBytes ||
+        item.container?.pinnedImage?.bytes >= options.minSizeBytes) &&
       matchesOnly(item, options.only) &&
       !excluded(item, options.exclude, pathApi) &&
       !underDaemonRoot(item, daemons, pathApi)
@@ -245,7 +300,14 @@ export function filterItems(items, options, daemons = [], pathApi) {
 }
 
 function envDescriptor(env, depth, chain) {
-  return { id: env.id, label: env.label, kind: env.kind, depth, chain };
+  return {
+    id: env.id,
+    label: env.label,
+    kind: env.kind,
+    depth,
+    chain,
+    hint: env.probeHint ?? null,
+  };
 }
 
 async function withDisk(env, descriptor) {
@@ -269,6 +331,7 @@ async function dockerSection(env, options, errors) {
       { ...options, selfContainerIds: await selfContainerIds(env) },
       (inner) => scanEnvironment(inner, options, { errors })
     );
+    errors.push(...result.errors);
     if (options.docker === true && result.daemons.length === 0) {
       errors.push({
         env: env.id,
@@ -314,6 +377,15 @@ export async function scan(input = {}) {
   const env = input.env ?? new LocalEnv();
   const startedAt = options.now();
   const errors = [];
+  resetWritableLayers(env.executor);
+  env.writableLayer = null;
+  env.scanPolicy = null;
+  await configureScanPolicy(env, options);
+  await configureContainerHost(
+    env,
+    options.docker === false ? [] : await selfContainerIds(env),
+    options
+  );
   const hostItems =
     options.host === false
       ? []
@@ -331,7 +403,7 @@ export async function scan(input = {}) {
     environments.push(inner);
   }
   environments[0] = await withDisk(env, environments[0]);
-  return buildReport({
+  const report = buildReport({
     options,
     env,
     items,
@@ -340,6 +412,8 @@ export async function scan(input = {}) {
     errors,
     startedAt,
   });
+  reportEnvironments.set(report, env);
+  return report;
 }
 
 function reportOptions(options) {

package/src/scanners/agents.js

@@ -132,7 +132,7 @@ async function appItems(context, app, root) {
       ...verdict,
       checks: { busy: [], cwd: null, mtime: true },
     });
-    const busy = scanTimeBusy(context, item);
+    const busy = await scanTimeBusy(context, item);
     if (busy) {
       block(item, `busy: ${busy}`);
     }

package/src/scanners/common.js

@@ -25,7 +25,8 @@ export async function listMany(env, dirs) {
  * Busy reason at scan time (recent writes, running tool, open files).
  * @returns {string|null}
  */
-export function scanTimeBusy(context, item) {
+export async function scanTimeBusy(context, item) {
+  await context.liveness?.resolve(item.paths);
   return context.liveness ? context.liveness.busyReason(item) : null;
 }
 

package/src/scanners/global.js

@@ -6,12 +6,17 @@
 
 import { CACHE_RULES } from '../rules/ecosystems.js';
 import { OTHER_RULES } from '../rules/other.js';
+import { APP_RULES, expandChromiumCaches } from '../rules/apps.js';
 import { compareVersions } from '../rules/versions.js';
 import { block, makeItem } from '../items.js';
 import { expandGlobPaths, expandRulePath } from '../paths.js';
 import { olderThan, scanTimeBusy } from './common.js';
 
-export const GLOBAL_RULES = [...CACHE_RULES, ...OTHER_RULES];
+export const GLOBAL_RULES = [
+  ...CACHE_RULES,
+  ...expandChromiumCaches(OTHER_RULES),
+  ...APP_RULES,
+];
 
 function scopeBases(rule, homes, tmpDirs) {
   const scope = rule.scope ?? 'home';
@@ -123,6 +128,9 @@ async function olderVersions(env, rule, paths) {
 async function buildItem(context, rule, base, group) {
   const { env } = context;
   const paths = group.map((entry) => entry.path);
+  const appRoot = rule.markers
+    ? env.path.dirname(paths[0].replace(/[/\\]Service Worker[/\\].*$/, ''))
+    : null;
   const { action, blocker } = await nativeAction(context, rule, base, paths);
   const scope = rule.scope ?? 'home';
   const item = makeItem(env, {
@@ -138,11 +146,15 @@ async function buildItem(context, rule, base, group) {
     reason: rule.minAge
       ? `untouched for longer than the ${rule.minAge === 'stale' ? 'activity' : 'inactivity'} window`
       : 're-downloaded or re-created on demand',
+    recheck: rule.git === 'ifPresent' ? { type: 'scratch' } : undefined,
     action: action ?? { type: 'none' },
     checks: {
-      busy: rule.busy ?? [],
+      busy: [
+        ...(rule.busy ?? []),
+        ...(appRoot ? [env.path.basename(appRoot)] : []),
+      ],
       cwd: scope === 'tmp' ? paths[0] : null,
-      mtime: scope === 'tmp' || Boolean(rule.minAge),
+      mtime: rule.mtime ?? (scope === 'tmp' || Boolean(rule.minAge)),
     },
   });
   block(item, blocker);
@@ -157,12 +169,14 @@ async function addBlockers(context, rule, item) {
   }
   if (rule.git) {
     for (const target of item.paths) {
-      for (const reason of await git.treeBlockers(target)) {
+      for (const reason of await git.treeBlockers(target, {
+        allowNoRepo: rule.git === 'ifPresent',
+      })) {
         block(item, reason);
       }
     }
   }
-  const busy = scanTimeBusy(context, item);
+  const busy = await scanTimeBusy(context, item);
   if (busy) {
     block(item, `busy: ${busy}`);
   }
@@ -193,8 +207,16 @@ export async function scanGlobal(context, { rules = GLOBAL_RULES } = {}) {
     const candidates = [
       ...new Set(patterns.flatMap((pattern) => matches.get(pattern) ?? [])),
     ].filter((target) => !seen.has(target));
-    candidates.forEach((target) => seen.add(target));
-    const paths = await olderVersions(env, rule, candidates);
+
+    const accepted = [];
+    for (const target of candidates) {
+      if (!(await acceptedPath(env, rule, target))) {
+        continue;
+      }
+      accepted.push(target);
+      seen.add(target);
+    }
+    const paths = await olderVersions(env, rule, accepted);
     if (paths.length > 0) {
       found.push({ rule, base, paths });
     }
@@ -215,3 +237,33 @@ export async function scanGlobal(context, { rules = GLOBAL_RULES } = {}) {
   }
   return items;
 }
+
+async function acceptedPath(env, rule, target) {
+  const name = env.path.basename(target);
+  if (rule.excludeNames?.includes(name)) {
+    return false;
+  }
+  if (rule.directoryOnly && (await env.stat(target))?.type !== 'dir') {
+    return false;
+  }
+  if (rule.fileOnly && (await env.stat(target))?.type !== 'file') {
+    return false;
+  }
+  if (
+    rule.protectProfiles &&
+    /(?:mcp|profile|userdata|user-data)/i.test(name)
+  ) {
+    return false;
+  }
+  if (!rule.markers) {
+    return true;
+  }
+  const parent = env.path.dirname(
+    target.replace(/[/\\]Service Worker[/\\].*$/, '')
+  );
+  return (
+    await Promise.all(
+      rule.markers.map((marker) => env.exists(env.path.join(parent, marker)))
+    )
+  ).some(Boolean);
+}

package/src/scanners/projects.js

@@ -169,7 +169,7 @@ function projectTier(context, rule, lastActivityMs) {
   const { inactiveMs } = context.options;
   if (olderThan(context, lastActivityMs, inactiveMs)) {
     return {
-      tier: 'moderate',
+      tier: rule.id === 'node-modules' ? 'safe' : 'moderate',
       reason: 'project inactive, re-created by the build or install step',
     };
   }
@@ -185,7 +185,7 @@ async function addBlockers(context, item, requireClean) {
   })) {
     block(item, reason);
   }
-  const busy = scanTimeBusy(context, item);
+  const busy = await scanTimeBusy(context, item);
   if (busy) {
     block(item, `busy: ${busy}`);
   }
@@ -209,7 +209,7 @@ async function projectActivity(context, project, candidate, usage, globs) {
 }
 
 async function projectItem(context, { candidate, rule }, usage, globs) {
-  const { env, options } = context;
+  const { env } = context;
   const project = rule.parentName
     ? env.path.dirname(candidate.parent)
     : candidate.parent;
@@ -234,11 +234,7 @@ async function projectItem(context, { candidate, rule }, usage, globs) {
     ...projectTier(context, rule, lastActivityMs),
     checks: { busy: rule.busy ?? [], cwd: project, mtime: true },
   });
-  await addBlockers(
-    context,
-    item,
-    item.tier !== 'safe' && !options.allowDirtyRepos
-  );
+  await addBlockers(context, item, false);
   return item;
 }
 

package/src/scanners/system.js

@@ -55,8 +55,8 @@ export function parseBrewCleanup(output) {
   );
 }
 
-function withBusy(context, item) {
-  const busy = scanTimeBusy(context, item);
+async function withBusy(context, item) {
+  const busy = await scanTimeBusy(context, item);
   if (busy) {
     block(item, `busy: ${busy}`);
   }
@@ -126,7 +126,7 @@ async function snapItems(context, isRoot) {
     if (!isRoot) {
       block(item, 'system location, run as root to clean it');
     }
-    items.push(withBusy(context, item));
+    items.push(await withBusy(context, item));
   }
   return items;
 }
@@ -154,7 +154,7 @@ async function brewItems(context, isRoot) {
     action: { type: 'command', argv: ['brew', 'cleanup'], measure: [] },
     checks: { busy: ['brew'], cwd: null, mtime: false },
   });
-  return [withBusy(context, item)];
+  return [await withBusy(context, item)];
 }
 
 /**

package/src/scanners/versions.js

@@ -26,7 +26,11 @@ async function installDirs(env, rule, home) {
       if ((rule.exclude ?? []).includes(name)) {
         continue;
       }
-      if ((await env.stat(candidate))?.type !== 'dir') {
+      if (
+        !(rule.installTypes ?? ['dir']).includes(
+          (await env.stat(candidate))?.type
+        )
+      ) {
         continue;
       }
       if (
@@ -86,7 +90,11 @@ async function managerRefs(env, rule, home, installs) {
     refs.push(...(await aliasRefs(env, expand(rule.aliasDir))));
   }
   for (const link of rule.defaultLinks ?? []) {
-    refs.push(...linkRefs(await env.readLink(expand(link))));
+    const target = await env.readLink(expand(link));
+    refs.push(...linkRefs(target));
+    if (rule.linkVersion) {
+      refs.push(rule.linkVersion(target));
+    }
   }
   if (rule.currentLink) {
     const parents = new Set(installs.map((dir) => env.path.dirname(dir)));
@@ -195,10 +203,14 @@ async function ruleItems(context, rule, home, pins) {
       tier: 'moderate',
       reason: `not the ${rule.manager} default, not pinned by a scanned project, not the newest`,
       checks: { busy: rule.busy ?? [], cwd: dir, mtime: true },
-      recheck: rule.id === 'pyenv-python' ? { type: 'pyenv-envs' } : null,
+      recheck: rule.recheck
+        ? { type: 'version', home }
+        : rule.id === 'pyenv-python'
+          ? { type: 'pyenv-envs' }
+          : null,
     });
     await blockPyenvEnvironments(env, rule, dir, item);
-    const busy = scanTimeBusy(context, item);
+    const busy = await scanTimeBusy(context, item);
     if (busy) {
       block(item, `busy: ${busy}`);
     }