@git.zone/tsdisk 1.1.0 → 1.3.0

package/dist_ts/tsdisk.plugins.d.ts

@@ -1,6 +1,6 @@
 import { spawn } from 'node:child_process';
-import { createReadStream, type ReadStream } from 'node:fs';
+import { constants, createReadStream, type ReadStream } from 'node:fs';
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { createInterface } from 'node:readline/promises';
-export { createInterface, createReadStream, fs, path, spawn, type ReadStream, };
+export { constants, createInterface, createReadStream, fs, path, spawn, type ReadStream, };

package/dist_ts/tsdisk.plugins.js

@@ -1,8 +1,8 @@
 // node native
 import { spawn } from 'node:child_process';
-import { createReadStream } from 'node:fs';
+import { constants, createReadStream } from 'node:fs';
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { createInterface } from 'node:readline/promises';
-export { createInterface, createReadStream, fs, path, spawn, };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHNkaXNrLnBsdWdpbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy90c2Rpc2sucGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjO0FBQ2QsT0FBTyxFQUFFLEtBQUssRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQzNDLE9BQU8sRUFBRSxnQkFBZ0IsRUFBbUIsTUFBTSxTQUFTLENBQUM7QUFDNUQsT0FBTyxLQUFLLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUN2QyxPQUFPLEtBQUssSUFBSSxNQUFNLFdBQVcsQ0FBQztBQUNsQyxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFFekQsT0FBTyxFQUNMLGVBQWUsRUFDZixnQkFBZ0IsRUFDaEIsRUFBRSxFQUNGLElBQUksRUFDSixLQUFLLEdBRU4sQ0FBQyJ9
+export { constants, createInterface, createReadStream, fs, path, spawn, };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHNkaXNrLnBsdWdpbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy90c2Rpc2sucGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjO0FBQ2QsT0FBTyxFQUFFLEtBQUssRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQzNDLE9BQU8sRUFBRSxTQUFTLEVBQUUsZ0JBQWdCLEVBQW1CLE1BQU0sU0FBUyxDQUFDO0FBQ3ZFLE9BQU8sS0FBSyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDdkMsT0FBTyxLQUFLLElBQUksTUFBTSxXQUFXLENBQUM7QUFDbEMsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBRXpELE9BQU8sRUFDTCxTQUFTLEVBQ1QsZUFBZSxFQUNmLGdCQUFnQixFQUNoQixFQUFFLEVBQ0YsSUFBSSxFQUNKLEtBQUssR0FFTixDQUFDIn0=

package/dist_ts/tsdisk.progress.d.ts

@@ -0,0 +1,31 @@
+import { type IUsageEntry } from './tsdisk.usage.js';
+import type { IToolCacheFinding } from './tsdisk.toolcaches.js';
+export interface IReclaimEstimate {
+    candidateBytes: number;
+    unknownSizeCount: number;
+    protectedCount: number;
+    confirmedReclaimableBytes: null;
+    status: 'owner-review-required';
+}
+/** Do not sum parents and children, or treat a protected descendant as removable. */
+export declare function estimateReclaimableSpace(findings: IToolCacheFinding[]): IReclaimEstimate;
+export interface IDiskProgress {
+    stage: string;
+    cacheCount: number;
+    measuredBytes: number;
+    reclaim: IReclaimEstimate;
+    largest: IUsageEntry[];
+}
+export declare function formatBytes(bytes: number): string;
+/** Timer ownership is explicit; callers stop it in finally even on failure. */
+export declare class DiskProgressReporter {
+    private write;
+    private timer?;
+    private startedAt;
+    private state;
+    constructor(write: (line: string) => void);
+    update(update: Partial<IDiskProgress>): void;
+    start(): void;
+    private print;
+    stop(stage?: string): void;
+}

package/dist_ts/tsdisk.progress.js

