@platless/axom-cli 0.3.13 → 0.5.9

package/dist/workstation/exec/shaping.js

@@ -0,0 +1,211 @@
+// Exec result shaping (spec §4.2, §14; analysis E §6.2): the daemon turns an exec's raw stdout/stderr BYTES into the `exec_exit`
+// strings. Per stream: the first 32 KiB and the last 32 KiB, with an omission marker between them when bytes were left out. Bytes
+// are counted, never UTF-16 code units, and UTF-8 is decoded by the daemon with chunk boundaries that never split a character
+// (no U+FFFD that the command did not print). Used by both the durable (keeper) path and the in-process fallback.
+//
+// The state is serialisable for the exec checkpoint: per stream the byte count, the head length, the rolling tail (≤ 32 KiB) and
+// the streaming decoder's held bytes (≤ 3). The head bytes themselves are NOT in the checkpoint: after a daemon restart they are
+// re-read from keeper-terminal's retained head reserve, which survives commits (keepers/terminal/exec.ts `survivesCommit`).
+export const RESULT_HEAD_BYTES = 32 * 1024;
+export const RESULT_TAIL_BYTES = 32 * 1024;
+/** The exact text placed between the head and the tail of a stream whose middle was left out. */
+export function omissionMarker(omittedBytes) {
+    return `\n[... ${omittedBytes} bytes omitted ...]\n`;
+}
+const EMPTY = Buffer.alloc(0);
+// ignoreBOM: a leading U+FEFF the command printed is output like any other character. Not fatal: invalid bytes the command
+// really printed become U+FFFD exactly as a one-shot decode of all its bytes would make them.
+const decoder = new TextDecoder('utf-8', { ignoreBOM: true });
+export const decodeUtf8 = (bytes) => (bytes.length === 0 ? '' : decoder.decode(bytes));
+/**
+ * Splits `bytes` before a trailing incomplete UTF-8 sequence (a lead byte still waiting for its continuation bytes). Decoding
+ * `complete` now and `pending + later bytes` later gives exactly what decoding everything at once gives: the cut is always right
+ * before a lead byte, which ends any earlier sequence in a UTF-8 decoder anyway.
+ */
+export function splitIncompleteUtf8(bytes) {
+    let i = bytes.length - 1;
+    let continuation = 0;
+    while (i >= 0 && continuation < 3 && (bytes[i] & 0xc0) === 0x80) {
+        i -= 1;
+        continuation += 1;
+    }
+    if (i < 0)
+        return [bytes, EMPTY];
+    const lead = bytes[i];
+    const need = lead >= 0xc2 && lead <= 0xdf ? 2 : lead >= 0xe0 && lead <= 0xef ? 3 : lead >= 0xf0 && lead <= 0xf4 ? 4 : 1;
+    if (need > 1 && bytes.length - i < need)
+        return [bytes.subarray(0, i), bytes.subarray(i)];
+    return [bytes, EMPTY];
+}
+/** Number of leading continuation bytes (at most 3): where a tail cut in the middle of a character starts its first whole one. */
+function leadingContinuation(bytes) {
+    let n = 0;
+    while (n < 3 && n < bytes.length && (bytes[n] & 0xc0) === 0x80)
+        n += 1;
+    return n;
+}
+/** A streaming UTF-8 decoder whose state (the held bytes of an incomplete character) can be checkpointed. */
+export class Utf8Stream {
+    pending = EMPTY;
+    constructor(pending) { if (pending)
+        this.pending = Buffer.from(pending); }
+    push(bytes) {
+        const all = this.pending.length > 0 ? Buffer.concat([this.pending, bytes]) : bytes;
+        const [complete, pending] = splitIncompleteUtf8(all);
+        this.pending = Buffer.from(pending);
+        return decodeUtf8(complete);
+    }
+    /** Decodes whatever is held (an incomplete character becomes U+FFFD) and starts over. */
+    flush() { const text = decodeUtf8(this.pending); this.pending = EMPTY; return text; }
+    get held() { return this.pending; }
+}
+/** One stream (stdout or stderr) of one exec. */
+export class ShapedStream {
+    total = 0;
+    head = [];
+    headLen = 0;
+    tail = [];
+    tailLen = 0;
+    lost = 0;
+    decoder;
+    constructor(state, headBytes) {
+        if (!state) {
+            this.decoder = new Utf8Stream();
+            return;
+        }
+        this.total = state.total;
+        // A head that could not be re-read in full stays short: the missing bytes read as omitted, never as wrong bytes.
+        const head = (headBytes ?? EMPTY).subarray(0, state.headLen);
+        if (head.length > 0) {
+            this.head = [Buffer.from(head)];
+            this.headLen = head.length;
+        }
+        const tail = Buffer.from(state.tail, 'base64');
+        if (tail.length > 0) {
+            this.tail = [tail];
+            this.tailLen = tail.length;
+        }
+        this.lost = state.lost;
+        this.decoder = new Utf8Stream(Buffer.from(state.pending, 'base64'));
+    }
+    get bytes() { return this.total; }
+    /** Bytes the streaming decoder holds (an incomplete character waiting for its continuation bytes). */
+    get heldBytes() { return this.decoder.held.length; }
+    /** Head bytes this stream holds (restore re-reads exactly this many). */
+    get headLength() { return this.headLen; }
+    /**
+     * Adds the chunk that starts at stream offset `so` and returns its streaming text (decoded with held bytes; an incomplete
+     * trailing character is held for the next chunk). A chunk past the expected offset means the bytes between were lost (keeper
+     * quota): they count as omitted, the tail restarts after them and the decoder flushes what it held. Bytes already seen are skipped.
+     */
+    push(so, chunk) {
+        let text = '';
+        if (so < this.total) {
+            chunk = chunk.subarray(Math.min(chunk.length, this.total - so));
+            so = this.total;
+            if (chunk.length === 0)
+                return '';
+        }
+        if (so > this.total) {
+            this.lost += so - this.total;
+            this.total = so;
+            this.tail = [];
+            this.tailLen = 0;
+            text += this.decoder.flush();
+        }
+        let rest = chunk;
+        // The head takes bytes only while it is contiguous from offset 0.
+        if (this.headLen === this.total && this.headLen < RESULT_HEAD_BYTES) {
+            const take = rest.subarray(0, RESULT_HEAD_BYTES - this.headLen);
+            this.head.push(Buffer.from(take));
+            this.headLen += take.length;
+            rest = rest.subarray(take.length);
+        }
+        if (rest.length > 0)
+            this.appendTail(rest);
+        this.total += chunk.length;
+        return text + this.decoder.push(chunk);
+    }
+    appendTail(bytes) {
+        this.tail.push(Buffer.from(bytes.length > RESULT_TAIL_BYTES ? bytes.subarray(bytes.length - RESULT_TAIL_BYTES) : bytes));
+        this.tailLen += Math.min(bytes.length, RESULT_TAIL_BYTES);
+        while (this.tailLen - this.tail[0].length >= RESULT_TAIL_BYTES)
+            this.tailLen -= this.tail.shift().length;
+        if (this.tailLen > RESULT_TAIL_BYTES) {
+            const cut = this.tailLen - RESULT_TAIL_BYTES;
+            this.tail[0] = this.tail[0].subarray(cut);
+            this.tailLen -= cut;
+        }
+    }
+    /** Text still held by the streaming decoder (at the end of the stream). */
+    flushStreaming() { return this.decoder.flush(); }
+    /** The `exec_exit` string: everything when nothing was left out, else head + marker + tail cut at whole characters. */
+    result() {
+        const head = Buffer.concat(this.head);
+        const tail = Buffer.concat(this.tail);
+        const omitted = this.total - head.length - tail.length;
+        if (omitted === 0)
+            return { text: decodeUtf8(Buffer.concat([head, tail])), truncated: false };
+        const [headText, headCut] = splitIncompleteUtf8(head);
+        const skip = leadingContinuation(tail);
+        return {
+            text: decodeUtf8(headText) + omissionMarker(omitted + headCut.length + skip) + decodeUtf8(tail.subarray(skip)),
+            truncated: true,
+        };
+    }
+    state() {
+        return {
+            total: this.total, headLen: this.headLen, tail: Buffer.concat(this.tail).toString('base64'),
+            pending: this.decoder.held.toString('base64'), lost: this.lost,
+        };
+    }
+}
+/** Both streams of one exec. */
+export class ExecShaper {
+    stdout;
+    stderr;
+    constructor(state, heads) {
+        this.stdout = new ShapedStream(state?.stdout, heads?.stdout);
+        this.stderr = new ShapedStream(state?.stderr, heads?.stderr);
+    }
+    stream(name) { return name === 'stdout' ? this.stdout : this.stderr; }
+    /** Neither streaming decoder holds bytes: decoding may restart here from nothing and produce the same text from then on. */
+    get clean() { return this.stdout.heldBytes === 0 && this.stderr.heldBytes === 0; }
+    result() {
+        const out = this.stdout.result();
+        const err = this.stderr.result();
+        return { stdout: out.text, stderr: err.text, truncated: out.truncated || err.truncated };
+    }
+    state() { return { stdout: this.stdout.state(), stderr: this.stderr.state() }; }
+}
+/**
+ * The streaming text of an exec's records exactly as {@link ShapedStream.push} produces it (held bytes of an incomplete character
+ * go out with the next chunk of the same stream; a jump in the stream offset flushes what is held), but WITHOUT the head/tail
+ * bookkeeping and starting from any point where decoding is clean (no held bytes): the stream offset is taken from the first
+ * chunk. Decoding the same records from any clean point yields, for every later record, the same text the daemon's shaper
+ * produced for it — which is what makes `exec_output` chunks identical across re-attaches (exec/attach.ts).
+ */
+export class ExecWireText {
+    streams = {
+        stdout: { total: undefined, decoder: new Utf8Stream() },
+        stderr: { total: undefined, decoder: new Utf8Stream() },
+    };
+    push(name, so, chunk) {
+        const stream = this.streams[name];
+        let text = '';
+        if (stream.total === undefined)
+            stream.total = so;
+        if (so < stream.total) {
+            chunk = chunk.subarray(Math.min(chunk.length, stream.total - so));
+            so = stream.total;
+            if (chunk.length === 0)
+                return '';
+        }
+        if (so > stream.total) {
+            stream.total = so;
+            text += stream.decoder.flush();
+        }
+        stream.total += chunk.length;
+        return text + stream.decoder.push(chunk);
+    }
+}

