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/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.', + ), + ), + ); + }, + ); +}