@minionry/minion 0.7.36

package/dist/server/services/websocket/file-share-handlers.js

@@ -0,0 +1,328 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { containsDangerousPatterns, validatePathWithinWorkingDir } from '../pathUtils.js';
+import { FileDownloadHandler } from './file-download-handler.js';
+import { readValidatedFile } from './file-utils.js';
+import { FileShareMessages } from './types.js';
+const registry = new Map();
+let shareDownloads = null;
+const FILE_SHARE_REQUEST_TYPES = new Set(FileShareMessages);
+export function isFileShareRequestType(type) {
+    return FILE_SHARE_REQUEST_TYPES.has(type);
+}
+function readDescriptor(raw) {
+    if (typeof raw !== 'object' || raw === null)
+        return null;
+    const row = raw;
+    if (typeof row.code !== 'string' || row.code.length === 0)
+        return null;
+    if (typeof row.rootPath !== 'string')
+        return null;
+    if (row.scope !== 'file' && row.scope !== 'directory')
+        return null;
+    return {
+        shareId: typeof row.shareId === 'string' ? row.shareId : '',
+        code: row.code,
+        rootPath: row.rootPath,
+        scope: row.scope,
+        expiresAt: typeof row.expiresAt === 'string' ? row.expiresAt : null,
+    };
+}
+function acceptsDescriptor(descriptor, workingDir) {
+    const root = validatePathWithinWorkingDir(descriptor.rootPath, workingDir);
+    if (root.valid)
+        return true;
+    console.error(`[FileShare] SECURITY: Refusing a share whose root resolves outside the workspace. ` +
+        `Code: "${descriptor.code}", RootPath: "${descriptor.rootPath}"`);
+    return false;
+}
+export function replaceFileShareRegistry(raw, workingDir) {
+    registry.clear();
+    if (!Array.isArray(raw))
+        return;
+    for (const entry of raw) {
+        const descriptor = readDescriptor(entry);
+        if (!descriptor)
+            continue;
+        if (!acceptsDescriptor(descriptor, workingDir))
+            continue;
+        registry.set(descriptor.code, descriptor);
+    }
+}
+export function applyFileShareSync(message, workingDir) {
+    const op = message.op;
+    const descriptor = readDescriptor(message.share);
+    if (!descriptor)
+        return;
+    if (op === 'remove') {
+        registry.delete(descriptor.code);
+        return;
+    }
+    if (op !== 'upsert')
+        return;
+    if (!acceptsDescriptor(descriptor, workingDir))
+        return;
+    registry.set(descriptor.code, descriptor);
+}
+export function lookupFileShare(code) {
+    return registry.get(code);
+}
+export function clearFileShareRegistry() {
+    registry.clear();
+    shareDownloads?.destroy();
+    shareDownloads = null;
+}
+function readClassStamps(msg) {
+    if (msg._role !== undefined)
+        return null;
+    const share = msg._share;
+    const viewer = msg._viewer;
+    if (typeof share !== 'string' || share.length === 0)
+        return null;
+    if (typeof viewer !== 'string' || viewer.length === 0)
+        return null;
+    return { share, viewer };
+}
+function resolveDescriptor(code) {
+    const descriptor = registry.get(code);
+    if (!descriptor) {
+        return { code: 'share_unknown', message: 'This share link is no longer available.' };
+    }
+    if (descriptor.expiresAt) {
+        const expiry = Date.parse(descriptor.expiresAt);
+        if (Number.isFinite(expiry) && expiry <= Date.now()) {
+            return { code: 'share_expired', message: 'This share link has expired.' };
+        }
+    }
+    return descriptor;
+}
+function isError(value) {
+    return typeof value === 'object' && value !== null && 'code' in value && 'message' in value;
+}
+function resolveShareRoot(descriptor, workingDir) {
+    const root = validatePathWithinWorkingDir(descriptor.rootPath, workingDir);
+    if (!root.valid) {
+        console.error(`[FileShare] SECURITY: Share root no longer resolves inside the workspace. Code: "${descriptor.code}"`);
+        return { code: 'share_invalid', message: 'This share is no longer available.' };
+    }
+    if (!existsSync(root.resolvedPath)) {
+        return { code: 'not_found', message: 'The shared file or folder no longer exists.' };
+    }
+    return root.resolvedPath;
+}
+function resolveTarget(descriptor, shareRoot, requestPath) {
+    if (requestPath.includes('\0') || containsDangerousPatterns(requestPath)) {
+        console.error(`[FileShare] SECURITY: Dangerous pattern in a share path. Code: "${descriptor.code}"`);
+        return { code: 'outside_share', message: 'That path is not part of this share.' };
+    }
+    if (descriptor.scope === 'file') {
+        if (requestPath !== '') {
+            return { code: 'wrong_scope', message: 'This link shares a single file.' };
+        }
+        return shareRoot;
+    }
+    const target = validatePathWithinWorkingDir(requestPath, shareRoot);
+    if (!target.valid) {
+        console.error(`[FileShare] SECURITY: Read refused outside the share root. Code: "${descriptor.code}"`);
+        return { code: 'outside_share', message: 'That path is not part of this share.' };
+    }
+    return target.resolvedPath;
+}
+function resolveRead(msg, workingDir) {
+    const stamps = readClassStamps(msg);
+    if (!stamps)
+        return null;
+    const descriptor = resolveDescriptor(stamps.share);
+    if (isError(descriptor))
+        return descriptor;
+    const shareRoot = resolveShareRoot(descriptor, workingDir);
+    if (isError(shareRoot))
+        return shareRoot;
+    const requestPath = typeof msg.data?.path === 'string' ? msg.data.path : '';
+    const target = resolveTarget(descriptor, shareRoot, requestPath);
+    if (isError(target))
+        return target;
+    return { descriptor, target, requestPath, viewer: stamps.viewer };
+}
+function reply(ctx, ws, viewer, response) {
+    ctx.send(ws, { ...response, _target: viewer });
+}
+function sendListing(ctx, ws, read, entries) {
+    reply(ctx, ws, read.viewer, {
+        type: 'fileShareDirectoryListing',
+        data: { path: read.requestPath, entries },
+    });
+}
+function sendRefusal(ctx, ws, viewer, type, data, error) {
+    reply(ctx, ws, viewer, { type, data: { ...data, error } });
+}
+function readShareDirectory(dir) {
+    return readdirSync(dir, { withFileTypes: true })
+        .filter((entry) => !entry.name.startsWith('.'))
+        .map((entry) => {
+        if (entry.isSymbolicLink())
+            return { name: entry.name, type: 'symlink' };
+        const type = entry.isDirectory() ? 'directory' : 'file';
+        try {
+            const stats = statSync(join(dir, entry.name));
+            return { name: entry.name, type, size: type === 'file' ? stats.size : undefined, modifiedAt: stats.mtime.toISOString() };
+        }
+        catch {
+            return { name: entry.name, type };
+        }
+    })
+        .sort((a, b) => {
+        if (a.type === 'directory' && b.type !== 'directory')
+            return -1;
+        if (a.type !== 'directory' && b.type === 'directory')
+            return 1;
+        return a.name.localeCompare(b.name);
+    });
+}
+function handleListDirectory(ctx, ws, read) {
+    const refuse = (error) => sendRefusal(ctx, ws, read.viewer, 'fileShareDirectoryListing', { path: read.requestPath, entries: [] }, error);
+    if (read.descriptor.scope === 'file') {
+        refuse({ code: 'wrong_scope', message: 'This link shares a single file.' });
+        return;
+    }
+    let stats;
+    try {
+        stats = statSync(read.target);
+    }
+    catch {
+        refuse({ code: 'not_found', message: 'That folder is not in this share any more.' });
+        return;
+    }
+    if (!stats.isDirectory()) {
+        refuse({ code: 'wrong_scope', message: 'That path is a file, not a folder.' });
+        return;
+    }
+    try {
+        sendListing(ctx, ws, read, readShareDirectory(read.target));
+    }
+    catch {
+        refuse({ code: 'not_found', message: 'That folder could not be read.' });
+    }
+}
+function handleReadFile(ctx, ws, read) {
+    const fileName = basename(read.target);
+    const refuse = (error) => sendRefusal(ctx, ws, read.viewer, 'fileShareFileContent', { path: read.requestPath, fileName: '', content: '' }, error);
+    let stats;
+    try {
+        stats = statSync(read.target);
+    }
+    catch {
+        refuse({ code: 'not_found', message: 'That file is not in this share any more.' });
+        return;
+    }
+    if (stats.isDirectory()) {
+        refuse({ code: 'wrong_scope', message: 'That path is a folder, not a file.' });
+        return;
+    }
+    const result = readValidatedFile(read.target, read.requestPath, fileName, stats);
+    if (result.error) {
+        refuse({ code: 'too_large', message: result.error });
+        return;
+    }
+    reply(ctx, ws, read.viewer, {
+        type: 'fileShareFileContent',
+        data: {
+            path: read.requestPath,
+            fileName: result.fileName,
+            content: result.content,
+            size: result.size,
+            modifiedAt: result.modifiedAt,
+            ...(result.isImage ? { isImage: true, mimeType: result.mimeType } : {}),
+        },
+    });
+}
+function handleDownloadStart(ctx, ws, read, downloadId, workingDir) {
+    const refuse = (error) => sendRefusal(ctx, ws, read.viewer, 'fileShareDownloadError', { downloadId }, error);
+    let stats;
+    try {
+        stats = statSync(read.target);
+    }
+    catch {
+        refuse({ code: 'not_found', message: 'That file is not in this share any more.' });
+        return;
+    }
+    if (stats.isDirectory()) {
+        refuse({ code: 'wrong_scope', message: 'Folders cannot be downloaded from a share link.' });
+        return;
+    }
+    if (!shareDownloads)
+        shareDownloads = new FileDownloadHandler(workingDir);
+    shareDownloads.startResolvedDownload(ws, (target, response) => ctx.send(target, { ...response, _target: read.viewer }), { downloadId, path: read.requestPath, resolvedPath: read.target, stats }, FILE_SHARE_DOWNLOAD_TYPES, (message) => refuse({ code: 'too_large', message }), read.viewer);
+}
+const FILE_SHARE_DOWNLOAD_TYPES = {
+    ready: 'fileShareDownloadReady',
+    chunk: 'fileShareDownloadChunk',
+    complete: 'fileShareDownloadComplete',
+};
+function refuse(ctx, ws, viewer, operation, message) {
+    if (!viewer)
+        return;
+    reply(ctx, ws, viewer, {
+        type: 'fileShareError',
+        data: { operation, error: { code: 'share_invalid', message } },
+    });
+}
+function refuseRead(ctx, ws, viewer, msg, error) {
+    const path = typeof msg.data?.path === 'string' ? msg.data.path : '';
+    if (msg.type === 'fileShareDownloadStart') {
+        sendRefusal(ctx, ws, viewer, 'fileShareDownloadError', { downloadId: msg.data?.downloadId ?? '' }, error);
+        return;
+    }
+    if (msg.type === 'fileShareListDirectory') {
+        sendRefusal(ctx, ws, viewer, 'fileShareDirectoryListing', { path, entries: [] }, error);
+        return;
+    }
+    sendRefusal(ctx, ws, viewer, 'fileShareFileContent', { path, fileName: '', content: '' }, error);
+}
+function handleDownloadCancel(msg) {
+    const stamps = readClassStamps(msg);
+    if (!stamps)
+        return;
+    if (typeof msg.data?.downloadId !== 'string')
+        return;
+    shareDownloads?.cancelDownload(msg.data.downloadId, stamps.viewer);
+}
+function dispatchRead(ctx, ws, msg, read, workingDir) {
+    switch (msg.type) {
+        case 'fileShareListDirectory':
+            handleListDirectory(ctx, ws, read);
+            return;
+        case 'fileShareReadFile':
+            handleReadFile(ctx, ws, read);
+            return;
+        case 'fileShareDownloadStart':
+            if (typeof msg.data?.downloadId === 'string' && msg.data.downloadId.length > 0) {
+                handleDownloadStart(ctx, ws, read, msg.data.downloadId, workingDir);
+            }
+    }
+}
+export function handleFileShareMessage(ctx, ws, msg, workingDir) {
+    const viewer = typeof msg._viewer === 'string' ? msg._viewer : '';
+    if (!isFileShareRequestType(msg.type)) {
+        console.error(`[FileShare] SECURITY: Refusing "${msg.type}" from a file-share connection — read-only vocabulary only`);
+        refuse(ctx, ws, viewer, msg.type, 'This link is read-only and limited to the shared files.');
+        return;
+    }
+    if (msg.type === 'fileShareDownloadCancel') {
+        handleDownloadCancel(msg);
+        return;
+    }
+    const read = resolveRead(msg, workingDir);
+    if (read === null) {
+        console.error(`[FileShare] SECURITY: Refusing a ${msg.type} frame without a consistent file-share class stamp`);
+        refuse(ctx, ws, viewer, msg.type, 'This request is not valid for a share link.');
+        return;
+    }
+    if (isError(read)) {
+        refuseRead(ctx, ws, viewer, msg, read);
+        return;
+    }
+    dispatchRead(ctx, ws, msg, read, workingDir);
+}

