@minionry/minion 0.7.36

package/dist/server/services/sdk/files-transfer.js

@@ -0,0 +1,279 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { basename, dirname } from 'node:path';
+import { zipSync } from 'fflate';
+import { buildDirectoryZipBuffer, ZipTooLargeError } from '../file-transfer-zip.js';
+import { notifyFileChangedAbsolute } from './file-change-notify.js';
+import { appDataDir, guardAppDataPath } from './files-app.js';
+import { guardWorkspacePath, parseWorkspacePath } from './files-workspace.js';
+import { SdkMethodError } from './registry.js';
+export const TRANSFER_CHUNK_BYTES = 256 * 1024;
+export const MAX_TRANSFER_BYTES = 50 * 1024 * 1024;
+const MAX_CHUNK_PAYLOAD_BYTES = TRANSFER_CHUNK_BYTES * 2;
+const SESSION_IDLE_TIMEOUT_MS = 120_000;
+function paramsObject(params) {
+    return typeof params === 'object' && params !== null && !Array.isArray(params)
+        ? params
+        : {};
+}
+function requireString(value, name, method) {
+    if (typeof value !== 'string' || value === '') {
+        throw new SdkMethodError('BAD_REQUEST', `${method} requires a non-empty string '${name}'`);
+    }
+    return value;
+}
+function requireNonNegativeInt(value, name, method) {
+    if (typeof value !== 'number' || !Number.isInteger(value) || value < 0) {
+        throw new SdkMethodError('BAD_REQUEST', `${method} requires a non-negative integer '${name}'`);
+    }
+    return value;
+}
+function statOrUndefined(path) {
+    try {
+        return statSync(path);
+    }
+    catch {
+        return undefined;
+    }
+}
+function reguard(guard) {
+    return guard.rooting === 'app'
+        ? guardAppDataPath(guard.root, guard.rel)
+        : guardWorkspacePath(guard.root, guard.rel).resolvedPath;
+}
+export function resolveGuardWithRoot(args, path) {
+    const workspaceTarget = parseWorkspacePath({ path });
+    if (workspaceTarget === null) {
+        const dataDir = appDataDir(args);
+        const guard = { rooting: 'app', root: dataDir, rel: path };
+        return { guard, resolvedPath: guardAppDataPath(dataDir, path), gitignoreRoot: dataDir };
+    }
+    const { realWorkingDir, resolvedPath } = guardWorkspacePath(args.workingDir, workspaceTarget.rel);
+    const guard = { rooting: 'workspace', root: args.workingDir, rel: workspaceTarget.rel };
+    return { guard, resolvedPath, gitignoreRoot: realWorkingDir };
+}
+const uploads = new Map();
+const downloads = new Map();
+let idCounter = 0;
+function mintId(prefix) {
+    idCounter += 1;
+    return `${prefix}-${Date.now().toString(36)}-${idCounter}`;
+}
+function sweepExpired(sessions) {
+    const now = Date.now();
+    for (const [id, session] of sessions) {
+        if (now - session.lastActivity > SESSION_IDLE_TIMEOUT_MS)
+            sessions.delete(id);
+    }
+}
+function ownsSession(args, session) {
+    return session.appId === args.appId && session.spaceKey === args.spaceKey;
+}
+function guessMimeType(path) {
+    const ext = path.toLowerCase().split('.').pop() || '';
+    if (ext === 'svg')
+        return 'image/svg+xml';
+    if (ext === 'jpg' || ext === 'jpeg')
+        return 'image/jpeg';
+    if (ext === 'pdf')
+        return 'application/pdf';
+    if (['png', 'gif', 'webp', 'bmp', 'tiff', 'ico'].includes(ext))
+        return `image/${ext}`;
+    if (ext === 'json')
+        return 'application/json';
+    if (['txt', 'md', 'ts', 'tsx', 'js', 'jsx', 'css', 'html', 'yml', 'yaml'].includes(ext))
+        return 'text/plain';
+    return 'application/octet-stream';
+}
+export function filesUploadStartHandler(args) {
+    sweepExpired(uploads);
+    const raw = paramsObject(args.params);
+    const path = requireString(raw.path, 'path', args.method);
+    requireNonNegativeInt(raw.fileSize, 'fileSize', args.method);
+    const totalChunks = requireNonNegativeInt(raw.totalChunks, 'totalChunks', args.method);
+    if (totalChunks < 1) {
+        throw new SdkMethodError('BAD_REQUEST', `${args.method}: totalChunks must be at least 1`);
+    }
+    const fileSize = raw.fileSize;
+    if (fileSize > MAX_TRANSFER_BYTES) {
+        throw new SdkMethodError('BAD_REQUEST', `${args.method}: ${fileSize} bytes exceeds the ${MAX_TRANSFER_BYTES}-byte transfer cap`);
+    }
+    const overwrite = raw.overwrite === true;
+    const { guard, resolvedPath } = resolveGuardWithRoot(args, path);
+    const stat = statOrUndefined(resolvedPath);
+    if (stat?.isDirectory()) {
+        throw new SdkMethodError('BAD_REQUEST', `${args.method}: '${path}' is a directory — cannot upload over it`);
+    }
+    if (stat && !overwrite) {
+        throw new SdkMethodError('BAD_REQUEST', `${args.method}: '${path}' already exists — pass overwrite to replace it`);
+    }
+    const uploadId = mintId('upload');
+    uploads.set(uploadId, {
+        appId: args.appId,
+        spaceKey: args.spaceKey,
+        guard,
+        overwrite,
+        totalChunks,
+        chunks: new Array(totalChunks),
+        nextExpectedChunk: 0,
+        bytesWritten: 0,
+        lastActivity: Date.now(),
+    });
+    return { uploadId, chunkSize: TRANSFER_CHUNK_BYTES, nextExpectedChunk: 0 };
+}
+function finishUpload(args, uploadId, session) {
+    const resolvedPath = reguard(session.guard);
+    const stat = statOrUndefined(resolvedPath);
+    if (stat?.isDirectory()) {
+        uploads.delete(uploadId);
+        throw new SdkMethodError('BAD_REQUEST', `${args.method}: '${session.guard.rel}' is a directory — cannot upload over it`);
+    }
+    if (stat && !session.overwrite) {
+        uploads.delete(uploadId);
+        throw new SdkMethodError('BAD_REQUEST', `${args.method}: '${session.guard.rel}' already exists — pass overwrite to replace it`);
+    }
+    mkdirSync(dirname(resolvedPath), { recursive: true });
+    writeFileSync(resolvedPath, Buffer.concat(session.chunks));
+    uploads.delete(uploadId);
+    if (session.guard.rooting === 'workspace') {
+        notifyFileChangedAbsolute(session.spaceKey, resolvedPath, 'changed');
+    }
+}
+export function filesUploadChunkHandler(args) {
+    const raw = paramsObject(args.params);
+    const uploadId = requireString(raw.uploadId, 'uploadId', args.method);
+    const chunkIndex = requireNonNegativeInt(raw.chunkIndex, 'chunkIndex', args.method);
+    const content = requireString(raw.content, 'content', args.method);
+    const session = uploads.get(uploadId);
+    if (!session || !ownsSession(args, session)) {
+        throw new SdkMethodError('BAD_REQUEST', `${args.method}: unknown uploadId '${uploadId}'`);
+    }
+    session.lastActivity = Date.now();
+    if (chunkIndex < session.nextExpectedChunk) {
+        return { chunkIndex, bytesWritten: session.bytesWritten };
+    }
+    if (chunkIndex !== session.nextExpectedChunk) {
+        throw new SdkMethodError('BAD_REQUEST', `${args.method}: expected chunk ${session.nextExpectedChunk}, got ${chunkIndex} — chunks must arrive in order`);
+    }
+    if (chunkIndex >= session.totalChunks) {
+        throw new SdkMethodError('BAD_REQUEST', `${args.method}: upload '${uploadId}' already has all ${session.totalChunks} chunks`);
+    }
+    let bytes;
+    try {
+        bytes = Buffer.from(content, 'base64');
+    }
+    catch {
+        throw new SdkMethodError('BAD_REQUEST', `${args.method}: 'content' is not valid base64`);
+    }
+    if (bytes.byteLength > MAX_CHUNK_PAYLOAD_BYTES) {
+        throw new SdkMethodError('BAD_REQUEST', `${args.method}: chunk ${chunkIndex} is ${bytes.byteLength} bytes — exceeds the per-chunk cap`);
+    }
+    if (session.bytesWritten + bytes.byteLength > MAX_TRANSFER_BYTES) {
+        throw new SdkMethodError('BAD_REQUEST', `${args.method}: upload '${uploadId}' would exceed the ${MAX_TRANSFER_BYTES}-byte transfer cap`);
+    }
+    reguard(session.guard);
+    session.chunks[chunkIndex] = bytes;
+    session.nextExpectedChunk = chunkIndex + 1;
+    session.bytesWritten += bytes.byteLength;
+    if (session.nextExpectedChunk === session.totalChunks) {
+        finishUpload(args, uploadId, session);
+    }
+    return { chunkIndex, bytesWritten: session.bytesWritten };
+}
+export function filesUploadStatusHandler(args) {
+    const raw = paramsObject(args.params);
+    const uploadId = requireString(raw.uploadId, 'uploadId', args.method);
+    const session = uploads.get(uploadId);
+    if (!session || !ownsSession(args, session)) {
+        throw new SdkMethodError('BAD_REQUEST', `${args.method}: unknown uploadId '${uploadId}'`);
+    }
+    return { nextExpectedChunk: session.nextExpectedChunk };
+}
+export function filesUploadCancelHandler(args) {
+    const raw = paramsObject(args.params);
+    const uploadId = requireString(raw.uploadId, 'uploadId', args.method);
+    const session = uploads.get(uploadId);
+    if (session && ownsSession(args, session))
+        uploads.delete(uploadId);
+    return null;
+}
+export function filesDownloadStartHandler(args) {
+    sweepExpired(downloads);
+    const raw = paramsObject(args.params);
+    const path = requireString(raw.path, 'path', args.method);
+    const asZip = raw.asZip === true;
+    const { resolvedPath, gitignoreRoot } = resolveGuardWithRoot(args, path);
+    const stat = statOrUndefined(resolvedPath);
+    if (!stat)
+        throw new SdkMethodError('BAD_REQUEST', `${args.method}: '${path}' not found`);
+    let content;
+    let mimeType;
+    let isZip;
+    if (stat.isDirectory()) {
+        try {
+            content = buildDirectoryZipBuffer(resolvedPath, { gitignoreRoot });
+        }
+        catch (error) {
+            if (error instanceof ZipTooLargeError) {
+                throw new SdkMethodError('BAD_REQUEST', `${args.method}: ${error.message}`);
+            }
+            throw error;
+        }
+        mimeType = 'application/zip';
+        isZip = true;
+    }
+    else if (asZip) {
+        const entryName = basename(resolvedPath);
+        content = Buffer.from(zipSync({ [entryName]: readFileSync(resolvedPath) }, { level: 6 }));
+        mimeType = 'application/zip';
+        isZip = true;
+    }
+    else {
+        if (stat.size > MAX_TRANSFER_BYTES) {
+            throw new SdkMethodError('BAD_REQUEST', `${args.method}: '${path}' is ${stat.size} bytes — exceeds the ${MAX_TRANSFER_BYTES}-byte transfer cap`);
+        }
+        content = readFileSync(resolvedPath);
+        mimeType = guessMimeType(resolvedPath);
+        isZip = false;
+    }
+    if (content.byteLength > MAX_TRANSFER_BYTES) {
+        throw new SdkMethodError('BAD_REQUEST', `${args.method}: '${path}' is ${content.byteLength} bytes zipped — exceeds the ${MAX_TRANSFER_BYTES}-byte transfer cap`);
+    }
+    const downloadId = mintId('download');
+    const totalChunks = Math.max(1, Math.ceil(content.byteLength / TRANSFER_CHUNK_BYTES));
+    downloads.set(downloadId, {
+        appId: args.appId,
+        spaceKey: args.spaceKey,
+        content,
+        totalChunks,
+        mimeType,
+        isZip,
+        lastActivity: Date.now(),
+    });
+    return { downloadId, fileSize: content.byteLength, totalChunks, chunkSize: TRANSFER_CHUNK_BYTES, mimeType, isZip };
+}
+export function filesDownloadChunkHandler(args) {
+    const raw = paramsObject(args.params);
+    const downloadId = requireString(raw.downloadId, 'downloadId', args.method);
+    const chunkIndex = requireNonNegativeInt(raw.chunkIndex, 'chunkIndex', args.method);
+    const session = downloads.get(downloadId);
+    if (!session || !ownsSession(args, session)) {
+        throw new SdkMethodError('BAD_REQUEST', `${args.method}: unknown downloadId '${downloadId}'`);
+    }
+    if (chunkIndex >= session.totalChunks) {
+        throw new SdkMethodError('BAD_REQUEST', `${args.method}: download '${downloadId}' has only ${session.totalChunks} chunks`);
+    }
+    session.lastActivity = Date.now();
+    const from = chunkIndex * TRANSFER_CHUNK_BYTES;
+    const to = Math.min(from + TRANSFER_CHUNK_BYTES, session.content.byteLength);
+    return { content: session.content.subarray(from, to).toString('base64') };
+}
+export function filesDownloadCancelHandler(args) {
+    const raw = paramsObject(args.params);
+    const downloadId = requireString(raw.downloadId, 'downloadId', args.method);
+    const session = downloads.get(downloadId);
+    if (session && ownsSession(args, session))
+        downloads.delete(downloadId);
+    return null;
+}

