@platless/axom-cli 0.3.13 → 0.6.36

package/dist/workstation/qoderAdapter/usage.js

@@ -1,37 +0,0 @@
-export const QODER_CREDITS_LABEL = 'Qoder Credits（厂商报告）';
-const validCredits = (value) => typeof value === 'number' &&
-    Number.isFinite(value) && value >= 0;
-/** Qoder's report is cumulative. A missing/invalid report never erases a prior valid value. */
-export function applyCredits(previous, reported) {
-    if (validCredits(reported))
-        return reported;
-    return validCredits(previous) ? previous : undefined;
-}
-function reportedCredits(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return undefined;
-    const input = value;
-    for (const key of ['total_credits', 'totalCredits', 'credits'])
-        if (validCredits(input[key]))
-            return input[key];
-    return undefined;
-}
-/**
- * Keeps vendor credits separate from ACP token/USD counters. Qoder's SDK does not
- * provide equivalent token or USD values, so zero placeholders are intentionally omitted.
- */
-export function normalizeQoderUsage(value, previousCredits) {
-    const input = value && typeof value === 'object' && !Array.isArray(value)
-        ? value : {};
-    const scope = input.cumulativeScope === 'unknown' ? 'unknown' : 'session';
-    const reported = reportedCredits(value);
-    if (scope === 'unknown') {
-        return { credits: undefined, creditsLabel: QODER_CREDITS_LABEL, creditsScope: scope,
-            inputTokens: undefined, outputTokens: undefined, costUsd: undefined,
-            ...(validCredits(previousCredits) ? { previousCredits } : {}) };
-    }
-    const credits = applyCredits(previousCredits, reported);
-    return { credits, creditsLabel: QODER_CREDITS_LABEL, creditsScope: scope,
-        inputTokens: undefined, outputTokens: undefined, costUsd: undefined,
-        ...(validCredits(previousCredits) ? { previousCredits } : {}) };
-}

package/dist/workstation/tools/core.js

@@ -1,50 +0,0 @@
-import os from 'node:os';
-import { StructuredFiles } from './files.js';
-import { PersistentTerminals } from './terminal.js';
-import { keys, validateRequest, TOOL_RESULT_BYTES } from './validation.js';
-/** All mutations are serialized across clients; shell processes continue independently. */
-export class ToolsCore {
-    files;
-    terminals;
-    queue = Promise.resolve();
-    disposed = false;
-    timer;
-    constructor(files, terminals, ttl) {
-        this.files = files;
-        this.terminals = terminals;
-        this.timer = setInterval(() => { this.queue = this.queue.then(() => this.files.expire()).catch(() => { }); }, Math.min(ttl, 60_000));
-        this.timer.unref();
-    }
-    static async create(options = {}) {
-        const files = await StructuredFiles.create(options.home ?? os.homedir(), options.roots ?? [], options.uploadTtlMs, options.uploadStateDir);
-        return new ToolsCore(files, new PersistentTerminals(files, options), options.uploadTtlMs ?? 15 * 60_000);
-    }
-    dispatch(method, params = {}) {
-        const task = this.queue.then(async () => {
-            if (this.disposed)
-                throw new Error('Workstation tools keeper stopped');
-            validateRequest(method, params);
-            let result;
-            if (method === 'tools.info') {
-                keys(params, []);
-                result = { version: 1, terminal: this.terminals.available, browser: false, files: true, home: this.files.home, roots: this.files.roots, downloads: this.files.downloads, ...(this.terminals.error ? { terminalError: this.terminals.error } : {}), browserError: 'Browser tools are not enabled in this release' };
-            }
-            else if (method.startsWith('terminal.'))
-                result = await this.terminals.dispatch(method, params);
-            else
-                result = await this.files.dispatch(method, params);
-            if (Buffer.byteLength(JSON.stringify(result)) > TOOL_RESULT_BYTES - 1024)
-                throw new Error('Tool result too large');
-            return result;
-        });
-        this.queue = task.catch(() => { });
-        return task;
-    }
-    async dispose() {
-        this.disposed = true;
-        clearInterval(this.timer);
-        await this.queue;
-        await this.terminals.dispose();
-        await this.files.dispose();
-    }
-}

