dsh-agent-plugins-market 0.7.0 → 0.7.2

package/lib/application/catalog-context.js

@@ -8,6 +8,7 @@
  * notification path — have a single owner.
  */
 import { join } from 'node:path';
+import { MARKET_SETTINGS_DEFAULTS } from '../contracts/settings.js';
 import { STATE_FILE_NAME } from '../catalog/paths.js';
 import { settlesWithin } from '../runtime/deadline.js';
 import { EMPTY_STATE, loadState, saveState } from '../runtime/state-store.js';
@@ -27,7 +28,13 @@ export class CatalogContext {
     mutationQueue = Promise.resolve();
     currentRevision = 0;
     currentScanGeneration = 0;
-    scanProjectLayoutsEnabled = false;
+    /**
+     * The project-layout switch in effect. The host settings document owns the
+     * value and pushes it here on registration and on every change; the initial
+     * value is the contract's declared default, which is what the catalog would
+     * read from the document before the settings service resolves.
+     */
+    scanProjectLayoutsEnabled = MARKET_SETTINGS_DEFAULTS.scanProjectLayouts;
     /** The derived refresh in flight, shared by every change that lands while it runs. */
     refreshPass;
     /** Whether a change landed after the running pass started; it earns one more pass. */

package/lib/application/catalog.js

@@ -48,6 +48,10 @@ export class Catalog {
     get userRoot() {
         return this.context.userRoot;
     }
+    /** The plugin storage root holding per-suite `${PLUGIN_DATA}` directories and overrides. */
+    get dataRoot() {
+        return this.context.dataRoot;
+    }
     get sources() {
         return this.context.state.sources;
     }
@@ -222,13 +226,17 @@ export class Catalog {
     async addMcpServer(name, server) {
         await this.mcp.addServer(name, server);
     }
+    /** Import several pasted services in one write; each entry reports its own outcome. */
+    async importMcpServers(servers, overwrite) {
+        return this.mcp.importServers(servers, overwrite);
+    }
     /** Read effective service configuration without exposing credential literals. */
     async serverConfig(kind, id) {
         return this.mcp.serverConfig(kind, id);
     }
     /** Validate a complete replacement before writing; plugin checkouts remain untouched. */
-    async saveServerConfig(kind, id, config) {
-        await this.mcp.saveServerConfig(kind, id, config);
+    async saveServerConfig(kind, id, config, policy) {
+        await this.mcp.saveServerConfig(kind, id, config, policy);
     }
     /** One suite's persisted MCP overrides, addressed by qualified suite id. */
     async mcpOverrides(sourceId, suiteId) {
@@ -238,6 +246,23 @@ export class Catalog {
     async setMcpOverride(sourceId, suiteId, serverKey, override) {
         await this.mcp.setOverride(sourceId, suiteId, serverKey, override);
     }
+    /**
+     * Enable or disable one declared MCP server, addressed by the same
+     * source-qualified suite id its status row carries. Disabling writes an
+     * override rather than editing the suite's `mcp.json`, so a refresh cannot
+     * clobber the user's choice.
+     */
+    async setMcpServerEnabled(suiteKey, serverKey, enabled) {
+        await this.mcp.setServerEnabled(suiteKey, serverKey, enabled);
+    }
+    /**
+     * Allow or deny one tool of a declared MCP server, addressed by the same
+     * source-qualified suite id its status row carries. The denial lands in the
+     * override record, so the suite's own `mcp.json` stays source-owned.
+     */
+    async setMcpServerToolEnabled(suiteKey, serverKey, tool, enabled) {
+        await this.mcp.setServerToolEnabled(suiteKey, serverKey, tool, enabled);
+    }
     /** Re-run the MCP reconcile pass without changing any catalog state. */
     async retryMounts() {
         await this.mcp.retryMounts();

package/lib/application/details.js

@@ -1,5 +1,5 @@
 /** Suite detail and preview projections owned by the application layer. */
-import { readFile } from 'node:fs/promises';
+import { readFile, stat } from 'node:fs/promises';
 import { parse as parseYaml } from 'yaml';
 import { discoverLspEntries } from '../catalog/surfaces.js';
 import { defaultMarkdownResources, resourceText } from '../catalog/component-files.js';
@@ -7,6 +7,16 @@ import { credentialRefsInServer } from '../runtime/mcp-config.js';
 import { redactMcpConfig, redactMcpOverrides } from '../runtime/mcp-redaction.js';
 import { applyOverride } from '../runtime/mcp-overrides.js';
 import { effectiveSurfaces } from '../model/types.js';
+/** The checkout's last modification, or null when the path cannot be read. */
+async function rootModifiedAt(root) {
+    try {
+        const stats = await stat(root);
+        return new Date(stats.mtimeMs).toISOString();
+    }
+    catch {
+        return null;
+    }
+}
 /** Build the detail response for one normalized suite. */
 export async function buildSuiteDetail(suite, installed, diagnostics, mcpOverrides = {}) {
     const remoteUrl = suite.remote?.url;
@@ -18,6 +28,7 @@ export async function buildSuiteDetail(suite, installed, diagnostics, mcpOverrid
         description: suite.manifest.description ?? null,
         author: suite.manifest.author ?? null,
         keywords: suite.manifest.keywords ?? [],
+        updatedAt: await rootModifiedAt(suite.root),
         layout: suite.manifest.layout,
         dimension: suite.dimension,
         root: remoteUrl ?? suite.root,
@@ -66,7 +77,7 @@ export async function readSkillContent(suite, skillName) {
         content = await readFile(skill.file, 'utf8');
     }
     catch (error) {
-        throw new Error(`skill file unreadable: ${error instanceof Error ? error.message : String(error)}`);
+        throw new Error(`skill file unreadable: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
     }
     return { name: skill.name, description: skill.description, content, path: skill.file };
 }

package/lib/application/install-store.js

@@ -77,7 +77,7 @@ export class InstallStore {
             await this.context.notifyChanged(true);
         });
     }
-    /** Append config-seeded sources missing from user state and persist them. */
+    /** Append seeded sources missing from user state and persist them. */
     async mergeSources(sources) {
         const existing = new Set(this.context.state.sources.map(source => source.id));
         const additions = sources.filter(source => !existing.has(source.id));

package/lib/application/mcp-service.js

@@ -11,13 +11,17 @@ import { isDirectory } from '../catalog/fs-probes.js';
 import { discoverSuitesInSource } from '../catalog/suite-scanner.js';
 import { readLocalePreference } from '../runtime/host-locale.js';
 import { probeHostMcpClient } from '../runtime/mcp-backend.js';
+import { declaredMcpPolicy, namespaceMcpPolicy, resolveMcpPolicy } from '../runtime/mcp-config.js';
 import { loadLspServers, saveLspServers } from '../runtime/lsp-direct-config.js';
-import { addUserMcpServer, loadUserMcpSuite, USER_MCP_SOURCE, USER_MCP_SUITE } from '../runtime/mcp-direct-config.js';
-import { applyOverride, loadSuiteOverrides, mergeOverridePatch, saveSuiteOverrides } from '../runtime/mcp-overrides.js';
+import { addUserMcpServer, importUserMcpServers, loadUserMcpSuite, USER_MCP_SOURCE, USER_MCP_SUITE } from '../runtime/mcp-direct-config.js';
+import { applyOverride, loadSuiteOverrides, mergeOverridePatch, parseMcpPolicyPatch, saveSuiteOverrides, withoutPolicyFields } from '../runtime/mcp-overrides.js';
 import { redactMcpConfig, redactMcpOverrides } from '../runtime/mcp-redaction.js';
 import { buildMcpStatus } from '../runtime/mcp-status.js';
 import { resolveRegion } from '../runtime/regions.js';
 import { applyLspOverrides, lspConfig, restoreRedactedConfig, saveLspOverride, validateServerLsp, validateServerMcp } from '../runtime/server-config.js';
+/** The host compatibility client mounts servers without a startup timeout or tool filters. */
+const HOST_STARTUP_TIMEOUT_UNSUPPORTED = 'the host MCP backend cannot enforce a startup timeout; switch the MCP backend to the built-in client to set one';
+const HOST_TOOL_FILTER_UNSUPPORTED = 'the host MCP backend cannot enforce tool filters; switch the MCP backend to the built-in client to choose tools';
 export class McpService {
     context;
     ports;
@@ -39,7 +43,9 @@ export class McpService {
                 entry.kind = 'direct';
                 entry.managed = true;
             }
-        const oauthBackend = (await this.backend()) === 'builtin' && this.reauthorizeAvailable();
+        const backend = await this.backend();
+        payload.backend = backend;
+        const oauthBackend = backend === 'builtin' && this.reauthorizeAvailable();
         for (const entry of payload.entries) {
             const auth = entry.config?.auth;
             entry.canReauthorize =
@@ -58,21 +64,71 @@ export class McpService {
             await this.context.notifyChanged(true);
         });
     }
+    /**
+     * Import several pasted services in one write. Each entry is checked on its
+     * own and reports back with its own outcome, so a paste of many services
+     * never fails as a block.
+     */
+    async importServers(servers, overwrite) {
+        if (!Array.isArray(servers))
+            throw new Error('servers must be an array');
+        const entries = servers.map(entry => {
+            if (typeof entry !== 'object' || entry === null)
+                throw new Error('each server must be an object');
+            const { name, config } = entry;
+            if (typeof name !== 'string' || name === '')
+                throw new Error('each server needs a name');
+            return { name, server: config };
+        });
+        return this.context.enqueue(async () => {
+            const result = await importUserMcpServers(this.context.agentsRoot, entries, overwrite);
+            if (result.imported.length > 0)
+                await this.context.notifyChanged(true);
+            return result;
+        });
+    }
     /** Read effective service configuration without exposing credential literals. */
     async serverConfig(kind, id) {
         const config = await this.resolveServerConfig(kind, id);
-        return { kind, id, editable: true, config: redactMcpConfig(config.value) };
+        const payload = { kind, id, key: config.key, editable: true, config: redactMcpConfig(config.value) };
+        if (kind === 'mcp') {
+            payload.backend = await this.backend();
+            if (config.policy !== undefined)
+                payload.policy = serverPolicyPayload(config.policy, config.override, config.declaredAuth);
+        }
+        return payload;
     }
-    /** Validate a complete replacement before writing; plugin checkouts remain untouched. */
-    async saveServerConfig(kind, id, config) {
+    /**
+     * Validate a complete replacement before writing; plugin checkouts remain
+     * untouched. `policy` carries what the portable document has no seat for —
+     * the two timeouts, the user's tool denials and the OAuth opt-in; an absent
+     * field keeps its stored value, `null` clears it.
+     */
+    async saveServerConfig(kind, id, config, policy) {
         return this.context.enqueue(async () => {
             const current = await this.resolveServerConfig(kind, id);
             const value = restoreRedactedConfig(config, current.value);
             if (kind === 'mcp') {
-                const server = await validateServerMcp(current.root, current.key, value);
+                const backend = await this.backend();
+                const patch = parseMcpPolicyPatch(policy);
+                if (backend === 'host' && patch.startupTimeoutMs !== undefined && patch.startupTimeoutMs !== null)
+                    throw new Error(HOST_STARTUP_TIMEOUT_UNSUPPORTED);
+                if (backend === 'host' && patch.disabledTools !== undefined)
+                    throw new Error(HOST_TOOL_FILTER_UNSUPPORTED);
+                const server = await validateServerMcp(current.root, current.key, value, { userOwned: isUserOwnedMcp(current.suiteKey) });
                 const overrides = await loadSuiteOverrides(this.context.dataRoot, current.suiteKey);
-                const enabled = overrides[current.key]?.enabled;
-                overrides[current.key] = { config: server, ...(enabled === undefined ? {} : { enabled }) };
+                const existing = overrides[current.key] ?? {};
+                // The complete configuration already carries every connection input, so
+                // a leftover url/headers/env/args field would shadow what was just
+                // saved. Enablement and the policy fields the save did not touch survive.
+                const next = { config: server };
+                if (existing.enabled !== undefined)
+                    next.enabled = existing.enabled;
+                applyAuth(next, patch.auth, existing.auth);
+                applyToolList(next, patch.disabledTools, existing.disabledTools);
+                applyTimeout(next, 'toolCallTimeoutMs', patch.toolCallTimeoutMs, existing.toolCallTimeoutMs);
+                applyTimeout(next, 'startupTimeoutMs', patch.startupTimeoutMs, existing.startupTimeoutMs);
+                overrides[current.key] = next;
                 await saveSuiteOverrides(this.context.dataRoot, current.suiteKey, overrides);
             }
             else {
@@ -104,6 +160,53 @@ export class McpService {
      * in the suite's parsed mcp.json.
      */
     async setOverride(sourceId, suiteId, serverKey, override) {
+        if (override !== null && (override.startupTimeoutMs !== undefined || override.disabledTools !== undefined) && (await this.backend()) === 'host')
+            throw new Error(override.startupTimeoutMs !== undefined ? HOST_STARTUP_TIMEOUT_UNSUPPORTED : HOST_TOOL_FILTER_UNSUPPORTED);
+        // Merge onto the stored record: the UI never receives literal secret
+        // values, so a verbatim write would drop keys it simply redacted.
+        await this.updateServerOverride(sourceId, suiteId, serverKey, current => (override === null ? null : mergeOverridePatch(current ?? {}, override)));
+    }
+    /**
+     * Enable or disable one declared server, addressed by the source-qualified
+     * suite id the status rows carry. The qualified id is split here rather than
+     * by callers so the separator stays a server-side detail.
+     */
+    async setServerEnabled(suiteKey, serverKey, enabled) {
+        const { sourceId, suiteId } = splitSuiteKey(suiteKey);
+        await this.setOverride(sourceId, suiteId, serverKey, { enabled });
+    }
+    /**
+     * Allow or deny one tool of a declared server, addressed by the
+     * source-qualified suite id the status rows carry. The stored record lists
+     * only the tools the user turned off, so a server with nothing denied
+     * carries no tool field at all.
+     */
+    async setServerToolEnabled(suiteKey, serverKey, tool, enabled) {
+        const { sourceId, suiteId } = splitSuiteKey(suiteKey);
+        if (tool === '')
+            throw new Error('tool name is required');
+        if ((await this.backend()) === 'host')
+            throw new Error(HOST_TOOL_FILTER_UNSUPPORTED);
+        await this.updateServerOverride(sourceId, suiteId, serverKey, current => {
+            const denied = new Set(current?.disabledTools ?? []);
+            if (enabled)
+                denied.delete(tool);
+            else
+                denied.add(tool);
+            const next = { ...(current ?? {}) };
+            if (denied.size === 0)
+                delete next.disabledTools;
+            else
+                next.disabledTools = [...denied];
+            return Object.keys(next).length === 0 ? null : next;
+        });
+    }
+    /**
+     * Rewrite one declared server's override record and remount it. The mutate
+     * callback receives the stored record — absent when none is persisted — and
+     * returns the replacement, or `null` to drop the record entirely.
+     */
+    async updateServerOverride(sourceId, suiteId, serverKey, mutate) {
         return this.context.enqueue(async () => {
             const suiteKey = qualifiedSuiteId(sourceId, suiteId);
             const source = this.context.state.sources.find(entry => entry.id === sourceId);
@@ -129,16 +232,19 @@ export class McpService {
             // Override files are keyed by the qualified id so two sources' same-named
             // suites never share one override record.
             const overrides = await loadSuiteOverrides(this.context.dataRoot, suiteKey);
-            if (override === null) {
+            const next = mutate(overrides[serverKey]);
+            if (next === null)
                 delete overrides[serverKey];
-            }
-            else {
-                // Merge onto the stored record: the UI never receives literal secret
-                // values, so a verbatim write would drop keys it simply redacted.
-                overrides[serverKey] = mergeOverridePatch(overrides[serverKey] ?? {}, override);
-            }
+            else
+                overrides[serverKey] = next;
             await saveSuiteOverrides(this.context.dataRoot, suiteKey, overrides);
             await this.context.notifyChanged(true);
+            // The status surface reads the live tool registry, so an immediate read
+            // races the reconciler's teardown: a just-disabled server still carries
+            // its observed tools and reports the orphaned state with its switch on
+            // until the pass finishes. Joining the pass here is bounded — one stuck
+            // mount costs the request its deadline, never the plugin.
+            await this.context.refreshSettled();
         });
     }
     /**
@@ -214,7 +320,11 @@ export class McpService {
         }
         return map;
     }
-    /** Resolve one editable server: its key, owning suite, root, and effective config. */
+    /**
+     * Resolve one editable server: its key, owning suite, root, and the service
+     * document the editor renders. An MCP document carries the portable shape
+     * only; the client policy behind it rides `policy`.
+     */
     async resolveServerConfig(kind, id) {
         if (kind === 'lsp' && id.startsWith('direct/')) {
             const key = id.slice(7);
@@ -230,8 +340,17 @@ export class McpService {
                 for (const [key, server] of Object.entries(suite.mcp?.servers ?? {})) {
                     if (id !== `plugin:${suiteKey}/${key}`)
                         continue;
-                    const overrides = await loadSuiteOverrides(this.context.dataRoot, suiteKey);
-                    return { key, suiteKey, root: suite.root, value: { ...applyOverride(server, overrides[key]) } };
+                    const override = (await loadSuiteOverrides(this.context.dataRoot, suiteKey))[key];
+                    const declared = namespaceMcpPolicy(suite, key);
+                    return {
+                        key,
+                        suiteKey,
+                        root: suite.root,
+                        value: { ...withoutPolicyFields(applyOverride(server, override)) },
+                        policy: resolveMcpPolicy(declaredMcpPolicy(server, declared), override),
+                        ...(override === undefined ? {} : { override }),
+                        ...(declared?.auth?.enabled === undefined ? {} : { declaredAuth: declared.auth.enabled })
+                    };
                 }
             }
             else {
@@ -244,3 +363,56 @@ export class McpService {
         throw new Error('service configuration is not managed by this plugin');
     }
 }
+/** Split one source-qualified suite id; the separator stays a server-side detail. */
+function splitSuiteKey(suiteKey) {
+    const separator = suiteKey.indexOf('/');
+    if (separator <= 0)
+        throw new Error(`invalid suite id "${suiteKey}"`);
+    return { sourceId: suiteKey.slice(0, separator), suiteId: suiteKey.slice(separator + 1) };
+}
+/** Project one resolved policy onto the wire shape the editor renders. */
+function serverPolicyPayload(policy, override, declaredAuth) {
+    const userDenied = override?.disabledTools ?? null;
+    const userAuth = override?.auth?.enabled ?? null;
+    const suiteAuth = declaredAuth ?? null;
+    return {
+        toolCallTimeout: policy.toolCallTimeout,
+        startupTimeout: policy.startupTimeout,
+        deniedTools: { user: userDenied, suite: policy.suiteDisabledTools ?? null, effective: policy.disabledTools ?? [] },
+        auth: { user: userAuth, suite: suiteAuth, effective: userAuth ?? suiteAuth ?? true }
+    };
+}
+/** The user-owned MCP declaration suite: its file is local data, not a package. */
+function isUserOwnedMcp(suiteKey) {
+    return suiteKey === `${USER_MCP_SOURCE}/${USER_MCP_SUITE}`;
+}
+/** Write the OAuth opt-in from a save: absent keeps the stored value, `null` clears it. */
+function applyAuth(target, patch, stored) {
+    if (patch === undefined) {
+        if (stored !== undefined)
+            target.auth = stored;
+        return;
+    }
+    if (patch !== null)
+        target.auth = patch;
+}
+/** Write the user's deny list: absent keeps it, `null` clears it, entries replace it. */
+function applyToolList(target, patch, stored) {
+    if (patch === undefined) {
+        if (stored !== undefined)
+            target.disabledTools = stored;
+        return;
+    }
+    if (patch !== null && patch.length > 0)
+        target.disabledTools = patch;
+}
+/** Write one timeout from a save: absent keeps the stored value, `null` clears it, a number sets it. */
+function applyTimeout(target, field, patch, stored) {
+    if (patch === undefined) {
+        if (stored !== undefined)
+            target[field] = stored;
+        return;
+    }
+    if (patch !== null)
+        target[field] = patch;
+}

package/lib/application/panel-resources.js

@@ -1,8 +1,9 @@
 /** Installed suite and user resources share one inventory; paths never come from HTTP callers. */
-import { realpath, unlink } from 'node:fs/promises';
+import { realpath, stat, unlink } from 'node:fs/promises';
 import { writeFileAtomic } from '@deepseek-ai/dsh-atomic-write';
 import { defaultMarkdownResources, resourceText } from '../catalog/component-files.js';
-import { isWithin } from '../catalog/paths.js';
+import { pluginRootOf } from '../catalog/plugin-variables.js';
+import { isWithin, suiteDataDir } from '../catalog/paths.js';
 import { stripFrontmatter } from '../catalog/skills-parse.js';
 import { parseFrontmatterRecord } from '../runtime/user-store.js';
 /**
@@ -68,11 +69,22 @@ class PanelResources {
                     rawText,
                     content: stripFrontmatter(rawText),
                     path: file,
-                    description: typeof metadata.description === 'string' ? metadata.description : ''
+                    description: typeof metadata.description === 'string' ? metadata.description : '',
+                    ...(pluginRootOf(suite) === undefined ? {} : { suiteRoot: suite.root, suiteData: suiteDataDir(this.catalog.dataRoot, suite.sourceId, suite.id) })
                 });
             }
         }
-        return entries;
+        // One pass stamps each entry's own last modification: the panel reads every
+        // file's text anyway, and both origins get the same treatment here.
+        return await Promise.all(entries.map(async (entry) => {
+            try {
+                const stats = await stat(entry.path);
+                return { ...entry, updatedAt: new Date(stats.mtimeMs).toISOString() };
+            }
+            catch {
+                return entry;
+            }
+        }));
     }
     async get(id) {
         return (await this.list()).find(entry => (entry.id ?? entry.name) === id);

package/lib/application/project-agent-roles.js

@@ -1,5 +1,7 @@
 /** Resolve read-only project roles from the calling session, never from tool-supplied paths. */
 import { defaultMarkdownResources, resourceText } from '../catalog/component-files.js';
+import { pluginRootOf } from '../catalog/plugin-variables.js';
+import { suiteDataDir } from '../catalog/paths.js';
 import { parseAgentRole } from '../runtime/agent-role-router.js';
 export async function projectAgentRoles(catalog, parent) {
     const cwd = parent?.session?.header?.cwd;
@@ -10,6 +12,8 @@ export async function projectAgentRoles(catalog, parent) {
     for (const suite of snapshot.enabledSuites) {
         if (suite.activeSurfaces.agents === false)
             continue;
+        const suiteRoot = pluginRootOf(suite);
+        const suiteData = suiteRoot === undefined ? undefined : suiteDataDir(catalog.dataRoot, suite.sourceId, suite.id);
         for (const resource of suite.resources?.agents ?? (await defaultMarkdownResources(suite.root, 'agents'))) {
             const path = resource.file;
             const rawText = await resourceText(resource).catch(error => {
@@ -27,7 +31,9 @@ export async function projectAgentRoles(catalog, parent) {
                     rawText,
                     title: policy.title ?? resource.name.replace(/\.agent$/, ''),
                     description: policy.description ?? `${suite.manifest.name}: ${resource.name}`,
-                    disabled: policy.disabled
+                    disabled: policy.disabled,
+                    ...(suiteRoot === undefined ? {} : { suiteRoot }),
+                    ...(suiteData === undefined ? {} : { suiteData })
                 });
             }
             catch {

package/lib/catalog/archive.js

@@ -43,6 +43,21 @@ export async function downloadArchive(url, tempFile, options = {}) {
     const response = await fetch(trimmed, { signal: AbortSignal.timeout(timeoutMs), redirect: 'follow' });
     if (!response.ok)
         throw new Error(`archive download failed: HTTP ${response.status} for ${trimmed}`);
+    // Fetch follows redirects. The origin was checked above, but the final URL
+    // must preserve the HTTPS-only policy as well; otherwise a trusted HTTPS URL
+    // could downgrade the payload request to plain HTTP.
+    if (options.allowHttp !== true) {
+        const finalUrl = response.url === '' ? trimmed : response.url;
+        let finalProtocol;
+        try {
+            finalProtocol = new URL(finalUrl).protocol;
+        }
+        catch {
+            throw new Error('archive redirected to an invalid URL');
+        }
+        if (finalProtocol !== 'https:')
+            throw new Error('archive redirected to non-https URL');
+    }
     const declared = Number(response.headers.get('content-length') ?? '0');
     if (Number.isFinite(declared) && declared > ARCHIVE_MAX_BYTES) {
         throw new Error(`archive exceeds the ${ARCHIVE_MAX_BYTES} byte limit: ${declared}`);
@@ -269,7 +284,7 @@ async function assertBoundedTree(root) {
                 stack.push(path);
                 continue;
             }
-            let size = 0;
+            let size;
             try {
                 size = (await stat(path)).size;
             }