package/dist/server/services/websocket/file-transfer-http.js

@@ -0,0 +1,361 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { randomBytes } from 'node:crypto';
+import { createReadStream, createWriteStream, existsSync, renameSync, rmSync, statSync } from 'node:fs';
+import { basename, dirname, join, resolve, sep } from 'node:path';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { can, normalizeStoredRole } from '@minionry/roles';
+import { buildDirectoryZipBuffer } from '../file-transfer-zip.js';
+import { getMaxUploadBytes, uploadTooLargeMessage } from '../settings.js';
+import { resolveFileTreeTarget } from './file-upload-handler.js';
+import { isPathInSafeLocation } from './file-utils.js';
+export const FILE_TRANSFER_CAPABILITY = 1;
+class UploadTooLargeError extends Error {
+}
+const MAX_CONCURRENT_TRANSFERS = 8;
+const MIME_TYPES = {
+    png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg', gif: 'image/gif',
+    webp: 'image/webp', bmp: 'image/bmp', tiff: 'image/tiff', ico: 'image/x-icon',
+    svg: 'image/svg+xml', avif: 'image/avif',
+    pdf: 'application/pdf',
+    mp4: 'video/mp4', m4v: 'video/mp4', webm: 'video/webm', mov: 'video/quicktime', mkv: 'video/x-matroska',
+    mp3: 'audio/mpeg', wav: 'audio/wav', ogg: 'audio/ogg', oga: 'audio/ogg', m4a: 'audio/mp4', flac: 'audio/flac',
+    zip: 'application/zip', gz: 'application/gzip', txt: 'text/plain', log: 'text/plain',
+    json: 'application/json', csv: 'text/csv',
+};
+export function transferMimeType(filePath) {
+    const ext = filePath.toLowerCase().split('.').pop() || '';
+    return MIME_TYPES[ext] || 'application/octet-stream';
+}
+export function parseRange(header, size) {
+    if (!header)
+        return null;
+    const match = /^bytes=(\d*)-(\d*)$/.exec(header.trim());
+    if (!match)
+        return null;
+    const [, rawStart, rawEnd] = match;
+    if (rawStart === '' && rawEnd === '')
+        return null;
+    if (rawStart === '') {
+        const suffix = Number.parseInt(rawEnd, 10);
+        if (suffix === 0 || size === 0)
+            return 'unsatisfiable';
+        const start = Math.max(0, size - suffix);
+        return { start, end: size - 1 };
+    }
+    const start = Number.parseInt(rawStart, 10);
+    if (start >= size)
+        return 'unsatisfiable';
+    const end = rawEnd === '' ? size - 1 : Math.min(Number.parseInt(rawEnd, 10), size - 1);
+    if (end < start)
+        return 'unsatisfiable';
+    return { start, end };
+}
+function parseRequestData(message) {
+    const data = message.data;
+    if (!data)
+        return null;
+    const { transferId, token, dataPath, mode, path } = data;
+    if (typeof transferId !== 'string' || typeof token !== 'string' || typeof dataPath !== 'string')
+        return null;
+    if (mode !== 'download' && mode !== 'preview' && mode !== 'upload')
+        return null;
+    if (typeof path !== 'string')
+        return null;
+    if (!dataPath.startsWith('/transfer/agent/'))
+        return null;
+    return {
+        transferId,
+        token,
+        dataPath,
+        mode,
+        path,
+        tabId: typeof data.tabId === 'string' ? data.tabId : undefined,
+        role: typeof data.role === 'string' ? data.role : undefined,
+        range: typeof data.range === 'string' ? data.range : undefined,
+        size: typeof data.size === 'number' ? data.size : undefined,
+        overwrite: data.overwrite === true,
+    };
+}
+export class FileTransferAgent {
+    deps;
+    active = 0;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    handleRequest(message) {
+        const data = parseRequestData(message);
+        if (!data) {
+            console.warn('[FileTransfer] Dropping malformed fileTransferRequest');
+            return Promise.resolve();
+        }
+        return this.run(data).catch((err) => {
+            console.error(`[FileTransfer] Transfer ${data.transferId} failed:`, err);
+        });
+    }
+    async run(data) {
+        if (this.active >= MAX_CONCURRENT_TRANSFERS) {
+            await this.refuseBusy(data);
+            return;
+        }
+        this.active++;
+        try {
+            if (data.mode === 'upload') {
+                await this.runUpload(data);
+            }
+            else {
+                await this.runDownload(data);
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            try {
+                if (data.mode === 'upload') {
+                    await this.postResult(data, { ok: false, error: message, code: 'stream_failed' });
+                }
+                else {
+                    await this.pushError(data, 500, message);
+                }
+            }
+            catch {
+            }
+            throw err;
+        }
+        finally {
+            this.active--;
+        }
+    }
+    dataUrl(data, suffix = '') {
+        return new URL(data.dataPath + suffix, this.deps.platformUrl).toString();
+    }
+    fetch() {
+        return this.deps.fetchImpl ?? fetch;
+    }
+    async refuseBusy(data) {
+        if (data.mode === 'upload') {
+            await this.claimUploadLeg(data);
+            await this.postResult(data, { ok: false, error: 'Too many concurrent transfers — try again shortly', code: 'busy' });
+        }
+        else {
+            await this.pushError(data, 429, 'Too many concurrent transfers — try again shortly');
+        }
+    }
+    resolveReadTarget(data) {
+        const effectiveDir = this.deps.resolveEffectiveDir(data.tabId);
+        const fullPath = data.path.startsWith('/') ? data.path : resolve(effectiveDir, data.path);
+        const normalized = resolve(fullPath);
+        const normalizedDir = resolve(effectiveDir);
+        const withinDir = normalized === normalizedDir || normalized.startsWith(normalizedDir + sep);
+        if (!withinDir && !isPathInSafeLocation(normalized)) {
+            return { kind: 'error', status: 403, message: 'Access denied: path outside allowed locations' };
+        }
+        if (!existsSync(normalized)) {
+            return { kind: 'error', status: 404, message: 'File not found' };
+        }
+        const stats = statSync(normalized);
+        if (stats.isDirectory()) {
+            if (data.mode === 'preview') {
+                return { kind: 'error', status: 400, message: 'Directories have no preview' };
+            }
+            try {
+                const buffer = buildDirectoryZipBuffer(normalized, { gitignoreRoot: this.deps.workingDir });
+                return { kind: 'zip', buffer, fileName: `${basename(normalized) || 'project'}.zip` };
+            }
+            catch (err) {
+                return { kind: 'error', status: 413, message: err instanceof Error ? err.message : String(err) };
+            }
+        }
+        return {
+            kind: 'file',
+            fullPath: normalized,
+            size: stats.size,
+            fileName: basename(normalized),
+            mime: transferMimeType(normalized),
+        };
+    }
+    async runDownload(data) {
+        const target = this.resolveReadTarget(data);
+        if (target.kind === 'error') {
+            await this.pushError(data, target.status, target.message);
+            return;
+        }
+        if (target.kind === 'zip') {
+            await this.pushBytes(data, {
+                status: 200,
+                mime: 'application/zip',
+                size: target.buffer.length,
+                fileName: target.fileName,
+                acceptRanges: false,
+                body: new Uint8Array(target.buffer),
+            });
+            return;
+        }
+        const range = parseRange(data.range, target.size);
+        if (range === 'unsatisfiable') {
+            await this.pushError(data, 416, 'Requested range not satisfiable', { 'x-mn-size': String(target.size) });
+            return;
+        }
+        const sliced = range !== null;
+        const start = sliced ? range.start : 0;
+        const end = sliced ? range.end : target.size - 1;
+        const stream = target.size === 0
+            ? Readable.from([])
+            : createReadStream(target.fullPath, { start, end });
+        try {
+            await this.pushBytes(data, {
+                status: sliced ? 206 : 200,
+                mime: target.mime,
+                size: target.size,
+                range: sliced ? `${start}-${end}` : undefined,
+                fileName: target.fileName,
+                acceptRanges: true,
+                body: Readable.toWeb(stream),
+            });
+        }
+        finally {
+            stream.destroy();
+        }
+    }
+    async pushBytes(data, payload) {
+        const headers = {
+            authorization: `Bearer ${data.token}`,
+            'content-type': 'application/octet-stream',
+            'x-mn-status': String(payload.status),
+            'x-mn-mime': payload.mime,
+            'x-mn-size': String(payload.size),
+            'x-mn-name': encodeURIComponent(payload.fileName),
+            'x-mn-accept-ranges': payload.acceptRanges ? '1' : '0',
+        };
+        if (payload.range)
+            headers['x-mn-range'] = payload.range;
+        const isStream = !(payload.body instanceof Uint8Array);
+        const res = await this.fetch()(this.dataUrl(data), {
+            method: 'POST',
+            headers,
+            body: payload.body,
+            ...(isStream ? { duplex: 'half' } : {}),
+        });
+        if (!res.ok) {
+            console.warn(`[FileTransfer] Relay refused data leg for ${data.transferId}: ${res.status}`);
+        }
+        await res.text().catch(() => { });
+    }
+    async pushError(data, status, message, extraHeaders = {}) {
+        const res = await this.fetch()(this.dataUrl(data), {
+            method: 'POST',
+            headers: {
+                authorization: `Bearer ${data.token}`,
+                'x-mn-status': String(status),
+                'x-mn-error': encodeURIComponent(message),
+                ...extraHeaders,
+            },
+        });
+        await res.text().catch(() => { });
+    }
+    async refuseUpload(data, error, code) {
+        await this.claimUploadLeg(data);
+        await this.postResult(data, { ok: false, error, code });
+    }
+    async runUpload(data) {
+        const effectiveDir = this.deps.resolveEffectiveDir(data.tabId);
+        const role = data.role === undefined ? 'owner' : normalizeStoredRole(data.role);
+        const maxUploadBytes = getMaxUploadBytes();
+        if (maxUploadBytes > 0 && data.size !== undefined && data.size > maxUploadBytes) {
+            await this.refuseUpload(data, uploadTooLargeMessage(data.size, maxUploadBytes), 'too_large');
+            return;
+        }
+        const resolved = resolveFileTreeTarget({
+            targetPath: data.path,
+            workingDir: effectiveDir,
+            permission: can(role, 'editFiles') ? undefined : 'view',
+            overwrite: data.overwrite,
+        });
+        if (!resolved.ok) {
+            const code = resolved.error.includes('cannot upload') ? 'denied' : 'invalid_path';
+            await this.refuseUpload(data, resolved.error, code);
+            return;
+        }
+        const tempPath = join(dirname(resolved.filePath), `.${resolved.fileName}.${randomBytes(6).toString('hex')}.mn-part`);
+        const relPath = resolved.targetRelPath ?? resolved.fileName;
+        try {
+            const size = await this.pullUploadBytes(data, resolved.filePath, tempPath);
+            await this.postResult(data, { ok: true, path: relPath, name: resolved.fileName, size });
+            this.deps.broadcast({
+                type: 'fileCreated',
+                data: { path: relPath, name: resolved.fileName, size, modifiedAt: new Date().toISOString() },
+            });
+        }
+        catch (err) {
+            await this.failUpload(data, tempPath, err);
+        }
+    }
+    async failUpload(data, tempPath, err) {
+        try {
+            if (existsSync(tempPath))
+                rmSync(tempPath, { force: true });
+        }
+        catch {   }
+        const message = err instanceof Error ? err.message : String(err);
+        if (err instanceof UploadTooLargeError) {
+            await this.postResult(data, { ok: false, error: message, code: 'too_large' });
+            return;
+        }
+        await this.postResult(data, { ok: false, error: `Upload failed: ${message}`, code: 'stream_failed' });
+    }
+    async pullUploadBytes(data, finalPath, tempPath) {
+        const res = await this.fetch()(this.dataUrl(data), {
+            headers: { authorization: `Bearer ${data.token}` },
+        });
+        if (!res.ok || !res.body) {
+            throw new Error(`Relay refused the upload stream (${res.status})`);
+        }
+        const maxUploadBytes = getMaxUploadBytes();
+        const source = Readable.fromWeb(res.body);
+        if (maxUploadBytes > 0) {
+            let seen = 0;
+            source.on('data', (chunk) => {
+                seen += chunk.length;
+                if (seen > maxUploadBytes) {
+                    source.destroy(new UploadTooLargeError(uploadTooLargeMessage(seen, maxUploadBytes)));
+                }
+            });
+        }
+        await pipeline(source, createWriteStream(tempPath));
+        const declared = Number.parseInt(res.headers.get('x-mn-size') ?? '', 10);
+        const written = statSync(tempPath).size;
+        if (Number.isFinite(declared) && declared >= 0 && written !== declared) {
+            throw new Error(`Upload truncated: received ${written} of ${declared} bytes`);
+        }
+        renameSync(tempPath, finalPath);
+        return written;
+    }
+    async claimUploadLeg(data) {
+        try {
+            const res = await this.fetch()(this.dataUrl(data), {
+                headers: { authorization: `Bearer ${data.token}` },
+            });
+            await res.body?.cancel().catch(() => { });
+        }
+        catch {   }
+    }
+    async postResult(data, result) {
+        try {
+            const res = await this.fetch()(this.dataUrl(data, '/result'), {
+                method: 'POST',
+                headers: {
+                    authorization: `Bearer ${data.token}`,
+                    'content-type': 'application/json',
+                },
+                body: JSON.stringify(result),
+            });
+            await res.text().catch(() => { });
+        }
+        catch (err) {
+            console.warn(`[FileTransfer] Failed to report result for ${data.transferId}:`, err);
+        }
+    }
+}
+export function createFileTransferAgent(deps) {
+    return new FileTransferAgent(deps);
+}