package/dist/workstation/tools/files.js

@@ -1,525 +0,0 @@
-import { constants, lstatSync, linkSync, renameSync } from 'node:fs';
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-import { createHash, randomUUID } from 'node:crypto';
-import { base64, CHUNK_BYTES, identifier, integer, keys, string } from './validation.js';
-const MAX_UPLOAD_BYTES = 100 * 1024 * 1024;
-const MAX_UPLOADS = 8;
-const TEMP_PREFIX = '.axom-upload-';
-/** Canonical roots and no descendant symlinks. Tools never compose a shell command. */
-export class StructuredFiles {
-    home;
-    roots;
-    downloads;
-    ttl;
-    stateDir;
-    uploads = new Map();
-    pin;
-    busy = false;
-    constructor(home, roots, downloads, ttl, stateDir) {
-        this.home = home;
-        this.roots = roots;
-        this.downloads = downloads;
-        this.ttl = ttl;
-        this.stateDir = stateDir;
-    }
-    static async create(home, roots, ttl = 15 * 60_000, stateDir) {
-        home = await fs.realpath(home);
-        const canonical = new Set([home]);
-        for (const root of roots) {
-            const real = await fs.realpath(root);
-            if (!(await fs.stat(real)).isDirectory())
-                throw new Error('File root must be a directory');
-            canonical.add(real);
-        }
-        const downloads = path.join(home, 'Downloads');
-        if (stateDir) {
-            await fs.mkdir(stateDir, { recursive: true, mode: 0o700 });
-            const stat = await fs.lstat(stateDir);
-            if (!stat.isDirectory() || stat.isSymbolicLink() || (process.getuid && stat.uid !== process.getuid()))
-                throw new Error('Unsafe upload state directory');
-            await fs.chmod(stateDir, 0o700);
-        }
-        const files = new StructuredFiles(home, [...canonical], downloads, ttl, stateDir);
-        await files.recover();
-        return files;
-    }
-    async recover() {
-        if (!this.stateDir)
-            return;
-        for (const name of await fs.readdir(this.stateDir)) {
-            if (!/^[0-9a-f-]{36}\.json$/.test(name))
-                continue;
-            const manifest = path.join(this.stateDir, name);
-            try {
-                const stat = await fs.lstat(manifest);
-                if (!stat.isFile() || stat.size > 8192)
-                    continue;
-                const value = JSON.parse(await fs.readFile(manifest, 'utf8'));
-                if (typeof value.dir !== 'string' || path.basename(value.dir) !== TEMP_PREFIX + name.slice(0, -5) || value.temp !== path.join(value.dir, 'payload'))
-                    throw new Error('Invalid orphan upload');
-                await this.resolve(value.dir, false, true);
-                const directory = await fs.lstat(value.dir);
-                if (!directory.isDirectory() || !this.same(directory, value.dirIdentity))
-                    throw new Error('Orphan upload directory changed');
-                await this.pinned(value.dir, async () => {
-                    for (const entry of await fs.readdir('.')) {
-                        if (entry !== 'payload' && !/^commit-[0-9a-f-]{36}$/.test(entry))
-                            continue;
-                        const item = await fs.lstat(entry);
-                        if (item.isFile() && this.same(item, value.identity))
-                            await fs.unlink(entry);
-                    }
-                });
-                await fs.rmdir(value.dir);
-            }
-            catch { /* Replaced entries are never followed or deleted during cleanup. */ }
-            await fs.unlink(manifest).catch(() => { });
-        }
-    }
-    same(stat, identity) { return stat.dev === identity.dev && stat.ino === identity.ino; }
-    /** Staging names must live beneath a root protected from other-UID rename/write. The destination
-     * parent remains kernel-pinned; staging can be on any allowed root on that same filesystem. */
-    async stagingRoot(dev) {
-        const uid = process.getuid?.();
-        for (const root of this.roots) {
-            const rootStat = await fs.lstat(root);
-            if (!rootStat.isDirectory() || rootStat.dev !== dev || rootStat.uid !== uid || (rootStat.mode & 0o022))
-                continue;
-            let child = root;
-            let childStat = rootStat;
-            let trusted = true;
-            while (path.dirname(child) !== child) {
-                const parent = path.dirname(child);
-                const stat = await fs.lstat(parent);
-                if (!stat.isDirectory() || ((stat.mode & 0o022) && !((stat.mode & 0o1000) && childStat.uid === uid))) {
-                    trusted = false;
-                    break;
-                }
-                child = parent;
-                childStat = stat;
-            }
-            if (trusted)
-                return root;
-        }
-        throw new Error('Upload requires a trusted private staging root on the destination filesystem');
-    }
-    async verifyUpload(upload) {
-        const directory = await fs.lstat(upload.dir);
-        if (!directory.isDirectory() || !this.same(directory, upload.dirIdentity) || (directory.mode & 0o077))
-            throw new Error('Upload staging directory changed');
-        const opened = await upload.handle.stat();
-        const named = await fs.lstat(upload.temp);
-        if (!opened.isFile() || opened.size !== upload.size || !named.isFile() || !this.same(named, opened))
-            throw new Error('Upload temporary file changed');
-        for (const [offset, receipt] of upload.chunks) {
-            const data = Buffer.alloc(receipt.length);
-            let read = 0;
-            while (read < data.length) {
-                const result = await upload.handle.read(data, read, data.length - read, offset + read);
-                if (!result.bytesRead)
-                    throw new Error('Upload integrity changed');
-                read += result.bytesRead;
-            }
-            if (createHash('sha256').update(data).digest('hex') !== receipt.digest)
-                throw new Error('Upload integrity changed');
-        }
-        const after = await upload.handle.stat();
-        if (after.size !== opened.size || after.mtimeMs !== opened.mtimeMs || after.ctimeMs !== opened.ctimeMs)
-            throw new Error('Upload integrity changed during verification');
-        return after;
-    }
-    inside(target, root) { return target === root || target.startsWith(root + path.sep); }
-    async resolve(raw, missingLeaf = false, mutation = false) {
-        if (!path.isAbsolute(raw) || raw.includes('\0') || raw.includes('\\') || raw.split(path.sep).includes('..') || raw.length > 4096)
-            throw new Error('Invalid file path');
-        const target = path.resolve(raw);
-        const root = this.roots.filter(root => this.inside(target, root)).sort((a, b) => b.length - a.length)[0];
-        if (!root)
-            throw new Error('Path outside allowed roots');
-        if (mutation && this.roots.includes(target))
-            throw new Error('Cannot modify file root');
-        // Detect root replacement as well as symlink components below it.
-        if (await fs.realpath(root) !== root)
-            throw new Error('File root changed');
-        let cursor = root;
-        const parts = path.relative(root, target).split(path.sep).filter(Boolean);
-        for (let i = 0; i < parts.length; i++) {
-            cursor = path.join(cursor, parts[i]);
-            let stat;
-            try {
-                stat = await fs.lstat(cursor);
-            }
-            catch (error) {
-                if (error.code === 'ENOENT' && missingLeaf && i === parts.length - 1)
-                    return target;
-                throw error;
-            }
-            if (stat.isSymbolicLink())
-                throw new Error('Symbolic links are not allowed');
-            if (i < parts.length - 1 && !stat.isDirectory())
-                throw new Error('Parent is not a directory');
-        }
-        return target;
-    }
-    async regularHandle(target, flags = constants.O_RDONLY) {
-        const handle = await fs.open(this.leaf(target), flags | constants.O_NOFOLLOW | constants.O_NONBLOCK);
-        try {
-            if (!(await handle.stat()).isFile())
-                throw new Error('Not a regular file');
-            return handle;
-        }
-        catch (error) {
-            await handle.close();
-            throw error;
-        }
-    }
-    /** The keeper is a dedicated process and ToolsCore serializes ALL calls/expiry. Pin cwd before
-     * touching any relative leaf: ancestor replacement after validation cannot redirect file IO.
-     * PTY callbacks use no paths, and PTY spawn always receives an explicit absolute cwd. */
-    async pinned(parent, action) {
-        if (this.busy)
-            throw new Error('Concurrent file access is not supported');
-        const previous = process.cwd();
-        this.busy = true;
-        try {
-            process.chdir(parent);
-            if (await fs.realpath('.') !== parent)
-                throw new Error('File parent escaped allowed roots');
-            this.pin = parent;
-            return await action();
-        }
-        finally {
-            this.pin = undefined;
-            process.chdir(previous);
-            this.busy = false;
-        }
-    }
-    leaf(target) {
-        if (!this.pin)
-            throw new Error('File directory is not pinned');
-        if (target === this.pin)
-            return '.';
-        if (path.dirname(target) !== this.pin)
-            throw new Error('File path escaped pinned directory');
-        return path.basename(target);
-    }
-    async dispatch(method, p) {
-        await this.expire();
-        let parent;
-        if (method === 'files.upload.chunk' || method === 'files.upload.finish' || method === 'files.upload.cancel') {
-            const upload = this.uploads.get(identifier(p, 'uploadId'));
-            if (!upload && method === 'files.upload.cancel') {
-                keys(p, ['uploadId']);
-                return { ok: true };
-            }
-            if (!upload)
-                throw new Error('Upload not found or expired');
-            parent = path.dirname(upload.target);
-        }
-        else {
-            const target = await this.resolve(string(p, 'path', 4096, method === 'files.list' ? this.home : undefined), method === 'files.mkdir' || method === 'files.upload.begin', !['files.list', 'files.read'].includes(method));
-            parent = method === 'files.list' ? target : path.dirname(target);
-        }
-        return this.pinned(parent, async () => {
-            if (method.startsWith('files.upload.') && method !== 'files.upload.begin') {
-                const upload = this.uploads.get(identifier(p, 'uploadId'));
-                const stat = await fs.stat('.');
-                if (stat.dev !== upload.parent.dev || stat.ino !== upload.parent.ino) {
-                    if (method === 'files.upload.cancel') {
-                        await this.abandon(upload);
-                        return { ok: true };
-                    }
-                    throw new Error('Upload parent changed');
-                }
-            }
-            return this.perform(method, p);
-        });
-    }
-    async perform(method, p) {
-        switch (method) {
-            case 'files.list': {
-                keys(p, ['path']);
-                const target = await this.resolve(string(p, 'path', 4096, this.home));
-                const listing = await fs.opendir(this.leaf(target));
-                const entries = [];
-                let visited = 0;
-                try {
-                    for await (const entry of listing) {
-                        if (++visited > 10000 || entries.length >= 2000)
-                            throw new Error('Directory entry limit exceeded');
-                        if (entry.name.startsWith(TEMP_PREFIX) || entry.isSymbolicLink())
-                            continue;
-                        const entryPath = path.join(target, entry.name);
-                        let stat;
-                        try {
-                            await this.resolve(entryPath);
-                            stat = await fs.lstat(this.leaf(entryPath));
-                        }
-                        catch {
-                            continue;
-                        }
-                        if (!stat.isFile() && !stat.isDirectory())
-                            continue;
-                        entries.push({ name: entry.name, path: entryPath, directory: stat.isDirectory(), size: stat.size, modifiedAt: stat.mtimeMs, createdAt: stat.birthtimeMs > 0 ? stat.birthtimeMs : stat.ctimeMs > 0 ? stat.ctimeMs : stat.mtimeMs });
-                    }
-                }
-                finally {
-                    await listing.close().catch(() => { });
-                }
-                entries.sort((a, b) => Number(b.directory) - Number(a.directory) || String(a.name).localeCompare(String(b.name)));
-                const parent = path.dirname(target);
-                return { path: target, parent: this.roots.includes(target) || !this.roots.some(root => this.inside(parent, root)) ? null : parent, entries, roots: this.roots };
-            }
-            case 'files.read': {
-                keys(p, ['path', 'offset', 'length']);
-                const offset = integer(p, 'offset', 0, Number.MAX_SAFE_INTEGER, 0);
-                const length = integer(p, 'length', 1, CHUNK_BYTES, CHUNK_BYTES);
-                const target = await this.resolve(string(p, 'path'));
-                const handle = await this.regularHandle(target);
-                try {
-                    const stat = await handle.stat();
-                    const buffer = Buffer.alloc(length);
-                    const { bytesRead } = await handle.read(buffer, 0, length, offset);
-                    return { data: buffer.subarray(0, bytesRead).toString('base64'), size: stat.size, eof: offset + bytesRead >= stat.size, name: path.basename(target) };
-                }
-                finally {
-                    await handle.close();
-                }
-            }
-            case 'files.mkdir': {
-                keys(p, ['path']);
-                const target = await this.resolve(string(p, 'path'), true, true);
-                await fs.mkdir(this.leaf(target));
-                return { ok: true };
-            }
-            case 'files.rename': {
-                keys(p, ['path', 'name']);
-                const target = await this.resolve(string(p, 'path'), false, true);
-                const name = string(p, 'name', 255);
-                if (name === '.' || name === '..' || /[/\\]/.test(name) || name.startsWith(TEMP_PREFIX))
-                    throw new Error('Invalid new name');
-                const destination = await this.resolve(path.join(path.dirname(target), name), true, true);
-                // Node rename() overwrites files. Hard-link commits are exclusive for files; for directories,
-                // reserve the destination with mkdir and replace only that empty reservation atomically.
-                const stat = await fs.lstat(this.leaf(target));
-                if (stat.isFile()) {
-                    await fs.link(this.leaf(target), this.leaf(destination));
-                    await fs.unlink(this.leaf(target));
-                }
-                else if (stat.isDirectory()) {
-                    await fs.mkdir(this.leaf(destination), { mode: stat.mode });
-                    try {
-                        await fs.rename(this.leaf(target), this.leaf(destination));
-                    }
-                    catch (error) {
-                        await fs.rmdir(this.leaf(destination)).catch(() => { });
-                        throw error;
-                    }
-                }
-                else
-                    throw new Error('Not a regular file or directory');
-                return { ok: true };
-            }
-            case 'files.delete': {
-                keys(p, ['path']);
-                const target = await this.resolve(string(p, 'path'), false, true);
-                const stat = await fs.lstat(this.leaf(target));
-                if (stat.isDirectory())
-                    await fs.rmdir(this.leaf(target));
-                else if (stat.isFile())
-                    await fs.unlink(this.leaf(target));
-                else
-                    throw new Error('Not a regular file or directory');
-                return { ok: true };
-            }
-            case 'files.upload.begin': {
-                keys(p, ['path', 'size', 'overwrite']);
-                const size = integer(p, 'size', 0, MAX_UPLOAD_BYTES);
-                if (p.overwrite !== undefined && typeof p.overwrite !== 'boolean')
-                    throw new Error('Invalid overwrite');
-                if (this.uploads.size >= MAX_UPLOADS)
-                    throw new Error('Upload limit exceeded');
-                const target = await this.resolve(string(p, 'path'), true, true);
-                if (path.basename(target).startsWith(TEMP_PREFIX))
-                    throw new Error('Reserved upload filename');
-                let existing;
-                try {
-                    existing = await fs.lstat(this.leaf(target));
-                }
-                catch (error) {
-                    if (error.code !== 'ENOENT')
-                        throw error;
-                }
-                if (existing && (p.overwrite !== true || !existing.isFile()))
-                    throw new Error('Target already exists');
-                const id = randomUUID();
-                const parent = await fs.stat('.');
-                const root = await this.stagingRoot(parent.dev);
-                const dir = path.join(root, `${TEMP_PREFIX}${id}`);
-                const temp = path.join(dir, 'payload');
-                const manifest = this.stateDir ? path.join(this.stateDir, `${id}.json`) : undefined;
-                await fs.mkdir(dir, { mode: 0o700 });
-                let handle;
-                try {
-                    handle = await fs.open(temp, constants.O_RDWR | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
-                }
-                catch (error) {
-                    await fs.rmdir(dir).catch(() => { });
-                    throw error;
-                }
-                const directory = await fs.lstat(dir);
-                const inode = await handle.stat();
-                const dirIdentity = { dev: directory.dev, ino: directory.ino };
-                const identity = { dev: inode.dev, ino: inode.ino };
-                try {
-                    if (manifest)
-                        await fs.writeFile(manifest, JSON.stringify({ temp, dir, identity, dirIdentity }), { flag: 'wx', mode: 0o600 });
-                }
-                catch (error) {
-                    await handle.close();
-                    await fs.unlink(temp).catch(() => { });
-                    await fs.rmdir(dir).catch(() => { });
-                    throw error;
-                }
-                this.uploads.set(id, { id, manifest, target, temp, dir, dirIdentity, identity, handle, size, offset: 0, overwrite: p.overwrite === true, touched: Date.now(), parent: { dev: parent.dev, ino: parent.ino }, chunks: new Map(), commits: new Set() });
-                return { uploadId: id };
-            }
-            case 'files.upload.chunk': {
-                keys(p, ['uploadId', 'offset', 'data']);
-                const upload = this.upload(p);
-                const offset = integer(p, 'offset', 0, MAX_UPLOAD_BYTES);
-                const bytes = base64(p.data);
-                const digest = createHash('sha256').update(bytes).digest('hex');
-                const receipt = upload.chunks.get(offset);
-                if (receipt && receipt.length === bytes.length && receipt.digest === digest)
-                    return { offset: upload.offset };
-                if (upload.chunks.size >= 16384)
-                    throw new Error('Upload chunk count limit exceeded');
-                if (offset !== upload.offset || !bytes.length || offset + bytes.length > upload.size)
-                    throw new Error('Upload offset or size mismatch');
-                let written = 0;
-                while (written < bytes.length) {
-                    const result = await upload.handle.write(bytes, written, bytes.length - written, offset + written);
-                    if (!result.bytesWritten)
-                        throw new Error('Upload write failed');
-                    written += result.bytesWritten;
-                }
-                upload.chunks.set(offset, { length: bytes.length, digest });
-                upload.offset += bytes.length;
-                return { offset: upload.offset };
-            }
-            case 'files.upload.finish': {
-                keys(p, ['uploadId']);
-                const upload = this.upload(p);
-                if (upload.offset !== upload.size)
-                    throw new Error('Upload size mismatch');
-                await this.resolve(upload.target, true, true);
-                const parent = await fs.stat('.');
-                if (parent.dev !== upload.parent.dev || parent.ino !== upload.parent.ino)
-                    throw new Error('Upload parent changed');
-                await upload.handle.sync();
-                await this.verifyUpload(upload);
-                const commit = path.join(upload.dir, `commit-${randomUUID()}`);
-                upload.commits.add(commit);
-                await fs.link(upload.temp, commit);
-                // The link may have raced source replacement. Check the actual linked inode before ever
-                // touching the destination; the final source lives in a trusted 0700 directory.
-                const linked = await fs.lstat(commit);
-                const opened = await upload.handle.stat();
-                if (!linked.isFile() || !this.same(linked, opened))
-                    throw new Error('Upload staging integrity changed');
-                const verified = await this.verifyUpload(upload);
-                // No asynchronous yield between the final identity guard and atomic commit. Other-UID
-                // processes cannot replace the private staging entry; unrestricted same-UID tampering is
-                // outside this boundary (that UID can also control the keeper/PTY or ptrace its process).
-                const directory = lstatSync(upload.dir);
-                const source = lstatSync(commit);
-                const original = lstatSync(upload.temp);
-                if (!directory.isDirectory() || !this.same(directory, upload.dirIdentity) || (directory.mode & 0o077)
-                    || !source.isFile() || !original.isFile() || !this.same(source, verified) || !this.same(original, verified)
-                    || source.size !== upload.size || source.mtimeMs !== verified.mtimeMs || source.ctimeMs !== verified.ctimeMs)
-                    throw new Error('Upload commit source changed');
-                if (upload.overwrite) {
-                    try {
-                        if (!lstatSync(this.leaf(upload.target)).isFile())
-                            throw new Error('Target is not a regular file');
-                    }
-                    catch (error) {
-                        if (error.code !== 'ENOENT')
-                            throw error;
-                    }
-                    renameSync(commit, this.leaf(upload.target));
-                }
-                else
-                    linkSync(commit, this.leaf(upload.target));
-                await this.clean(upload);
-                return { ok: true, path: upload.target };
-            }
-            case 'files.upload.cancel': {
-                keys(p, ['uploadId']);
-                const id = identifier(p, 'uploadId');
-                const upload = this.uploads.get(id);
-                if (upload)
-                    await this.clean(upload);
-                return { ok: true };
-            }
-            default: throw new Error('Unsupported file tool');
-        }
-    }
-    upload(p) {
-        const upload = this.uploads.get(identifier(p, 'uploadId'));
-        if (!upload)
-            throw new Error('Upload not found or expired');
-        upload.touched = Date.now();
-        return upload;
-    }
-    async clean(upload) {
-        this.uploads.delete(upload.id);
-        await upload.handle.close().catch(() => { });
-        try {
-            const directory = await fs.lstat(upload.dir);
-            if (directory.isDirectory() && this.same(directory, upload.dirIdentity)) {
-                for (const item of [upload.temp, ...upload.commits]) {
-                    try {
-                        const stat = await fs.lstat(item);
-                        if (stat.isFile() && this.same(stat, upload.identity))
-                            await fs.unlink(item);
-                    }
-                    catch { /* Preserve substituted entries. */ }
-                }
-                await fs.rmdir(upload.dir).catch(() => { });
-            }
-        }
-        catch { /* Inaccessible private staging paths are not followed. */ }
-        if (upload.manifest)
-            await fs.unlink(upload.manifest).catch(() => { });
-    }
-    async abandon(upload) {
-        this.uploads.delete(upload.id);
-        await upload.handle.close().catch(() => { });
-        // Retain the private journal when its original parent cannot be safely resolved for cleanup.
-        // A later keeper startup can retry; never remove a same-name file in a replacement directory.
-    }
-    async expire() {
-        for (const upload of this.uploads.values())
-            if (Date.now() - upload.touched >= this.ttl) {
-                await this.pinned(path.dirname(upload.target), async () => {
-                    const stat = await fs.stat('.');
-                    if (stat.dev !== upload.parent.dev || stat.ino !== upload.parent.ino)
-                        throw new Error('Upload parent changed');
-                    await this.clean(upload);
-                }).catch(() => this.abandon(upload));
-            }
-    }
-    async dispose() {
-        for (const upload of this.uploads.values()) {
-            await this.pinned(path.dirname(upload.target), async () => {
-                const stat = await fs.stat('.');
-                if (stat.dev !== upload.parent.dev || stat.ino !== upload.parent.ino)
-                    throw new Error('Upload parent changed');
-                await this.clean(upload);
-            }).catch(() => this.abandon(upload));
-        }
-    }
-}