package/dist/workstation/exec.js

@@ -1,112 +1,3 @@
-import { spawn } from 'node:child_process';
-import path from 'node:path';
-const MAX_BYTES = 65536;
-export function runExec(req, onOutput, signal) {
-    const running = startExec(req, onOutput);
-    const onAbort = () => { void running.cancel(); };
-    if (signal?.aborted)
-        onAbort();
-    else
-        signal?.addEventListener('abort', onAbort, { once: true });
-    void running.result.finally(() => signal?.removeEventListener('abort', onAbort));
-    return running.result;
-}
-/** Starts an exec in its own process group and exposes the same cancellation used by force update. */
-export function startExec(req, onOutput) {
-    let cancel = async () => { };
-    const result = new Promise((resolve) => {
-        const env = { ...process.env, ...req.env };
-        if (req.pathPrepend.length > 0) {
-            env.PATH = [...req.pathPrepend, env.PATH ?? ''].filter(Boolean).join(path.delimiter);
-        }
-        // macOS and Linux create a new session/process group for a detached child. Every command it
-        // launches (pipelines and background jobs included) stays in that group, so cancellation does
-        // not leave descendants running after the shell parent is gone.
-        const child = spawn(req.shell, ['-lc', req.command], { cwd: req.cwd, env, detached: process.platform !== 'win32' });
-        let stdout = '';
-        let stderr = '';
-        let truncated = false;
-        let timedOut = false;
-        let cancelled = false;
-        let settled = false;
-        const capture = (buf, stream) => {
-            const text = buf.toString();
-            if (req.streaming && onOutput)
-                onOutput(stream, text);
-            if (stream === 'stdout') {
-                if (stdout.length >= MAX_BYTES) {
-                    truncated = true;
-                    return;
-                }
-                if (stdout.length + text.length > MAX_BYTES) {
-                    stdout += text.slice(0, MAX_BYTES - stdout.length);
-                    truncated = true;
-                }
-                else {
-                    stdout += text;
-                }
-            }
-            else {
-                if (stderr.length >= MAX_BYTES) {
-                    truncated = true;
-                    return;
-                }
-                if (stderr.length + text.length > MAX_BYTES) {
-                    stderr += text.slice(0, MAX_BYTES - stderr.length);
-                    truncated = true;
-                }
-                else {
-                    stderr += text;
-                }
-            }
-        };
-        child.stdout.on('data', (b) => capture(b, 'stdout'));
-        child.stderr.on('data', (b) => capture(b, 'stderr'));
-        const terminateCommandGroup = () => {
-            if (child.pid && process.platform !== 'win32') {
-                try {
-                    process.kill(-child.pid, 'SIGKILL');
-                    return;
-                }
-                catch {
-                    // The group may have already exited between pid observation and signal delivery.
-                }
-            }
-            child.kill('SIGKILL');
-        };
-        let timer;
-        if (req.timeoutSeconds && req.timeoutSeconds > 0) {
-            timer = setTimeout(() => { timedOut = true; terminateCommandGroup(); }, req.timeoutSeconds * 1000);
-        }
-        const abort = () => { cancelled = true; terminateCommandGroup(); };
-        cancel = async () => { abort(); };
-        child.on('close', (code) => {
-            if (settled)
-                return;
-            settled = true;
-            if (timer)
-                clearTimeout(timer);
-            resolve({
-                t: 'exec_exit', id: req.id,
-                exitCode: timedOut || cancelled ? null : code,
-                stdout, stderr, timedOut, truncated,
-            });
-        });
-        child.on('error', (err) => {
-            if (settled)
-                return;
-            settled = true;
-            if (timer)
-                clearTimeout(timer);
-            resolve({
-                t: 'exec_exit', id: req.id,
-                exitCode: null,
-                stdout,
-                stderr: stderr + String(err?.message ?? err),
-                timedOut: false,
-                truncated,
-            });
-        });
-    });
-    return { result, cancel: async () => cancel() };
-}
+// The daemon's in-process exec, kept at its historical path for existing importers. It is now the FALLBACK implementation
+// (exec/fallback.ts): commands normally run in keeper-terminal through the exec policy (exec/policy.ts).
+export { runExec, startExec } from './exec/fallback.js';

