Merge branch 'worktree-agent-ae487572986d7a387' into integrate/chat-ntfy-attachments

This commit is contained in:
2026-10-30 21:05:32 +00:00
18 changed files with 1397 additions and 29 deletions
@@ -9,6 +9,7 @@ import 'package:flutter/services.dart';
import '../../../core/api_gateway.dart';
import '../../../core/transport/pipelines_client.dart';
import '../data/chat_attachment_images.dart';
import '../data/upload/chat_upload.dart';
import '../domain/chat_attachment_draft.dart';
import '../domain/chat_attachment_picker.dart';
@@ -94,8 +95,13 @@ class ChatComposerBar extends StatefulWidget {
this.backgroundTasks,
this.placeholder = chatComposerPlaceholder,
this.enterSends,
this.images,
});
/// The transcript's image cache, told about uploaded files so the sent turn
/// shows them without a round trip.
final ChatAttachmentImages? images;
/// Overrides [chatEnterSends] for this composer; null follows the host.
final bool? enterSends;
@@ -472,8 +478,18 @@ class _ChatComposerBarState extends State<ChatComposerBar> {
parts = await chatAttachmentUploadParts(
_attachments,
read: _readAttachment,
upload: (attachment, bytes) async => _uploaded[attachment] ??=
await uploadChatAttachment(endpoint, attachment, bytes),
upload: (attachment, bytes) async {
final stored = _uploaded[attachment] ??= await uploadChatAttachment(
endpoint,
attachment,
bytes,
);
// The sent turn draws these bytes instead of fetching them back.
if (attachment.mime.toLowerCase().startsWith('image/')) {
widget.images?.rememberUpload(stored, bytes);
}
return stored;
},
);
}
} on ChatAttachmentWireException catch (error) {
@@ -6,8 +6,10 @@ import 'package:flutter/rendering.dart';
import '../../../core/api_gateway.dart';
import '../../../shell/shell_bar.dart';
import '../data/chat_attachment_images.dart';
import '../data/chat_repository.dart';
import '../domain/chat_activity_detail.dart';
import '../domain/chat_attachment_image.dart';
import '../domain/chat_notice.dart';
import '../domain/chat_attachment_picker.dart';
import '../domain/chat_transcript.dart';
@@ -129,6 +131,9 @@ class _ChatThreadViewState extends State<ChatThreadView> {
late ChatComposerController _composer = _attachComposer();
late ChatRowKeys _rowKeys = ChatRowKeys();
/// Sent images' bytes for this server, cached across rebuilds and scrolling.
late ChatAttachmentImages _images = ChatAttachmentImages(widget.gateway);
/// Local notices the operator hid; cleared when the conversation or socket
/// changes so a reconnect never keeps a stale dismissal.
ChatNoticeDismissals _dismissals = ChatNoticeDismissals();
@@ -253,7 +258,7 @@ class _ChatThreadViewState extends State<ChatThreadView> {
{
'type': 'file',
'name': attachment['name'],
'uri': attachment['name'],
'uri': chatOptimisticAttachmentUri(attachment),
'mime': attachment['mime'],
},
],
@@ -352,6 +357,8 @@ class _ChatThreadViewState extends State<ChatThreadView> {
// A transcript from another server is not this one's to keep.
if (oldWidget.gateway == widget.gateway) {
_saveTranscript(oldWidget.transcripts, oldWidget.sessionId);
} else {
_images = ChatAttachmentImages(widget.gateway);
}
_controller.dispose();
_composer.dispose();
@@ -901,6 +908,7 @@ class _ChatThreadViewState extends State<ChatThreadView> {
running: _controller.running,
commands: _commandActions(),
picker: widget.attachmentPicker,
images: _images,
placeholder: chatComposerPlaceholderFor(
'${widget.session?['directory'] ?? ''}',
),
@@ -1026,6 +1034,7 @@ class _ChatThreadViewState extends State<ChatThreadView> {
row: row,
textBuilder: chatMarkdownText,
footer: chips,
images: _images,
);
}
@@ -0,0 +1,150 @@
import 'dart:async';
import 'dart:collection';
import 'dart:convert';
import 'dart:typed_data';
import '../../../core/api_gateway.dart';
import '../../../core/transport/connection_state.dart';
import '../domain/chat_attachment_image.dart';
/// Why a transcript image cannot be drawn, in words the placeholder shows.
class ChatAttachmentImageException implements Exception {
const ChatAttachmentImageException(this.message);
final String message;
@override
String toString() => message;
}
/// The placeholder's wording when the server no longer has the file.
const String chatImageGoneMessage = 'Image no longer available';
/// Loads and caches the bytes of images attached to sent chat messages, keyed
/// by the part's URI. A transcript row asks lazily when it builds; scrolling
/// back reuses the bytes instead of fetching again. Decoded bytes are bounded
/// by [maxCachedBytes], least recently used first out.
class ChatAttachmentImages {
ChatAttachmentImages(this.gateway, {this.maxCachedBytes = 48 << 20});
/// Null for a host with no server (only `data:` images draw).
final ApiGateway? gateway;
final int maxCachedBytes;
final LinkedHashMap<String, Uint8List> _ready = LinkedHashMap();
final Map<String, Future<Uint8List>> _pending = {};
final Map<String, String> _failed = {};
final Map<String, Uint8List> _uploads = {};
int _cachedBytes = 0;
/// Bytes already loaded for [uri], so a rebuilt row draws without a frame
/// of loading state.
Uint8List? ready(String uri) {
final bytes = _ready.remove(uri);
if (bytes != null) _ready[uri] = bytes;
return bytes;
}
/// The settled reason [uri] cannot be drawn, if a previous load failed.
String? failure(String uri) => _failed[uri];
/// Records the composer's own bytes for a file it uploaded ahead of a
/// prompt, so the sent turn draws them before and after the server echo.
void rememberUpload(String storedName, Uint8List bytes) {
if (storedName.isEmpty || bytes.isEmpty) return;
_uploads[storedName] = bytes;
while (_uploads.length > 16) {
_uploads.remove(_uploads.keys.first);
}
}
/// The image bytes behind [uri]. A server refusal is remembered; a transport
/// failure is not, so a later rebuild after reconnecting tries again.
Future<Uint8List> load(String uri) {
final bytes = ready(uri);
if (bytes != null) return Future.value(bytes);
final failed = _failed[uri];
if (failed != null) {
return Future.error(ChatAttachmentImageException(failed));
}
return _pending[uri] ??= _fetch(uri).then(
(bytes) {
_pending.remove(uri);
_store(uri, bytes);
return bytes;
},
onError: (Object error) {
_pending.remove(uri);
if (error is ChatAttachmentImageException) {
_failed[uri] = error.message;
throw error;
}
// Not connected, timed out: worth another try on a later build.
throw const ChatAttachmentImageException('Image unavailable');
},
);
}
Future<Uint8List> _fetch(String uri) async {
final local = _uploads[chatStoredFileName(uri)];
switch (chatImageSourceOf(uri)) {
case ChatImageSource.inline:
final bytes = chatDataUriBytes(uri);
if (bytes == null || bytes.isEmpty) {
throw const ChatAttachmentImageException('Image could not be read');
}
return bytes;
case ChatImageSource.upload:
if (local == null) {
throw const ChatAttachmentImageException(chatImageGoneMessage);
}
return local;
case ChatImageSource.stored:
if (local != null) return local;
return _request(uri);
case null:
throw const ChatAttachmentImageException('Image unavailable');
}
}
Future<Uint8List> _request(String uri) async {
final gateway = this.gateway;
if (gateway == null) {
throw const ChatAttachmentImageException('Image unavailable');
}
final JsonMap reply;
try {
reply = await gateway.call('chat_attachment_image', {
'chat_attachment_image_request': {'uri': uri},
});
} on ProtocolError catch (error) {
// The server's answer is settled; remember it rather than re-ask.
throw ChatAttachmentImageException(_wording(error.message));
}
final content = reply['chat_attachment_image'];
final data = content is Map ? content['data'] : null;
if (data is! String || data.isEmpty) {
throw const ChatAttachmentImageException('Image could not be read');
}
try {
return base64Decode(data);
} on FormatException {
throw const ChatAttachmentImageException('Image could not be read');
}
}
void _store(String uri, Uint8List bytes) {
_ready[uri] = bytes;
_cachedBytes += bytes.length;
while (_cachedBytes > maxCachedBytes && _ready.length > 1) {
final oldest = _ready.keys.first;
_cachedBytes -= _ready.remove(oldest)!.length;
}
}
static String _wording(String message) {
if (message.contains('no longer available')) return chatImageGoneMessage;
if (message.contains('too large')) return 'Image too large to preview';
return 'Image unavailable';
}
}
@@ -0,0 +1,107 @@
import 'dart:typed_data';
import '../../../core/api_gateway.dart';
/// Raster types the transcript can draw. SVG and unknown types stay file rows.
const Set<String> _imageMimes = {
'image/png',
'image/jpeg',
'image/jpg',
'image/gif',
'image/webp',
'image/bmp',
};
const Map<String, String> _imageExtensions = {
'png': 'image/png',
'jpg': 'image/jpeg',
'jpeg': 'image/jpeg',
'gif': 'image/gif',
'webp': 'image/webp',
'bmp': 'image/bmp',
};
/// Where a transcript image's bytes come from.
enum ChatImageSource {
/// A `data:` URI the history already carries (Claude Code transcripts).
inline,
/// A server-local `file://` path read through `chat_attachment_image`.
stored,
/// A just-sent prompt's upload, known only by its stored name until the
/// server echoes the recorded turn.
upload,
}
/// The image type a file part names: its own MIME, else the type of a `data:`
/// URI, else its name or URI extension. Null when it is not a drawable image.
String? chatPartImageMime(JsonMap part) {
if (part['type'] != 'file') return null;
final mime = '${part['mime'] ?? ''}'.trim().toLowerCase();
if (mime.isNotEmpty && mime != 'application/octet-stream') {
return _imageMimes.contains(mime) ? mime : null;
}
final uri = '${part['uri'] ?? ''}'.trim();
if (uri.startsWith('data:')) {
final type = uri.substring(5).split(RegExp('[;,]')).first.toLowerCase();
return _imageMimes.contains(type) ? type : null;
}
for (final candidate in ['${part['name'] ?? ''}', uri]) {
final dot = candidate.lastIndexOf('.');
if (dot < 0) continue;
final type = _imageExtensions[candidate.substring(dot + 1).toLowerCase()];
if (type != null) return type;
}
return null;
}
/// How a drawable image part is loaded, or null when its URI is one the client
/// does not fetch (remote http(s) URLs stay plain file rows).
ChatImageSource? chatImageSourceOf(String uri) {
if (uri.startsWith('data:')) return ChatImageSource.inline;
if (uri.startsWith('file:///')) return ChatImageSource.stored;
if (uri.startsWith(chatUploadUriPrefix)) return ChatImageSource.upload;
return null;
}
/// The optimistic row's URI for a file the composer uploaded ahead of the
/// prompt; the loader resolves it from the composer's own bytes.
const String chatUploadUriPrefix = 'upload:';
/// The URI a just-sent turn's file part carries before the server records it:
/// an inline file's own `data:` URI, an uploaded file's `upload:` name, else
/// its name (drawn as a plain file row).
String chatOptimisticAttachmentUri(JsonMap wirePart) {
final name = '${wirePart['name'] ?? ''}';
final data = '${wirePart['data'] ?? ''}';
final upload = '${wirePart['upload'] ?? ''}';
if (upload.isNotEmpty) return '$chatUploadUriPrefix$upload';
if (data.isNotEmpty) {
final mime = '${wirePart['mime'] ?? ''}'.trim();
return 'data:${mime.isEmpty ? 'application/octet-stream' : mime};base64,$data';
}
return name;
}
/// The stored file name a `file://` or `upload:` URI ends in; the upload store
/// names files `up-<id>-<name>`, so the same bytes match before and after the
/// server records the turn.
String chatStoredFileName(String uri) {
if (uri.startsWith(chatUploadUriPrefix)) {
return uri.substring(chatUploadUriPrefix.length);
}
final path = Uri.tryParse(uri)?.pathSegments ?? const <String>[];
return path.isEmpty ? '' : path.last;
}
/// The bytes of a base64 `data:` image URI, or null when it is malformed.
Uint8List? chatDataUriBytes(String uri) {
try {
final data = UriData.parse(uri);
if (!data.isBase64) return null;
return data.contentAsBytes();
} on FormatException {
return null;
}
}
@@ -0,0 +1,57 @@
import 'package:flutter/widgets.dart';
import '../../../../core/api_gateway.dart';
import '../../data/chat_attachment_images.dart';
import '../../domain/chat_attachment_image.dart';
import 'chat_attachment_thumbnail.dart';
/// Whether a file part draws as a thumbnail: a raster image whose bytes the
/// client can reach (inline, the server's attachment store or a fresh upload).
bool chatPartIsThumbnail(JsonMap part) =>
chatPartImageMime(part) != null &&
chatImageSourceOf('${part['uri'] ?? ''}'.trim()) != null;
/// The operator's attached images above their message, end-aligned like the
/// turn itself, wrapping onto further lines on a narrow pane.
class ChatAttachmentGallery extends StatelessWidget {
const ChatAttachmentGallery({
super.key,
required this.parts,
required this.images,
required this.cupertino,
});
/// File parts for which [chatPartIsThumbnail] holds.
final List<JsonMap> parts;
final ChatAttachmentImages images;
final bool cupertino;
@override
Widget build(BuildContext context) => Wrap(
key: const Key('chat-attachment-gallery'),
alignment: WrapAlignment.end,
spacing: 8,
runSpacing: 8,
children: [
for (final (index, part) in parts.indexed)
ChatAttachmentThumbnail(
key: ValueKey<String>('chat-attachment-image-$index'),
name: chatAttachmentPartName(part),
uri: '${part['uri'] ?? ''}'.trim(),
images: images,
cupertino: cupertino,
),
],
);
}
/// The web's attachment name rule: its own name, else the URI basename, else
/// `file`. A `data:` URI has no useful basename, so it reads `image`.
String chatAttachmentPartName(JsonMap part) {
final name = '${part['name'] ?? ''}'.trim();
if (name.isNotEmpty) return name;
final uri = '${part['uri'] ?? ''}'.trim();
if (uri.startsWith('data:')) return 'image';
final basename = uri.split('/').last.trim();
return basename.isEmpty ? 'file' : basename;
}
@@ -0,0 +1,202 @@
import 'dart:typed_data';
import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
import '../../data/chat_attachment_images.dart';
import 'chat_image_viewer.dart';
/// The largest edge a sent image's thumbnail takes in the transcript.
const double chatThumbnailMaxWidth = 200;
const double chatThumbnailMaxHeight = 240;
const BorderRadius _radius = BorderRadius.all(Radius.circular(12));
/// One image the operator attached, drawn as a rounded thumbnail that opens
/// [ChatImageViewer]. Bytes load lazily through [images] and stay cached there;
/// a file the server no longer has becomes a small labelled placeholder.
class ChatAttachmentThumbnail extends StatefulWidget {
const ChatAttachmentThumbnail({
super.key,
required this.name,
required this.uri,
required this.images,
required this.cupertino,
});
final String name;
final String uri;
final ChatAttachmentImages images;
final bool cupertino;
@override
State<ChatAttachmentThumbnail> createState() =>
_ChatAttachmentThumbnailState();
}
class _ChatAttachmentThumbnailState extends State<ChatAttachmentThumbnail> {
Uint8List? _bytes;
String? _failure;
@override
void initState() {
super.initState();
_resolve();
}
@override
void didUpdateWidget(covariant ChatAttachmentThumbnail oldWidget) {
super.didUpdateWidget(oldWidget);
if (oldWidget.uri != widget.uri || oldWidget.images != widget.images) {
_resolve();
}
}
void _resolve() {
final uri = widget.uri;
_bytes = widget.images.ready(uri);
_failure = widget.images.failure(uri);
if (_bytes != null || _failure != null) return;
widget.images
.load(uri)
.then(
(bytes) {
if (mounted && widget.uri == uri) setState(() => _bytes = bytes);
},
onError: (Object error) {
if (mounted && widget.uri == uri) {
setState(() => _failure = '$error');
}
},
);
}
@override
Widget build(BuildContext context) {
final bytes = _bytes;
if (bytes != null) return _thumbnail(context, bytes);
final failure = _failure;
if (failure != null) return _placeholder(context, failure);
return Semantics(
label: '${widget.name}, loading',
child: _pending(context),
);
}
/// A quiet surface square while loaded bytes decode, which is brief.
Widget _decoding(BuildContext context) => SizedBox.square(
dimension: 96,
child: ColoredBox(
color: widget.cupertino
? CupertinoColors.systemGrey5.resolveFrom(context)
: Theme.of(context).colorScheme.surfaceContainerHighest,
),
);
/// A square the thumbnail occupies while its bytes load from the server.
Widget _pending(BuildContext context) => SizedBox.square(
key: const Key('chat-attachment-thumbnail-loading'),
dimension: 96,
child: Center(
child: widget.cupertino
? const CupertinoActivityIndicator()
: const CircularProgressIndicator.adaptive(),
),
);
Widget _thumbnail(BuildContext context, Uint8List bytes) {
final ratio = MediaQuery.devicePixelRatioOf(context);
final image = ClipRRect(
borderRadius: _radius,
child: Image(
key: const Key('chat-attachment-thumbnail-image'),
// Decode at the thumbnail's size, not the photo's, while scrolling.
image: ResizeImage(
MemoryImage(bytes),
width: (chatThumbnailMaxWidth * ratio).round(),
height: (chatThumbnailMaxHeight * ratio).round(),
policy: ResizeImagePolicy.fit,
allowUpscaling: false,
),
fit: BoxFit.contain,
gaplessPlayback: true,
// Until the first frame decodes, hold the loading square's place so
// the row does not collapse and the control can still be tapped.
frameBuilder: (context, child, frame, synchronous) =>
frame == null && !synchronous ? _decoding(context) : child,
errorBuilder: (context, _, _) =>
_placeholder(context, 'Image could not be read'),
),
);
void open() => openChatImageViewer(
context,
name: widget.name,
bytes: bytes,
cupertino: widget.cupertino,
);
final constrained = ConstrainedBox(
constraints: const BoxConstraints(
maxWidth: chatThumbnailMaxWidth,
maxHeight: chatThumbnailMaxHeight,
),
child: image,
);
return Semantics(
button: true,
image: true,
label: widget.name,
excludeSemantics: true,
onTap: open,
child: widget.cupertino
? CupertinoButton(
key: const Key('chat-attachment-thumbnail'),
padding: EdgeInsets.zero,
minimumSize: Size.zero,
onPressed: open,
child: constrained,
)
: Material(
type: MaterialType.transparency,
child: InkWell(
key: const Key('chat-attachment-thumbnail'),
borderRadius: _radius,
onTap: open,
child: constrained,
),
),
);
}
Widget _placeholder(BuildContext context, String reason) {
final secondary = widget.cupertino
? CupertinoColors.secondaryLabel.resolveFrom(context)
: Theme.of(context).colorScheme.onSurfaceVariant;
return Semantics(
key: const Key('chat-attachment-thumbnail-unavailable'),
label: '${widget.name}, $reason',
excludeSemantics: true,
child: ConstrainedBox(
constraints: const BoxConstraints(maxWidth: chatThumbnailMaxWidth),
child: Row(
mainAxisSize: MainAxisSize.min,
children: [
Icon(
widget.cupertino
? CupertinoIcons.photo
: Icons.broken_image_outlined,
color: secondary,
),
const SizedBox(width: 8),
Flexible(
child: Text(
reason,
style: DefaultTextStyle.of(
context,
).style.copyWith(color: secondary),
),
),
],
),
),
);
}
}
@@ -0,0 +1,90 @@
import 'dart:typed_data';
import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
/// The accessible name and visible label of the viewer's close control.
const String chatImageViewerClose = 'Close';
/// One attached image full screen: pinch or scroll to zoom, drag to pan once
/// zoomed, and the host's own close control in the navigation bar.
class ChatImageViewer extends StatelessWidget {
const ChatImageViewer({
super.key,
required this.name,
required this.bytes,
required this.cupertino,
});
final String name;
final Uint8List bytes;
final bool cupertino;
@override
Widget build(BuildContext context) {
final body = SafeArea(
child: InteractiveViewer(
key: const Key('chat-image-viewer-zoom'),
maxScale: 8,
child: Center(
child: Semantics(
image: true,
label: name,
child: Image.memory(
bytes,
key: const Key('chat-image-viewer-image'),
fit: BoxFit.contain,
gaplessPlayback: true,
errorBuilder: (context, _, _) => Icon(
cupertino ? CupertinoIcons.photo : Icons.broken_image_outlined,
),
),
),
),
),
);
void close() => Navigator.of(context).maybePop();
if (cupertino) {
return CupertinoPageScaffold(
navigationBar: CupertinoNavigationBar(
automaticallyImplyLeading: false,
middle: Text(name, overflow: TextOverflow.ellipsis),
leading: CupertinoButton(
key: const Key('chat-image-viewer-close'),
padding: EdgeInsets.zero,
onPressed: close,
child: const Text(chatImageViewerClose),
),
),
child: body,
);
}
return Scaffold(
appBar: AppBar(
automaticallyImplyLeading: false,
leading: IconButton(
key: const Key('chat-image-viewer-close'),
tooltip: chatImageViewerClose,
onPressed: close,
icon: const Icon(Icons.close),
),
title: Text(name, overflow: TextOverflow.ellipsis),
),
body: body,
);
}
}
/// Pushes [ChatImageViewer] with the host's full-screen dialog transition.
Future<void> openChatImageViewer(
BuildContext context, {
required String name,
required Uint8List bytes,
required bool cupertino,
}) {
final page = ChatImageViewer(name: name, bytes: bytes, cupertino: cupertino);
final route = cupertino
? CupertinoPageRoute<void>(fullscreenDialog: true, builder: (_) => page)
: MaterialPageRoute<void>(fullscreenDialog: true, builder: (_) => page);
return Navigator.of(context).push(route);
}
@@ -4,7 +4,9 @@ import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
import '../../../../core/api_gateway.dart';
import '../../data/chat_attachment_images.dart';
import '../sessions/chat_adaptive.dart';
import 'chat_attachment_gallery.dart';
import '../../domain/chat_tool_calls.dart';
import 'chat_copy_button.dart';
import 'chat_message_bubble.dart';
@@ -22,11 +24,18 @@ class ChatMessageView extends StatelessWidget {
required this.row,
this.textBuilder,
this.footer = const [],
this.images,
});
final JsonMap row;
final ChatMessageTextBuilder? textBuilder;
/// Loads attached images for the operator's turn; without one, only images
/// the history carries inline can draw.
final ChatAttachmentImages? images;
static final ChatAttachmentImages _inlineImages = ChatAttachmentImages(null);
/// The turn's settled permissions, independent of passive activity details.
final List<Widget> footer;
@@ -69,7 +78,7 @@ class ChatMessageView extends StatelessWidget {
: 720,
),
child: user
? ChatUserBubble(cupertino: cupertino, child: body)
? _userTurn(cupertino, content, body)
: _agentTurn(
context,
content,
@@ -89,10 +98,38 @@ class ChatMessageView extends StatelessWidget {
bool _isCupertino(BuildContext context) =>
chatControlsStyleOf(context) == ChatControlsStyle.cupertino;
JsonMap get _userMessage => row['message'] is Map
? Map<String, dynamic>.from(row['message'] as Map)
: row;
/// Attached images sit above the operator's bubble, as their own thumbnails;
/// an images-only turn draws no empty bubble.
Widget _userTurn(bool cupertino, List<Widget> content, Widget body) {
final thumbnails = [
for (final part in _partsOf(_userMessage))
if (_isFile(part) && chatPartIsThumbnail(part)) part,
];
if (thumbnails.isEmpty) {
return ChatUserBubble(cupertino: cupertino, child: body);
}
return Column(
mainAxisSize: MainAxisSize.min,
crossAxisAlignment: CrossAxisAlignment.end,
children: [
ChatAttachmentGallery(
parts: thumbnails,
images: images ?? _inlineImages,
cupertino: cupertino,
),
if (content.isNotEmpty) const SizedBox(height: 6),
if (content.isNotEmpty)
ChatUserBubble(cupertino: cupertino, child: body),
],
);
}
List<Widget> _userParts(BuildContext context) {
final message = row['message'] is Map
? Map<String, dynamic>.from(row['message'] as Map)
: row;
final message = _userMessage;
final parts = _partsOf(message);
final text = parts
.where((part) => part['type'] == null || part['type'] == 'text')
@@ -100,7 +137,8 @@ class ChatMessageView extends StatelessWidget {
.join('\n');
final widgets = <Widget>[
if (text.trim().isNotEmpty) SelectableText(text),
for (final part in parts.where(_isFile)) _attachment(context, part),
for (final part in parts.where(_isFile))
if (!chatPartIsThumbnail(part)) _attachment(context, part),
for (final part in parts)
if (part['type'] != 'text' &&
!_isFile(part) &&
@@ -262,11 +300,7 @@ class ChatMessageView extends StatelessWidget {
padding: const EdgeInsets.only(right: 8),
child: Icon(cupertino ? CupertinoIcons.paperclip : Icons.attach_file),
),
Expanded(
child: SelectableText(
_attachmentDisplayName(part['name'], part['uri']),
),
),
Expanded(child: SelectableText(chatAttachmentPartName(part))),
],
);
}
@@ -288,11 +322,3 @@ List<JsonMap> _partsOf(Map<dynamic, dynamic> source) {
bool _isFile(JsonMap part) =>
part['type'] == 'file' &&
'${part['name'] ?? ''}${part['uri'] ?? ''}'.trim().isNotEmpty;
/// The web's attachment name rule: its own name, else the URI basename, else
/// `file`, so an attachment never shows an empty label.
String _attachmentDisplayName(Object? name, Object? uri) {
final shown = '${name ?? ''}'.trim();
final basename = '${uri ?? ''}'.split('/').last.trim();
return shown.isNotEmpty ? shown : (basename.isEmpty ? 'file' : basename);
}
+60
View File
@@ -0,0 +1,60 @@
# Chat attachment thumbnails
Images the operator sends now show as rounded thumbnails above the user bubble
(up to 200x240 logical px). Tapping one opens a full-screen viewer that you can
zoom with pinch or scroll. The viewer uses the platform's own close control:
an IconButton in the AppBar on Material, and a CupertinoButton in the
CupertinoNavigationBar on Cupertino. Other files keep the paperclip row.
## How the image bytes are loaded
- **`data:` URI.** Claude Code history stores image blocks inline, so the app
decodes these directly.
- **`file://` URI.** OpenCode and Codex history point at the server's
attachment store. The app fetches these with the new websocket request
`chat_attachment_image`:
- Request: `{chat_attachment_image_request: {uri}}`.
- Reply: `{chat_attachment_image: {uri, mime, size, data(base64)}}`.
- The server opens the store with `os.Root`. It serves only regular files
that sit directly in that directory and are 4 MiB or smaller. The type is
sniffed from the bytes and must be png, jpeg, gif, webp or bmp.
- It refuses traversal, symlinks, nested paths, other hosts and other
schemes.
- A missing file gets the error "image is no longer available". The app
then shows a placeholder that reads "Image no longer available".
- **`upload:<stored name>`.** This is the URI on a just-sent (optimistic) row.
The composer gives its own bytes to the cache, so the image shows right
away. The same bytes also serve the recorded `file:///…/up-…` URI after the
server records the turn, because the stored file name is the same. Files
sent inline use their own `data:` URI.
- **http(s) URLs.** These are never loaded. They stay as file rows.
`ChatAttachmentImages` is created once per thread view and per gateway. It
holds the decoded bytes in memory, keyed by URI, up to 48 MiB, and drops the
least recently used first. When the server refuses an image, that answer is
kept and the image is not requested again. Transport errors are not kept, so a
later build tries again.
## Evidence
- `go test ./internal/server/ -run ChatAttachment` passes. This covers a
stored image, the outside, traversal, encoded, nested, symlink, directory,
host, scheme, query, fragment and non-image cases, and the missing,
oversize and removed-store cases.
- `flutter test` (full suite) passes, including
`test/features/chat/ui/transcript/chat_attachment_thumbnail_test.dart` and
`test/features/chat/domain/chat_attachment_image_test.dart`.
- `flutter analyze` reports only the existing info in
`artifact_viewer_page_test.dart`.
- `flutter build web` succeeds.
- No browser or device capture was taken. The rendered look has not been
checked outside widget tests.
## Known gaps
- Claude Code history drops an image block whose base64 data is over 512 KiB
(`internal/claude/transcript.go`). After a reload, such an image is missing
from the turn entirely, so there is nothing to draw.
- Images over 4 MiB show "Image too large to preview". The limit exists
because the reply is a single websocket frame that the server must write
within its 5 s deadline, and the client sends requests one at a time.
@@ -215,7 +215,13 @@ void main() {
await tester.tap(find.byKey(const Key('chat-composer-attach')));
await tester.pumpAndSettle();
await typeAndSend(tester, 'hello');
expect(find.text('screen.png'), findsOneWidget);
// The sent image draws from its own inline bytes as a thumbnail named
// for the file; the text file stays a named row.
expect(
find.byKey(const Key('chat-attachment-thumbnail')),
findsOneWidget,
);
expect(find.bySemanticsLabel('screen.png'), findsOneWidget);
expect(find.text('notes.txt'), findsOneWidget);
expect(find.textContaining('data'), findsNothing);
@@ -0,0 +1,70 @@
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/features/chat/domain/chat_attachment_image.dart';
void main() {
test('image type comes from MIME, data: URI or extension', () {
expect(
chatPartImageMime({'type': 'file', 'mime': 'image/PNG', 'uri': 'x'}),
'image/png',
);
expect(
chatPartImageMime({'type': 'file', 'uri': 'data:image/jpeg;base64,AA'}),
'image/jpeg',
);
expect(
chatPartImageMime({'type': 'file', 'name': 'a.WEBP', 'uri': 'file:///a'}),
'image/webp',
);
expect(
chatPartImageMime({'type': 'file', 'mime': 'image/svg+xml', 'uri': 'a'}),
isNull,
);
expect(
chatPartImageMime({
'type': 'file',
'mime': 'text/plain',
'name': 'a.png',
}),
isNull,
);
expect(chatPartImageMime({'type': 'text', 'mime': 'image/png'}), isNull);
});
test('only inline, stored and uploaded URIs are loaded', () {
expect(
chatImageSourceOf('data:image/png;base64,AA'),
ChatImageSource.inline,
);
expect(chatImageSourceOf('file:///s/up-1-a.png'), ChatImageSource.stored);
expect(chatImageSourceOf('upload:up-1-a.png'), ChatImageSource.upload);
expect(chatImageSourceOf('https://x.test/a.png'), isNull);
expect(chatImageSourceOf('a.png'), isNull);
});
test('optimistic URIs and stored names line up with the recorded turn', () {
expect(
chatOptimisticAttachmentUri({
'name': 'a b.png',
'upload': 'up-1-a b.png',
}),
'upload:up-1-a b.png',
);
expect(
chatOptimisticAttachmentUri({
'name': 'a.png',
'mime': 'image/png',
'data': 'AA',
}),
'data:image/png;base64,AA',
);
expect(chatOptimisticAttachmentUri({'name': 'a.png'}), 'a.png');
expect(chatStoredFileName('upload:up-1-a b.png'), 'up-1-a b.png');
expect(chatStoredFileName('file:///s/up-1-a%20b.png'), 'up-1-a b.png');
});
test('data: URIs decode, malformed ones do not', () {
expect(chatDataUriBytes('data:image/png;base64,AAEC'), [0, 1, 2]);
expect(chatDataUriBytes('data:image/png,plain'), isNull);
expect(chatDataUriBytes('data:image/png;base64,%%%'), isNull);
});
}
@@ -0,0 +1,253 @@
import 'dart:convert';
import 'package:flutter/cupertino.dart';
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/connection_state.dart';
import 'package:pipelines_app/features/chat/data/chat_attachment_images.dart';
import 'package:pipelines_app/features/chat/domain/chat_transcript.dart';
import 'package:pipelines_app/features/chat/ui/transcript/chat_message_view.dart';
/// A 1x1 PNG.
const String _png =
'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==';
const String _stored =
'file:///home/op/.pipelines-chat-attachments/up-1-shot.png';
class _ImageGateway implements ApiGateway {
final calls = <JsonMap>[];
Object? failure;
@override
Stream<JsonMap> get frames => const Stream.empty();
@override
Future<JsonMap> call(String type, [JsonMap fields = const {}]) async {
expect(type, 'chat_attachment_image');
calls.add(fields);
final failure = this.failure;
if (failure != null) throw failure;
final uri = (fields['chat_attachment_image_request'] as Map)['uri'];
return {
'type': 'chat_attachment_image',
'chat_attachment_image': {'uri': uri, 'mime': 'image/png', 'data': _png},
};
}
}
JsonMap _user(List<JsonMap> parts) => transcriptRows([
{'id': 'u1', 'role': 'user', 'parts': parts},
]).single;
Widget _host(
JsonMap row,
ChatAttachmentImages? images, {
bool cupertino = false,
}) {
final body = ListView(
children: [ChatMessageView(row: row, images: images)],
);
if (cupertino) {
return CupertinoApp(home: CupertinoPageScaffold(child: body));
}
return MaterialApp(
theme: ThemeData(platform: TargetPlatform.android),
home: Scaffold(body: body),
);
}
final _thumbnail = find.byKey(const Key('chat-attachment-thumbnail'));
final _viewerImage = find.byKey(const Key('chat-image-viewer-image'));
void main() {
for (final cupertino in [false, true]) {
final style = cupertino ? 'Cupertino' : 'Material';
testWidgets(
'$style: an inline data: image draws a thumbnail above the text '
'and opens the full-screen viewer',
(tester) async {
final handle = tester.ensureSemantics();
await tester.pumpWidget(
_host(
_user([
{'type': 'text', 'text': 'See this'},
{
'type': 'file',
'name': 'image',
'mime': 'image/png',
'uri': 'data:image/png;base64,$_png',
},
]),
null,
cupertino: cupertino,
),
);
await tester.pump();
expect(_thumbnail, findsOneWidget);
expect(
find.byKey(const Key('chat-attachment-thumbnail-image')),
findsOneWidget,
);
// No paperclip row and no base64 shown as a file name.
expect(find.byIcon(Icons.attach_file), findsNothing);
expect(find.byIcon(CupertinoIcons.paperclip), findsNothing);
expect(find.textContaining('base64'), findsNothing);
expect(
tester.getTopLeft(_thumbnail).dy,
lessThan(tester.getTopLeft(find.text('See this')).dy),
);
expect(
tester.getSemantics(_thumbnail.first),
matchesSemantics(
label: 'image',
isButton: true,
isImage: true,
hasTapAction: true,
),
);
handle.dispose();
await tester.tap(_thumbnail);
await tester.pumpAndSettle();
expect(_viewerImage, findsOneWidget);
expect(find.byKey(const Key('chat-image-viewer-zoom')), findsOneWidget);
await tester.tap(find.byKey(const Key('chat-image-viewer-close')));
await tester.pumpAndSettle();
expect(_viewerImage, findsNothing);
expect(_thumbnail, findsOneWidget);
},
);
}
testWidgets('a stored file:// image is fetched once through the gateway and '
'reused when the row is rebuilt', (tester) async {
final gateway = _ImageGateway();
final images = ChatAttachmentImages(gateway);
// Codex records no MIME: the name's extension makes it an image.
final row = _user([
{'type': 'file', 'name': 'shot.png', 'uri': _stored},
]);
await tester.pumpWidget(_host(row, images));
expect(
find.byKey(const Key('chat-attachment-thumbnail-loading')),
findsOneWidget,
);
await tester.pump();
await tester.pump();
expect(_thumbnail, findsOneWidget);
expect(gateway.calls, [
{
'chat_attachment_image_request': {'uri': _stored},
},
]);
await tester.pumpWidget(const SizedBox());
await tester.pumpWidget(_host(row, images));
expect(_thumbnail, findsOneWidget);
expect(gateway.calls, hasLength(1));
await tester.tap(_thumbnail);
await tester.pumpAndSettle();
expect(_viewerImage, findsOneWidget);
expect(find.text('shot.png'), findsOneWidget);
});
testWidgets('an expired stored image becomes a labelled placeholder', (
tester,
) async {
final gateway = _ImageGateway()
..failure = const ProtocolError('image is no longer available');
final images = ChatAttachmentImages(gateway);
final row = _user([
{'type': 'text', 'text': 'Old screenshot'},
{'type': 'file', 'name': 'shot.png', 'mime': 'image/png', 'uri': _stored},
]);
await tester.pumpWidget(_host(row, images));
await tester.pump();
await tester.pump();
expect(find.text(chatImageGoneMessage), findsOneWidget);
expect(_thumbnail, findsNothing);
expect(find.text('Old screenshot'), findsOneWidget);
// The refusal is settled: rebuilding does not ask again.
await tester.pumpWidget(const SizedBox());
await tester.pumpWidget(_host(row, images));
expect(find.text(chatImageGoneMessage), findsOneWidget);
expect(gateway.calls, hasLength(1));
});
testWidgets('non-image files and remote image URLs keep the file row', (
tester,
) async {
final gateway = _ImageGateway();
await tester.pumpWidget(
_host(
_user([
{'type': 'text', 'text': 'Files'},
{
'type': 'file',
'name': 'report.pdf',
'mime': 'application/pdf',
'uri':
'file:///home/op/.pipelines-chat-attachments/up-2-report.pdf',
},
{'type': 'file', 'name': 'remote.png', 'uri': 'https://x.test/a.png'},
{
'type': 'file',
'name': 'logo.svg',
'mime': 'image/svg+xml',
'uri': 'file:///home/op/.pipelines-chat-attachments/up-3-logo.svg',
},
]),
ChatAttachmentImages(gateway),
),
);
await tester.pump();
expect(_thumbnail, findsNothing);
expect(find.text('report.pdf'), findsOneWidget);
expect(find.text('remote.png'), findsOneWidget);
expect(find.text('logo.svg'), findsOneWidget);
expect(find.byIcon(Icons.attach_file), findsNWidgets(3));
expect(gateway.calls, isEmpty);
});
testWidgets('a just-uploaded image draws from the composer bytes before and '
'after the server records the turn', (tester) async {
final gateway = _ImageGateway();
final images = ChatAttachmentImages(gateway)
..rememberUpload('up-1-shot.png', base64Decode(_png));
await tester.pumpWidget(
_host(
_user([
{
'type': 'file',
'name': 'shot.png',
'mime': 'image/png',
'uri': 'upload:up-1-shot.png',
},
]),
images,
),
);
await tester.pump();
expect(_thumbnail, findsOneWidget);
await tester.pumpWidget(
_host(
_user([
{
'type': 'file',
'name': 'shot.png',
'mime': 'image/png',
'uri': _stored,
},
]),
images,
),
);
await tester.pump();
expect(_thumbnail, findsOneWidget);
expect(gateway.calls, isEmpty);
});
}
+21
View File
@@ -80,6 +80,12 @@ const (
// session. ChatShellOutput reads a bounded page from one such shell.
ChatShells = "chat_shells"
ChatShellOutput = "chat_shell_output"
// ChatAttachmentImage reads back one image the operator attached earlier,
// so a transcript can draw it after a reload. The request body is
// ChatAttachmentImageRequest (the history part's file:// URI) and the reply
// carries ChatAttachmentImageContent. Only regular image files inside the
// server's private chat attachment store are served.
ChatAttachmentImage = "chat_attachment_image"
// ChatEvent and ChatPermission are the server-pushed frames; they are the
// only types the server sends without a matching request.
ChatEvent = "chat_event"
@@ -361,6 +367,21 @@ type ChatAttachment struct {
Upload string `json:"upload,omitempty"`
}
// ChatAttachmentImageRequest names one stored attachment by the file:// URI a
// history file part carries.
type ChatAttachmentImageRequest struct {
URI string `json:"uri"`
}
// ChatAttachmentImageContent is the chat_attachment_image reply: the file's
// bytes as standard base64 and the image MIME type sniffed from those bytes.
type ChatAttachmentImageContent struct {
URI string `json:"uri"`
Mime string `json:"mime"`
Size int64 `json:"size"`
Data string `json:"data"`
}
// ChatMessage is one stored turn returned by chat_messages. A user turn is a
// single text part; an assistant turn holds the text, reasoning and tool parts
// the phone renders. Parts corresponds to the OpenCode content array.
+4
View File
@@ -229,6 +229,10 @@ type Message struct {
ChatShellOutputQuery *ChatShellOutputQuery `json:"chat_shell_output_query,omitempty"`
ChatShells []ChatShell `json:"chat_shells,omitempty"`
ChatShellOutput *ChatShellOutputPage `json:"chat_shell_output,omitempty"`
// ChatAttachmentImageRequest is the chat_attachment_image body and
// ChatAttachmentImage its reply.
ChatAttachmentImageRequest *ChatAttachmentImageRequest `json:"chat_attachment_image_request,omitempty"`
ChatAttachmentImage *ChatAttachmentImageContent `json:"chat_attachment_image,omitempty"`
// RunEvent is the server-pushed run state delta (see runevents.go) and
// RunIDs the optional subscribe scope, so a client asks for the runs it
// displays. Both are optional so older peers ignore them.
+3
View File
@@ -215,6 +215,9 @@ func handleChat(ctx context.Context, request protocol.Message, broker chatBroker
case protocol.ChatShellOutput:
handleChatShellOutput(ctx, request, broker, registry, write)
return true
case protocol.ChatAttachmentImage:
handleChatAttachmentImage(request, broker, write)
return true
}
return false
}
+136
View File
@@ -0,0 +1,136 @@
package server
import (
"encoding/base64"
"errors"
"fmt"
"io"
"io/fs"
"net/http"
"net/url"
"os"
"path/filepath"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// maxChatAttachmentImageBytes bounds one chat_attachment_image reply. The
// bytes travel base64-encoded in a single websocket frame that the server must
// write within its per-frame deadline, and clients serialize requests, so a
// preview stays well below the 100 MiB upload limit.
const maxChatAttachmentImageBytes = 4 << 20
// errChatAttachmentGone is the reply for a stored file that was collected by
// retention or never existed; clients show it as "no longer available".
var errChatAttachmentGone = errors.New("image is no longer available")
// chatAttachmentImageTypes are the sniffed types a client can draw. SVG and
// anything unrecognised stay a plain file row.
var chatAttachmentImageTypes = map[string]bool{
"image/png": true,
"image/jpeg": true,
"image/gif": true,
"image/webp": true,
"image/bmp": true,
}
// handleChatAttachmentImage returns one image file the operator attached, so a
// transcript can draw it after a reload. Only regular files directly inside the
// private attachment store are readable; anything else is refused before it is
// opened.
func handleChatAttachmentImage(request protocol.Message, broker chatBroker, write func(protocol.Message) error) {
fail := func(message string) {
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: message})
}
if broker == nil {
fail("chat is not configured on this server")
return
}
query := request.ChatAttachmentImageRequest
if query == nil || query.URI == "" {
fail("a chat_attachment_image_request with a uri is required")
return
}
data, mime, err := readChatAttachmentImage(query.URI)
if err != nil {
fail(err.Error())
return
}
_ = write(protocol.Message{Type: protocol.ChatAttachmentImage, ID: request.ID, ChatAttachmentImage: &protocol.ChatAttachmentImageContent{
URI: query.URI,
Mime: mime,
Size: int64(len(data)),
Data: base64.StdEncoding.EncodeToString(data),
}})
}
// readChatAttachmentImage resolves a file:// URI to one regular file in the
// attachment store and returns its bytes and sniffed image type.
func readChatAttachmentImage(uri string) ([]byte, string, error) {
notStored := errors.New("not a stored chat attachment")
u, err := url.Parse(uri)
if err != nil || u.Scheme != "file" || u.Host != "" || u.User != nil || u.Opaque != "" || u.RawQuery != "" || u.ForceQuery || u.Fragment != "" {
return nil, "", notStored
}
path := u.Path
if !filepath.IsAbs(path) || filepath.Clean(path) != path {
return nil, "", notStored
}
dir, err := chatAttachmentDir()
if err != nil {
return nil, "", err
}
name := filepath.Base(path)
if filepath.Dir(path) != dir || name == "." || name == ".." || name == string(filepath.Separator) {
return nil, "", notStored
}
dirInfo, err := os.Lstat(dir)
if errors.Is(err, fs.ErrNotExist) {
return nil, "", errChatAttachmentGone
}
if err != nil || !dirInfo.IsDir() {
return nil, "", errors.New("attachment storage must be a directory, not a symlink")
}
root, err := os.OpenRoot(dir)
if err != nil {
return nil, "", err
}
defer root.Close()
if actual, err := root.Stat("."); err != nil || !os.SameFile(dirInfo, actual) {
return nil, "", errors.New("chat attachment storage changed while opening")
}
info, err := root.Lstat(name)
if errors.Is(err, fs.ErrNotExist) {
return nil, "", errChatAttachmentGone
}
if err != nil || !info.Mode().IsRegular() {
return nil, "", notStored
}
if info.Size() > maxChatAttachmentImageBytes {
return nil, "", fmt.Errorf("image is too large to preview (over %d MiB)", maxChatAttachmentImageBytes>>20)
}
file, err := root.Open(name)
if errors.Is(err, fs.ErrNotExist) {
return nil, "", errChatAttachmentGone
}
if err != nil {
return nil, "", notStored
}
defer file.Close()
opened, err := file.Stat()
if err != nil || !os.SameFile(info, opened) || !opened.Mode().IsRegular() {
return nil, "", errors.New("attachment changed while opening")
}
data, err := io.ReadAll(io.LimitReader(file, maxChatAttachmentImageBytes+1))
if err != nil {
return nil, "", fmt.Errorf("read attachment: %w", err)
}
if len(data) > maxChatAttachmentImageBytes {
return nil, "", fmt.Errorf("image is too large to preview (over %d MiB)", maxChatAttachmentImageBytes>>20)
}
mime := http.DetectContentType(data)
if !chatAttachmentImageTypes[mime] {
return nil, "", errors.New("attachment is not a previewable image")
}
return data, mime, nil
}
@@ -0,0 +1,149 @@
package server
import (
"context"
"encoding/base64"
"net/url"
"os"
"path/filepath"
"strings"
"testing"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// pngHeader is enough for content sniffing to report image/png.
var pngHeader = []byte("\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00\x00\x01\x08\x06\x00\x00\x00")
func attachmentImageStore(t *testing.T) string {
t.Helper()
dir := filepath.Join(t.TempDir(), "uploads")
if err := os.Mkdir(dir, 0o700); err != nil {
t.Fatal(err)
}
t.Setenv("PIPELINES_CHAT_ATTACHMENT_DIR", dir)
return dir
}
func fileURI(path string) string { return (&url.URL{Scheme: "file", Path: path}).String() }
func requestAttachmentImage(t *testing.T, uri string) protocol.Message {
t.Helper()
var reply protocol.Message
request := protocol.Message{Type: protocol.ChatAttachmentImage, ID: "img-1", ChatAttachmentImageRequest: &protocol.ChatAttachmentImageRequest{URI: uri}}
handled := handleChat(context.Background(), request, &fakeChat{}, nil, nil, "conn-test", func(message protocol.Message) error {
reply = message
return nil
})
if !handled {
t.Fatal("chat_attachment_image was not dispatched")
}
if reply.ID != "img-1" {
t.Fatalf("reply id = %q", reply.ID)
}
return reply
}
func TestChatAttachmentImageServesStoredImage(t *testing.T) {
dir := attachmentImageStore(t)
path := filepath.Join(dir, "up-0123456789abcdef0123456789abcdef-shot one.png")
if err := os.WriteFile(path, pngHeader, 0o600); err != nil {
t.Fatal(err)
}
reply := requestAttachmentImage(t, fileURI(path))
if reply.Type != protocol.ChatAttachmentImage || reply.ChatAttachmentImage == nil {
t.Fatalf("reply = %+v", reply)
}
got := reply.ChatAttachmentImage
data, err := base64.StdEncoding.DecodeString(got.Data)
if err != nil || string(data) != string(pngHeader) {
t.Fatalf("data = %q err=%v", data, err)
}
if got.Mime != "image/png" || got.Size != int64(len(pngHeader)) || got.URI != fileURI(path) {
t.Fatalf("content = %+v", got)
}
}
func TestChatAttachmentImageRefusesOutsideAndUnsafeReferences(t *testing.T) {
dir := attachmentImageStore(t)
outside := filepath.Join(filepath.Dir(dir), "secret.png")
if err := os.WriteFile(outside, pngHeader, 0o600); err != nil {
t.Fatal(err)
}
nested := filepath.Join(dir, "nested")
if err := os.Mkdir(nested, 0o700); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(nested, "inner.png"), pngHeader, 0o600); err != nil {
t.Fatal(err)
}
link := filepath.Join(dir, "link.png")
if err := os.Symlink(outside, link); err != nil {
t.Fatal(err)
}
text := filepath.Join(dir, "notes.txt")
if err := os.WriteFile(text, []byte("plain text, not an image"), 0o600); err != nil {
t.Fatal(err)
}
cases := map[string]string{
"outside": fileURI(outside),
"traversal": "file://" + dir + "/../secret.png",
"encoded": "file://" + dir + "/%2e%2e/secret.png",
"nested": fileURI(filepath.Join(nested, "inner.png")),
"symlink": fileURI(link),
"directory": fileURI(nested),
"store itself": fileURI(dir),
"relative": "file:secret.png",
"remote host": "file://example.com" + outside,
"http": "https://example.com/a.png",
"data": "data:image/png;base64,AAAA",
"query": fileURI(outside) + "?x=1",
"not an image": fileURI(text),
"plain path": outside,
"fragment": fileURI(outside) + "#top",
}
for name, uri := range cases {
t.Run(name, func(t *testing.T) {
reply := requestAttachmentImage(t, uri)
if reply.Type != protocol.Error || reply.ChatAttachmentImage != nil {
t.Fatalf("%s was served: %+v", uri, reply)
}
})
}
}
func TestChatAttachmentImageMissingAndOversize(t *testing.T) {
dir := attachmentImageStore(t)
missing := requestAttachmentImage(t, fileURI(filepath.Join(dir, "up-gone.png")))
if missing.Type != protocol.Error || !strings.Contains(missing.Error, "no longer available") {
t.Fatalf("missing = %+v", missing)
}
large := filepath.Join(dir, "large.png")
body := append(append([]byte{}, pngHeader...), make([]byte, maxChatAttachmentImageBytes)...)
if err := os.WriteFile(large, body, 0o600); err != nil {
t.Fatal(err)
}
oversize := requestAttachmentImage(t, fileURI(large))
if oversize.Type != protocol.Error || !strings.Contains(oversize.Error, "too large") {
t.Fatalf("oversize = %+v", oversize)
}
if err := os.RemoveAll(dir); err != nil {
t.Fatal(err)
}
gone := requestAttachmentImage(t, fileURI(filepath.Join(dir, "up-any.png")))
if gone.Type != protocol.Error || !strings.Contains(gone.Error, "no longer available") {
t.Fatalf("store gone = %+v", gone)
}
}
func TestChatAttachmentImageRequiresRequestBody(t *testing.T) {
attachmentImageStore(t)
var reply protocol.Message
handleChat(context.Background(), protocol.Message{Type: protocol.ChatAttachmentImage, ID: "x"}, &fakeChat{}, nil, nil, "c", func(m protocol.Message) error {
reply = m
return nil
})
if reply.Type != protocol.Error {
t.Fatalf("reply = %+v", reply)
}
}
+16 -7
View File
@@ -190,22 +190,31 @@ func safeChatAttachmentName(value string) string {
return name
}
// openChatAttachmentStore opens the private attachment directory, collects
// unleased files past retention and reports what the rest occupy. The caller
// holds chatAttachmentStore and closes the root.
func openChatAttachmentStore() (*os.Root, string, int64, int, error) {
// chatAttachmentDir is the configured attachment store directory: an absolute,
// cleaned path that may not exist yet.
func chatAttachmentDir() (string, error) {
dir := os.Getenv("PIPELINES_CHAT_ATTACHMENT_DIR")
if dir == "" {
home, err := os.UserHomeDir()
if err != nil {
return nil, "", 0, 0, err
return "", err
}
dir = filepath.Join(home, ".pipelines-chat-attachments")
}
if !filepath.IsAbs(dir) {
return nil, "", 0, 0, fmt.Errorf("chat attachment storage must be an absolute path")
return "", fmt.Errorf("chat attachment storage must be an absolute path")
}
return filepath.Clean(dir), nil
}
// openChatAttachmentStore opens the private attachment directory, collects
// unleased files past retention and reports what the rest occupy. The caller
// holds chatAttachmentStore and closes the root.
func openChatAttachmentStore() (*os.Root, string, int64, int, error) {
dir, err := chatAttachmentDir()
if err != nil {
return nil, "", 0, 0, err
}
dir = filepath.Clean(dir)
if err := os.Mkdir(dir, 0o700); err != nil && !os.IsExist(err) {
return nil, "", 0, 0, fmt.Errorf("prepare attachment directory: %w", err)
}