diff --git a/app/lib/features/chat/files/files_controller.dart b/app/lib/features/chat/files/files_controller.dart index 854e1588..c91dffa9 100644 --- a/app/lib/features/chat/files/files_controller.dart +++ b/app/lib/features/chat/files/files_controller.dart @@ -1,7 +1,10 @@ import 'package:flutter/foundation.dart'; import '../../../core/api_gateway.dart'; +import '../../../core/transport/pipelines_client.dart'; import '../data/directory_listing.dart'; +import '../domain/chat_attachment_picker.dart'; import 'files_models.dart'; +import 'files_upload.dart'; class FilesController extends ChangeNotifier { FilesController({required this.gateway, required this.initialPath}); @@ -18,7 +21,17 @@ class FilesController extends ChangeNotifier { int _request = 0; bool _disposed = false; + /// Files still being stored and the size of the batch they belong to. + int uploading = 0; + int uploadTotal = 0; + + /// Why the last upload batch failed, until dismissed or a new batch starts. + String? uploadError; + bool get missingDirectory => initialPath.trim().isEmpty; + String get uploadLabel => uploadTotal <= 1 + ? 'Uploading…' + : 'Uploading ${uploadTotal - uploading + 1} of $uploadTotal…'; List get entries { final current = listing; if (current == null) return const []; @@ -75,6 +88,54 @@ class FilesController extends ChangeNotifier { } Future retry() => open(listing?.path ?? initialPath); + + /// Stores [files] in the shown folder, one request each, then reloads that + /// folder so the new entries appear. Each refusal is kept in [uploadError] + /// in the server's words; the remaining files are still attempted. + Future upload(List files) async { + final directory = listing?.path; + if (files.isEmpty) return; + if (directory == null) { + reportUploadError('Open a folder before uploading files.'); + return; + } + final endpoint = configuredGatewayEndpoint(gateway); + uploadTotal += files.length; + uploading += files.length; + uploadError = null; + _notify(); + final failures = []; + for (final file in files) { + try { + await uploadFileInto(endpoint, directory, file); + } on FilesUploadException catch (error) { + failures.add(error.message); + } finally { + uploading -= 1; + } + if (_disposed) return; + _notify(); + } + if (uploading == 0) uploadTotal = 0; + if (failures.isNotEmpty) uploadError = failures.join('\n'); + _notify(); + // The operator may have moved on while the batch was in flight; only the + // folder that received the files is reloaded. + if (listing?.path == directory) await retry(); + } + + /// Shows a host-side upload failure (no picker, unreadable drop) in the + /// same place as a server refusal. + void reportUploadError(String message) { + uploadError = message; + _notify(); + } + + void dismissUploadError() { + uploadError = null; + _notify(); + } + void toggleHidden(bool value) { showHidden = value; _notify(); diff --git a/app/lib/features/chat/files/files_drop.dart b/app/lib/features/chat/files/files_drop.dart new file mode 100644 index 00000000..6610ebc9 --- /dev/null +++ b/app/lib/features/chat/files/files_drop.dart @@ -0,0 +1,79 @@ +import 'dart:ui' show Offset; + +import '../domain/chat_attachment_picker.dart'; +import 'files_drop_stub.dart' + if (dart.library.js_interop) 'files_drop_web.dart' + as impl; + +/// Stops observing the host's drag events for one drop area. +typedef FilesDropUnsubscribe = void Function(); + +/// Registers [listener] with the host and returns its cancellation. +typedef FilesDropSubscribe = + FilesDropUnsubscribe Function(FilesDropListener listener); + +/// One drop area's view of a host drag that carries files. +/// +/// Positions are logical pixels in the Flutter view's coordinate space, so a +/// listener compares them with its own render box. The host asks [accepts] +/// before it takes over the drag; a drag the area does not accept keeps the +/// host's default behaviour. +class FilesDropListener { + const FilesDropListener({ + required this.accepts, + required this.onHover, + required this.onLeave, + required this.onDrop, + required this.onError, + }); + + /// Whether a drop at [position] would land on this area right now. + final bool Function(Offset position) accepts; + + /// A file drag is over the area at [position]. + final void Function(Offset position) onHover; + + /// The drag left the area, ended or was dropped. + final void Function() onLeave; + + /// Files were dropped on the area, in the host's order. + final void Function(List files) onDrop; + + /// One dropped item whose bytes could not be read (a folder, for example). + final void Function(Object error) onError; +} + +/// The file drag-and-drop seam for one host. +/// +/// The web host observes the browser's own drag events on the document and +/// reads dropped files before reporting them as [ChatPickedFile] rows. A host +/// without file drops constructs [FilesDrop.unsupported] so the panel offers +/// the Upload button alone instead of pretending to listen. Tests inject a +/// fake [subscribe] and drive the listener directly. +class FilesDrop { + const FilesDrop({required FilesDropSubscribe this.subscribe}) + : unsupportedMessage = null; + + const FilesDrop.unsupported(String message) + : subscribe = null, + unsupportedMessage = message; + + /// The host's drag listener registration, or null when unsupported. + final FilesDropSubscribe? subscribe; + + /// Why this host cannot observe file drops, when [subscribe] is null. + final String? unsupportedMessage; + + bool get isSupported => subscribe != null; + + /// Starts observing the host's drag events. A host without the capability + /// throws [UnsupportedError] with [unsupportedMessage]. + FilesDropUnsubscribe listen(FilesDropListener listener) { + final subscribe = this.subscribe; + if (subscribe == null) throw UnsupportedError(unsupportedMessage!); + return subscribe(listener); + } +} + +/// The drop seam for the running host. +FilesDrop get hostFilesDrop => impl.hostFilesDrop; diff --git a/app/lib/features/chat/files/files_drop_area.dart b/app/lib/features/chat/files/files_drop_area.dart new file mode 100644 index 00000000..b63007f6 --- /dev/null +++ b/app/lib/features/chat/files/files_drop_area.dart @@ -0,0 +1,111 @@ +import 'package:flutter/material.dart'; + +import '../domain/chat_attachment_picker.dart'; +import 'files_drop.dart'; + +/// Makes [child] a drop target for host file drags: while a file drag is over +/// it, a highlight names the folder the files would land in, and a drop hands +/// the files to [onFiles]. Nothing is drawn when the host has no drop support +/// or [folderLabel] is null (no folder is open yet). +class FilesDropArea extends StatefulWidget { + const FilesDropArea({ + super.key, + required this.drop, + required this.folderLabel, + required this.onFiles, + required this.onError, + required this.child, + }); + + final FilesDrop drop; + + /// The shown folder's label, or null while there is no folder to drop into. + final String? folderLabel; + final ValueChanged> onFiles; + final ValueChanged onError; + final Widget child; + + @override + State createState() => _FilesDropAreaState(); +} + +class _FilesDropAreaState extends State { + FilesDropUnsubscribe? _unsubscribe; + bool _hovering = false; + + @override + void initState() { + super.initState(); + if (widget.drop.isSupported) { + _unsubscribe = widget.drop.listen( + FilesDropListener( + accepts: _accepts, + onHover: (_) => _setHovering(true), + onLeave: () => _setHovering(false), + onDrop: _dropped, + onError: (error) { + if (mounted) widget.onError(error); + }, + ), + ); + } + } + + @override + void dispose() { + _unsubscribe?.call(); + super.dispose(); + } + + bool _accepts(Offset position) { + if (!mounted || widget.folderLabel == null) return false; + final box = context.findRenderObject(); + if (box is! RenderBox || !box.hasSize) return false; + return box.paintBounds.contains(box.globalToLocal(position)); + } + + void _setHovering(bool value) { + if (!mounted || _hovering == value) return; + setState(() => _hovering = value); + } + + void _dropped(List files) { + _setHovering(false); + if (mounted && files.isNotEmpty) widget.onFiles(files); + } + + @override + Widget build(BuildContext context) { + final scheme = Theme.of(context).colorScheme; + return Stack( + fit: StackFit.passthrough, + children: [ + widget.child, + if (_hovering && widget.folderLabel != null) + Positioned.fill( + child: IgnorePointer( + child: Semantics( + label: 'Drop to upload to ${widget.folderLabel}', + child: DecoratedBox( + decoration: BoxDecoration( + color: scheme.primaryContainer.withValues(alpha: .6), + border: Border.all(color: scheme.primary, width: 2), + ), + child: Center( + child: Padding( + padding: const EdgeInsets.all(24), + child: Text( + 'Drop to upload to ${widget.folderLabel}', + textAlign: TextAlign.center, + style: Theme.of(context).textTheme.titleMedium, + ), + ), + ), + ), + ), + ), + ), + ], + ); + } +} diff --git a/app/lib/features/chat/files/files_drop_stub.dart b/app/lib/features/chat/files/files_drop_stub.dart new file mode 100644 index 00000000..b1cc88db --- /dev/null +++ b/app/lib/features/chat/files/files_drop_stub.dart @@ -0,0 +1,11 @@ +import 'files_drop.dart'; + +/// Native fallback for file drag-and-drop in the Files panel. +/// +/// Only the web host observes drag events in this slice; a native host keeps +/// the Upload button and reports the missing drop capability plainly. +const String filesDropUnsupportedMessage = + 'Dropping files is not supported on this platform yet.'; + +FilesDrop get hostFilesDrop => + const FilesDrop.unsupported(filesDropUnsupportedMessage); diff --git a/app/lib/features/chat/files/files_drop_web.dart b/app/lib/features/chat/files/files_drop_web.dart new file mode 100644 index 00000000..4f9a4e99 --- /dev/null +++ b/app/lib/features/chat/files/files_drop_web.dart @@ -0,0 +1,177 @@ +import 'dart:async'; +import 'dart:js_interop'; +import 'dart:ui' show Offset; + +import '../domain/chat_attachment_picker.dart'; +import 'files_drop.dart'; + +/// Browser file drops observed at the document for each mounted Files panel. +/// A drag that carries files and sits over an accepting area is taken over +/// (so the browser does not navigate to the dropped file); everything else +/// keeps the browser's default. Uses dart:js_interop so the bridge supports +/// JavaScript and WebAssembly builds. +@JS('document') +external _Document get _document; + +extension type _Document._(JSObject _) implements JSObject { + external void addEventListener( + JSString type, + JSFunction listener, + JSBoolean capture, + ); + + external void removeEventListener( + JSString type, + JSFunction listener, + JSBoolean capture, + ); + + external _Element? querySelector(JSString selectors); +} + +extension type _Element._(JSObject _) implements JSObject { + external _DOMRect getBoundingClientRect(); +} + +extension type _DOMRect._(JSObject _) implements JSObject { + external double get left; + + external double get top; +} + +extension type _DragEvent._(JSObject _) implements JSObject { + external double get clientX; + + external double get clientY; + + external _DataTransfer? get dataTransfer; + + external JSObject? get relatedTarget; + + external void preventDefault(); +} + +extension type _DataTransfer._(JSObject _) implements JSObject { + external JSArray get types; + + external _FileList get files; + + external set dropEffect(JSString value); +} + +extension type _FileList._(JSObject _) implements JSObject { + external int get length; + + external _File? item(int index); +} + +extension type _File._(JSObject _) implements JSObject { + external JSString get name; + + external JSString get type; + + external JSPromise arrayBuffer(); +} + +FilesDrop get hostFilesDrop => const FilesDrop(subscribe: _subscribe); + +bool _carriesFiles(_DragEvent event) { + final data = event.dataTransfer; + if (data == null) return false; + for (final type in data.types.toDart) { + if (type.toDart == 'Files') return true; + } + return false; +} + +/// The pointer in Flutter view coordinates. The view normally fills the page, +/// so this is the viewport position minus the view's own offset. +Offset _position(_DragEvent event) { + final view = _document.querySelector('flutter-view'.toJS); + if (view == null) return Offset(event.clientX, event.clientY); + final rect = view.getBoundingClientRect(); + return Offset(event.clientX - rect.left, event.clientY - rect.top); +} + +FilesDropUnsubscribe _subscribe(FilesDropListener listener) { + var hovering = false; + void leave() { + if (!hovering) return; + hovering = false; + listener.onLeave(); + } + + void handleOver(JSObject raw) { + final event = _DragEvent._(raw); + if (!_carriesFiles(event)) return; + final position = _position(event); + if (!listener.accepts(position)) { + leave(); + return; + } + event.preventDefault(); + event.dataTransfer!.dropEffect = 'copy'.toJS; + hovering = true; + listener.onHover(position); + } + + void handleLeave(JSObject raw) { + // relatedTarget is null when the drag leaves the window; movement between + // page elements keeps reporting through dragover. + if (_DragEvent._(raw).relatedTarget == null) leave(); + } + + void handleDrop(JSObject raw) { + final event = _DragEvent._(raw); + if (!_carriesFiles(event)) return; + final accepted = listener.accepts(_position(event)); + leave(); + if (!accepted) return; + event.preventDefault(); + final files = event.dataTransfer!.files; + final dropped = <_File>[]; + for (var index = 0; index < files.length; index += 1) { + final file = files.item(index); + if (file != null) dropped.add(file); + } + unawaited(_readFiles(dropped, listener)); + } + + final over = handleOver.toJS; + final left = handleLeave.toJS; + final drop = handleDrop.toJS; + _document.addEventListener('dragenter'.toJS, over, true.toJS); + _document.addEventListener('dragover'.toJS, over, true.toJS); + _document.addEventListener('dragleave'.toJS, left, true.toJS); + _document.addEventListener('drop'.toJS, drop, true.toJS); + return () { + _document.removeEventListener('dragenter'.toJS, over, true.toJS); + _document.removeEventListener('dragover'.toJS, over, true.toJS); + _document.removeEventListener('dragleave'.toJS, left, true.toJS); + _document.removeEventListener('drop'.toJS, drop, true.toJS); + }; +} + +Future _readFiles(List<_File> files, FilesDropListener listener) async { + final picked = []; + final failures = []; + for (final file in files) { + try { + final buffer = await file.arrayBuffer().toDart; + picked.add( + ChatPickedFile( + name: file.name.toDart, + mime: file.type.toDart, + bytes: buffer.toDart.asUint8List(), + ), + ); + } catch (error) { + // A dropped folder has no readable bytes; it must not hide the files. + failures.add(error); + } + } + if (picked.isNotEmpty) listener.onDrop(picked); + for (final failure in failures) { + listener.onError(failure); + } +} diff --git a/app/lib/features/chat/files/files_entries.dart b/app/lib/features/chat/files/files_entries.dart new file mode 100644 index 00000000..78a68484 --- /dev/null +++ b/app/lib/features/chat/files/files_entries.dart @@ -0,0 +1,91 @@ +import 'package:flutter/material.dart'; + +import '../data/directory_listing.dart'; +import 'files_icons.dart'; +import 'files_models.dart'; +import 'files_thumbnail.dart'; + +/// The folder's entries as the list or the thumbnail grid. Tapping opens a +/// folder or a file through [onTap]; [menu] supplies a file's action menu. +class FilesEntries extends StatelessWidget { + const FilesEntries({ + super.key, + required this.entries, + required this.view, + required this.endpoint, + required this.onTap, + required this.menu, + }); + final List entries; + final FilesViewMode view; + final String endpoint; + final ValueChanged onTap; + final Widget Function(DirectoryEntry entry) menu; + + @override + Widget build(BuildContext context) => + view == FilesViewMode.grid ? _grid() : _list(); + + Widget _list() => ListView.builder( + itemCount: entries.length, + itemBuilder: (_, index) { + final entry = entries[index]; + return ListTile( + onTap: () => onTap(entry), + leading: Icon(fileIcon(entry)), + title: Text(entry.name, maxLines: 2, overflow: TextOverflow.ellipsis), + subtitle: Text( + entry.isDir + ? 'Folder' + : '${fileModifiedLabel(entry.modified)} · ${fileSizeLabel(entry.size)}', + ), + trailing: entry.isDir + ? null + : Row( + mainAxisSize: MainAxisSize.min, + children: [Text(fileKind(entry)), menu(entry)], + ), + ); + }, + ); + + Widget _grid() => GridView.builder( + padding: const EdgeInsets.all(12), + gridDelegate: const SliverGridDelegateWithMaxCrossAxisExtent( + maxCrossAxisExtent: 180, + childAspectRatio: .85, + ), + itemCount: entries.length, + itemBuilder: (_, index) { + final entry = entries[index]; + return InkWell( + onTap: () => onTap(entry), + child: Card( + child: Padding( + padding: const EdgeInsets.all(12), + child: Column( + children: [ + Align( + alignment: Alignment.centerRight, + child: entry.isDir ? const SizedBox(height: 48) : menu(entry), + ), + Expanded( + child: Center( + child: FileThumbnail(entry: entry, endpoint: endpoint), + ), + ), + const SizedBox(height: 8), + Text( + entry.name, + maxLines: 2, + overflow: TextOverflow.ellipsis, + textAlign: TextAlign.center, + ), + ], + ), + ), + ), + ); + }, + ); +} diff --git a/app/lib/features/chat/files/files_header.dart b/app/lib/features/chat/files/files_header.dart index 122e710f..33b7251e 100644 --- a/app/lib/features/chat/files/files_header.dart +++ b/app/lib/features/chat/files/files_header.dart @@ -2,6 +2,7 @@ import 'package:flutter/cupertino.dart'; import 'package:flutter/material.dart'; import '../../../ui/layout/app_overflow_menu.dart'; import '../data/directory_listing.dart'; +import '../domain/chat_attachment_picker.dart'; import '../ui/sessions/chat_adaptive.dart'; import 'files_controller.dart'; import 'files_models.dart'; @@ -11,9 +12,23 @@ class FilesHeader extends StatelessWidget { super.key, required this.controller, required this.filter, + required this.picker, + required this.onUpload, }); final FilesController controller; final TextEditingController filter; + + /// The host's file picker; an unsupported host disables Upload with its + /// reason in the tooltip. + final ChatAttachmentPicker picker; + final VoidCallback onUpload; + + bool get _canUpload => + picker.isSupported && + controller.listing != null && + !controller.loading && + controller.uploading == 0; + @override Widget build(BuildContext context) { final listing = controller.listing; @@ -40,6 +55,13 @@ class FilesHeader extends StatelessWidget { overflow: TextOverflow.ellipsis, ), ), + IconButton( + tooltip: picker.isSupported + ? 'Upload files' + : 'Upload files: ${picker.unsupportedMessage}', + onPressed: _canUpload ? onUpload : null, + icon: const Icon(Icons.upload_file), + ), IconButton( tooltip: 'Refresh', onPressed: controller.loading ? null : controller.retry, diff --git a/app/lib/features/chat/files/files_panel.dart b/app/lib/features/chat/files/files_panel.dart index bed90cbc..3ef9be06 100644 --- a/app/lib/features/chat/files/files_panel.dart +++ b/app/lib/features/chat/files/files_panel.dart @@ -3,11 +3,13 @@ import 'package:flutter/cupertino.dart'; import '../../../ui/adaptive/host.dart'; import '../../../core/transport/pipelines_client.dart'; import '../data/directory_listing.dart'; +import '../domain/chat_attachment_picker.dart'; import '../ui/sessions/chat_adaptive.dart'; import 'files_controller.dart'; -import 'files_icons.dart'; -import 'files_models.dart'; -import 'files_thumbnail.dart'; +import 'files_drop.dart'; +import 'files_drop_area.dart'; +import 'files_entries.dart'; +import 'files_upload_notice.dart'; import 'files_viewer.dart'; import 'files_header.dart'; import '../../../ui/layout/app_overflow_menu.dart'; @@ -28,20 +30,43 @@ class FilesPanel extends StatefulWidget { required this.controller, this.onOpen, this.viewer = const FilesViewer(), + this.picker, + this.drop, }); final FilesController controller; final ValueChanged? onOpen; /// Opens and downloads files; tests inject one that never fetches. final FilesViewer viewer; + + /// The Upload button's file picker and the host drag-and-drop seam; null + /// means the running host's. Tests inject fakes. + final ChatAttachmentPicker? picker; + final FilesDrop? drop; @override State createState() => _FilesPanelState(); } class _FilesPanelState extends State { late final TextEditingController _filter = TextEditingController(); + late final ChatAttachmentPicker _picker = + widget.picker ?? hostChatAttachmentPicker; + late final FilesDrop _drop = widget.drop ?? hostFilesDrop; FilesController get controller => widget.controller; String get _endpoint => configuredGatewayEndpoint(controller.gateway); + + Future _pickAndUpload() async { + final List? files; + try { + files = await _picker.pick(); + } catch (error) { + controller.reportUploadError('$error'); + return; + } + if (files == null || files.isEmpty) return; + await controller.upload(files); + } + @override void initState() { super.initState(); @@ -80,109 +105,66 @@ class _FilesPanelState extends State { child: Builder( builder: (context) => Material( color: Theme.of(context).colorScheme.surface, - child: Column( - children: [ - FilesHeader(controller: controller, filter: _filter), - if (controller.error != null) - ChatErrorNotice( - message: controller.error!, - onRetry: controller.retry, + child: FilesDropArea( + drop: _drop, + folderLabel: listing == null + ? null + : homeRelativeLabel(listing.home, listing.path), + onFiles: controller.upload, + onError: (error) => controller.reportUploadError( + 'A dropped item could not be read: $error', + ), + child: Column( + children: [ + FilesHeader( + controller: controller, + filter: _filter, + picker: _picker, + onUpload: _pickAndUpload, ), - if (controller.loading && listing == null) - const Expanded(child: ChatLoadingIndicator()) - else if (listing != null && - entries.isEmpty && - !controller.loading) - Expanded( - child: _FilesMessage( - controller.filter.isEmpty - ? 'This folder is empty.' - : 'No files match your filter.', + if (controller.error != null) + ChatErrorNotice( + message: controller.error!, + onRetry: controller.retry, ), - ) - else - Expanded( - child: controller.view == FilesViewMode.grid - ? _grid(entries) - : _list(entries), - ), - if (listing?.truncated == true) - const Padding( - padding: EdgeInsets.all(8), - child: Text('Some entries are not shown.'), - ), - ], + FilesUploadNotice(controller: controller), + if (controller.loading && listing == null) + const Expanded(child: ChatLoadingIndicator()) + else if (listing != null && + entries.isEmpty && + !controller.loading) + Expanded( + child: _FilesMessage( + controller.filter.isEmpty + ? 'This folder is empty.' + : 'No files match your filter.', + ), + ) + else + Expanded( + child: FilesEntries( + entries: entries, + view: controller.view, + endpoint: _endpoint, + onTap: (entry) => entry.isDir + ? controller.open(entry.path) + : _open(entry), + menu: _menu, + ), + ), + if (listing?.truncated == true) + const Padding( + padding: EdgeInsets.all(8), + child: Text('Some entries are not shown.'), + ), + ], + ), ), ), ), ); } - Widget _list(List entries) => ListView.builder( - itemCount: entries.length, - itemBuilder: (_, index) { - final entry = entries[index]; - return ListTile( - onTap: () => entry.isDir ? controller.open(entry.path) : _open(entry), - leading: Icon(fileIcon(entry)), - title: Text(entry.name, maxLines: 2, overflow: TextOverflow.ellipsis), - subtitle: Text( - entry.isDir - ? 'Folder' - : '${fileModifiedLabel(entry.modified)} · ${fileSizeLabel(entry.size)}', - ), - trailing: entry.isDir - ? null - : Row( - mainAxisSize: MainAxisSize.min, - children: [Text(fileKind(entry)), _menu(entry)], - ), - ); - }, - ); - - Widget _grid(List entries) => GridView.builder( - padding: const EdgeInsets.all(12), - gridDelegate: const SliverGridDelegateWithMaxCrossAxisExtent( - maxCrossAxisExtent: 180, - childAspectRatio: .85, - ), - itemCount: entries.length, - itemBuilder: (_, index) { - final entry = entries[index]; - return InkWell( - onTap: () => entry.isDir ? controller.open(entry.path) : _open(entry), - child: Card( - child: Padding( - padding: const EdgeInsets.all(12), - child: Column( - children: [ - Align( - alignment: Alignment.centerRight, - child: entry.isDir - ? const SizedBox(height: 48) - : _menu(entry), - ), - Expanded( - child: Center( - child: FileThumbnail(entry: entry, endpoint: _endpoint), - ), - ), - const SizedBox(height: 8), - Text( - entry.name, - maxLines: 2, - overflow: TextOverflow.ellipsis, - textAlign: TextAlign.center, - ), - ], - ), - ), - ), - ); - }, - ); - /// Open and Download for one file; a folder has no menu (nothing to save). Widget _menu(DirectoryEntry entry) => AppOverflowMenu( label: 'File actions', diff --git a/app/lib/features/chat/files/files_upload.dart b/app/lib/features/chat/files/files_upload.dart new file mode 100644 index 00000000..032f0b7f --- /dev/null +++ b/app/lib/features/chat/files/files_upload.dart @@ -0,0 +1,99 @@ +import 'dart:convert'; +import 'dart:typed_data'; + +import '../../../core/transport/server_url.dart'; +import '../data/upload/chat_upload.dart'; +import '../domain/chat_attachment_picker.dart'; + +/// Posts one file's bytes to a `POST /files?path=` URL. +typedef FilesUploadPost = + Future Function( + Uri uri, { + required String name, + required String mime, + required Uint8List bytes, + }); + +/// The transport the Files panel uploads with. +/// +/// Production keeps [postChatUpload] (raw body, name header, session cookie). +/// Widget tests swap in a recorder so no socket is opened. Restore it after a +/// test. +FilesUploadPost postFileUpload = postChatUpload; + +/// Why one file could not be stored, in words the panel shows as they are. +class FilesUploadException implements Exception { + const FilesUploadException(this.message); + final String message; + @override + String toString() => message; +} + +/// Uploads [file] into [directory] on the server behind [endpoint] and returns +/// the stored path the server reports. Every failure is a +/// [FilesUploadException]; nothing is retried or renamed on the caller's +/// behalf, so an existing file is reported rather than replaced. +Future uploadFileInto( + String endpoint, + String directory, + ChatPickedFile file, +) async { + final name = file.name.trim(); + if (name.isEmpty) { + throw const FilesUploadException( + 'A file without a name cannot be uploaded.', + ); + } + final Uri uri; + try { + uri = ServerUrl.resourceUri( + endpoint, + '/files', + query: {'path': directory}, + ); + } on FormatException { + throw const FilesUploadException( + 'No server is configured to upload files to.', + ); + } + final ChatUploadReply reply; + try { + reply = await postFileUpload( + uri, + name: name, + mime: file.mime.trim().isEmpty ? 'application/octet-stream' : file.mime, + bytes: file.bytes, + ); + } catch (error) { + throw FilesUploadException('"$name" could not be uploaded: $error'); + } + final reason = reply.body.trim(); + switch (reply.status) { + case 200: + break; + case 401: + throw const FilesUploadException( + 'Sign in to upload files (Settings → Sign in).', + ); + case 409: + throw FilesUploadException('"$name" already exists in this folder.'); + case 413: + throw FilesUploadException( + '"$name" is too large to upload (100 MiB limit).', + ); + default: + throw FilesUploadException( + reason.isEmpty + ? '"$name" could not be uploaded (HTTP ${reply.status}).' + : '"$name" could not be uploaded: $reason', + ); + } + try { + final decoded = jsonDecode(reply.body); + final path = decoded is Map ? decoded['path'] : null; + if (path is String && path.isNotEmpty) return path; + } on FormatException { + // Reported below. + } + throw FilesUploadException('"$name" upload returned no stored path.'); +} diff --git a/app/lib/features/chat/files/files_upload_notice.dart b/app/lib/features/chat/files/files_upload_notice.dart new file mode 100644 index 00000000..8909b4e1 --- /dev/null +++ b/app/lib/features/chat/files/files_upload_notice.dart @@ -0,0 +1,60 @@ +import 'package:flutter/cupertino.dart'; +import 'package:flutter/material.dart'; + +import '../ui/sessions/chat_adaptive.dart'; +import 'files_controller.dart'; + +/// The Files panel's upload feedback: a progress strip while files are being +/// stored and the server's refusal (exists, sign in, too large) until the +/// operator dismisses it. Upload failures are separate from the folder error, +/// whose Retry reloads the listing. +class FilesUploadNotice extends StatelessWidget { + const FilesUploadNotice({super.key, required this.controller}); + final FilesController controller; + + @override + Widget build(BuildContext context) { + final error = controller.uploadError; + final cupertino = + chatControlsStyleOf(context) == ChatControlsStyle.cupertino; + return Column( + children: [ + if (controller.uploading > 0) + Semantics( + label: controller.uploadLabel, + child: Padding( + padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 4), + child: Row( + children: [ + Expanded( + child: cupertino + ? const CupertinoActivityIndicator() + : const LinearProgressIndicator(), + ), + const SizedBox(width: 12), + Text(controller.uploadLabel), + ], + ), + ), + ), + if (error != null) + cupertino + ? ChatCupertinoMessage( + message: error, + icon: CupertinoIcons.exclamationmark_circle, + actionLabel: 'Dismiss', + onAction: controller.dismissUploadError, + ) + : MaterialBanner( + content: Text(error), + actions: [ + TextButton( + onPressed: controller.dismissUploadError, + child: const Text('Dismiss'), + ), + ], + ), + ], + ); + } +} diff --git a/app/notes/files-upload.md b/app/notes/files-upload.md new file mode 100644 index 00000000..676eb970 --- /dev/null +++ b/app/notes/files-upload.md @@ -0,0 +1,104 @@ +# Files panel: upload into the shown folder + +## Behaviour + +- The chat Files panel header has an **Upload files** button (next to Refresh). + It opens the host file picker (`hostChatAttachmentPicker`: `file_picker` on + native, `` on web). On a host without a picker the button is + disabled and its tooltip carries the reason + (`Upload files: `). +- The whole panel is a drop target. On web, `files_drop_web.dart` observes the + document's `dragenter`/`dragover`/`dragleave`/`drop` events through + `dart:js_interop`; a drag that carries files and sits over the panel is taken + over (default prevented, `dropEffect = copy`) and the panel shows a highlight + reading `Drop to upload to `. Drags elsewhere keep the browser's + default. Native hosts use `FilesDrop.unsupported` and keep the button only. +- Every picked or dropped file is posted on its own to + `POST /files?path=` (the listing's `path`), with the name in + `X-Pipelines-Upload-Name` (percent-encoded) and the MIME type as + `Content-Type`, through the same transport as chat uploads (`postChatUpload`: + session cookie on native, same-origin fetch on web; relay endpoints post to + `/peers//files`). After the batch the folder that received the files is + reloaded. +- Progress: `Uploading…` / `Uploading n of m…` with a progress strip; the + Upload button is disabled while a batch is in flight. +- Refusals are shown in the panel until dismissed (not swallowed), one line per + failed file; the rest of the batch is still attempted: + - 409: `"name" already exists in this folder.` (the server never overwrites) + - 401: `Sign in to upload files (Settings → Sign in).` + - 413: `"name" is too large to upload (100 MiB limit).` + - other statuses: the server's text, or `(HTTP n)` + - transport error / unreadable dropped item (a folder): reported in words. + +## Server and proxy + +- `internal/server/home_files_upload.go`: `POST /files?path=`. The folder + is resolved like `GET /files` (`expandHomePath` + `resolveInsideHome`, so it + must be inside `$HOME`, symlinks resolved); special filesystems and + non-directories are refused; the name must be a plain file name (no + separators, not `.`/`..`, ≤255 bytes); the file is created with `O_EXCL` and + mode 0644 (set explicitly, independent of umask), so an existing name is + `409 Conflict`; the chat upload limit (100 MiB) applies on `Content-Length` + and on the streamed body (partial file removed). Reply: + `{"name","path","size"}`. `GET /files` is unchanged. +- `web/serve.mjs` already forwarded every `/files` method to the server behind + the sign-in gate; `web/src/peerRelay.js` now allows `POST /files` beside + `POST /chat-uploads` (allowlist + POST check) and forwards + `content-type`, `content-length`, `x-pipelines-upload-name`. + +## Files + +- `app/lib/features/chat/files/files_upload.dart` — `postFileUpload` seam, + `uploadFileInto`, `FilesUploadException`. +- `files_drop.dart`, `files_drop_stub.dart`, `files_drop_web.dart` — drop seam. +- `files_drop_area.dart` — drop target with highlight. +- `files_upload_notice.dart` — progress and refusal strip (Material banner / + Cupertino message with Dismiss). +- `files_entries.dart` — the list/grid builders moved out of `files_panel.dart`. +- `files_controller.dart` — `upload`, `uploading`, `uploadTotal`, + `uploadError`, `reportUploadError`, `dismissUploadError`. +- `files_header.dart` — Upload button; `files_panel.dart` — `picker`/`drop` + parameters, drop wrap, notice. +- Tests: `app/test/features/chat/files/files_upload_test.dart`, + `files_panel_upload_test.dart`; `internal/server/home_files_upload_test.go`; + `web/test/serve.test.mjs`, `web/test/peerRelay.test.mjs`. + +## Verification (2026-11-09) + +``` +$ go test ./internal/server/ -run 'TestServeHomeFile|TestChatUpload' -v | grep -E "^(PASS|ok|FAIL)" +PASS +ok git.a-wan.net/alan/pipelines/internal/server 0.432s + +$ go test ./internal/server/... +ok git.a-wan.net/alan/pipelines/internal/server 65.194s + +$ cd web && node --test test/ +ℹ tests 16 +ℹ pass 16 +ℹ fail 0 + +$ cd app && tool/analyze.sh +analyze: clean; 7s; exit 0 + +$ cd app && tool/memwatch/full.sh test/features/chat/files +memwatch: PASS: 37 passed, 0 failed, 0 skipped; peak 1263 MB; 6s; exit 0 (test/features/chat/files) + +$ cd app && flutter build web --release +Compiling lib/main.dart for the Web... 25.0s +✓ Built build/web +``` + +## Not done / caveats + +- Desktop (macOS/Linux/Windows) drag-and-drop: not implemented. It would need + the `desktop_drop` plugin (a new native dependency in `pubspec.yaml`) whose + desktop builds could not be verified here; desktop hosts get the Upload + button, which works through `file_picker`. Mobile gets the button only, as + specified. +- No real-browser capture of the drag-and-drop interaction was recorded in this + lane (the web build compiles the interop; the drop path is covered through + the seam in widget tests). A browser drop requires a DataTransfer with files, + which the capture kit does not synthesise. +- The web drop listener assumes the Flutter view fills the page (it subtracts + the `flutter-view` element's bounding rect from the pointer position). diff --git a/app/test/features/chat/files/files_panel_upload_test.dart b/app/test/features/chat/files/files_panel_upload_test.dart new file mode 100644 index 00000000..87032b4d --- /dev/null +++ b/app/test/features/chat/files/files_panel_upload_test.dart @@ -0,0 +1,261 @@ +import 'dart:async'; +import 'dart:typed_data'; + +import 'package:flutter/material.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/core/api_gateway.dart'; +import 'package:pipelines_app/core/transport/pipelines_client.dart'; +import 'package:pipelines_app/features/chat/domain/chat_attachment_picker.dart'; +import 'package:pipelines_app/features/chat/files/files_controller.dart'; +import 'package:pipelines_app/features/chat/files/files_drop.dart'; +import 'package:pipelines_app/features/chat/files/files_panel.dart'; +import 'package:pipelines_app/features/chat/files/files_upload.dart'; +import 'package:pipelines_app/features/chat/files/files_urls.dart'; +import 'package:pipelines_app/features/chat/files/files_viewer.dart'; + +/// Lists `/home/demo` and counts the listings so a refresh after an upload is +/// observable. +class Gateway extends PipelinesClient { + @override + Uri get endpoint => Uri.parse('ws://example.test/connect'); + int listings = 0; + @override + Stream get frames => const Stream.empty(); + @override + Future call(String type, [JsonMap fields = const {}]) async { + listings += 1; + return { + 'directory_listing': { + 'path': '/home/demo', + 'home': '/home', + 'entries': [ + {'name': 'notes.txt', 'path': '/home/demo/notes.txt', 'size': 12}, + ], + }, + }; + } +} + +/// One recorded `POST /files`. +typedef Posted = ({Uri uri, String name, String mime, int size}); + +ChatPickedFile picked(String name, [String mime = 'text/plain']) => + ChatPickedFile(name: name, mime: mime, bytes: Uint8List.fromList([1, 2])); + +void main() { + late FileUrlResolver originalUrls; + late FilesUploadPost originalPost; + final posted = []; + var reply = (status: 200, body: '{"path":"/home/demo/new.txt"}'); + Completer? gate; + setUp(() { + originalUrls = resolveFileUrls; + originalPost = postFileUpload; + resolveFileUrls = (_, path) => fileUrls('ws://example.test/connect', path); + posted.clear(); + reply = (status: 200, body: '{"path":"/home/demo/new.txt"}'); + gate = null; + postFileUpload = + (uri, {required name, required mime, required bytes}) async { + posted.add((uri: uri, name: name, mime: mime, size: bytes.length)); + if (gate != null) await gate!.future; + return reply; + }; + }); + tearDown(() { + resolveFileUrls = originalUrls; + postFileUpload = originalPost; + }); + + Future<({FilesController controller, Gateway gateway})> pump( + WidgetTester tester, { + ChatAttachmentPicker? picker, + FilesDrop? drop, + }) async { + final gateway = Gateway(); + final controller = FilesController( + gateway: gateway, + initialPath: '/home/demo', + ); + addTearDown(controller.dispose); + await tester.pumpWidget( + MaterialApp( + home: Scaffold( + body: FilesPanel( + controller: controller, + viewer: const FilesViewer(), + picker: + picker ?? + ChatAttachmentPicker(select: () async => [picked('new.txt')]), + drop: drop ?? const FilesDrop.unsupported('no drops in tests'), + ), + ), + ), + ); + await tester.pumpAndSettle(); + return (controller: controller, gateway: gateway); + } + + testWidgets('Upload button picks files, posts them to the shown folder and ' + 'refreshes', (tester) async { + gate = Completer(); + final mounted = await pump(tester); + expect(mounted.gateway.listings, 1); + await tester.tap(find.byTooltip('Upload files')); + await tester.pump(); + expect(find.text('Uploading…'), findsOneWidget); + expect(find.byType(LinearProgressIndicator), findsOneWidget); + expect( + tester + .widget( + find.ancestor( + of: find.byIcon(Icons.upload_file), + matching: find.byType(IconButton), + ), + ) + .onPressed, + isNull, + reason: 'a second batch waits for the first', + ); + gate!.complete(); + await tester.pumpAndSettle(); + expect(posted, hasLength(1)); + expect(posted.single.uri.path, '/files'); + expect(posted.single.uri.queryParameters['path'], '/home/demo'); + expect(posted.single.name, 'new.txt'); + expect(posted.single.mime, 'text/plain'); + expect(posted.single.size, 2); + expect(mounted.gateway.listings, 2, reason: 'the folder is reloaded'); + expect(find.text('Uploading…'), findsNothing); + expect(mounted.controller.uploadError, isNull); + }); + + testWidgets('a cancelled picker uploads nothing', (tester) async { + final mounted = await pump( + tester, + picker: ChatAttachmentPicker(select: () async => null), + ); + await tester.tap(find.byTooltip('Upload files')); + await tester.pumpAndSettle(); + expect(posted, isEmpty); + expect(mounted.gateway.listings, 1); + }); + + testWidgets('an unsupported picker disables Upload with its reason', ( + tester, + ) async { + await pump( + tester, + picker: const ChatAttachmentPicker.unsupported('No picker here.'), + ); + final button = tester.widget( + find.ancestor( + of: find.byIcon(Icons.upload_file), + matching: find.byType(IconButton), + ), + ); + expect(button.onPressed, isNull); + expect(find.byTooltip('Upload files: No picker here.'), findsOneWidget); + }); + + testWidgets('server refusals are shown until dismissed', (tester) async { + final mounted = await pump(tester); + for (final (status, body, message) in [ + (409, 'exists', '"new.txt" already exists in this folder.'), + ( + 401, + 'Sign in required', + 'Sign in to upload files (Settings → Sign in).', + ), + (413, 'too big', '"new.txt" is too large to upload (100 MiB limit).'), + ]) { + reply = (status: status, body: body); + await tester.tap(find.byTooltip('Upload files')); + await tester.pumpAndSettle(); + expect(find.byType(MaterialBanner), findsOneWidget); + expect(find.text(message), findsOneWidget); + expect(mounted.controller.uploadError, message); + await tester.tap(find.text('Dismiss')); + await tester.pumpAndSettle(); + expect(find.byType(MaterialBanner), findsNothing); + } + expect(posted, hasLength(3)); + }); + + testWidgets('a batch keeps going after one refusal and lists both', ( + tester, + ) async { + var calls = 0; + postFileUpload = + (uri, {required name, required mime, required bytes}) async { + calls += 1; + return name == 'kept.txt' + ? (status: 409, body: 'exists') + : (status: 200, body: '{"path":"/home/demo/$name"}'); + }; + final mounted = await pump( + tester, + picker: ChatAttachmentPicker( + select: () async => [picked('kept.txt'), picked('other.txt')], + ), + ); + await tester.tap(find.byTooltip('Upload files')); + await tester.pumpAndSettle(); + expect(calls, 2); + expect( + find.text('"kept.txt" already exists in this folder.'), + findsOneWidget, + ); + expect(mounted.gateway.listings, 2); + }); + + testWidgets('a file drag over the panel highlights the folder and a drop ' + 'uploads there', (tester) async { + FilesDropListener? listener; + var unsubscribed = 0; + final drop = FilesDrop( + subscribe: (registered) { + listener = registered; + return () => unsubscribed += 1; + }, + ); + final mounted = await pump(tester, drop: drop); + expect(listener, isNotNull); + final inside = tester.getCenter(find.byType(FilesPanel)); + expect(listener!.accepts(inside), isTrue); + expect(listener!.accepts(const Offset(-5, -5)), isFalse); + expect(find.text('Drop to upload to ~/demo'), findsNothing); + listener!.onHover(inside); + await tester.pump(); + expect(find.text('Drop to upload to ~/demo'), findsOneWidget); + listener!.onLeave(); + await tester.pump(); + expect(find.text('Drop to upload to ~/demo'), findsNothing); + listener!.onHover(inside); + await tester.pump(); + listener!.onDrop([picked('dropped.png', 'image/png')]); + await tester.pumpAndSettle(); + expect(find.text('Drop to upload to ~/demo'), findsNothing); + expect(posted, hasLength(1)); + expect(posted.single.name, 'dropped.png'); + expect(posted.single.mime, 'image/png'); + expect(posted.single.uri.queryParameters['path'], '/home/demo'); + expect(mounted.gateway.listings, 2); + listener!.onError(StateError('is a directory')); + await tester.pump(); + expect( + find.textContaining('A dropped item could not be read'), + findsOneWidget, + ); + await tester.pumpWidget(const SizedBox()); + expect(unsubscribed, 1); + }); + + testWidgets('an unsupported drop host keeps the panel and the button', ( + tester, + ) async { + await pump(tester, drop: const FilesDrop.unsupported('no drops')); + expect(find.text('notes.txt'), findsOneWidget); + expect(find.byTooltip('Upload files'), findsOneWidget); + }); +} diff --git a/app/test/features/chat/files/files_upload_test.dart b/app/test/features/chat/files/files_upload_test.dart new file mode 100644 index 00000000..56acdf3a --- /dev/null +++ b/app/test/features/chat/files/files_upload_test.dart @@ -0,0 +1,138 @@ +import 'dart:typed_data'; + +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/features/chat/domain/chat_attachment_picker.dart'; +import 'package:pipelines_app/features/chat/files/files_upload.dart'; + +void main() { + late FilesUploadPost original; + setUp(() => original = postFileUpload); + tearDown(() => postFileUpload = original); + + final file = ChatPickedFile( + name: 'notes.txt', + mime: 'text/plain', + bytes: Uint8List.fromList([1, 2, 3]), + ); + + test( + 'posts to /files with the shown folder and returns the stored path', + () async { + Uri? posted; + String? postedName; + String? postedMime; + postFileUpload = + (uri, {required name, required mime, required bytes}) async { + posted = uri; + postedName = name; + postedMime = mime; + return ( + status: 200, + body: + '{"name":"notes.txt","path":"/home/demo/notes.txt","size":3}', + ); + }; + final path = await uploadFileInto( + 'ws://example.test/connect', + '/home/demo', + file, + ); + expect(path, '/home/demo/notes.txt'); + expect(posted?.path, '/files'); + expect(posted?.queryParameters, {'path': '/home/demo'}); + expect(posted?.scheme, 'http'); + expect(postedName, 'notes.txt'); + expect(postedMime, 'text/plain'); + }, + ); + + test('a relay endpoint posts through its peer prefix', () async { + Uri? posted; + postFileUpload = + (uri, {required name, required mime, required bytes}) async { + posted = uri; + return (status: 200, body: '{"path":"/home/x/notes.txt"}'); + }; + await uploadFileInto( + 'wss://web.test/peers/laptop/connect', + '/home/x', + file, + ); + expect(posted?.path, '/peers/laptop/files'); + }); + + test('server refusals become plain messages', () async { + Future message(int status, String body) async { + postFileUpload = + (uri, {required name, required mime, required bytes}) async => + (status: status, body: body); + try { + await uploadFileInto('ws://example.test/connect', '/home/demo', file); + } on FilesUploadException catch (error) { + return error.message; + } + return 'no error'; + } + + expect( + await message(409, 'a file named notes.txt already exists'), + '"notes.txt" already exists in this folder.', + ); + expect( + await message(401, 'Sign in required'), + 'Sign in to upload files (Settings → Sign in).', + ); + expect( + await message(413, 'file exceeds the 100 MiB limit'), + '"notes.txt" is too large to upload (100 MiB limit).', + ); + expect( + await message(403, 'folder access denied'), + '"notes.txt" could not be uploaded: folder access denied', + ); + expect( + await message(500, ''), + '"notes.txt" could not be uploaded (HTTP 500).', + ); + expect( + await message(200, 'not json'), + '"notes.txt" upload returned no stored path.', + ); + }); + + test( + 'transport failures and blank names are reported, not swallowed', + () async { + postFileUpload = (uri, {required name, required mime, required bytes}) => + throw StateError('socket closed'); + await expectLater( + uploadFileInto('ws://example.test/connect', '/home/demo', file), + throwsA( + isA().having( + (e) => e.message, + 'message', + '"notes.txt" could not be uploaded: Bad state: socket closed', + ), + ), + ); + await expectLater( + uploadFileInto( + 'ws://example.test/connect', + '/home/demo', + ChatPickedFile(name: ' ', mime: '', bytes: Uint8List(0)), + ), + throwsA(isA()), + ); + await expectLater( + uploadFileInto('', '/home/demo', file), + throwsA( + isA().having( + (e) => e.message, + 'message', + 'No server is configured to upload files to.', + ), + ), + ); + }, + ); +} diff --git a/internal/server/home_files_upload.go b/internal/server/home_files_upload.go new file mode 100644 index 00000000..cbb76a55 --- /dev/null +++ b/internal/server/home_files_upload.go @@ -0,0 +1,149 @@ +package server + +import ( + "encoding/json" + "errors" + "io" + "io/fs" + "net/http" + "net/url" + "os" + "path/filepath" + "strings" + "unicode/utf8" +) + +// maxHomeFileUploadBytes bounds one file stored through POST /files. It +// matches the chat upload limit so both raw-body routes behave alike. +const maxHomeFileUploadBytes = maxChatUploadBytes + +type homeFileUploadReply struct { + Name string `json:"name"` + Path string `json:"path"` + Size int64 `json:"size"` +} + +// serveHomeFileUpload stores the request body as a new file inside the +// folder named by ?path=, which must lie inside the operator's home. The name +// travels in X-Pipelines-Upload-Name; an existing file is never overwritten. +func serveHomeFileUpload(w http.ResponseWriter, r *http.Request) { + home, err := OperatorHomeDirectory() + if err != nil { + http.NotFound(w, r) + return + } + serveHomeFileUploadTo(w, r, home) +} + +func serveHomeFileUploadTo(w http.ResponseWriter, r *http.Request, home string) { + fail := func(status int, message string) { http.Error(w, message, status) } + rawName := r.Header.Get(chatUploadHeader) + if rawName == "" { + fail(http.StatusBadRequest, "missing "+chatUploadHeader) + return + } + if r.Header.Get("Sec-Fetch-Site") == "cross-site" { + fail(http.StatusForbidden, "cross-site upload refused") + return + } + decoded, err := url.PathUnescape(rawName) + if err != nil { + decoded = rawName + } + name, err := uploadFileName(decoded) + if err != nil { + fail(http.StatusBadRequest, err.Error()) + return + } + if r.ContentLength > maxHomeFileUploadBytes { + fail(http.StatusRequestEntityTooLarge, "file exceeds the 100 MiB limit") + return + } + home = filepath.Clean(home) + realHome, err := filepath.EvalSymlinks(home) + if err != nil { + fail(http.StatusNotFound, "home directory unavailable") + return + } + target, err := expandHomePath(home, r.URL.Query().Get("path")) + if err != nil { + fail(http.StatusNotFound, "folder not found") + return + } + _, realDir, err := resolveInsideHome(realHome, target) + if err != nil { + if strings.Contains(err.Error(), "outside the home directory") { + fail(http.StatusForbidden, "folder access denied") + } else { + fail(http.StatusNotFound, "folder not found") + } + return + } + info, err := os.Stat(realDir) + if err != nil || !info.IsDir() { + fail(http.StatusNotFound, "folder not found") + return + } + if specialFilesystem(realDir) { + fail(http.StatusForbidden, "folder access denied") + return + } + file, err := os.OpenFile(filepath.Join(realDir, name), os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0o644) + if err != nil { + switch { + case errors.Is(err, fs.ErrExist): + fail(http.StatusConflict, "a file named "+name+" already exists") + case errors.Is(err, fs.ErrPermission): + fail(http.StatusForbidden, "folder access denied") + default: + fail(http.StatusInternalServerError, "write file: "+err.Error()) + } + return + } + // The process umask may narrow the create mode; the stored file is meant + // to be readable like one the operator saved themselves. + size, err := int64(0), file.Chmod(0o644) + if err == nil { + size, err = io.Copy(file, io.LimitReader(r.Body, maxHomeFileUploadBytes+1)) + } + if err == nil && size > maxHomeFileUploadBytes { + err = errors.New("file exceeds the 100 MiB limit") + } + if err == nil { + err = file.Sync() + } + if closeErr := file.Close(); err == nil { + err = closeErr + } + if err != nil { + _ = os.Remove(file.Name()) + status := http.StatusBadRequest + if size > maxHomeFileUploadBytes { + status = http.StatusRequestEntityTooLarge + } + fail(status, err.Error()) + return + } + w.Header().Set("Content-Type", "application/json") + w.Header().Set("Cache-Control", "no-store") + _ = json.NewEncoder(w).Encode(homeFileUploadReply{Name: name, Path: filepath.Join(target, name), Size: size}) +} + +// uploadFileName accepts one plain file name: no directory parts, no NUL, +// not "." or "..", and short enough for common filesystems. The name is kept +// as given rather than rewritten, so the stored file is the one the operator +// asked for. +func uploadFileName(value string) (string, error) { + name := strings.TrimSpace(value) + switch { + case name == "" || name == "." || name == "..": + return "", errors.New("file name is missing") + case strings.ContainsAny(name, "/\\\x00"): + return "", errors.New("file name must not contain path separators") + case !utf8.ValidString(name): + return "", errors.New("file name is not valid UTF-8") + case len(name) > 255: + return "", errors.New("file name is too long") + } + return name, nil +} diff --git a/internal/server/home_files_upload_test.go b/internal/server/home_files_upload_test.go new file mode 100644 index 00000000..74017eb3 --- /dev/null +++ b/internal/server/home_files_upload_test.go @@ -0,0 +1,153 @@ +package server + +import ( + "encoding/json" + "net/http" + "net/http/httptest" + "os" + "path/filepath" + "strings" + "testing" +) + +func postHomeFile(t *testing.T, home, dir, name, body string) *httptest.ResponseRecorder { + t.Helper() + req := httptest.NewRequest(http.MethodPost, "/files?path="+dir, strings.NewReader(body)) + if name != "" { + req.Header.Set(chatUploadHeader, name) + } + req.Header.Set("Content-Type", "text/plain") + rec := httptest.NewRecorder() + serveHomeFileUploadTo(rec, req, home) + return rec +} + +func TestServeHomeFileUpload(t *testing.T) { + root := t.TempDir() + home := filepath.Join(root, "home") + outside := filepath.Join(root, "outside") + for _, dir := range []string{filepath.Join(home, "project"), outside} { + if err := os.MkdirAll(dir, 0o755); err != nil { + t.Fatal(err) + } + } + if err := os.WriteFile(filepath.Join(home, "project", "kept.txt"), []byte("original"), 0o644); err != nil { + t.Fatal(err) + } + if err := os.Symlink(outside, filepath.Join(home, "escape")); err != nil { + t.Fatal(err) + } + + t.Run("stores a new file in the shown folder", func(t *testing.T) { + rec := postHomeFile(t, home, "~/project", "big%20photo.txt", "hello upload") + if rec.Code != http.StatusOK { + t.Fatalf("status = %d %s", rec.Code, rec.Body) + } + var reply homeFileUploadReply + if err := json.Unmarshal(rec.Body.Bytes(), &reply); err != nil { + t.Fatal(err) + } + want := filepath.Join(home, "project", "big photo.txt") + if reply.Name != "big photo.txt" || reply.Path != want || reply.Size != int64(len("hello upload")) { + t.Fatalf("reply = %+v", reply) + } + info, err := os.Stat(want) + if err != nil || info.Mode().Perm() != 0o644 { + t.Fatalf("stored file = %v %v", info, err) + } + data, _ := os.ReadFile(want) + if string(data) != "hello upload" { + t.Fatalf("contents = %q", data) + } + }) + + t.Run("operator home seam and absolute path", func(t *testing.T) { + originalHomeDirectory := operatorHomeDirectory + operatorHomeDirectory = func() (string, error) { return home, nil } + t.Cleanup(func() { operatorHomeDirectory = originalHomeDirectory }) + req := httptest.NewRequest(http.MethodPost, "/files?path="+filepath.Join(home, "project"), strings.NewReader("x")) + req.Header.Set(chatUploadHeader, "seam.txt") + rec := httptest.NewRecorder() + serveHomeFileUpload(rec, req) + if rec.Code != http.StatusOK { + t.Fatalf("status = %d %s", rec.Code, rec.Body) + } + if _, err := os.Stat(filepath.Join(home, "project", "seam.txt")); err != nil { + t.Fatal(err) + } + }) + + t.Run("existing file is refused and kept", func(t *testing.T) { + rec := postHomeFile(t, home, "~/project", "kept.txt", "replacement") + if rec.Code != http.StatusConflict || !strings.Contains(rec.Body.String(), "already exists") { + t.Fatalf("response = %d %s", rec.Code, rec.Body) + } + data, _ := os.ReadFile(filepath.Join(home, "project", "kept.txt")) + if string(data) != "original" { + t.Fatalf("contents = %q, want original", data) + } + }) + + t.Run("empty file is stored", func(t *testing.T) { + rec := postHomeFile(t, home, "~", "empty.txt", "") + if rec.Code != http.StatusOK { + t.Fatalf("status = %d %s", rec.Code, rec.Body) + } + info, err := os.Stat(filepath.Join(home, "empty.txt")) + if err != nil || info.Size() != 0 { + t.Fatalf("stored file = %v %v", info, err) + } + }) + + refusals := []struct { + label string + dir string + name string + want int + }{ + {"missing name", "~/project", "", http.StatusBadRequest}, + {"name with slash", "~/project", "sub%2Fname.txt", http.StatusBadRequest}, + {"dot dot name", "~/project", "..", http.StatusBadRequest}, + {"outside home", filepath.Join(home, "..", "outside"), "x.txt", http.StatusForbidden}, + {"symlink outside home", "~/escape", "x.txt", http.StatusForbidden}, + {"missing folder", "~/nowhere", "x.txt", http.StatusNotFound}, + {"file is not a folder", "~/project/kept.txt", "x.txt", http.StatusNotFound}, + {"relative path", "project", "x.txt", http.StatusNotFound}, + } + for _, tc := range refusals { + t.Run(tc.label, func(t *testing.T) { + rec := postHomeFile(t, home, tc.dir, tc.name, "x") + if rec.Code != tc.want { + t.Fatalf("status = %d %s, want %d", rec.Code, rec.Body, tc.want) + } + }) + } + if entries, _ := os.ReadDir(outside); len(entries) != 0 { + t.Fatalf("outside directory gained %d entries", len(entries)) + } + + t.Run("declared size over the limit", func(t *testing.T) { + req := httptest.NewRequest(http.MethodPost, "/files?path=~/project", strings.NewReader("x")) + req.Header.Set(chatUploadHeader, "huge.bin") + req.ContentLength = maxHomeFileUploadBytes + 1 + rec := httptest.NewRecorder() + serveHomeFileUploadTo(rec, req, home) + if rec.Code != http.StatusRequestEntityTooLarge { + t.Fatalf("status = %d %s", rec.Code, rec.Body) + } + if _, err := os.Stat(filepath.Join(home, "project", "huge.bin")); !os.IsNotExist(err) { + t.Fatalf("oversized file was stored: %v", err) + } + }) + + t.Run("cross-site post is refused", func(t *testing.T) { + req := httptest.NewRequest(http.MethodPost, "/files?path=~/project", strings.NewReader("x")) + req.Header.Set(chatUploadHeader, "cross.txt") + req.Header.Set("Sec-Fetch-Site", "cross-site") + rec := httptest.NewRecorder() + serveHomeFileUploadTo(rec, req, home) + if rec.Code != http.StatusForbidden { + t.Fatalf("status = %d %s", rec.Code, rec.Body) + } + }) +} diff --git a/internal/server/websocket.go b/internal/server/websocket.go index a32c1034..dcb8bbb7 100644 --- a/internal/server/websocket.go +++ b/internal/server/websocket.go @@ -155,6 +155,7 @@ func HandlerWithOptions(ctx context.Context, options Options, stores ...*pipelin }) mux.HandleFunc("GET /discovery", serveServerDiscovery) mux.HandleFunc("GET /files", serveHomeFile) + mux.HandleFunc("POST /files", serveHomeFileUpload) mux.HandleFunc("POST /chat-uploads", serveChatUpload) mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") diff --git a/web/src/peerRelay.js b/web/src/peerRelay.js index 48bf40c2..18525a84 100644 --- a/web/src/peerRelay.js +++ b/web/src/peerRelay.js @@ -17,6 +17,8 @@ const allowed = (path) => path === "/chat-uploads" || path.startsWith("/artifacts/") || path.startsWith("/updates/"); +// Raw-body uploads: chat attachments and files stored into a home folder. +const postable = (path) => path === "/chat-uploads" || path === "/files"; export class PeerRelay extends PeerRegistry { target(req, path) { const parsed = new URL(req.url, "http://localhost"); @@ -45,7 +47,7 @@ export class PeerRelay extends PeerRegistry { !target || !allowed(target.url.pathname) || !["GET", "HEAD", "POST"].includes(req.method) || - (req.method === "POST" && target.url.pathname !== "/chat-uploads") + (req.method === "POST" && !postable(target.url.pathname)) ) { json(res, 404, { error: "Unsupported remote resource" }); return true; diff --git a/web/test/peerRelay.test.mjs b/web/test/peerRelay.test.mjs index 6cee5a8c..6869a5fc 100644 --- a/web/test/peerRelay.test.mjs +++ b/web/test/peerRelay.test.mjs @@ -76,6 +76,22 @@ async function fixture(t) { return; } res.setHeader("Set-Cookie", "do-not-forward=private"); + if (req.method === "POST") { + let body = ""; + for await (const chunk of req) body += chunk; + res.end( + JSON.stringify({ + name, + method: req.method, + url: req.url, + cookie: req.headers.cookie, + upload: req.headers["x-pipelines-upload-name"], + type: req.headers["content-type"], + body, + }), + ); + return; + } if ( req.url.startsWith("/artifacts/") || req.url.includes("untrusted.svg") @@ -289,6 +305,46 @@ test("browser can authenticate both machines, relay files and keep local credent ); }); +test("file uploads relay to the chosen machine's home folder and other POSTs are refused", async (t) => { + const f = await fixture(t); + await f.register("one", { + endpoints: [f.remotes[0]], + password: "password-one", + }); + const upload = (path, headers = {}) => + fetch(f.base + `/peers/one${path}`, { + method: "POST", + headers: { + Cookie: f.cookie, + "Content-Type": "text/plain", + "X-Pipelines-Upload-Name": "notes%20two.txt", + ...headers, + }, + body: "hello upload", + }); + const reply = await upload("/files?path=%2Fhome%2Fproject"); + assert.equal(reply.status, 200); + assert.equal(reply.headers.get("set-cookie"), null); + assert.deepEqual(await reply.json(), { + name: "one", + method: "POST", + url: "/files?path=%2Fhome%2Fproject", + cookie: "pipelines_session=remote-one", + upload: "notes%20two.txt", + type: "text/plain", + body: "hello upload", + }); + // The remote never sees a POST the relay does not allow. + const before = f.observations.length; + assert.equal((await upload("/artifacts/1/2/report.txt")).status, 404); + assert.equal((await upload("/discovery")).status, 404); + assert.equal(f.observations.length, before); + assert.equal( + (await upload("/files?path=%2Fhome", { Cookie: await f.login() })).status, + 401, + ); +}); + test("websocket relay authenticates the chosen machine without forwarding browser Origin", async (t) => { const f = await fixture(t); await f.register("two", { diff --git a/web/test/serve.test.mjs b/web/test/serve.test.mjs index f08e9f3f..b85b4966 100644 --- a/web/test/serve.test.mjs +++ b/web/test/serve.test.mjs @@ -139,3 +139,53 @@ test("files require sign-in and proxy query, ranges and attachment headers", asy { method: "HEAD", url: path, range: undefined }, ]); }); + +test("file uploads require sign-in and reach the server with their name header", async (t) => { + const requests = []; + const upstream = createServer(async (req, res) => { + let body = ""; + for await (const chunk of req) body += chunk; + requests.push({ + method: req.method, + url: req.url, + upload: req.headers["x-pipelines-upload-name"], + type: req.headers["content-type"], + body, + }); + res.writeHead(409, { "Content-Type": "text/plain; charset=utf-8" }); + res.end("a file named notes.txt already exists"); + }).listen(0, "127.0.0.1"); + await once(upstream, "listening"); + t.after(() => new Promise((done) => upstream.close(done))); + const dir = await mkdtemp(join(tmpdir(), "serve-upload-")); + const auth = join(dir, "auth.json"); + await writeFile(auth, JSON.stringify({ password: "password-1", secret: "s".repeat(40) })); + const port = await freePort(); + const child = spawn(process.execPath, ["serve.mjs", "--port", String(port), + "--pipelines", `127.0.0.1:${upstream.address().port}`], { + cwd: here, + env: { ...process.env, PIPELINES_WEB_AUTH: "", PIPELINES_WEB_AUTH_FILE: auth }, + stdio: ["ignore", "pipe", "inherit"], + }); + t.after(async () => { const exited = once(child, "exit"); child.kill(); await exited; }); + await once(child.stdout, "data"); + const base = `http://127.0.0.1:${port}`; + const path = "/files?path=%2Fhome%2Fproject"; + const post = (headers) => fetch(base + path, { + method: "POST", + headers: { "Content-Type": "text/plain", "X-Pipelines-Upload-Name": "notes.txt", ...headers }, + body: "hello upload", + }); + assert.equal((await post({})).status, 401); + assert.equal(requests.length, 0); + const login = await fetch(base + "/login", { + method: "POST", body: new URLSearchParams({ password: "password-1" }), redirect: "manual", + }); + const cookie = login.headers.get("set-cookie").split(";")[0]; + const reply = await post({ Cookie: cookie }); + assert.equal(reply.status, 409); + assert.equal(await reply.text(), "a file named notes.txt already exists"); + assert.deepEqual(requests, [ + { method: "POST", url: path, upload: "notes.txt", type: "text/plain", body: "hello upload" }, + ]); +});