crewly 1.20.301 → 1.20.303

package/dist/cli/backend/src/services/worktree/worktree-janitor.git.d.ts

@@ -0,0 +1,224 @@
+/**
+ * Worktree janitor — low-level helpers.
+ *
+ * A command runner that never throws, a parser for `git worktree list
+ * --porcelain`, path helpers, and the process-cwd probe used to tell whether
+ * anything is still working inside a worktree. Kept apart from the service so
+ * each piece can be tested on its own.
+ *
+ * @module services/worktree/worktree-janitor.git
+ */
+/** Result of one external command. `code` is null when it could not start or timed out. */
+export interface CommandResult {
+    /** Exit code, or null when the process did not exit normally */
+    code: number | null;
+    /** Captured stdout */
+    stdout: string;
+    /** Captured stderr (or the spawn error message) */
+    stderr: string;
+}
+/** Options for {@link runCommand}. */
+export interface RunCommandOptions {
+    /** Working directory */
+    cwd?: string;
+    /** Timeout in ms (default: GIT_TIMEOUT_MS) */
+    timeoutMs?: number;
+    /** Extra environment variables merged over process.env */
+    env?: Record<string, string>;
+    /** Text written to the command's stdin (then closed) */
+    input?: string;
+}
+/**
+ * Run a command without a shell and never throw.
+ *
+ * Git and gh are told never to prompt (no credential dialogs, no pager), so a
+ * periodic background job cannot hang on input, and git takes no optional
+ * locks (a status never rewrites the index).
+ *
+ * @param file - Executable (e.g. `git`, `gh`, or an absolute path)
+ * @param args - Arguments
+ * @param options - cwd / timeout / env
+ * @returns Exit code and output; `code` is null on spawn failure or timeout
+ *
+ * @example
+ * ```typescript
+ * const r = await runCommand('git', ['-C', repo, 'status', '--porcelain']);
+ * if (r.code === 0 && r.stdout === '') console.log('clean');
+ * ```
+ */
+export declare function runCommand(file: string, args: string[], options?: RunCommandOptions): Promise<CommandResult>;
+/** One entry of `git worktree list --porcelain`. */
+export interface PorcelainWorktree {
+    /** Absolute worktree path as git reports it */
+    path: string;
+    /** HEAD commit, or null (bare) */
+    head: string | null;
+    /** Short branch name (`refs/heads/` stripped), or null when detached */
+    branch: string | null;
+    /** True for the bare entry */
+    bare: boolean;
+    /** True when HEAD is detached */
+    detached: boolean;
+    /** True when the worktree is locked (`git worktree lock`) */
+    locked: boolean;
+    /** Lock reason, when given */
+    lockReason?: string;
+    /** True when git reports the directory as gone (`prunable`) */
+    prunable: boolean;
+    /** True for the first entry — the main worktree */
+    isMain: boolean;
+}
+/**
+ * Parse `git worktree list --porcelain` output.
+ *
+ * Entries are separated by blank lines; the first entry is the main worktree.
+ *
+ * @param output - Raw porcelain output
+ * @returns Parsed entries in git's order
+ *
+ * @example
+ * ```typescript
+ * parsePorcelainWorktrees('worktree /r\nHEAD abc\nbranch refs/heads/main\n');
+ * // [{ path: '/r', head: 'abc', branch: 'main', isMain: true, ... }]
+ * ```
+ */
+export declare function parsePorcelainWorktrees(output: string): PorcelainWorktree[];
+/**
+ * Real path of `p`, or its resolved form when it does not exist.
+ *
+ * @param p - Path
+ * @returns Canonical path for comparisons
+ */
+export declare function canonicalPath(p: string): string;
+/**
+ * Whether `child` is `parent` or inside it (both canonicalised first).
+ *
+ * @param child - Candidate path
+ * @param parent - Directory
+ * @returns True when child === parent or child is under parent
+ *
+ * @example
+ * ```typescript
+ * isPathInside('/r/.claude/worktrees/a/src', '/r/.claude/worktrees/a'); // true
+ * isPathInside('/r/.claude/worktrees/ab', '/r/.claude/worktrees/a');    // false
+ * ```
+ */
+export declare function isPathInside(child: string, parent: string): boolean;
+/**
+ * Latest modification time (ms) of a worktree: the directory itself plus its
+ * private git dir's `index`, `HEAD` and `logs/HEAD` — every commit, checkout,
+ * stage or reset touches one of those. Uncommitted edits are caught by the
+ * dirty check instead.
+ *
+ * @param worktreePath - Worktree root
+ * @param gitDir - Its private git dir (`.git/worktrees/<name>`), when known
+ * @returns Newest mtime in ms, or null when nothing could be stat'ed
+ */
+export declare function latestWorktreeMtimeMs(worktreePath: string, gitDir: string | null): number | null;
+/**
+ * Current working directories of every process this user can see.
+ *
+ * macOS: `lsof -a -d cwd -u <uid> -Fn`. Linux: `/proc/<pid>/cwd`. Returns
+ * null when the probe cannot run, so the caller can treat "unknown" as busy.
+ *
+ * @returns Absolute cwd paths (deduplicated), or null when unavailable
+ */
+export declare function listProcessCwds(): Promise<string[] | null>;
+/**
+ * Whether the kill switch disables the janitor.
+ *
+ * @param env - Environment (defaults to process.env)
+ * @returns True when `CREWLY_WORKTREE_JANITOR` is `0`/`off`/`false`/`no`
+ */
+export declare function isJanitorDisabled(env?: NodeJS.ProcessEnv): boolean;
+/**
+ * Yield to the event loop every YIELD_EVERY_ENTRIES calls, so a long
+ * filesystem walk never holds up Slack, relay polls or PTY I/O.
+ */
+export declare class EventLoopYielder {
+    private count;
+    /**
+     * Count one unit of work; every YIELD_EVERY_ENTRIES units, wait one
+     * `setImmediate` turn.
+     *
+     * @returns Resolves when the caller may continue
+     */
+    tick(): Promise<void>;
+}
+/**
+ * Git dir a `.git` file points to (`gitdir: <path>`), resolved against `dir`.
+ *
+ * @param dir - Directory holding the `.git` file
+ * @returns Absolute git dir, or null when there is no readable `.git` file
+ */
+export declare function readGitFilePointer(dir: string): Promise<string | null>;
+/**
+ * Main worktree of the repo a linked worktree belongs to, read from the
+ * worktree's `.git` file (`gitdir: <main>/.git/worktrees/<name>`). Returns
+ * null for anything else: a `.git` directory (a normal clone), a submodule
+ * (`gitdir: …/.git/modules/…`), or an unreadable file.
+ *
+ * @param dir - Directory that may be a linked worktree
+ * @returns Absolute path of the main worktree, or null
+ *
+ * @example
+ * ```typescript
+ * // /tmp/visa-cm-wt/.git contains "gitdir: /src/ce-core/.git/worktrees/visa-cm-wt"
+ * await mainRepoOfLinkedWorktree('/tmp/visa-cm-wt'); // '/src/ce-core'
+ * ```
+ */
+export declare function mainRepoOfLinkedWorktree(dir: string): Promise<string | null>;
+/** A git checkout found on disk. */
+export interface FoundRepo {
+    /** Directory holding `.git` */
+    path: string;
+    /** `dir` for a `.git` directory (clone / main worktree), `file` for a `.git` file (linked worktree or submodule) */
+    kind: 'dir' | 'file';
+}
+/**
+ * Find git checkouts under `root` without following symlinks. A directory
+ * with a `.git` directory or file is a checkout and is not descended into;
+ * `node_modules` and `.git` are never descended into. Fully async; yields to
+ * the event loop every few directories.
+ *
+ * @param root - Directory to search (itself included, at depth 0)
+ * @param maxDepth - Deepest level searched (root = 0)
+ * @param maxDirs - Stop after visiting this many directories
+ * @returns Checkouts found, in walk order
+ */
+export declare function findGitCheckouts(root: string, maxDepth: number, maxDirs?: number): Promise<FoundRepo[]>;
+/**
+ * Main worktrees of every repo that owns a linked worktree somewhere under
+ * the given roots (e.g. `/tmp/claude-501/visa-cm-wt` → `~/src/ce-core`), so
+ * repos that are not registered projects still get their temp worktrees
+ * cleaned. Visits at most DISCOVERY_MAX_DIRS directories per root.
+ *
+ * @param roots - Temp roots to scan (missing roots are skipped)
+ * @returns De-duplicated main-worktree paths
+ */
+export declare function discoverLinkedWorktreeRepos(roots: readonly string[]): Promise<string[]>;
+/**
+ * Newest mtime (ms) of `dir` and everything within `depth` levels below it,
+ * using lstat (symlinks are not followed). Async; yields every few entries.
+ *
+ * @param dir - Directory
+ * @param depth - Levels below `dir` to include (0 = only `dir`)
+ * @returns Newest mtime in ms, or null when `dir` cannot be stat'ed
+ */
+export declare function latestTreeMtimeMs(dir: string, depth: number): Promise<number | null>;
+/**
+ * Disk usage of a path in bytes (`du -sk` in a child process, so the event
+ * loop is never blocked; `du` does not follow symlinks).
+ *
+ * @param p - File or directory
+ * @returns Bytes, or null when `du` failed or timed out
+ */
+export declare function diskUsageBytes(p: string): Promise<number | null>;
+/**
+ * Human-readable size (`1.8 GB`, `512 MB`).
+ *
+ * @param bytes - Size in bytes
+ * @returns Short string with one decimal for GB
+ */
+export declare function formatBytes(bytes: number): string;
+//# sourceMappingURL=worktree-janitor.git.d.ts.map

