From 81460c4a4d02a42b5cb03c4f0d9563c7b43c2fa0 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Sun, 8 Nov 2026 23:57:53 +0000 Subject: [PATCH 1/4] Add POST /files to store an uploaded file inside a home folder The handler reuses the home-path resolution of GET /files, refuses special filesystems and non-directories, writes with O_EXCL so an existing name is answered 409 instead of overwritten, enforces the chat upload size limit and replies with the stored name, path and size. --- internal/server/home_files_upload.go | 149 +++++++++++++++++++++ internal/server/home_files_upload_test.go | 153 ++++++++++++++++++++++ internal/server/websocket.go | 1 + 3 files changed, 303 insertions(+) create mode 100644 internal/server/home_files_upload.go create mode 100644 internal/server/home_files_upload_test.go diff --git a/internal/server/home_files_upload.go b/internal/server/home_files_upload.go new file mode 100644 index 00000000..cbb76a55 --- /dev/null +++ b/internal/server/home_files_upload.go @@ -0,0 +1,149 @@ +package server + +import ( + "encoding/json" + "errors" + "io" + "io/fs" + "net/http" + "net/url" + "os" + "path/filepath" + "strings" + "unicode/utf8" +) + +// maxHomeFileUploadBytes bounds one file stored through POST /files. It +// matches the chat upload limit so both raw-body routes behave alike. +const maxHomeFileUploadBytes = maxChatUploadBytes + +type homeFileUploadReply struct { + Name string `json:"name"` + Path string `json:"path"` + Size int64 `json:"size"` +} + +// serveHomeFileUpload stores the request body as a new file inside the +// folder named by ?path=, which must lie inside the operator's home. The name +// travels in X-Pipelines-Upload-Name; an existing file is never overwritten. +func serveHomeFileUpload(w http.ResponseWriter, r *http.Request) { + home, err := OperatorHomeDirectory() + if err != nil { + http.NotFound(w, r) + return + } + serveHomeFileUploadTo(w, r, home) +} + +func serveHomeFileUploadTo(w http.ResponseWriter, r *http.Request, home string) { + fail := func(status int, message string) { http.Error(w, message, status) } + rawName := r.Header.Get(chatUploadHeader) + if rawName == "" { + fail(http.StatusBadRequest, "missing "+chatUploadHeader) + return + } + if r.Header.Get("Sec-Fetch-Site") == "cross-site" { + fail(http.StatusForbidden, "cross-site upload refused") + return + } + decoded, err := url.PathUnescape(rawName) + if err != nil { + decoded = rawName + } + name, err := uploadFileName(decoded) + if err != nil { + fail(http.StatusBadRequest, err.Error()) + return + } + if r.ContentLength > maxHomeFileUploadBytes { + fail(http.StatusRequestEntityTooLarge, "file exceeds the 100 MiB limit") + return + } + home = filepath.Clean(home) + realHome, err := filepath.EvalSymlinks(home) + if err != nil { + fail(http.StatusNotFound, "home directory unavailable") + return + } + target, err := expandHomePath(home, r.URL.Query().Get("path")) + if err != nil { + fail(http.StatusNotFound, "folder not found") + return + } + _, realDir, err := resolveInsideHome(realHome, target) + if err != nil { + if strings.Contains(err.Error(), "outside the home directory") { + fail(http.StatusForbidden, "folder access denied") + } else { + fail(http.StatusNotFound, "folder not found") + } + return + } + info, err := os.Stat(realDir) + if err != nil || !info.IsDir() { + fail(http.StatusNotFound, "folder not found") + return + } + if specialFilesystem(realDir) { + fail(http.StatusForbidden, "folder access denied") + return + } + file, err := os.OpenFile(filepath.Join(realDir, name), os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0o644) + if err != nil { + switch { + case errors.Is(err, fs.ErrExist): + fail(http.StatusConflict, "a file named "+name+" already exists") + case errors.Is(err, fs.ErrPermission): + fail(http.StatusForbidden, "folder access denied") + default: + fail(http.StatusInternalServerError, "write file: "+err.Error()) + } + return + } + // The process umask may narrow the create mode; the stored file is meant + // to be readable like one the operator saved themselves. + size, err := int64(0), file.Chmod(0o644) + if err == nil { + size, err = io.Copy(file, io.LimitReader(r.Body, maxHomeFileUploadBytes+1)) + } + if err == nil && size > maxHomeFileUploadBytes { + err = errors.New("file exceeds the 100 MiB limit") + } + if err == nil { + err = file.Sync() + } + if closeErr := file.Close(); err == nil { + err = closeErr + } + if err != nil { + _ = os.Remove(file.Name()) + status := http.StatusBadRequest + if size > maxHomeFileUploadBytes { + status = http.StatusRequestEntityTooLarge + } + fail(status, err.Error()) + return + } + w.Header().Set("Content-Type", "application/json") + w.Header().Set("Cache-Control", "no-store") + _ = json.NewEncoder(w).Encode(homeFileUploadReply{Name: name, Path: filepath.Join(target, name), Size: size}) +} + +// uploadFileName accepts one plain file name: no directory parts, no NUL, +// not "." or "..", and short enough for common filesystems. The name is kept +// as given rather than rewritten, so the stored file is the one the operator +// asked for. +func uploadFileName(value string) (string, error) { + name := strings.TrimSpace(value) + switch { + case name == "" || name == "." || name == "..": + return "", errors.New("file name is missing") + case strings.ContainsAny(name, "/\\\x00"): + return "", errors.New("file name must not contain path separators") + case !utf8.ValidString(name): + return "", errors.New("file name is not valid UTF-8") + case len(name) > 255: + return "", errors.New("file name is too long") + } + return name, nil +} diff --git a/internal/server/home_files_upload_test.go b/internal/server/home_files_upload_test.go new file mode 100644 index 00000000..74017eb3 --- /dev/null +++ b/internal/server/home_files_upload_test.go @@ -0,0 +1,153 @@ +package server + +import ( + "encoding/json" + "net/http" + "net/http/httptest" + "os" + "path/filepath" + "strings" + "testing" +) + +func postHomeFile(t *testing.T, home, dir, name, body string) *httptest.ResponseRecorder { + t.Helper() + req := httptest.NewRequest(http.MethodPost, "/files?path="+dir, strings.NewReader(body)) + if name != "" { + req.Header.Set(chatUploadHeader, name) + } + req.Header.Set("Content-Type", "text/plain") + rec := httptest.NewRecorder() + serveHomeFileUploadTo(rec, req, home) + return rec +} + +func TestServeHomeFileUpload(t *testing.T) { + root := t.TempDir() + home := filepath.Join(root, "home") + outside := filepath.Join(root, "outside") + for _, dir := range []string{filepath.Join(home, "project"), outside} { + if err := os.MkdirAll(dir, 0o755); err != nil { + t.Fatal(err) + } + } + if err := os.WriteFile(filepath.Join(home, "project", "kept.txt"), []byte("original"), 0o644); err != nil { + t.Fatal(err) + } + if err := os.Symlink(outside, filepath.Join(home, "escape")); err != nil { + t.Fatal(err) + } + + t.Run("stores a new file in the shown folder", func(t *testing.T) { + rec := postHomeFile(t, home, "~/project", "big%20photo.txt", "hello upload") + if rec.Code != http.StatusOK { + t.Fatalf("status = %d %s", rec.Code, rec.Body) + } + var reply homeFileUploadReply + if err := json.Unmarshal(rec.Body.Bytes(), &reply); err != nil { + t.Fatal(err) + } + want := filepath.Join(home, "project", "big photo.txt") + if reply.Name != "big photo.txt" || reply.Path != want || reply.Size != int64(len("hello upload")) { + t.Fatalf("reply = %+v", reply) + } + info, err := os.Stat(want) + if err != nil || info.Mode().Perm() != 0o644 { + t.Fatalf("stored file = %v %v", info, err) + } + data, _ := os.ReadFile(want) + if string(data) != "hello upload" { + t.Fatalf("contents = %q", data) + } + }) + + t.Run("operator home seam and absolute path", func(t *testing.T) { + originalHomeDirectory := operatorHomeDirectory + operatorHomeDirectory = func() (string, error) { return home, nil } + t.Cleanup(func() { operatorHomeDirectory = originalHomeDirectory }) + req := httptest.NewRequest(http.MethodPost, "/files?path="+filepath.Join(home, "project"), strings.NewReader("x")) + req.Header.Set(chatUploadHeader, "seam.txt") + rec := httptest.NewRecorder() + serveHomeFileUpload(rec, req) + if rec.Code != http.StatusOK { + t.Fatalf("status = %d %s", rec.Code, rec.Body) + } + if _, err := os.Stat(filepath.Join(home, "project", "seam.txt")); err != nil { + t.Fatal(err) + } + }) + + t.Run("existing file is refused and kept", func(t *testing.T) { + rec := postHomeFile(t, home, "~/project", "kept.txt", "replacement") + if rec.Code != http.StatusConflict || !strings.Contains(rec.Body.String(), "already exists") { + t.Fatalf("response = %d %s", rec.Code, rec.Body) + } + data, _ := os.ReadFile(filepath.Join(home, "project", "kept.txt")) + if string(data) != "original" { + t.Fatalf("contents = %q, want original", data) + } + }) + + t.Run("empty file is stored", func(t *testing.T) { + rec := postHomeFile(t, home, "~", "empty.txt", "") + if rec.Code != http.StatusOK { + t.Fatalf("status = %d %s", rec.Code, rec.Body) + } + info, err := os.Stat(filepath.Join(home, "empty.txt")) + if err != nil || info.Size() != 0 { + t.Fatalf("stored file = %v %v", info, err) + } + }) + + refusals := []struct { + label string + dir string + name string + want int + }{ + {"missing name", "~/project", "", http.StatusBadRequest}, + {"name with slash", "~/project", "sub%2Fname.txt", http.StatusBadRequest}, + {"dot dot name", "~/project", "..", http.StatusBadRequest}, + {"outside home", filepath.Join(home, "..", "outside"), "x.txt", http.StatusForbidden}, + {"symlink outside home", "~/escape", "x.txt", http.StatusForbidden}, + {"missing folder", "~/nowhere", "x.txt", http.StatusNotFound}, + {"file is not a folder", "~/project/kept.txt", "x.txt", http.StatusNotFound}, + {"relative path", "project", "x.txt", http.StatusNotFound}, + } + for _, tc := range refusals { + t.Run(tc.label, func(t *testing.T) { + rec := postHomeFile(t, home, tc.dir, tc.name, "x") + if rec.Code != tc.want { + t.Fatalf("status = %d %s, want %d", rec.Code, rec.Body, tc.want) + } + }) + } + if entries, _ := os.ReadDir(outside); len(entries) != 0 { + t.Fatalf("outside directory gained %d entries", len(entries)) + } + + t.Run("declared size over the limit", func(t *testing.T) { + req := httptest.NewRequest(http.MethodPost, "/files?path=~/project", strings.NewReader("x")) + req.Header.Set(chatUploadHeader, "huge.bin") + req.ContentLength = maxHomeFileUploadBytes + 1 + rec := httptest.NewRecorder() + serveHomeFileUploadTo(rec, req, home) + if rec.Code != http.StatusRequestEntityTooLarge { + t.Fatalf("status = %d %s", rec.Code, rec.Body) + } + if _, err := os.Stat(filepath.Join(home, "project", "huge.bin")); !os.IsNotExist(err) { + t.Fatalf("oversized file was stored: %v", err) + } + }) + + t.Run("cross-site post is refused", func(t *testing.T) { + req := httptest.NewRequest(http.MethodPost, "/files?path=~/project", strings.NewReader("x")) + req.Header.Set(chatUploadHeader, "cross.txt") + req.Header.Set("Sec-Fetch-Site", "cross-site") + rec := httptest.NewRecorder() + serveHomeFileUploadTo(rec, req, home) + if rec.Code != http.StatusForbidden { + t.Fatalf("status = %d %s", rec.Code, rec.Body) + } + }) +} diff --git a/internal/server/websocket.go b/internal/server/websocket.go index a32c1034..dcb8bbb7 100644 --- a/internal/server/websocket.go +++ b/internal/server/websocket.go @@ -155,6 +155,7 @@ func HandlerWithOptions(ctx context.Context, options Options, stores ...*pipelin }) mux.HandleFunc("GET /discovery", serveServerDiscovery) mux.HandleFunc("GET /files", serveHomeFile) + mux.HandleFunc("POST /files", serveHomeFileUpload) mux.HandleFunc("POST /chat-uploads", serveChatUpload) mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") From c600f1560c3081d7de24df310ca69182be137c9d Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Mon, 9 Nov 2026 00:00:00 +0000 Subject: [PATCH 2/4] Relay POST /files uploads through the web proxy and peer relay The direct proxy already forwards every /files method behind the sign-in gate; the peer relay now allows POST /files beside /chat-uploads. Tests cover the name header, body and refusal of other POST targets. --- web/src/peerRelay.js | 4 ++- web/test/peerRelay.test.mjs | 56 +++++++++++++++++++++++++++++++++++++ web/test/serve.test.mjs | 50 +++++++++++++++++++++++++++++++++ 3 files changed, 109 insertions(+), 1 deletion(-) diff --git a/web/src/peerRelay.js b/web/src/peerRelay.js index 48bf40c2..18525a84 100644 --- a/web/src/peerRelay.js +++ b/web/src/peerRelay.js @@ -17,6 +17,8 @@ const allowed = (path) => path === "/chat-uploads" || path.startsWith("/artifacts/") || path.startsWith("/updates/"); +// Raw-body uploads: chat attachments and files stored into a home folder. +const postable = (path) => path === "/chat-uploads" || path === "/files"; export class PeerRelay extends PeerRegistry { target(req, path) { const parsed = new URL(req.url, "http://localhost"); @@ -45,7 +47,7 @@ export class PeerRelay extends PeerRegistry { !target || !allowed(target.url.pathname) || !["GET", "HEAD", "POST"].includes(req.method) || - (req.method === "POST" && target.url.pathname !== "/chat-uploads") + (req.method === "POST" && !postable(target.url.pathname)) ) { json(res, 404, { error: "Unsupported remote resource" }); return true; diff --git a/web/test/peerRelay.test.mjs b/web/test/peerRelay.test.mjs index 6cee5a8c..6869a5fc 100644 --- a/web/test/peerRelay.test.mjs +++ b/web/test/peerRelay.test.mjs @@ -76,6 +76,22 @@ async function fixture(t) { return; } res.setHeader("Set-Cookie", "do-not-forward=private"); + if (req.method === "POST") { + let body = ""; + for await (const chunk of req) body += chunk; + res.end( + JSON.stringify({ + name, + method: req.method, + url: req.url, + cookie: req.headers.cookie, + upload: req.headers["x-pipelines-upload-name"], + type: req.headers["content-type"], + body, + }), + ); + return; + } if ( req.url.startsWith("/artifacts/") || req.url.includes("untrusted.svg") @@ -289,6 +305,46 @@ test("browser can authenticate both machines, relay files and keep local credent ); }); +test("file uploads relay to the chosen machine's home folder and other POSTs are refused", async (t) => { + const f = await fixture(t); + await f.register("one", { + endpoints: [f.remotes[0]], + password: "password-one", + }); + const upload = (path, headers = {}) => + fetch(f.base + `/peers/one${path}`, { + method: "POST", + headers: { + Cookie: f.cookie, + "Content-Type": "text/plain", + "X-Pipelines-Upload-Name": "notes%20two.txt", + ...headers, + }, + body: "hello upload", + }); + const reply = await upload("/files?path=%2Fhome%2Fproject"); + assert.equal(reply.status, 200); + assert.equal(reply.headers.get("set-cookie"), null); + assert.deepEqual(await reply.json(), { + name: "one", + method: "POST", + url: "/files?path=%2Fhome%2Fproject", + cookie: "pipelines_session=remote-one", + upload: "notes%20two.txt", + type: "text/plain", + body: "hello upload", + }); + // The remote never sees a POST the relay does not allow. + const before = f.observations.length; + assert.equal((await upload("/artifacts/1/2/report.txt")).status, 404); + assert.equal((await upload("/discovery")).status, 404); + assert.equal(f.observations.length, before); + assert.equal( + (await upload("/files?path=%2Fhome", { Cookie: await f.login() })).status, + 401, + ); +}); + test("websocket relay authenticates the chosen machine without forwarding browser Origin", async (t) => { const f = await fixture(t); await f.register("two", { diff --git a/web/test/serve.test.mjs b/web/test/serve.test.mjs index f08e9f3f..b85b4966 100644 --- a/web/test/serve.test.mjs +++ b/web/test/serve.test.mjs @@ -139,3 +139,53 @@ test("files require sign-in and proxy query, ranges and attachment headers", asy { method: "HEAD", url: path, range: undefined }, ]); }); + +test("file uploads require sign-in and reach the server with their name header", async (t) => { + const requests = []; + const upstream = createServer(async (req, res) => { + let body = ""; + for await (const chunk of req) body += chunk; + requests.push({ + method: req.method, + url: req.url, + upload: req.headers["x-pipelines-upload-name"], + type: req.headers["content-type"], + body, + }); + res.writeHead(409, { "Content-Type": "text/plain; charset=utf-8" }); + res.end("a file named notes.txt already exists"); + }).listen(0, "127.0.0.1"); + await once(upstream, "listening"); + t.after(() => new Promise((done) => upstream.close(done))); + const dir = await mkdtemp(join(tmpdir(), "serve-upload-")); + const auth = join(dir, "auth.json"); + await writeFile(auth, JSON.stringify({ password: "password-1", secret: "s".repeat(40) })); + const port = await freePort(); + const child = spawn(process.execPath, ["serve.mjs", "--port", String(port), + "--pipelines", `127.0.0.1:${upstream.address().port}`], { + cwd: here, + env: { ...process.env, PIPELINES_WEB_AUTH: "", PIPELINES_WEB_AUTH_FILE: auth }, + stdio: ["ignore", "pipe", "inherit"], + }); + t.after(async () => { const exited = once(child, "exit"); child.kill(); await exited; }); + await once(child.stdout, "data"); + const base = `http://127.0.0.1:${port}`; + const path = "/files?path=%2Fhome%2Fproject"; + const post = (headers) => fetch(base + path, { + method: "POST", + headers: { "Content-Type": "text/plain", "X-Pipelines-Upload-Name": "notes.txt", ...headers }, + body: "hello upload", + }); + assert.equal((await post({})).status, 401); + assert.equal(requests.length, 0); + const login = await fetch(base + "/login", { + method: "POST", body: new URLSearchParams({ password: "password-1" }), redirect: "manual", + }); + const cookie = login.headers.get("set-cookie").split(";")[0]; + const reply = await post({ Cookie: cookie }); + assert.equal(reply.status, 409); + assert.equal(await reply.text(), "a file named notes.txt already exists"); + assert.deepEqual(requests, [ + { method: "POST", url: path, upload: "notes.txt", type: "text/plain", body: "hello upload" }, + ]); +}); From b8fb4d350c5efbd68ed470753d5c3538c4a74a39 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Mon, 9 Nov 2026 00:09:01 +0000 Subject: [PATCH 3/4] Upload files into the shown folder from the chat Files panel The header gains an Upload button that uses the host file picker (disabled with its reason where no picker exists), and the panel body becomes a drop target: on web, document drag events are observed through a dart:js_interop seam and a file drag over the panel shows a highlight naming the folder. Each file is posted to POST /files?path= through an injectable transport; refusals (exists, sign in, too large) stay visible until dismissed and the folder reloads afterwards. The list/grid builders move to files_entries.dart to keep the panel small. --- .../features/chat/files/files_controller.dart | 61 ++++ app/lib/features/chat/files/files_drop.dart | 79 ++++++ .../features/chat/files/files_drop_area.dart | 111 ++++++++ .../features/chat/files/files_drop_stub.dart | 11 + .../features/chat/files/files_drop_web.dart | 177 ++++++++++++ .../features/chat/files/files_entries.dart | 91 ++++++ app/lib/features/chat/files/files_header.dart | 22 ++ app/lib/features/chat/files/files_panel.dart | 178 ++++++------ app/lib/features/chat/files/files_upload.dart | 99 +++++++ .../chat/files/files_upload_notice.dart | 60 ++++ .../chat/files/files_panel_upload_test.dart | 261 ++++++++++++++++++ .../chat/files/files_upload_test.dart | 138 +++++++++ 12 files changed, 1190 insertions(+), 98 deletions(-) create mode 100644 app/lib/features/chat/files/files_drop.dart create mode 100644 app/lib/features/chat/files/files_drop_area.dart create mode 100644 app/lib/features/chat/files/files_drop_stub.dart create mode 100644 app/lib/features/chat/files/files_drop_web.dart create mode 100644 app/lib/features/chat/files/files_entries.dart create mode 100644 app/lib/features/chat/files/files_upload.dart create mode 100644 app/lib/features/chat/files/files_upload_notice.dart create mode 100644 app/test/features/chat/files/files_panel_upload_test.dart create mode 100644 app/test/features/chat/files/files_upload_test.dart 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.', + ), + ), + ); + }, + ); +} From 6112e83f62fa49195331aadedbe5fc8161e38af7 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Mon, 9 Nov 2026 00:10:19 +0000 Subject: [PATCH 4/4] Record Files panel upload behaviour, limits and verification --- app/notes/files-upload.md | 104 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 104 insertions(+) create mode 100644 app/notes/files-upload.md diff --git a/app/notes/files-upload.md b/app/notes/files-upload.md new file mode 100644 index 00000000..676eb970 --- /dev/null +++ b/app/notes/files-upload.md @@ -0,0 +1,104 @@ +# Files panel: upload into the shown folder + +## Behaviour + +- The chat Files panel header has an **Upload files** button (next to Refresh). + It opens the host file picker (`hostChatAttachmentPicker`: `file_picker` on + native, `` on web). On a host without a picker the button is + disabled and its tooltip carries the reason + (`Upload files: `). +- The whole panel is a drop target. On web, `files_drop_web.dart` observes the + document's `dragenter`/`dragover`/`dragleave`/`drop` events through + `dart:js_interop`; a drag that carries files and sits over the panel is taken + over (default prevented, `dropEffect = copy`) and the panel shows a highlight + reading `Drop to upload to `. Drags elsewhere keep the browser's + default. Native hosts use `FilesDrop.unsupported` and keep the button only. +- Every picked or dropped file is posted on its own to + `POST /files?path=` (the listing's `path`), with the name in + `X-Pipelines-Upload-Name` (percent-encoded) and the MIME type as + `Content-Type`, through the same transport as chat uploads (`postChatUpload`: + session cookie on native, same-origin fetch on web; relay endpoints post to + `/peers//files`). After the batch the folder that received the files is + reloaded. +- Progress: `Uploading…` / `Uploading n of m…` with a progress strip; the + Upload button is disabled while a batch is in flight. +- Refusals are shown in the panel until dismissed (not swallowed), one line per + failed file; the rest of the batch is still attempted: + - 409: `"name" already exists in this folder.` (the server never overwrites) + - 401: `Sign in to upload files (Settings → Sign in).` + - 413: `"name" is too large to upload (100 MiB limit).` + - other statuses: the server's text, or `(HTTP n)` + - transport error / unreadable dropped item (a folder): reported in words. + +## Server and proxy + +- `internal/server/home_files_upload.go`: `POST /files?path=`. The folder + is resolved like `GET /files` (`expandHomePath` + `resolveInsideHome`, so it + must be inside `$HOME`, symlinks resolved); special filesystems and + non-directories are refused; the name must be a plain file name (no + separators, not `.`/`..`, ≤255 bytes); the file is created with `O_EXCL` and + mode 0644 (set explicitly, independent of umask), so an existing name is + `409 Conflict`; the chat upload limit (100 MiB) applies on `Content-Length` + and on the streamed body (partial file removed). Reply: + `{"name","path","size"}`. `GET /files` is unchanged. +- `web/serve.mjs` already forwarded every `/files` method to the server behind + the sign-in gate; `web/src/peerRelay.js` now allows `POST /files` beside + `POST /chat-uploads` (allowlist + POST check) and forwards + `content-type`, `content-length`, `x-pipelines-upload-name`. + +## Files + +- `app/lib/features/chat/files/files_upload.dart` — `postFileUpload` seam, + `uploadFileInto`, `FilesUploadException`. +- `files_drop.dart`, `files_drop_stub.dart`, `files_drop_web.dart` — drop seam. +- `files_drop_area.dart` — drop target with highlight. +- `files_upload_notice.dart` — progress and refusal strip (Material banner / + Cupertino message with Dismiss). +- `files_entries.dart` — the list/grid builders moved out of `files_panel.dart`. +- `files_controller.dart` — `upload`, `uploading`, `uploadTotal`, + `uploadError`, `reportUploadError`, `dismissUploadError`. +- `files_header.dart` — Upload button; `files_panel.dart` — `picker`/`drop` + parameters, drop wrap, notice. +- Tests: `app/test/features/chat/files/files_upload_test.dart`, + `files_panel_upload_test.dart`; `internal/server/home_files_upload_test.go`; + `web/test/serve.test.mjs`, `web/test/peerRelay.test.mjs`. + +## Verification (2026-11-09) + +``` +$ go test ./internal/server/ -run 'TestServeHomeFile|TestChatUpload' -v | grep -E "^(PASS|ok|FAIL)" +PASS +ok git.a-wan.net/alan/pipelines/internal/server 0.432s + +$ go test ./internal/server/... +ok git.a-wan.net/alan/pipelines/internal/server 65.194s + +$ cd web && node --test test/ +ℹ tests 16 +ℹ pass 16 +ℹ fail 0 + +$ cd app && tool/analyze.sh +analyze: clean; 7s; exit 0 + +$ cd app && tool/memwatch/full.sh test/features/chat/files +memwatch: PASS: 37 passed, 0 failed, 0 skipped; peak 1263 MB; 6s; exit 0 (test/features/chat/files) + +$ cd app && flutter build web --release +Compiling lib/main.dart for the Web... 25.0s +✓ Built build/web +``` + +## Not done / caveats + +- Desktop (macOS/Linux/Windows) drag-and-drop: not implemented. It would need + the `desktop_drop` plugin (a new native dependency in `pubspec.yaml`) whose + desktop builds could not be verified here; desktop hosts get the Upload + button, which works through `file_picker`. Mobile gets the button only, as + specified. +- No real-browser capture of the drag-and-drop interaction was recorded in this + lane (the web build compiles the interop; the drop path is covered through + the seam in widget tests). A browser drop requires a DataTransfer with files, + which the capture kit does not synthesise. +- The web drop listener assumes the Flutter view fills the page (it subtracts + the `flutter-view` element's bounding rect from the pointer position).