package cfbrowser import ( "bytes" "clusterflow.dev/cfbrowser/internal/capture" "context" "crypto/sha256" "encoding/hex" "errors" "io" "mime" "os" "path/filepath" "sort" "strings" "clusterflow.dev/cfbrowser/api" ) type storedFile struct { info api.FileInfo name string } func (m *Manager) store(s *session, name, mimeType string, r io.Reader, max int64) (api.FileInfo, error) { s.mu.Lock() defer s.mu.Unlock() if s.closed { return api.FileInfo{}, api.Err("BROWSER_CLOSED", "session is closed") } if len(s.files) >= 64 { return api.FileInfo{}, api.Err("BROWSER_LIMIT", "file quota reached") } root, err := os.OpenRoot(s.downloadDir) if err != nil { return api.FileInfo{}, err } defer root.Close() id := newID("file-") f, err := root.OpenFile(id, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0600) if err != nil { return api.FileInfo{}, err } hash := sha256.New() n, err := io.Copy(io.MultiWriter(f, hash), io.LimitReader(r, max+1)) err = errors.Join(err, f.Close()) if err != nil || n > max { _ = root.Remove(id) if err != nil { return api.FileInfo{}, err } return api.FileInfo{}, api.Err("BROWSER_DOWNLOAD_LIMIT", "file exceeds configured limit") } info := api.FileInfo{ID: id, Name: safeName(name), MIME: mimeType, Size: n, SHA256: hex.EncodeToString(hash.Sum(nil))} s.files[id] = storedFile{info: info, name: id} return info, nil } func safeName(s string) string { s = filepath.Base(strings.ReplaceAll(s, "\\", "/")) s = strings.Map(func(r rune) rune { if r < 32 || r == 127 { return -1 } return r }, s) if s == "" || s == "." || s == ".." { return "download.bin" } return truncate(s, 200) } func (m *Manager) Capture(ctx context.Context, o api.Owner, sid, pid string) (api.FileInfo, error) { return m.CapturePage(ctx, o, sid, pid, false) } // CapturePage captures a viewport or a bounded full document without scrolling. func (m *Manager) CapturePage(ctx context.Context, o api.Owner, sid, pid string, fullPage bool) (api.FileInfo, error) { ctx, cancel := m.operation(ctx) defer cancel() p, unlock, err := m.lockedPage(ctx, o, sid, pid) if err != nil { return api.FileInfo{}, err } defer unlock() var data []byte if fullPage { engine, ok := p.engine.(api.FullPageCapturer) if !ok { return api.FileInfo{}, api.Err("BROWSER_CAPABILITY_UNSUPPORTED", "full-page capture is unavailable") } data, err = engine.CaptureFullPage(ctx) } else { data, err = p.engine.Capture(ctx) } if err != nil { return api.FileInfo{}, err } if err = capture.Validate(data); err != nil { return api.FileInfo{}, err } s, err := m.owned(o, sid) if err != nil { return api.FileInfo{}, err } return m.store(s, "screenshot.png", "clusterflow.dev/cfbrowser/internal/capture", bytes.NewReader(data), 4*1024*1024) } // Files imports completed engine downloads and returns metadata without disk paths. func (m *Manager) Files(ctx context.Context, o api.Owner, sid string) ([]api.FileInfo, error) { s, err := m.owned(o, sid) if err != nil { return nil, err } for _, d := range s.engine.Downloads() { if err = ctx.Err(); err != nil { return nil, err } if d.State != "completed" { continue } s.mu.Lock() already := s.imported[d.ID] if !already { s.imported[d.ID] = true } s.mu.Unlock() if already { continue } root, e := os.OpenRoot(s.downloadDir) if e != nil { return nil, e } f, e := root.Open(filepath.Base(d.Path)) if e != nil { root.Close() s.mu.Lock() delete(s.imported, d.ID) s.mu.Unlock() return nil, e } _, e = m.store(s, d.Name, mime.TypeByExtension(filepath.Ext(d.Name)), f, m.cfg.MaxDownloadBytes) f.Close() root.Close() if e != nil { s.mu.Lock() delete(s.imported, d.ID) s.mu.Unlock() return nil, e } } s.mu.Lock() defer s.mu.Unlock() out := make([]api.FileInfo, 0, len(s.files)) for _, f := range s.files { out = append(out, f.info) } sort.Slice(out, func(i, j int) bool { return out[i].ID < out[j].ID }) return out, nil } // Export requires a host-authorized destination root and never overwrites files. func (m *Manager) Export(ctx context.Context, o api.Owner, sid, fileID, destinationRoot, relative string) (api.FileInfo, error) { if !filepath.IsLocal(relative) || strings.Contains(relative, "\\") || strings.ContainsRune(relative, 0) { return api.FileInfo{}, api.Err("BROWSER_PATH_BLOCKED", "destination must be a local relative path") } for _, part := range strings.Split(filepath.ToSlash(relative), "/") { if part == ".." || part == "." || part == "" { return api.FileInfo{}, api.Err("BROWSER_PATH_BLOCKED", "invalid destination component") } } s, err := m.owned(o, sid) if err != nil { return api.FileInfo{}, err } s.mu.Lock() f, ok := s.files[fileID] closed := s.closed s.mu.Unlock() if !ok || closed { return api.FileInfo{}, api.Err("BROWSER_FILE_NOT_FOUND", "file is unavailable") } if err = ctx.Err(); err != nil { return api.FileInfo{}, err } srcRoot, err := os.OpenRoot(s.downloadDir) if err != nil { return api.FileInfo{}, err } defer srcRoot.Close() src, err := srcRoot.Open(f.name) if err != nil { return api.FileInfo{}, err } defer src.Close() dstRoot, err := os.OpenRoot(destinationRoot) if err != nil { return api.FileInfo{}, err } defer dstRoot.Close() dst, err := dstRoot.OpenFile(relative, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0600) if err != nil { return api.FileInfo{}, err } _, err = copyContext(ctx, dst, src) err = errors.Join(err, dst.Close()) if err != nil { _ = dstRoot.Remove(relative) return api.FileInfo{}, err } return f.info, nil } func copyContext(ctx context.Context, w io.Writer, r io.Reader) (int64, error) { buf := make([]byte, 32*1024) var total int64 for { if err := ctx.Err(); err != nil { return total, err } n, err := r.Read(buf) if n > 0 { written, e := w.Write(buf[:n]) total += int64(written) if e != nil { return total, e } if written != n { return total, io.ErrShortWrite } } if err == io.EOF { return total, nil } if err != nil { return total, err } } }