package/dist/workstation/files/adapters/computerFileFrames.js

@@ -0,0 +1,51 @@
+import { toFileError } from '../errors.js';
+import { requestRoot } from '../scope.js';
+import { listDir, makeDir, readText, writeText, } from '../text.js';
+/** Same shape as channels/computer.ts `FileExecutors`, backed by the files module instead of the fork-per-request worker. */
+export const requestRootFileExecutors = {
+    readFile: async (request, signal) => readText(requestRoot(request.root), { path: request.path, startLine: request.startLine, maxLines: request.maxLines }, signal),
+    writeFile: async (request, signal) => writeText(requestRoot(request.root), { path: request.path, content: request.content, mode: request.mode, expectedSha256: request.expectedSha256 }, signal),
+    listDir: async (request, signal) => listDir(requestRoot(request.root), { path: request.path, startAfter: request.startAfter, maxEntries: request.maxEntries }, signal),
+    createDir: async (request, signal) => makeDir(requestRoot(request.root), { path: request.path, parents: request.parents }, signal),
+};
+/** Any thrown value as a wire error: one of the 14 codes plus a message that never carries an OS path. */
+export function fileErrorPayload(error) {
+    const mapped = toFileError(error);
+    return { code: mapped.code, message: mapped.message };
+}
+/** The error a request cancelled while under way reports (channels/computer.ts sends exactly these). */
+export function cancelledFilePayload(t) {
+    if (t === 'file_write_request')
+        return { code: 'outcome_unknown', message: 'Write outcome is unknown after cancellation' };
+    if (t === 'file_mkdir_request')
+        return { code: 'outcome_unknown', message: 'Directory creation outcome is unknown after cancellation' };
+    return { code: 'workstation_offline', message: 'Read was cancelled' };
+}
+export function fileErrorFrame(request, error) {
+    if (request.t === 'file_read_request')
+        return { t: 'file_read_result', id: request.id, error };
+    if (request.t === 'file_write_request')
+        return { t: 'file_write_result', id: request.id, error };
+    if (request.t === 'file_ls_request')
+        return { t: 'file_ls_result', id: request.id, error };
+    return { t: 'file_mkdir_result', id: request.id, error };
+}
+/** Executes one request frame in the request-root scope and returns its result frame; never throws. */
+export async function runFileFrame(request, signal, hooks) {
+    try {
+        const scope = requestRoot(request.root);
+        if (request.t === 'file_read_request') {
+            return { t: 'file_read_result', id: request.id, data: await readText(scope, { path: request.path, startLine: request.startLine, maxLines: request.maxLines }, signal, hooks) };
+        }
+        if (request.t === 'file_write_request') {
+            return { t: 'file_write_result', id: request.id, data: await writeText(scope, { path: request.path, content: request.content, mode: request.mode, expectedSha256: request.expectedSha256 }, signal, hooks) };
+        }
+        if (request.t === 'file_ls_request') {
+            return { t: 'file_ls_result', id: request.id, data: await listDir(scope, { path: request.path, startAfter: request.startAfter, maxEntries: request.maxEntries }, signal, hooks) };
+        }
+        return { t: 'file_mkdir_result', id: request.id, data: await makeDir(scope, { path: request.path, parents: request.parents }, signal, hooks) };
+    }
+    catch (error) {
+        return fileErrorFrame(request, signal?.aborted ? cancelledFilePayload(request.t) : fileErrorPayload(error));
+    }
+}