package/dist/cli/backend/src/services/worktree/worktree-janitor.git.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worktree-janitor.git.d.ts","sourceRoot":"","sources":["../../../../../../backend/src/services/worktree/worktree-janitor.git.ts"],"names":[],"mappings":"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"}

package/dist/cli/backend/src/services/worktree/worktree-janitor.git.js

@@ -0,0 +1,449 @@
+/**
+ * Worktree janitor — low-level helpers.
+ *
+ * A command runner that never throws, a parser for `git worktree list
+ * --porcelain`, path helpers, and the process-cwd probe used to tell whether
+ * anything is still working inside a worktree. Kept apart from the service so
+ * each piece can be tested on its own.
+ *
+ * @module services/worktree/worktree-janitor.git
+ */
+import { execFile } from 'child_process';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { WORKTREE_JANITOR_CONSTANTS } from '../../constants.js';
+/**
+ * Run a command without a shell and never throw.
+ *
+ * Git and gh are told never to prompt (no credential dialogs, no pager), so a
+ * periodic background job cannot hang on input, and git takes no optional
+ * locks (a status never rewrites the index).
+ *
+ * @param file - Executable (e.g. `git`, `gh`, or an absolute path)
+ * @param args - Arguments
+ * @param options - cwd / timeout / env
+ * @returns Exit code and output; `code` is null on spawn failure or timeout
+ *
+ * @example
+ * ```typescript
+ * const r = await runCommand('git', ['-C', repo, 'status', '--porcelain']);
+ * if (r.code === 0 && r.stdout === '') console.log('clean');
+ * ```
+ */
+export function runCommand(file, args, options = {}) {
+    return new Promise((resolve) => {
+        try {
+            const child = execFile(file, args, {
+                cwd: options.cwd,
+                timeout: options.timeoutMs ?? WORKTREE_JANITOR_CONSTANTS.GIT_TIMEOUT_MS,
+                maxBuffer: WORKTREE_JANITOR_CONSTANTS.MAX_OUTPUT_BYTES,
+                env: {
+                    ...process.env,
+                    GIT_TERMINAL_PROMPT: '0',
+                    GIT_PAGER: 'cat',
+                    // `git status` must not rewrite the index: that would bump its
+                    // mtime (resetting the idle clock) and contend with agents' git.
+                    GIT_OPTIONAL_LOCKS: '0',
+                    GH_PROMPT_DISABLED: '1',
+                    GH_NO_UPDATE_NOTIFIER: '1',
+                    ...(options.env ?? {}),
+                },
+            }, (error, stdout, stderr) => {
+                const out = typeof stdout === 'string' ? stdout : String(stdout ?? '');
+                const err = typeof stderr === 'string' ? stderr : String(stderr ?? '');
+                if (!error) {
+                    resolve({ code: 0, stdout: out, stderr: err });
+                    return;
+                }
+                const errCode = error.code;
+                const code = typeof errCode === 'number' && !error.killed ? errCode : null;
+                resolve({ code, stdout: out, stderr: err || error.message });
+            });
+            if (options.input !== undefined) {
+                // A command that exits early closes the pipe: ignore EPIPE.
+                child.stdin?.on('error', () => undefined);
+                child.stdin?.end(options.input);
+            }
+        }
+        catch (spawnErr) {
+            resolve({ code: null, stdout: '', stderr: spawnErr instanceof Error ? spawnErr.message : String(spawnErr) });
+        }
+    });
+}
+/**
+ * Parse `git worktree list --porcelain` output.
+ *
+ * Entries are separated by blank lines; the first entry is the main worktree.
+ *
+ * @param output - Raw porcelain output
+ * @returns Parsed entries in git's order
+ *
+ * @example
+ * ```typescript
+ * parsePorcelainWorktrees('worktree /r\nHEAD abc\nbranch refs/heads/main\n');
+ * // [{ path: '/r', head: 'abc', branch: 'main', isMain: true, ... }]
+ * ```
+ */
+export function parsePorcelainWorktrees(output) {
+    const result = [];
+    let current = null;
+    for (const rawLine of output.split('\n')) {
+        const line = rawLine.replace(/\r$/, '');
+        if (line.startsWith('worktree ')) {
+            current = {
+                path: line.slice('worktree '.length),
+                head: null,
+                branch: null,
+                bare: false,
+                detached: false,
+                locked: false,
+                prunable: false,
+                isMain: result.length === 0,
+            };
+            result.push(current);
+            continue;
+        }
+        if (!current || line === '')
+            continue;
+        if (line.startsWith('HEAD '))
+            current.head = line.slice('HEAD '.length);
+        else if (line.startsWith('branch '))
+            current.branch = line.slice('branch '.length).replace(/^refs\/heads\//, '');
+        else if (line === 'bare')
+            current.bare = true;
+        else if (line === 'detached')
+            current.detached = true;
+        else if (line === 'locked' || line.startsWith('locked ')) {
+            current.locked = true;
+            const reason = line.slice('locked'.length).trim();
+            if (reason)
+                current.lockReason = reason;
+        }
+        else if (line === 'prunable' || line.startsWith('prunable '))
+            current.prunable = true;
+    }
+    return result;
+}
+/**
+ * Real path of `p`, or its resolved form when it does not exist.
+ *
+ * @param p - Path
+ * @returns Canonical path for comparisons
+ */
+export function canonicalPath(p) {
+    try {
+        return fs.realpathSync(p);
+    }
+    catch {
+        return path.resolve(p);
+    }
+}
+/**
+ * Whether `child` is `parent` or inside it (both canonicalised first).
+ *
+ * @param child - Candidate path
+ * @param parent - Directory
+ * @returns True when child === parent or child is under parent
+ *
+ * @example
+ * ```typescript
+ * isPathInside('/r/.claude/worktrees/a/src', '/r/.claude/worktrees/a'); // true
+ * isPathInside('/r/.claude/worktrees/ab', '/r/.claude/worktrees/a');    // false
+ * ```
+ */
+export function isPathInside(child, parent) {
+    const c = canonicalPath(child);
+    const p = canonicalPath(parent);
+    if (c === p)
+        return true;
+    const withSep = p.endsWith(path.sep) ? p : p + path.sep;
+    return c.startsWith(withSep);
+}
+/**
+ * Latest modification time (ms) of a worktree: the directory itself plus its
+ * private git dir's `index`, `HEAD` and `logs/HEAD` — every commit, checkout,
+ * stage or reset touches one of those. Uncommitted edits are caught by the
+ * dirty check instead.
+ *
+ * @param worktreePath - Worktree root
+ * @param gitDir - Its private git dir (`.git/worktrees/<name>`), when known
+ * @returns Newest mtime in ms, or null when nothing could be stat'ed
+ */
+export function latestWorktreeMtimeMs(worktreePath, gitDir) {
+    const candidates = [worktreePath, path.join(worktreePath, '.git')];
+    if (gitDir) {
+        candidates.push(gitDir, path.join(gitDir, 'index'), path.join(gitDir, 'HEAD'), path.join(gitDir, 'logs', 'HEAD'));
+    }
+    let newest = null;
+    for (const c of candidates) {
+        try {
+            const m = fs.lstatSync(c).mtimeMs;
+            if (newest === null || m > newest)
+                newest = m;
+        }
+        catch {
+            // missing — ignore
+        }
+    }
+    return newest;
+}
+/**
+ * Current working directories of every process this user can see.
+ *
+ * macOS: `lsof -a -d cwd -u <uid> -Fn`. Linux: `/proc/<pid>/cwd`. Returns
+ * null when the probe cannot run, so the caller can treat "unknown" as busy.
+ *
+ * @returns Absolute cwd paths (deduplicated), or null when unavailable
+ */
+export async function listProcessCwds() {
+    if (process.platform === 'linux') {
+        try {
+            const out = new Set();
+            for (const entry of fs.readdirSync('/proc')) {
+                if (!/^\d+$/.test(entry))
+                    continue;
+                try {
+                    out.add(fs.readlinkSync(path.join('/proc', entry, 'cwd')));
+                }
+                catch {
+                    // other user's process or already gone
+                }
+            }
+            return [...out];
+        }
+        catch {
+            return null;
+        }
+    }
+    if (process.platform === 'win32')
+        return null;
+    const uid = typeof process.getuid === 'function' ? String(process.getuid()) : String(os.userInfo().uid);
+    const r = await runCommand('lsof', ['-a', '-d', 'cwd', '-u', uid, '-Fn', '-w'], {
+        timeoutMs: WORKTREE_JANITOR_CONSTANTS.CWD_PROBE_TIMEOUT_MS,
+    });
+    // lsof exits 1 when some listed item had no match; the output is still valid.
+    if (r.code === null || !r.stdout)
+        return null;
+    const out = new Set();
+    for (const line of r.stdout.split('\n')) {
+        if (line.startsWith('n/'))
+            out.add(line.slice(1));
+    }
+    return out.size > 0 ? [...out] : null;
+}
+/**
+ * Whether the kill switch disables the janitor.
+ *
+ * @param env - Environment (defaults to process.env)
+ * @returns True when `CREWLY_WORKTREE_JANITOR` is `0`/`off`/`false`/`no`
+ */
+export function isJanitorDisabled(env = process.env) {
+    const raw = env[WORKTREE_JANITOR_CONSTANTS.ENV_VAR];
+    if (raw === undefined)
+        return false;
+    return WORKTREE_JANITOR_CONSTANTS.DISABLED_VALUES.includes(raw.trim().toLowerCase());
+}
+/**
+ * Yield to the event loop every YIELD_EVERY_ENTRIES calls, so a long
+ * filesystem walk never holds up Slack, relay polls or PTY I/O.
+ */
+export class EventLoopYielder {
+    count = 0;
+    /**
+     * Count one unit of work; every YIELD_EVERY_ENTRIES units, wait one
+     * `setImmediate` turn.
+     *
+     * @returns Resolves when the caller may continue
+     */
+    async tick() {
+        this.count++;
+        if (this.count % WORKTREE_JANITOR_CONSTANTS.YIELD_EVERY_ENTRIES === 0) {
+            await new Promise((resolve) => setImmediate(resolve));
+        }
+    }
+}
+/** lstat that resolves null instead of throwing. */
+async function lstatOrNull(p) {
+    try {
+        return await fs.promises.lstat(p);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Git dir a `.git` file points to (`gitdir: <path>`), resolved against `dir`.
+ *
+ * @param dir - Directory holding the `.git` file
+ * @returns Absolute git dir, or null when there is no readable `.git` file
+ */
+export async function readGitFilePointer(dir) {
+    try {
+        const m = /^gitdir:\s*(.+?)\s*$/m.exec(await fs.promises.readFile(path.join(dir, '.git'), 'utf-8'));
+        return m ? path.resolve(dir, m[1]) : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Main worktree of the repo a linked worktree belongs to, read from the
+ * worktree's `.git` file (`gitdir: <main>/.git/worktrees/<name>`). Returns
+ * null for anything else: a `.git` directory (a normal clone), a submodule
+ * (`gitdir: …/.git/modules/…`), or an unreadable file.
+ *
+ * @param dir - Directory that may be a linked worktree
+ * @returns Absolute path of the main worktree, or null
+ *
+ * @example
+ * ```typescript
+ * // /tmp/visa-cm-wt/.git contains "gitdir: /src/ce-core/.git/worktrees/visa-cm-wt"
+ * await mainRepoOfLinkedWorktree('/tmp/visa-cm-wt'); // '/src/ce-core'
+ * ```
+ */
+export async function mainRepoOfLinkedWorktree(dir) {
+    const st = await lstatOrNull(path.join(dir, '.git'));
+    if (!st?.isFile())
+        return null;
+    const gitDir = await readGitFilePointer(dir);
+    if (!gitDir)
+        return null;
+    const worktreesDir = path.dirname(gitDir);
+    if (path.basename(worktreesDir) !== 'worktrees')
+        return null;
+    const commonDir = path.dirname(worktreesDir);
+    if (path.basename(commonDir) !== '.git')
+        return null;
+    return path.dirname(commonDir);
+}
+/**
+ * Find git checkouts under `root` without following symlinks. A directory
+ * with a `.git` directory or file is a checkout and is not descended into;
+ * `node_modules` and `.git` are never descended into. Fully async; yields to
+ * the event loop every few directories.
+ *
+ * @param root - Directory to search (itself included, at depth 0)
+ * @param maxDepth - Deepest level searched (root = 0)
+ * @param maxDirs - Stop after visiting this many directories
+ * @returns Checkouts found, in walk order
+ */
+export async function findGitCheckouts(root, maxDepth, maxDirs = Number.POSITIVE_INFINITY) {
+    const out = [];
+    const yielder = new EventLoopYielder();
+    let visited = 0;
+    const walk = async (dir, depth) => {
+        if (visited >= maxDirs)
+            return;
+        visited++;
+        await yielder.tick();
+        const dotGit = await lstatOrNull(path.join(dir, '.git'));
+        if (dotGit && (dotGit.isDirectory() || dotGit.isFile())) {
+            out.push({ path: dir, kind: dotGit.isDirectory() ? 'dir' : 'file' });
+            return;
+        }
+        if (depth >= maxDepth)
+            return;
+        let entries;
+        try {
+            entries = await fs.promises.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            // Dirent.isDirectory() is false for symlinks, so links are never followed.
+            if (!e.isDirectory() || WORKTREE_JANITOR_CONSTANTS.SEARCH_SKIP_DIRS.includes(e.name))
+                continue;
+            await walk(path.join(dir, e.name), depth + 1);
+        }
+    };
+    await walk(root, 0);
+    return out;
+}
+/**
+ * Main worktrees of every repo that owns a linked worktree somewhere under
+ * the given roots (e.g. `/tmp/claude-501/visa-cm-wt` → `~/src/ce-core`), so
+ * repos that are not registered projects still get their temp worktrees
+ * cleaned. Visits at most DISCOVERY_MAX_DIRS directories per root.
+ *
+ * @param roots - Temp roots to scan (missing roots are skipped)
+ * @returns De-duplicated main-worktree paths
+ */
+export async function discoverLinkedWorktreeRepos(roots) {
+    const out = new Set();
+    for (const root of roots) {
+        if (!(await lstatOrNull(root)))
+            continue;
+        const found = await findGitCheckouts(root, WORKTREE_JANITOR_CONSTANTS.DISCOVERY_DEPTH, WORKTREE_JANITOR_CONSTANTS.DISCOVERY_MAX_DIRS);
+        for (const f of found) {
+            if (f.kind !== 'file')
+                continue;
+            const main = await mainRepoOfLinkedWorktree(f.path);
+            if (main && (await lstatOrNull(main)))
+                out.add(main);
+        }
+    }
+    return [...out];
+}
+/**
+ * Newest mtime (ms) of `dir` and everything within `depth` levels below it,
+ * using lstat (symlinks are not followed). Async; yields every few entries.
+ *
+ * @param dir - Directory
+ * @param depth - Levels below `dir` to include (0 = only `dir`)
+ * @returns Newest mtime in ms, or null when `dir` cannot be stat'ed
+ */
+export async function latestTreeMtimeMs(dir, depth) {
+    let newest = null;
+    const yielder = new EventLoopYielder();
+    const visit = async (p, level) => {
+        await yielder.tick();
+        const st = await lstatOrNull(p);
+        if (!st)
+            return;
+        if (newest === null || st.mtimeMs > newest)
+            newest = st.mtimeMs;
+        if (level >= depth || !st.isDirectory())
+            return;
+        let names;
+        try {
+            names = await fs.promises.readdir(p);
+        }
+        catch {
+            return;
+        }
+        for (const n of names)
+            await visit(path.join(p, n), level + 1);
+    };
+    await visit(dir, 0);
+    return newest;
+}
+/**
+ * Disk usage of a path in bytes (`du -sk` in a child process, so the event
+ * loop is never blocked; `du` does not follow symlinks).
+ *
+ * @param p - File or directory
+ * @returns Bytes, or null when `du` failed or timed out
+ */
+export async function diskUsageBytes(p) {
+    const r = await runCommand('du', ['-sk', p], { timeoutMs: WORKTREE_JANITOR_CONSTANTS.DU_TIMEOUT_MS });
+    const kb = Number.parseInt(r.stdout.trim().split(/\s+/)[0] ?? '', 10);
+    return Number.isFinite(kb) ? kb * 1024 : null;
+}
+/**
+ * Human-readable size (`1.8 GB`, `512 MB`).
+ *
+ * @param bytes - Size in bytes
+ * @returns Short string with one decimal for GB
+ */
+export function formatBytes(bytes) {
+    const gb = bytes / 1024 ** 3;
+    if (gb >= 1)
+        return `${gb.toFixed(1)} GB`;
+    const mb = bytes / 1024 ** 2;
+    if (mb >= 1)
+        return `${Math.round(mb)} MB`;
+    return `${Math.round(bytes / 1024)} KB`;
+}
+//# sourceMappingURL=worktree-janitor.git.js.map