From d95839a9071543613f6fae2e836b68d1021c5cdf Mon Sep 17 00:00:00 2001 From: QQ Date: Sat, 14 Nov 2026 14:56:56 +0800 Subject: [PATCH] Import packages/plugin/src/remote-file-content-provider.ts --- .../src/remote-file-content-provider.ts | 163 ++++++++++++++++++ 1 file changed, 163 insertions(+) create mode 100644 packages/plugin/src/remote-file-content-provider.ts diff --git a/packages/plugin/src/remote-file-content-provider.ts b/packages/plugin/src/remote-file-content-provider.ts new file mode 100644 index 0000000..dde5166 --- /dev/null +++ b/packages/plugin/src/remote-file-content-provider.ts @@ -0,0 +1,163 @@ +import { REMOTE_FILE_CHUNK_BYTES } from './file-viewer-contract.js' + +export interface RemoteFileContentMeta { + name: string + size: number + mime?: string + mtimeMs?: number + isDirectory?: boolean +} + +export interface RemoteFileContentEntry extends RemoteFileContentMeta { + locator: string +} + +export interface RemoteFileReadRequest { + offset: number + length: number + signal: AbortSignal +} + +export interface RemoteFileContentProvider { + id: string + priority: number + supports(locator: string): boolean + stat(locator: string, signal: AbortSignal): Promise + read(locator: string, request: RemoteFileReadRequest): Promise + list(locator: string, signal: AbortSignal): Promise + openExternal?: (locator: string, signal: AbortSignal) => Promise + saveAsAllowed?: (locator: string) => boolean | { allowed: boolean; maxBytes?: number } +} + +export type RemoteFileControlCall = ( + endpoint: 'fileviewer.stat' | 'fileviewer.readRange' | 'fileviewer.list', + payload: Record, + signal?: AbortSignal, +) => Promise + +export interface RemoteFileViewerStatus { + mode: 'local' | 'remote' + transport?: 'LAN' | 'P2P' | 'TURN' | 'Relay' | 'Disconnected' + remoteFeatures?: { fileViewer: boolean } +} + +/** Fail closed for legacy/unknown Hosts that predate remote file-viewer support. */ +export function shouldUseRemoteFileViewer(status: RemoteFileViewerStatus): boolean { + return status.mode === 'remote' && status.remoteFeatures?.fileViewer === true +} + +export const REMOTE_FILE_SAVE_AS_MAX_BYTES = 100 * 1024 * 1024 +export const REMOTE_FILE_FAST_SAVE_AS_MAX_BYTES = 1024 * 1024 * 1024 + +export function shouldAllowRemoteFileSaveAs(status: RemoteFileViewerStatus): boolean { + return shouldUseRemoteFileViewer(status) && (status.transport === 'LAN' || status.transport === 'P2P' || status.transport === 'TURN') +} + +export function remoteFileSaveAsMaxBytes(status: RemoteFileViewerStatus): number { + return status.transport === 'LAN' || status.transport === 'P2P' + ? REMOTE_FILE_FAST_SAVE_AS_MAX_BYTES + : REMOTE_FILE_SAVE_AS_MAX_BYTES +} + +interface RemoteStatWire { + path: string + name: string + ext: string + mime: string + size: number + mtimeMs?: number + isDirectory: boolean + exists: boolean +} + +interface RemoteRangeWire { + data: string + offset: number + size: number + eof: boolean +} + +interface RemoteListWire { + path: string + entries: Array<{ + name: string + path: string + isDirectory: boolean + size?: number + mtimeMs?: number + }> +} + +/** Browser-side provider registered into dsh-file-viewer's `fileViewer` service. */ +export function createRemoteFileContentProvider(call: RemoteFileControlCall, options: { saveAsAllowed?: boolean | (() => boolean); saveAsMaxBytes?: number | (() => number) } = {}): RemoteFileContentProvider { + return { + id: 'dsh-remote-files', + priority: 10_000, + supports: () => true, + saveAsAllowed: () => ({ + allowed: currentSaveAsAllowed(options.saveAsAllowed), + maxBytes: currentSaveAsMaxBytes(options.saveAsMaxBytes), + }), + async stat(locator, signal) { + const value = await call('fileviewer.stat', { path: locator }, signal) + if (!value.exists) return undefined + return { + name: value.name, + size: value.isDirectory ? 0 : value.size, + mime: value.mime, + mtimeMs: value.mtimeMs, + isDirectory: value.isDirectory, + } + }, + async read(locator, request) { + if (!Number.isInteger(request.offset) || request.offset < 0) throw new Error('A non-negative integer offset is required.') + if (!Number.isInteger(request.length) || request.length <= 0) throw new Error('A positive integer length is required.') + const chunks: Uint8Array[] = [] + let received = 0 + while (received < request.length) { + request.signal.throwIfAborted() + const length = Math.min(REMOTE_FILE_CHUNK_BYTES, request.length - received) + const offset = request.offset + received + const range = await call('fileviewer.readRange', { path: locator, offset, length }, request.signal) + if (range.offset !== offset) throw new Error('The Remote Host returned a mismatched file range.') + const bytes = decodeBase64(range.data) + if (bytes.byteLength > length) throw new Error('The Remote Host returned more file bytes than requested.') + chunks.push(bytes) + received += bytes.byteLength + if (range.eof || bytes.byteLength === 0) break + } + const merged = new Uint8Array(received) + let cursor = 0 + for (const chunk of chunks) { + merged.set(chunk, cursor) + cursor += chunk.byteLength + } + return merged + }, + async list(locator, signal) { + const value = await call('fileviewer.list', { path: locator }, signal) + return value.entries.map(entry => ({ + locator: entry.path, + name: entry.name, + size: entry.isDirectory ? 0 : (entry.size ?? 0), + mtimeMs: entry.mtimeMs, + isDirectory: entry.isDirectory, + })) + }, + } +} + +function currentSaveAsAllowed(value: boolean | (() => boolean) | undefined): boolean { + return typeof value === 'function' ? value() : value === true +} + +function currentSaveAsMaxBytes(value: number | (() => number) | undefined): number { + return typeof value === 'function' ? value() : value ?? REMOTE_FILE_SAVE_AS_MAX_BYTES +} + +function decodeBase64(value: string): Uint8Array { + const binary = atob(value) + const bytes = new Uint8Array(binary.length) + for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index) + return bytes +}