package/dist/workstation/files/adapters/toolRequests.js

@@ -0,0 +1,121 @@
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { TOOL_METHODS, TOOL_RESULT_BYTES, validateRequest } from '../../tools/validation.js';
+import { WorkstationMedia } from '../media/media.js';
+import { StructuredFiles } from '../structured.js';
+import { UPLOAD_TTL_MS, UploadStore } from '../uploads.js';
+/*
+ * Wire adapter for the Files tab: `tool_request{method: files.*}` <-> `tool_result{ok, result, error: string}`.
+ * Failures are thrown as errors whose `message` is the `tool_result.error` text (the channel truncates it to 1024);
+ * an expired media consumer is a successful result `{errorCode: 'media-consumer-expired'}` (see media/media.ts).
+ * Unlike the legacy ToolsCore there is no global queue: only `pinned()` sections are mutually exclusive.
+ */
+export const FILES_TOOL_METHODS = new Set([...TOOL_METHODS].filter(method => method.startsWith('files.')));
+export function isFilesToolMethod(method) { return FILES_TOOL_METHODS.has(method); }
+/** `files.*` methods that change the filesystem: when the process running one is lost, its outcome is unknown. */
+export const FILES_MUTATING_METHODS = new Set([
+    'files.mkdir', 'files.rename', 'files.delete', 'files.upload.begin', 'files.upload.chunk', 'files.upload.finish', 'files.upload.cancel',
+]);
+/** `tool_result.error` text for a thrown value. */
+export function toolErrorMessage(error) { return error instanceof Error ? error.message : 'Workstation tool failed'; }
+export class FileTools {
+    files;
+    media;
+    filesystem;
+    filesystemMedia;
+    disposed = false;
+    inFlight = new Set();
+    timer;
+    constructor(files, media, filesystem, filesystemMedia, ttl) {
+        this.files = files;
+        this.media = media;
+        this.filesystem = filesystem;
+        this.filesystemMedia = filesystemMedia;
+        this.timer = setInterval(() => { void Promise.allSettled([this.files.expire(), this.filesystem.expire()]); }, Math.min(ttl, 60_000));
+        this.timer.unref();
+    }
+    /** Every path option must be absolute: a relative one would resolve against whatever directory a section pinned. */
+    static async create(options = {}) {
+        for (const [name, value] of [['home', options.home], ['uploadStateDir', options.uploadStateDir], ['mediaCache', options.mediaCache], ...(options.roots ?? []).map(root => ['roots', root])]) {
+            if (value !== undefined && !path.isAbsolute(value))
+                throw new Error(`File tools option ${name} must be an absolute path`);
+        }
+        const ttl = options.uploadTtlMs ?? UPLOAD_TTL_MS;
+        const files = await StructuredFiles.create(options.home ?? os.homedir(), options.roots ?? [], ttl, options.uploadStateDir);
+        const media = new WorkstationMedia(files, options.mediaCache ?? path.join(files.home, '.cache', 'axom', 'media'));
+        const filesystem = await StructuredFiles.create(files.home, [], ttl, options.uploadStateDir ? path.join(options.uploadStateDir, 'filesystem') : undefined, true);
+        const filesystemMedia = new WorkstationMedia(filesystem, options.mediaCache ?? path.join(files.home, '.cache', 'axom', 'media'));
+        return new FileTools(files, media, filesystem, filesystemMedia, ttl);
+    }
+    info() {
+        return { files: true, readOnlyFilesVersion: 1, filesystemFilesVersion: 1, mediaPreviewVersion: 2, fileFindVersion: 1, home: this.files.home, userName: os.userInfo().username, roots: this.files.roots, downloads: this.files.downloads };
+    }
+    /** Uploads in flight; the daemon samples it as activity. */
+    get activeUploads() { return this.files.activeUploads + this.filesystem.activeUploads; }
+    /** Media encodes running or queued; the daemon samples it as activity. */
+    get activeEncodes() { return this.media.activeEncodes + this.filesystemMedia.activeEncodes; }
+    dispatch(method, params = {}) {
+        const call = this.run(method, params);
+        this.inFlight.add(call);
+        void call.finally(() => this.inFlight.delete(call)).catch(() => { });
+        return call;
+    }
+    async run(method, params) {
+        if (this.disposed)
+            throw new Error('Workstation files host stopped');
+        if (params.filesystem !== undefined && typeof params.filesystem !== 'boolean')
+            throw new Error('Invalid filesystem');
+        if (params.filesystem !== undefined && !method.startsWith('files.'))
+            throw new Error('Unexpected tool parameter');
+        if (params.filesystem === true && params.readOnly !== undefined)
+            throw new Error('Conflicting file scopes');
+        const filesystem = params.filesystem === true;
+        const { filesystem: _filesystem, ...scopedParams } = params;
+        validateRequest(method, scopedParams);
+        if (!isFilesToolMethod(method))
+            throw new Error('Unsupported workstation tool');
+        const files = filesystem ? this.filesystem : this.files;
+        const media = filesystem ? this.filesystemMedia : this.media;
+        const result = method.startsWith('files.media.') ? await media.dispatch(method, scopedParams) : await files.dispatch(method, scopedParams);
+        if (Buffer.byteLength(JSON.stringify(result)) > TOOL_RESULT_BYTES - 1024)
+            throw new Error('Tool result too large');
+        return result;
+    }
+    /**
+     * `terminal.create`'s working directory, resolved exactly as the legacy tools keeper did (`StructuredFiles.resolve(cwd ??
+     * home)`, configured-roots scope, same error texts). The terminal keeper itself checks that it is a directory.
+     */
+    resolveTerminalCwd(cwd) {
+        if (cwd !== undefined && typeof cwd !== 'string')
+            return Promise.reject(new Error('Invalid cwd'));
+        return this.files.resolve(cwd ?? this.files.home);
+    }
+    /**
+     * Cleans the orphaned upload temporaries recorded in `stateDir` by another process that has stopped for good (the retired
+     * legacy tools keeper's `<sockdir>/uploads`), inside this instance's configured roots. A missing directory is nothing to do;
+     * an unsafe one (symlink, not a directory, another owner) is refused.
+     */
+    async recoverUploads(stateDir) {
+        if (typeof stateDir !== 'string' || !path.isAbsolute(stateDir))
+            throw new Error('Upload state directory must be an absolute path');
+        const stat = await fs.lstat(stateDir).catch((error) => { if (error.code === 'ENOENT')
+            return null; throw error; });
+        if (!stat)
+            return;
+        if (!stat.isDirectory() || stat.isSymbolicLink() || (process.getuid && stat.uid !== process.getuid()))
+            throw new Error('Unsafe upload state directory');
+        await new UploadStore(this.files.roots, UPLOAD_TTL_MS, stateDir).recover((raw, missingLeaf, mutation) => this.files.resolve(raw, missingLeaf, mutation));
+        await fs.rmdir(stateDir).catch(() => { }); // only when recover left it empty
+    }
+    /** Refuses new calls, waits for the ones in flight (as ToolsCore awaited its queue), then stops media and uploads. */
+    async dispose() {
+        this.disposed = true;
+        clearInterval(this.timer);
+        await Promise.allSettled([...this.inFlight]);
+        await this.media.dispose();
+        await this.files.dispose();
+        await this.filesystemMedia.dispose();
+        await this.filesystem.dispose();
+    }
+}