@@ -0,0 +1,64 @@
+import { containsPath } from './tsdisk.usage.js';
+/** Do not sum parents and children, or treat a protected descendant as removable. */
+export function estimateReclaimableSpace(findings) {
+    const protectedPaths = findings.filter((finding) => finding.marker?.safeToPrune === false).map((finding) => finding.path);
+    const candidates = findings.filter((finding) => !protectedPaths.some((path) => containsPath(path, finding.path) || containsPath(finding.path, path)));
+    const selected = [];
+    for (const finding of [...candidates].sort((a, b) => a.path.length - b.path.length)) {
+        if (finding.bytes === undefined || selected.some((parent) => containsPath(parent.path, finding.path)))
+            continue;
+        selected.push(finding);
+    }
+    return {
+        candidateBytes: selected.reduce((sum, finding) => sum + (finding.bytes ?? 0), 0),
+        unknownSizeCount: candidates.filter((finding) => finding.bytes === undefined).length,
+        protectedCount: protectedPaths.length,
+        confirmedReclaimableBytes: null,
+        status: 'owner-review-required',
+    };
+}
+export function formatBytes(bytes) {
+    if (!Number.isFinite(bytes) || bytes < 0)
+        return 'n/a';
+    const units = ['B', 'KiB', 'MiB', 'GiB', 'TiB'];
+    let value = bytes;
+    let index = 0;
+    while (value >= 1024 && index < units.length - 1) {
+        value /= 1024;
+        index++;
+    }
+    return `${value.toFixed(index === 0 || value >= 100 ? 0 : value >= 10 ? 1 : 2)} ${units[index]}`;
+}
+/** Timer ownership is explicit; callers stop it in finally even on failure. */
+export class DiskProgressReporter {
+    write;
+    timer;
+    startedAt = Date.now();
+    state = { stage: 'starting', cacheCount: 0, measuredBytes: 0, reclaim: estimateReclaimableSpace([]), largest: [] };
+    constructor(write) {
+        this.write = write;
+    }
+    update(update) { Object.assign(this.state, update); }
+    start() {
+        if (this.timer)
+            return;
+        this.startedAt = Date.now();
+        this.print();
+        this.timer = setInterval(() => this.print(), 5000);
+        this.timer.unref();
+    }
+    print() {
+        const state = this.state;
+        const top = state.largest.slice(0, 3).map((entry) => `${formatBytes(entry.bytes)}${entry.complete ? '' : '+'} ${JSON.stringify(entry.path)}`).join('; ');
+        this.write(`[tsdisk ${Math.floor((Date.now() - this.startedAt) / 1000)}s] ${state.stage} | measured ${formatBytes(state.measuredBytes)} | ${state.cacheCount} caches | potential cleanup ${formatBytes(state.reclaim.candidateBytes)} (owner review; ${state.reclaim.unknownSizeCount} unsized) | confirmed reclaimable: unknown${top ? ` | largest: ${top}` : ''}`);
+    }
+    stop(stage = 'finished') {
+        if (!this.timer)
+            return;
+        clearInterval(this.timer);
+        this.timer = undefined;
+        this.state.stage = stage;
+        this.print();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/tsdisk.scan.d.ts

@@ -0,0 +1,22 @@
+import { type IToolCacheFinding } from './tsdisk.toolcaches.js';
+export interface IWorkspaceScanOptions {
+    maxDepth: number;
+    timeoutMs: number;
+    maxEntries: number;
+    onProgress?: (result: IWorkspaceScanResult) => void;
+}
+export interface IScanIssue {
+    path: string;
+    reason: 'read-error' | 'invalid-marker' | 'depth-limit' | 'entry-limit' | 'timeout' | 'mount-boundary' | 'symlink' | 'size-unavailable';
+    detail: string;
+}
+export interface IWorkspaceScanResult {
+    root: string;
+    findings: IToolCacheFinding[];
+    issues: IScanIssue[];
+    complete: boolean;
+    visitedEntries: number;
+    issueCounts: Partial<Record<IScanIssue['reason'], number>>;
+    usagePriorityPaths: string[];
+}
+export declare function scanWorkspace(root: string, options: IWorkspaceScanOptions): Promise<IWorkspaceScanResult>;

package/dist_ts/tsdisk.scan.js

@@ -0,0 +1,147 @@
+import * as plugins from './tsdisk.plugins.js';
+import { classifyToolCachePath, parseToolCacheMarker, toolCacheMarkerFile } from './tsdisk.toolcaches.js';
+const excludedDirectories = new Set(['.git', 'node_modules', 'dist_ts', 'dist_ts_web', 'coverage', '.pnpm-store']);
+export async function scanWorkspace(root, options) {
+    for (const name of ['maxDepth', 'timeoutMs', 'maxEntries']) {
+        const value = options[name];
+        if (!Number.isSafeInteger(value) || value < (name === 'maxDepth' ? 0 : 1)) {
+            throw new Error(`Invalid scan option ${name}: ${value}`);
+        }
+    }
+    const result = { root: plugins.path.resolve(root), findings: [], issues: [], issueCounts: {}, usagePriorityPaths: [], complete: true, visitedEntries: 0 };
+    const deadline = Date.now() + options.timeoutMs;
+    let stopped = false;
+    const issue = (path, reason, detail) => {
+        result.complete = false;
+        result.issueCounts[reason] = (result.issueCounts[reason] ?? 0) + 1;
+        if (result.issues.length < 200)
+            result.issues.push({ path, reason, detail });
+    };
+    const limited = (path) => {
+        if (stopped)
+            return true;
+        if (Date.now() >= deadline || result.visitedEntries >= options.maxEntries) {
+            issue(path, Date.now() >= deadline ? 'timeout' : 'entry-limit', 'Scan stopped before visiting all entries.');
+            stopped = true;
+        }
+        return stopped;
+    };
+    let rootDev;
+    try {
+        const stat = await plugins.fs.lstat(result.root);
+        if (stat.isSymbolicLink() || await plugins.fs.realpath(result.root) !== result.root) {
+            issue(result.root, 'symlink', 'Scan roots must not contain symbolic links.');
+            return result;
+        }
+        if (!stat.isDirectory())
+            throw new Error('Scan root is not a directory.');
+        rootDev = stat.dev;
+    }
+    catch (error) {
+        issue(result.root, 'read-error', error instanceof Error ? error.message : String(error));
+        return result;
+    }
+    const queue = [{ directory: result.root, depth: 0 }];
+    let queueLimited = false;
+    const visit = async (directory, depth) => {
+        if (limited(directory))
+            return;
+        result.visitedEntries++;
+        try {
+            const stat = await plugins.fs.lstat(directory);
+            if (stat.isSymbolicLink()) {
+                issue(directory, 'symlink', 'Symbolic link skipped.');
+                return;
+            }
+            if (stat.dev !== rootDev) {
+                issue(directory, 'mount-boundary', 'Different filesystem skipped.');
+                return;
+            }
+            if (plugins.path.basename(directory) === '.nogit')
+                result.usagePriorityPaths.push(directory);
+            let marker;
+            const markerPath = plugins.path.join(directory, toolCacheMarkerFile);
+            const markerStat = await plugins.fs.lstat(markerPath).catch((error) => {
+                if (error.code === 'ENOENT')
+                    return undefined;
+                throw error;
+            });
+            if (markerStat) {
+                if (!markerStat.isFile() || markerStat.size > 65536) {
+                    issue(markerPath, 'invalid-marker', 'Marker must be a regular file of at most 64 KiB.');
+                }
+                else {
+                    marker = parseToolCacheMarker(await plugins.fs.readFile(markerPath, 'utf8'));
+                    if (!marker)
+                        issue(markerPath, 'invalid-marker', 'Invalid cache ownership marker.');
+                }
+            }
+            const heuristic = classifyToolCachePath(directory);
+            const classification = classifyToolCachePath(directory, marker);
+            if (classification)
+                result.findings.push({ path: directory, ...classification });
+            // Cache contents are not workspaces. Registry session directories can carry their own markers.
+            if (classification && heuristic?.kind !== 'docker-registry-cache')
+                return;
+            let enumerated = 0;
+            const children = await plugins.fs.opendir(directory);
+            for await (const child of children) {
+                // A huge flat directory must not consume the budget of sibling projects.
+                if (++enumerated > 4096) {
+                    issue(directory, 'entry-limit', 'Directory listing stopped at 4096 entries; sibling directories are still scanned.');
+                    break;
+                }
+                if (excludedDirectories.has(child.name))
+                    continue;
+                if (!child.isDirectory() && !child.isSymbolicLink())
+                    continue;
+                if (depth >= options.maxDepth) {
+                    issue(directory, 'depth-limit', `Maximum scan depth ${options.maxDepth} reached.`);
+                    break;
+                }
+                const childPath = plugins.path.join(directory, child.name);
+                if (limited(childPath))
+                    return;
+                if (child.isSymbolicLink()) {
+                    result.visitedEntries++;
+                    issue(childPath, 'symlink', 'Symbolic link skipped.');
+                    continue;
+                }
+                if (heuristic?.kind === 'docker-registry-cache') {
+                    // Only direct sessions, never registry blob trees.
+                    const sessionMarker = await plugins.fs.lstat(plugins.path.join(childPath, toolCacheMarkerFile)).catch((error) => {
+                        if (error.code === 'ENOENT')
+                            return undefined;
+                        throw error;
+                    });
+                    if (!sessionMarker) {
+                        result.visitedEntries++;
+                        continue;
+                    }
+                }
+                if (queue.length >= options.maxEntries) {
+                    if (!queueLimited)
+                        issue(directory, 'entry-limit', 'Directory queue budget exhausted; already queued siblings are still scanned.');
+                    queueLimited = true;
+                    continue;
+                }
+                queue.push({ directory: childPath, depth: depth + 1 });
+            }
+        }
+        catch (error) {
+            issue(directory, 'read-error', error instanceof Error ? error.message : String(error));
+        }
+    };
+    // Breadth first: canonical projects precede deeply nested retained worktrees.
+    let lastProgress = 0;
+    for (let index = 0; index < queue.length && !stopped; index++) {
+        await visit(queue[index].directory, queue[index].depth);
+        if (Date.now() - lastProgress >= 250) {
+            options.onProgress?.(result);
+            lastProgress = Date.now();
+        }
+    }
+    options.onProgress?.(result);
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tsdisk.scan.js","sourceRoot":"","sources":["../ts/tsdisk.scan.ts"],"names":[],"mappings":"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"}

package/dist_ts/tsdisk.toolcaches.js

@@ -1,12 +1,12 @@
-import * as path from 'node:path';
+import { path } from './tsdisk.plugins.js';
 export const toolCacheMarkerFile = '.gitzone-tool-cache.json';
 export function parseToolCacheMarker(rawArg) {
     try {
         const marker = JSON.parse(rawArg);
-        if (typeof marker.owner === 'string' &&
-            typeof marker.kind === 'string' &&
-            marker.safeToPrune === true &&
-            typeof marker.createdAt === 'string' &&
+        if (typeof marker.owner === 'string' && marker.owner.length > 0 &&
+            typeof marker.kind === 'string' && marker.kind.length > 0 &&
+            typeof marker.safeToPrune === 'boolean' &&
+            typeof marker.createdAt === 'string' && Number.isFinite(Date.parse(marker.createdAt)) &&
             marker.schemaVersion === 1) {
             return marker;
         }
@@ -48,8 +48,10 @@ export function classifyToolCachePath(pathArg, markerArg) {
         return {
             ownerGuess: markerArg.owner,
             kind: markerArg.kind,
-            risk: markerArg.safeToPrune ? 'safe-marked' : 'review',
-            suggestedCleanupCommand: `rm -rf ${quotePath(pathArg)}`,
+            risk: 'review',
+            suggestedCleanupCommand: markerArg.safeToPrune
+                ? `report-only: ownership marker is not proof of inactivity; use the owning tool to review ${quotePath(pathArg)}`
+                : `protected: owner explicitly disallows pruning ${quotePath(pathArg)}`,
             marker: markerArg,
         };
     }
@@ -69,7 +71,7 @@ export function classifyToolCachePath(pathArg, markerArg) {
             suggestedCleanupCommand: `report-only: verify ownership before removing ${quotePath(path.dirname(pathArg))}`,
         };
     }
-    if (normalized.endsWith('/.nogit/tsbundle-temp')) {
+    if (/\/\.nogit\/tsbundle-temp(?:-[^/]+)?$/.test(normalized)) {
         return {
             ownerGuess: '@git.zone/tsbundle',
             kind: 'bundle-temp-workspace',
@@ -77,6 +79,22 @@ export function classifyToolCachePath(pathArg, markerArg) {
             suggestedCleanupCommand: `report-only: verify ownership before removing ${quotePath(pathArg)}`,
         };
     }
+    if (/\/\.nogit\/tsrust-matrix(?:-archive|-probes)?$/.test(normalized)) {
+        return {
+            ownerGuess: '@git.zone/tsrust',
+            kind: 'rust-matrix-artifacts',
+            risk: 'report-only',
+            suggestedCleanupCommand: `report-only: retained matrix runs may be needed for recovery; inspect ${quotePath(pathArg)}`,
+        };
+    }
+    if (/\/\.nogit\/(?:docker-registry\.[^/]+|docker-registry-v1-cache|dockerimagestore)$/.test(normalized)) {
+        return {
+            ownerGuess: '@git.zone/tsdocker',
+            kind: 'legacy-docker-registry-cache',
+            risk: 'report-only',
+            suggestedCleanupCommand: `report-only: verify release recovery requirements before removing ${quotePath(pathArg)}`,
+        };
+    }
     if (normalized.endsWith('/.nogit/docker-registry') || normalized.includes('/.nogit/docker-registry/')) {
         return {
             ownerGuess: '@git.zone/tsdocker',
@@ -103,4 +121,4 @@ export function classifyToolCachePath(pathArg, markerArg) {
     }
     return undefined;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/tsdisk.usage.d.ts

@@ -0,0 +1,50 @@
+export interface IUsageEntry {
+    path: string;
+    bytes: number;
+    complete: boolean;
+}
+export interface IUsageReport {
+    roots: string[];
+    measuredBytes: number;
+    entries: IUsageEntry[];
+    records: number;
+    complete: boolean;
+    code: number;
+    stderr: string;
+}
+export declare function containsPath(parent: string, child: string): boolean;
+/** Preserve explicitly selected nested mounts; subsume overlapping roots on the same device. */
+export declare function normalizeScanRoots(roots: string[]): Promise<string[]>;
+/** GNU du emits files immediately and inclusive directory totals on completion.
+ * Reconcile each completed directory with its observed children, rather than
+ * adding inclusive totals twice. The active ancestor chain survives a timeout.
+ */
+export declare class UsageAccumulator {
+    private roots;
+    private trackedPaths;
+    private priorityPaths;
+    private pending;
+    private active;
+    private largest;
+    private tracked;
+    private minimumLargestBytes;
+    private operandBytes;
+    private accountingRoots;
+    private currentRoot?;
+    measuredBytes: number;
+    records: number;
+    currentPath: string;
+    constructor(roots: string[], trackedPaths?: Set<string>, priorityPaths?: string[]);
+    consume(chunk: string): void;
+    private record;
+    snapshot(): IUsageEntry[];
+    get endedOnRecordBoundary(): boolean;
+}
+export interface IUsageOptions {
+    timeoutSeconds: number;
+    trackedPaths?: string[];
+    priorityPaths?: string[];
+    onProgress?: (usage: UsageAccumulator) => void;
+}
+/** One streaming native pass; no output export, no symlink traversal, no raw file content reads. */
+export declare function measureDiskUsage(roots: string[], options: IUsageOptions): Promise<IUsageReport>;