package/dist/server/services/sdk/files-workspace.js

@@ -0,0 +1,233 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { readdirSync, realpathSync, statSync } from 'node:fs';
+import { basename, resolve, sep } from 'node:path';
+import { createDirectory, deleteFile, listDirectory, renameFile, writeFile } from '../files.js';
+import { SPACE_DIRNAME, SPACE_LAYOUT } from '../space-layout.js';
+import { readFileContent } from '../websocket/file-utils.js';
+import { notifyFileChangedAbsolute } from './file-change-notify.js';
+import { FILES_APP_MAX_WRITE_BYTES, filesDeleteHandler, filesListHandler, filesMkdirHandler, filesReadEntryHandler, filesReadHandler, filesRenameHandler, filesWriteHandler, } from './files-app.js';
+import { SdkMethodError } from './registry.js';
+import { resolveWithinRoot } from './sandbox.js';
+export const WORKSPACE_PATH_PREFIX = 'workspace:';
+function paramsObject(params) {
+    return typeof params === 'object' && params !== null && !Array.isArray(params)
+        ? params
+        : {};
+}
+export function parseWorkspacePath(params) {
+    const raw = paramsObject(params);
+    if (typeof raw.path !== 'string' || !raw.path.startsWith(WORKSPACE_PATH_PREFIX))
+        return null;
+    return {
+        original: raw.path,
+        rel: raw.path.slice(WORKSPACE_PATH_PREFIX.length).replace(/^\/+/, ''),
+    };
+}
+export function resolveFilesReadScopes(params) {
+    return parseWorkspacePath(params) === null ? ['files:app'] : ['files:workspace:read'];
+}
+export function resolveFilesWriteScopes(params) {
+    return parseWorkspacePath(params) === null ? ['files:app'] : ['files:workspace:write'];
+}
+function entryKey(name) {
+    const colon = name.indexOf(':');
+    return (colon === -1 ? name : name.slice(0, colon)).replace(/[. ]+$/, '').toLowerCase();
+}
+const SPACE_DIR = entryKey(SPACE_DIRNAME);
+const APP_AREA_ENTRIES = new Set([SPACE_LAYOUT.apps, SPACE_LAYOUT.appsRoster].map(entryKey));
+const APP_AREA_DENIED = "Access denied: a Space's app area ('.minionry/apps', '.minionry/apps.json') is excluded from workspace file access — an app reaches its own sandbox via app-relative paths (files:app), never via workspace paths, and a Space's apps change only through that Space";
+function inSpaceAppArea(segments) {
+    for (let index = 0; index + 1 < segments.length; index++) {
+        if (entryKey(segments[index]) === SPACE_DIR && APP_AREA_ENTRIES.has(entryKey(segments[index + 1]))) {
+            return true;
+        }
+    }
+    return false;
+}
+export function guardWorkspacePath(workingDir, rel) {
+    let realWorkingDir;
+    try {
+        realWorkingDir = realpathSync(resolve(workingDir));
+    }
+    catch (error) {
+        throw new SdkMethodError('INTERNAL', `Space working directory unavailable: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const guarded = resolveWithinRoot(realWorkingDir, rel);
+    if (!guarded.valid) {
+        throw new SdkMethodError('SCOPE_DENIED', 'Access denied: path escapes the Space workspace');
+    }
+    const below = guarded.resolvedPath.slice(realWorkingDir.length).split(sep).filter(Boolean);
+    if (inSpaceAppArea(below))
+        throw new SdkMethodError('SCOPE_DENIED', APP_AREA_DENIED);
+    return { realWorkingDir, resolvedPath: guarded.resolvedPath };
+}
+export const MAX_APP_AREA_SEARCH_DIRS = 50_000;
+export function containsSpaceAppArea(dir, limit = MAX_APP_AREA_SEARCH_DIRS) {
+    const pending = [dir];
+    let visited = 0;
+    while (pending.length > 0) {
+        const current = pending.pop();
+        visited += 1;
+        if (visited > limit) {
+            throw new SdkMethodError('SCOPE_DENIED', `Access denied: this directory is too large to verify that it holds no Space's app area (more than ${limit} directories)`);
+        }
+        let entries;
+        try {
+            entries = readdirSync(current, { withFileTypes: true });
+        }
+        catch {
+            throw new SdkMethodError('SCOPE_DENIED', "Access denied: part of this directory cannot be read, so it cannot be verified to hold no Space's app area");
+        }
+        const isSpaceDir = entryKey(basename(current)) === SPACE_DIR;
+        for (const entry of entries) {
+            if (isSpaceDir && APP_AREA_ENTRIES.has(entryKey(entry.name)))
+                return true;
+            if (entry.isDirectory())
+                pending.push(`${current}${sep}${entry.name}`);
+        }
+    }
+    return false;
+}
+function refuseAppAreaTree(resolvedPath) {
+    if (statOrUndefined(resolvedPath)?.isDirectory() && containsSpaceAppArea(resolvedPath)) {
+        throw new SdkMethodError('SCOPE_DENIED', APP_AREA_DENIED);
+    }
+}
+function statOrUndefined(resolved) {
+    try {
+        return statSync(resolved);
+    }
+    catch {
+        return undefined;
+    }
+}
+function notFound(original) {
+    return new SdkMethodError('BAD_REQUEST', `'${original}' not found in the Space workspace`);
+}
+function serviceError(error) {
+    const message = error ?? 'file operation failed';
+    return /denied|dangerous|invalid path/i.test(message)
+        ? new SdkMethodError('SCOPE_DENIED', message)
+        : new SdkMethodError('BAD_REQUEST', message);
+}
+export function filesReadRoutedHandler(args) {
+    const target = parseWorkspacePath(args.params);
+    if (target === null)
+        return filesReadHandler(args);
+    const { realWorkingDir, resolvedPath } = guardWorkspacePath(args.workingDir, target.rel);
+    const stat = statOrUndefined(resolvedPath);
+    if (!stat)
+        throw notFound(target.original);
+    if (stat.isDirectory()) {
+        throw new SdkMethodError('BAD_REQUEST', `'${target.original}' is a directory — files.read reads files (use files.list)`);
+    }
+    const result = readFileContent(resolvedPath, realWorkingDir);
+    if (result.error)
+        throw serviceError(result.error);
+    return result.content;
+}
+export function filesWriteRoutedHandler(args) {
+    const target = parseWorkspacePath(args.params);
+    if (target === null)
+        return filesWriteHandler(args);
+    const raw = paramsObject(args.params);
+    if (typeof raw.content !== 'string') {
+        throw new SdkMethodError('BAD_REQUEST', `${args.method} requires params { path, content } with string content`);
+    }
+    const bytes = Buffer.byteLength(raw.content, 'utf-8');
+    if (bytes > FILES_APP_MAX_WRITE_BYTES) {
+        throw new SdkMethodError('BAD_REQUEST', `content is ${bytes} bytes — exceeds the ${FILES_APP_MAX_WRITE_BYTES}-byte per-file files.write cap`);
+    }
+    const { realWorkingDir, resolvedPath } = guardWorkspacePath(args.workingDir, target.rel);
+    const result = writeFile(resolvedPath, raw.content, realWorkingDir);
+    if (!result.success)
+        throw serviceError(result.error);
+    notifyFileChangedAbsolute(args.spaceKey, resolvedPath, 'changed');
+    return null;
+}
+export function filesListRoutedHandler(args) {
+    const target = parseWorkspacePath(args.params);
+    if (target === null)
+        return filesListHandler(args);
+    const { realWorkingDir, resolvedPath } = guardWorkspacePath(args.workingDir, target.rel);
+    const stat = statOrUndefined(resolvedPath);
+    if (!stat)
+        throw notFound(target.original);
+    if (!stat.isDirectory()) {
+        throw new SdkMethodError('BAD_REQUEST', `'${target.original}' is not a directory — files.list lists directories`);
+    }
+    const result = listDirectory(resolvedPath, realWorkingDir, false);
+    if (!result.success || !result.entries)
+        throw serviceError(result.error);
+    return result.entries.map((entry) => ({
+        name: entry.name,
+        dir: entry.type === 'directory',
+        kind: entry.type,
+        size: entry.size,
+        modifiedAt: entry.modifiedAt,
+    }));
+}
+export function filesReadEntryRoutedHandler(args) {
+    const target = parseWorkspacePath(args.params);
+    if (target === null)
+        return filesReadEntryHandler(args);
+    const { realWorkingDir, resolvedPath } = guardWorkspacePath(args.workingDir, target.rel);
+    const stat = statOrUndefined(resolvedPath);
+    if (!stat)
+        throw notFound(target.original);
+    if (stat.isDirectory()) {
+        throw new SdkMethodError('BAD_REQUEST', `'${target.original}' is a directory — files.readEntry reads files (use files.list)`);
+    }
+    const result = readFileContent(resolvedPath, realWorkingDir);
+    if (result.error)
+        throw serviceError(result.error);
+    return result.isImage
+        ? { kind: 'binary', content: result.content, mimeType: result.mimeType ?? 'application/octet-stream' }
+        : { kind: 'text', content: result.content };
+}
+export function filesMkdirRoutedHandler(args) {
+    const target = parseWorkspacePath(args.params);
+    if (target === null)
+        return filesMkdirHandler(args);
+    const { realWorkingDir, resolvedPath } = guardWorkspacePath(args.workingDir, target.rel);
+    const result = createDirectory(resolvedPath, realWorkingDir);
+    if (!result.success)
+        throw serviceError(result.error);
+    return null;
+}
+export function filesRenameRoutedHandler(args) {
+    const raw = paramsObject(args.params);
+    const source = typeof raw.path === 'string' ? parseWorkspacePath({ path: raw.path }) : null;
+    const dest = typeof raw.newPath === 'string' ? parseWorkspacePath({ path: raw.newPath }) : null;
+    if (source === null && dest === null)
+        return filesRenameHandler(args);
+    if (source === null || dest === null) {
+        throw new SdkMethodError('BAD_REQUEST', 'files.rename: path and newPath must share the same rooting — both workspace: paths or both app-rooted paths');
+    }
+    const { realWorkingDir, resolvedPath: resolvedOld } = guardWorkspacePath(args.workingDir, source.rel);
+    const { resolvedPath: resolvedNew } = guardWorkspacePath(args.workingDir, dest.rel);
+    refuseAppAreaTree(resolvedOld);
+    if (entryKey(basename(resolvedNew)) === SPACE_DIR && statOrUndefined(resolvedOld)?.isDirectory()) {
+        const carried = readdirSync(resolvedOld).some((name) => APP_AREA_ENTRIES.has(entryKey(name)));
+        if (carried)
+            throw new SdkMethodError('SCOPE_DENIED', APP_AREA_DENIED);
+    }
+    const result = renameFile(resolvedOld, resolvedNew, realWorkingDir);
+    if (!result.success)
+        throw serviceError(result.error);
+    return null;
+}
+export function filesDeleteRoutedHandler(args) {
+    const target = parseWorkspacePath(args.params);
+    if (target === null)
+        return filesDeleteHandler(args);
+    const { realWorkingDir, resolvedPath } = guardWorkspacePath(args.workingDir, target.rel);
+    if (!statOrUndefined(resolvedPath))
+        throw notFound(target.original);
+    refuseAppAreaTree(resolvedPath);
+    const result = deleteFile(resolvedPath, realWorkingDir);
+    if (!result.success)
+        throw serviceError(result.error);
+    return null;
+}