From 6f8f884d75ce3d2903fb6c39abce5939ab89d0ff Mon Sep 17 00:00:00 2001 From: kodi Date: Thu, 12 Mar 2026 11:22:24 +0100 Subject: [PATCH] feat: SHIFT-CMD-F zoek functionaliteit toegevoegd --- project_docs/SEARCH_V1_DESIGN.md | 212 ++++++++++++++++++ .../__pycache__/dependencies.cpython-313.pyc | Bin 4580 -> 4851 bytes .../app/__pycache__/main.cpython-313.pyc | Bin 2694 -> 2806 bytes .../__pycache__/routes_search.cpython-313.pyc | Bin 0 -> 912 bytes .../api/__pycache__/schemas.cpython-313.pyc | Bin 7328 -> 7842 bytes webui/backend/app/api/routes_search.py | 18 ++ webui/backend/app/api/schemas.py | 13 ++ webui/backend/app/dependencies.py | 5 + .../filesystem_adapter.cpython-313.pyc | Bin 7115 -> 8562 bytes webui/backend/app/fs/filesystem_adapter.py | 23 ++ webui/backend/app/main.py | 2 + .../search_service.cpython-313.pyc | Bin 0 -> 4203 bytes webui/backend/app/services/search_service.py | 82 +++++++ .../test_api_search_golden.cpython-313.pyc | Bin 0 -> 8546 bytes .../test_ui_smoke_golden.cpython-313.pyc | Bin 10127 -> 10891 bytes .../tests/golden/test_api_search_golden.py | 117 ++++++++++ .../tests/golden/test_ui_smoke_golden.py | 10 + webui/html/app.js | 146 ++++++++++++ webui/html/index.html | 12 + webui/html/style.css | 48 ++++ 20 files changed, 688 insertions(+) create mode 100644 project_docs/SEARCH_V1_DESIGN.md create mode 100644 webui/backend/app/api/__pycache__/routes_search.cpython-313.pyc create mode 100644 webui/backend/app/api/routes_search.py create mode 100644 webui/backend/app/services/__pycache__/search_service.cpython-313.pyc create mode 100644 webui/backend/app/services/search_service.py create mode 100644 webui/backend/tests/golden/__pycache__/test_api_search_golden.cpython-313.pyc create mode 100644 webui/backend/tests/golden/test_api_search_golden.py diff --git a/project_docs/SEARCH_V1_DESIGN.md b/project_docs/SEARCH_V1_DESIGN.md new file mode 100644 index 0000000..2a1ece0 --- /dev/null +++ b/project_docs/SEARCH_V1_DESIGN.md @@ -0,0 +1,212 @@ +# Search v1 + +## 1. Doel + +Search voegt nu waarde toe omdat de app inmiddels bruikbaar is als dual-pane file manager, maar nog volledig afhankelijk is van handmatige navigatie. Bij grotere directory trees kost dat te veel stappen. + +Search moet passen binnen de bestaande dual-pane workflow: +- zoeken gebeurt vanuit het actieve paneel +- resultaten helpen navigatie versnellen +- de browse-workspace blijft het primaire werkvlak +- search is ondersteunend, geen nieuw hoofdscherm + +## 2. Scope + +Search v1 ondersteunt: +- zoeken op bestandsnaam +- zoeken op mapnaam +- case-insensitive substring matching + +Search v1 ondersteunt niet: +- full-text content search +- indexer of achtergrondindexering +- regex +- geavanceerde querytaal +- saved searches +- fuzzy ranking + +Aanbevolen zoekmodel voor v1: +- eenvoudige naamzoeking met substring match +- optioneel later uit te breiden naar glob of prefix filters, maar niet in deze slice + +## 3. Zoekbereik + +Mogelijke richtingen: +- zoeken vanaf `current path` +- zoeken vanaf de root van het actieve paneel + +Aanbeveling voor v1: +- standaard zoeken vanaf `current path` van het actieve paneel + +Reden: +- laag regressierisico +- voorspelbaar voor de gebruiker +- technisch goedkoper +- minder kans op trage scans van volledige opslagvolumes +- sluit goed aan op de huidige paneel-context + +Gedrag: +- `activePane` bepaalt de zoekcontext +- de query zoekt recursief onder `currentPath` van dat paneel +- resultaten horen dus altijd bij de context van het actieve paneel op het moment van starten + +Later uitbreidbaar: +- een simpele scope-toggle `Current folder tree` versus `Current root` + +## 4. UI-richting + +Aanbevolen v1-richting: +- aparte compacte search-modal +- geen verstoring van de dual-pane layout + +Startmechanisme: +- alleen keyboard shortcut +- geen zichtbare knop in topbar +- geen zichtbare knop in functiebalk + +Aanbevolen shortcut voor v1: +- Mac: `Cmd+Shift+F` +- Windows/Linux: `Ctrl+Shift+F` + +Reden: +- sluit goed aan op bestaande zoekverwachtingen +- vermijdt extra visuele drukte in de UI +- vermijdt conflict met bestaande F1-F8 functiebalklogica + +Modal-inhoud: +- titel `Search` +- actieve paneelcontext tonen +- zoekveld +- korte contextregel: `Searching under: ` +- resultatenlijst onder het invoerveld + +Gedrag bij resultaatklik: +- klik op resultaat opent de parentlocatie in het actieve paneel +- en selecteert het gevonden item + +Voor directories: +- resultaatklik navigeert naar die directory in het actieve paneel + +Voor files: +- resultaatklik navigeert naar de parent directory in het actieve paneel +- en selecteert de file + +Dit sluit aan op de bestaande browse- en selectieflow zonder extra viewer/open-semantiek. + +## 5. Resultaatsemantiek + +Minimale velden per resultaat: +- `name` +- `path` +- `type` (`file` of `directory`) +- `parent_path` +- `root` of equivalent contextveld + +Weergave in v1: +- primaire regel: naam +- secundaire regel: parent path of volledig path +- compacte type-indicatie (`file` / `dir`) + +Aanbevolen presentatie: +- naam prominent +- parent path als muted secundaire regel +- type als kleine badge of label + +## 6. Backend-impact + +Aanbevolen endpoint: +- `GET /api/search?path=...&query=...` + +Waarom een nieuw endpoint nodig is: +- browse-endpoint is contractueel directory listing +- search vereist recursieve traversal en resultaatlimieten +- aparte fout- en limietsemantiek is logisch + +Securitymodel: +- `path` moet via bestaande `path_guard` +- zoekroot moet binnen whitelist vallen +- traversal en invalid root alias blijven via bestaande validatie lopen +- geen vrije scan buiten geconfigureerde roots + +Implementatierichting: +- backend scant recursief vanaf gevalideerde startdirectory +- vergelijkt naam case-insensitive met query +- retourneert gemaximeerde lijst van matches + +## 7. Performance en risico + +Grootste risico: +- diepe directory trees op grote volumes + +Aanbevolen v1-beheersing: +- result limit, bijvoorbeeld `100` +- optionele harde scan limit op aantal bezochte entries +- geen parallelle scanner +- geen indexer + +Aanbevolen gedrag bij limiet: +- response bevat `truncated: true/false` +- als limiet bereikt is, toon alleen eerste resultaten + +Timeouts: +- geen aparte timeoutsemantiek nodig in eerste slice als result-limiet en current-path scope klein blijven + +## 8. Regressierisico + +Belangrijkste risico’s: +- browse-flow mag niet veranderen +- selectieflow mag niet onverwacht resetten buiten het actieve paneel +- keyboardflow mag niet botsen met bestaande shortcuts +- modal focus moet bestaande paneelnavigatie blokkeren zolang search open is + +Beperkende keuzes die risico laag houden: +- aparte modal +- zoeken alleen op naam +- starten vanuit actief paneel +- resultaten openen in bestaand paneelgedrag + +## 9. Teststrategie + +Backend golden tests: +- lege resultaatlijst +- simpele file match +- simpele directory match +- search onder current path +- traversal geblokkeerd +- path not found +- invalid root alias +- result limit / truncated gedrag + +UI smoke/regressietests: +- search-modal container aanwezig +- zoekveld aanwezig +- resultaatlijst container aanwezig +- keyboard wiring voor `Cmd/Ctrl+Shift+F` + +Handmatige validatie: +- zoeken vanuit links paneel raakt alleen linkse context +- zoeken vanuit rechts paneel raakt alleen rechtse context +- resultaatklik navigeert correct +- resultaatklik op directory opent directory +- resultaatklik op file opent parent + selecteert file +- `Escape` sluit modal + +## 10. Aanbeveling + +Aanbevolen v1-richting met laag regressierisico: +- nieuw backend-endpoint `GET /api/search` +- recursieve naamzoeking +- scope = `currentPath` van actief paneel +- case-insensitive substring match +- harde result limit, bijvoorbeeld `100` +- aparte compacte search-modal +- resultaatklik hergebruikt bestaande paneelnavigatie en selectie + +Niet aanbevelen voor v1: +- root-brede zoeking als default +- content search +- indexer +- regex +- aparte zoekpagina + +Dit levert een bruikbare eerste search op zonder de huidige dual-pane file manager semantiek te verstoren. diff --git a/webui/backend/app/__pycache__/dependencies.cpython-313.pyc b/webui/backend/app/__pycache__/dependencies.cpython-313.pyc index 9e7fc02e46549bad517a2cffef2a2e7c22bc84ca..a8e015a010174808e8793db653d52f3dda194efe 100644 GIT binary patch delta 1620 zcma)6OHUI~6z-I^K!-kfLxI`{rL;hK2oi*X1`PsFZeG%7&+?M{rFl#6x!-j+Htg(n|XA$P19f+_fYZ55RI#{zn9jueJ z2-L~Cm{*`K7GtLbim`6y6R4Z@Fuz^Eo~1yf_ths!mP#E=RbX+Me>Ojt8u|T_OV$?5 zzm9(>Ss3wBC7RLX>z34P;znv!)i$-Px|UFqN+zoU_>m+BO-6Iqv@bXB$=+Ry7rb1y zUFGjAk*J4g361Yas+y#-infvfHIvp-*)(iI8}fc0vIZqOcsBYx@_~X(jYHXLz&O9?;j+pcIjFMeWENv)|gf8^Jl$|6*EjSYQ z5i00biHsqATT>I73b#^=Dx5}_Vf-KPJ7o`g`se^@K@3gA0&cPC8_U8agCW^bslq;66@FfBji>nBcYcCvov=63E-&C~Fad6WSf3TW6cflO_}8d>U-3SClpEiNhWA48 zxAN$&W%Lk+sri%8i#*0ujSoX>e6%c-TJ%~IxAVByljx$7TR)iro^#Y~O%bH~hw%zr zZoqVT^nIFq9n%c!m_|;=G%Y%&EObmQ)G;+h#}2yw`hu#ZW6BM`F=w2zSqk!;tJZxY zm1-V$hqve*`Gy5$aYbEE#*|DZMxO>P@n?XykC`3=#Z BNech~ delta 1397 zcma)5%}*0i5Z`UPOKH2smV*7*e$Z0NwopX{#Q-AlD{A!cq6a0ZMHb|vEqQG@8LP&B zfV{*+VyOH`>o3+LT;vwE~k@S)7ps;KkMK8E$pNWeTUmF)UaS77X#wAQ# zKk04b`b}Jt91PaXA55Ca0pf2993UwYz!RDxgCxk&Akj#OBaNhq%2AqRNSLDx86pvm zhR869ax}ac)3V>OJ58)R^Ti^wS$;F0byM`SH`WW13QP~P*yiLgDiC7JHZ>Rn7=pX( z1an{5a;jgPkssZI0LCXm}IZi?5+}!&H!_ZJypWB6M%5yGSw?p zTBNR4=vfTKrH3>ecbYJ6vT=^93Q9G`(<8mXNZ6xbk82LodhTK2Wl z<+QLFPeSZw3!X@gulnvj@o93+c)NVAxRHE)C@u!YiPC8_s2D{B_6lsDD3s=_tNIkZ z4lMrHGdas;D1t4fSYkoV*o zM)g=VC5B+07!^JSV|p*FE}&~Pfmj8mFIXU0 z(2^-wC|KB%8R%N|pwLN7vdlngvI3NLfYJ$2`T&$}fYJ+?WEFwxF|CV{4HgL&wPXSr zJ6V8PWb!8_X;vMe715K0m~|QTHajruGcl@9E?`~FXgXPjEtXM#a~0c6#>uAa5`4v} siABj7w|F7+WNwakT;4z{K;c+CaWXTf9;4%Aea>f-PjU)R7Ue1g0E^~KRR910 delta 405 zcmew++9t~TnU|M~0SKh`Zp^fu$ScVxF;RVmGl#c~mu!)&0z-_f5`!s79teOuW+jFg zIa5XmKgb?JBa<+-K@OAU7$pN0Nzs994ul=d#R_BubL(<5Fcc}pCoKca_UX)<9sr?m8%c{TgE^} diff --git a/webui/backend/app/api/__pycache__/routes_search.cpython-313.pyc b/webui/backend/app/api/__pycache__/routes_search.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a77be1cebca86f6fac97544ae3d2860d3e8345fe GIT binary patch literal 912 zcmY*X&ui0g6o20&P0}B!vkK1YM%fQBmzE939B4uDVhckW1P_H0yKlG5EsZa!I1e)Q z;5>;3VMjfB^)IP-k-$I^k=-)t#f$j9NebNy-}n3b-sk&XMuw3CqL1%BJO3EKPhpHH zlPGNTft2@PfyJ88V8|*$mzq*TM!BJ&65Db!(@;^3b)~5_bkt)#)66zjYi#>|iU*JRWe|6CKmuG8%LTi^M`Lh3bozl}aUCtl6GdduVqb z(Mx09_M94u0r=_js@@)+5fub0(DA2<9m76E1t^?*TYpnO3=ZnU{L)Za`s*tcd^uHO z>!uzz4rM>UxI308gj0g)#6lH$FhCboGR$I_>vVbpa_~+E1-ww}*?vH9P?SV5nD9c1 zv`VPyI90#9#dmE#t`Sa8MmOT+akuMmA2o4#elk2BMD_Fz$HssMOa z)X{Iy+6Ftkjx%J6)%Y&4NM?*3!Q5}S@(Y%aVD$)Y{>YXN%`e%7eKk@+(qETfln-tn zKHo17S@lGR*~Q`F>erd;k(Oc0-*QGIll-19Mj4WHqj)KfL^`PF|76KGl0mASNTlIq GYWW`oG2y}h literal 0 HcmV?d00001 diff --git a/webui/backend/app/api/__pycache__/schemas.cpython-313.pyc b/webui/backend/app/api/__pycache__/schemas.cpython-313.pyc index 00be5ad2aa76c049b1330ca469979302e0f3c02c..15aee84e5a9a0c09fa58a894ee8be469ad9d3292 100644 GIT binary patch delta 415 zcmZ2rxyY99GcPX}0}!-M+?2_~Gm%e%v1OxrB$I&zgAzlqxfDaNMGUhkGe`vkLy;U< z)DkFag(NDUZmnsvxrK>CVzLX57^BDJkDPLo8`!xfCrEHj=H(Ny(gQP#^7AJ@6NwNMxy&L0-I(dfJ&{j>F=C^7Boj-zxu(VD4NM#o%zm13lk;U3PnMCD c SearchResponse: + return service.search(path=path, query=query) diff --git a/webui/backend/app/api/schemas.py b/webui/backend/app/api/schemas.py index 625e855..d011282 100644 --- a/webui/backend/app/api/schemas.py +++ b/webui/backend/app/api/schemas.py @@ -166,3 +166,16 @@ class HistoryItem(BaseModel): class HistoryListResponse(BaseModel): items: list[HistoryItem] + + +class SearchResultItem(BaseModel): + name: str + path: str + type: str + parent_path: str + root: str + + +class SearchResponse(BaseModel): + items: list[SearchResultItem] + truncated: bool diff --git a/webui/backend/app/dependencies.py b/webui/backend/app/dependencies.py index 3a5f79b..669717e 100644 --- a/webui/backend/app/dependencies.py +++ b/webui/backend/app/dependencies.py @@ -14,6 +14,7 @@ from backend.app.services.copy_task_service import CopyTaskService from backend.app.services.file_ops_service import FileOpsService from backend.app.services.history_service import HistoryService from backend.app.services.move_task_service import MoveTaskService +from backend.app.services.search_service import SearchService from backend.app.services.task_service import TaskService from backend.app.tasks_runner import TaskRunner @@ -95,3 +96,7 @@ async def get_bookmark_service() -> BookmarkService: async def get_history_service() -> HistoryService: return HistoryService(repository=get_history_repository()) + + +async def get_search_service() -> SearchService: + return SearchService(path_guard=get_path_guard(), filesystem=get_filesystem_adapter()) diff --git a/webui/backend/app/fs/__pycache__/filesystem_adapter.cpython-313.pyc b/webui/backend/app/fs/__pycache__/filesystem_adapter.cpython-313.pyc index 4a311659b20d49d6baf833c1eb2225d465785c30..a49c9cd4b093910e0347ac05e1285a8f65c7fca0 100644 GIT binary patch delta 2602 zcmb_d*>4-i8J}4$k0q&-l*B_4S4Rx5BU?_b)QZoF1#&#vl7 zbwUSC4527ctJ9)#U7#(Bz|Kn&SqKmW?Su1@0zDwYN+oRlm_MLCP{0obI^R%~oS+5z zkOlGE-+cG?&2aY5+n?;KeOgoFNBntb_P+7&#@X7BOP}-AFVJ~JF+o%!n7T+Kkz(kw zOl1-xF2UR+Ok}}4q=~o%^O9!b5zNP#S1^UN5T9Uv?x6@4;LI;rkVHt71c6`1w1&h; zoV-!9x~%2PR#LmVsv~Wroz$(a>d!Zj1gVGBt57|EXd`K$p|OCbE?D?|7yghvm-l<( zplN0M+<)o(|k5gV*Y#@V5&g{M3=4`IN*mf!0`2?nOoSFjrI_f?vfI z#$Krjvrp>%TSMqDKC&61Np3VTR`d;ftHvpB2%S+ZsTWyN2pwrf$h@6YSXl}&wMNl4 zuG(dI!V@usQp!o`L_0zOq;iL%GAwq58?l7k)I(gaNhvQu1Z_Ysr0{)rDKxVRj)`G^LP8)>@ zliKODBVWtpuTXv(5LH3vvTRB{u!Ljdxbk{YD+Oo|NFci7zB;MXDaV~R3Wn{}7fo8o zr+_{^k+H`uzI8}le`q}<3R-%G zX2;XTObOiE4{>*E%Chys8@bGctsq_60JI>zkzt{KW-UoXZ$(iN-LwCF9 z`^z0?mo8?OFOHQjj+M%>@tGsDr)G{linPy1A0~$GNAHEd?0wL?m`pA2J9Af_kCqcd zOBXIJUl=X(Uu0}%;Oj{1-03_1nSp;q)LZgOsO#?Z@1}o${j1Qnm2mu*gR_J84t)0V zA~|0s*>YEIDXc$giOp?i*MB?tRZGuGV#7Uo?(L;W&tnBeOC3*xDBAhIqHOq+Q69Wl z?n*C(Fa7r*&v=l|$1P~nQT)$NRNpe^o_S}{*Y^BL2kJbBpF4>mtA)?+kI{o&{s%D+ z$1hOy;70!!Z61zUcFa41d)P-`Ur5yLl1i6BvVnt!9gj|_Ni9vLZ6Jl4*HLUbS=h#V+E}FR}lG75C8sEg{7Ltu4_~3h7r%CIjX>P}VjT*L|w)MB{ZY(nvByolc#404PT+|J zv)RN+*kBq3;GY1*4aHR8%S1Z?x&Yh&-2g8Eh;d64CLzo%$gis6|4H9vTO(cghwOAD z8GxIia%*g1^O09dK5#~`AJ~NWn)$1zMLDvJ~Y4@Z(y1AdbuUGsdkzce4CtR#AcCpoRvel$#2)8KhDXX|?uF!lt%YIbN$5 z6&!>hTq*$?PP_y8+aJRrdo*SQ1NRF7F1i?|;T)x%cATalASHGxe*PZHiCY)HhpX6Of-0r%aY9maZtw_?lZ z_0Z=|2Gt156gJ%SuDZ2r5f`T>ax>H|HXA`Rh|njkqjyEM$A<7G-h{Q@PZKpbi_+($ z2E#dKoVkKQ#NCKrjUFAUMbXBfDK@16QM^5M7S?;;Om*RDwfSu_rzqG|8;OlJ=a-Z1 z=*^&oA^Fn%LgIX72{z>!z7Cgqzg0q5AE*3D!c-DylQszRgav|0SR@=Fs1Ke(`W9$Q zw5h*sV~Gqc@x|;S_@Xzvo;^kei*Q_&=1z2tBu803mFC!ZBW!WUN={apS0AQO0DdOX z_s4oWLR9|G$u;mlS{6Sce~wbqNokd^+9k7+o>bS1b+6IzY7K7RuxXA172&$si8hZf z%Y3ySgO;((DO3urc8AJFVX8@#`_P8t0`5R-T!U! zA`EJ)eN$~`MErXA*{u^4^&H^^!i$7g2n29miy{naort$x7xzSH&t$34$J#%sF>^tDZC?gg49(BKwnz0w2y_GD^osl& qbsGFM?#m^}U;D7c-#P%?(-!{F^1o|O+|wriwOoJz?rZ9$3j7B#x*?YU diff --git a/webui/backend/app/fs/filesystem_adapter.py b/webui/backend/app/fs/filesystem_adapter.py index ff1c572..f934be8 100644 --- a/webui/backend/app/fs/filesystem_adapter.py +++ b/webui/backend/app/fs/filesystem_adapter.py @@ -29,6 +29,29 @@ class FilesystemAdapter: return directories, files + def search_names(self, directory: Path, query: str, limit: int) -> tuple[list[dict], bool]: + normalized_query = query.lower() + results: list[dict] = [] + + for root, dirnames, filenames in __import__("os").walk(directory): + dirnames[:] = sorted([name for name in dirnames if not name.startswith(".")], key=str.lower) + filenames = sorted([name for name in filenames if not name.startswith(".")], key=str.lower) + + root_path = Path(root) + for name in dirnames: + if normalized_query in name.lower(): + results.append({"name": name, "kind": "directory", "absolute": root_path / name}) + if len(results) >= limit: + return results, True + + for name in filenames: + if normalized_query in name.lower(): + results.append({"name": name, "kind": "file", "absolute": root_path / name}) + if len(results) >= limit: + return results, True + + return results, False + def make_directory(self, path: Path) -> None: path.mkdir(parents=False, exist_ok=False) diff --git a/webui/backend/app/main.py b/webui/backend/app/main.py index e58b93f..9b5740b 100644 --- a/webui/backend/app/main.py +++ b/webui/backend/app/main.py @@ -13,6 +13,7 @@ from backend.app.api.routes_copy import router as copy_router from backend.app.api.routes_files import router as files_router from backend.app.api.routes_history import router as history_router from backend.app.api.routes_move import router as move_router +from backend.app.api.routes_search import router as search_router from backend.app.api.routes_tasks import router as tasks_router from backend.app.logging import configure_logging @@ -29,6 +30,7 @@ app.include_router(browse_router, prefix="/api") app.include_router(files_router, prefix="/api") app.include_router(copy_router, prefix="/api") app.include_router(move_router, prefix="/api") +app.include_router(search_router, prefix="/api") app.include_router(bookmarks_router, prefix="/api") app.include_router(history_router, prefix="/api") app.include_router(tasks_router, prefix="/api") diff --git a/webui/backend/app/services/__pycache__/search_service.cpython-313.pyc b/webui/backend/app/services/__pycache__/search_service.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..db4c1dda53608cab018206f3a3e3f3e8ca47e997 GIT binary patch literal 4203 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 literal 0 HcmV?d00001 diff --git a/webui/backend/app/services/search_service.py b/webui/backend/app/services/search_service.py new file mode 100644 index 0000000..537eb42 --- /dev/null +++ b/webui/backend/app/services/search_service.py @@ -0,0 +1,82 @@ +from __future__ import annotations + +from backend.app.api.errors import AppError +from backend.app.api.schemas import SearchResponse, SearchResultItem +from backend.app.fs.filesystem_adapter import FilesystemAdapter +from backend.app.security.path_guard import PathGuard + +SEARCH_RESULT_LIMIT = 100 +SEARCH_MIN_QUERY_LENGTH = 3 + + +class SearchService: + def __init__(self, path_guard: PathGuard, filesystem: FilesystemAdapter): + self._path_guard = path_guard + self._filesystem = filesystem + + def search(self, path: str, query: str) -> SearchResponse: + normalized_query = (query or "").strip() + if len(normalized_query) < SEARCH_MIN_QUERY_LENGTH: + raise AppError( + code="invalid_request", + message=f"Query must be at least {SEARCH_MIN_QUERY_LENGTH} characters", + status_code=400, + ) + + items: list[SearchResultItem] = [] + truncated = False + + if self._path_guard.is_virtual_volumes_path(path): + for entry in self._path_guard.virtual_volumes_entries(): + resolved = self._path_guard.resolve_directory_path(entry["path"]) + remaining = SEARCH_RESULT_LIMIT - len(items) + if remaining <= 0: + truncated = True + break + matches, chunk_truncated = self._filesystem.search_names( + resolved.absolute, + normalized_query, + remaining, + ) + items.extend(self._map_results(matches, resolved.display_style)) + if chunk_truncated or len(items) >= SEARCH_RESULT_LIMIT: + truncated = True + break + return SearchResponse(items=items, truncated=truncated) + + resolved = self._path_guard.resolve_directory_path(path) + matches, truncated = self._filesystem.search_names( + resolved.absolute, + normalized_query, + SEARCH_RESULT_LIMIT, + ) + return SearchResponse(items=self._map_results(matches, resolved.display_style), truncated=truncated) + + def _map_results(self, matches: list[dict], display_style: str) -> list[SearchResultItem]: + items: list[SearchResultItem] = [] + for match in matches: + absolute = match["absolute"] + alias = self._match_alias_for_path(absolute) + path = self._path_guard.entry_relative_path(alias, absolute, display_style=display_style) + parent_path = self._path_guard.entry_relative_path(alias, absolute.parent, display_style=display_style) + items.append( + SearchResultItem( + name=match["name"], + path=path, + type=match["kind"], + parent_path=parent_path, + root=alias, + ) + ) + return items + + def _match_alias_for_path(self, absolute) -> str: + resolved = absolute.resolve(strict=False) + for alias, root in self._path_guard._roots.items(): # internal mapping, shared security source + if self._path_guard._is_under_root(resolved, root): + return alias + raise AppError( + code="path_outside_whitelist", + message="Requested path is outside allowed roots", + status_code=403, + ) diff --git a/webui/backend/tests/golden/__pycache__/test_api_search_golden.cpython-313.pyc b/webui/backend/tests/golden/__pycache__/test_api_search_golden.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f2fdcf6cabec8745522533263845c5a98d502160 GIT binary patch literal 8546 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 literal 0 HcmV?d00001 diff --git a/webui/backend/tests/golden/__pycache__/test_ui_smoke_golden.cpython-313.pyc b/webui/backend/tests/golden/__pycache__/test_ui_smoke_golden.cpython-313.pyc index 6732ac56f5d9998aad17d968eedec501a061ef35..996853e235dca65ca2f8b77cd81caf5397299fe3 100644 GIT binary patch delta 717 zcmeD8?+)er%*)Hg00gTiZOZJE*~s^gnduMbIbJ=&-qtcMGFQ zacW{wa)xeheoA7FQk7t4imeh&7)huowYW5=qKaxaJN#15t z!6l4L@+_Ng3#l?qjuPdc>t#G-*VK_NPEM4|8qg1dZOEM$GMPQN@ zNHQ}pFn+$b`GMFJmdP;^V$5=(%#$}tD^LE;!8bWhLS(WervR9?h0u&jll>)>8I>oe zOS?0xgtANylu%?=h0rflFa-(h5UllykKxpX=ql-CKgxbB`d%si%XMoGfUvo z>XRqPOD3R%qGlCuf_`E_ranZ}zDho|EH$r0FFUnTuO#0mzdW_bIk7lZLsP-l)>c6& zO{q#j1EL}~wItCywNjy`Mgby_TvC(+6wutvCAXi2Egcwg#V;qHS2`Y`yQ1t0huIAd zo_^j=-V0);8-QFpIM@Dw*cA>BD0f2s0-&TGT+)08P|^X;wb-F{g~M@kuW}<3hd(2$ z`S&Cy{mo)(o{R?WOpKN@IIc@*UX;-M!T{oZ2w`Dh;pwQl%q)3>g{R%O$+y-212Y4Q JRFN3aX#lP;)a3vG delta 300 zcmeAU?f2*V%*)Hg00f)bHf4rMZRGpM%$T#8m*o!oXRVcG56G#&Sg93v-L$LMaHr{qdo6UTDTNpS00=1um-|` z=?t2hoA1ggFm7I_u#bf;8E9kigvmv!$2U(>t6<{rW@I)09>t`&SxD29QKXiU(Q*dI UbqURj5}IEaK)eqQlk>G?0IGaR?f?J) diff --git a/webui/backend/tests/golden/test_api_search_golden.py b/webui/backend/tests/golden/test_api_search_golden.py new file mode 100644 index 0000000..5deca3c --- /dev/null +++ b/webui/backend/tests/golden/test_api_search_golden.py @@ -0,0 +1,117 @@ +from __future__ import annotations + +import asyncio +import sys +import tempfile +import unittest +from pathlib import Path + +import httpx + +sys.path.insert(0, str(Path(__file__).resolve().parents[3])) + +from backend.app.dependencies import get_search_service +from backend.app.fs.filesystem_adapter import FilesystemAdapter +from backend.app.main import app +from backend.app.security.path_guard import PathGuard +from backend.app.services.search_service import SearchService + + +class SearchApiGoldenTest(unittest.TestCase): + def setUp(self) -> None: + self.temp_dir = tempfile.TemporaryDirectory() + self.root = Path(self.temp_dir.name) / "root" + self.root.mkdir(parents=True, exist_ok=True) + self.service = SearchService(path_guard=PathGuard({"storage1": str(self.root)}), filesystem=FilesystemAdapter()) + + async def _override_search_service() -> SearchService: + return self.service + + app.dependency_overrides[get_search_service] = _override_search_service + + def tearDown(self) -> None: + app.dependency_overrides.clear() + self.temp_dir.cleanup() + + def _request(self, path: str, query: str) -> httpx.Response: + async def _run() -> httpx.Response: + transport = httpx.ASGITransport(app=app) + async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client: + return await client.get("/api/search", params={"path": path, "query": query}) + + return asyncio.run(_run()) + + def test_search_empty_result_list(self) -> None: + (self.root / "docs").mkdir() + (self.root / "docs" / "alpha.txt").write_text("a", encoding="utf-8") + + response = self._request("storage1/docs", "zzz") + + self.assertEqual(response.status_code, 200) + self.assertEqual(response.json(), {"items": [], "truncated": False}) + + def test_search_file_match(self) -> None: + (self.root / "docs").mkdir() + (self.root / "docs" / "holiday-video.mp4").write_bytes(b"x") + + response = self._request("storage1/docs", "video") + + self.assertEqual(response.status_code, 200) + payload = response.json() + self.assertEqual(payload["truncated"], False) + self.assertEqual(len(payload["items"]), 1) + self.assertEqual( + payload["items"][0], + { + "name": "holiday-video.mp4", + "path": "storage1/docs/holiday-video.mp4", + "type": "file", + "parent_path": "storage1/docs", + "root": "storage1", + }, + ) + + def test_search_directory_match(self) -> None: + (self.root / "Projects").mkdir() + (self.root / "Projects" / "DemoFolder").mkdir() + + response = self._request("storage1/Projects", "demo") + + self.assertEqual(response.status_code, 200) + payload = response.json() + self.assertEqual(payload["items"][0]["type"], "directory") + self.assertEqual(payload["items"][0]["path"], "storage1/Projects/DemoFolder") + + def test_search_traversal_blocked(self) -> None: + response = self._request("storage1/../etc", "passwd") + + self.assertEqual(response.status_code, 403) + self.assertEqual(response.json()["error"]["code"], "path_traversal_detected") + + def test_search_path_not_found(self) -> None: + response = self._request("storage1/missing", "abc") + + self.assertEqual(response.status_code, 404) + self.assertEqual(response.json()["error"]["code"], "path_not_found") + + def test_search_invalid_root_alias(self) -> None: + response = self._request("unknown/path", "abc") + + self.assertEqual(response.status_code, 403) + self.assertEqual(response.json()["error"]["code"], "invalid_root_alias") + + def test_search_result_limit_sets_truncated(self) -> None: + (self.root / "many").mkdir() + for idx in range(120): + (self.root / "many" / f"match-{idx:03d}.txt").write_text("x", encoding="utf-8") + + response = self._request("storage1/many", "match") + + self.assertEqual(response.status_code, 200) + payload = response.json() + self.assertEqual(len(payload["items"]), 100) + self.assertEqual(payload["truncated"], True) + + +if __name__ == "__main__": + unittest.main() diff --git a/webui/backend/tests/golden/test_ui_smoke_golden.py b/webui/backend/tests/golden/test_ui_smoke_golden.py index 4a50ea8..65a49f2 100644 --- a/webui/backend/tests/golden/test_ui_smoke_golden.py +++ b/webui/backend/tests/golden/test_ui_smoke_golden.py @@ -54,6 +54,9 @@ class UiSmokeGoldenTest(unittest.TestCase): self.assertIn('id="video-player"', body) self.assertIn('id="video-close-btn"', body) self.assertIn('id="settings-modal"', body) + self.assertIn('id="search-modal"', body) + self.assertIn('id="search-input"', body) + self.assertIn('id="search-results"', body) self.assertIn('id="rename-popup"', body) self.assertIn('id="rename-input"', body) self.assertIn('id="rename-apply-btn"', body) @@ -80,6 +83,7 @@ class UiSmokeGoldenTest(unittest.TestCase): self.assertIn('id="right-breadcrumbs"', body) self.assertIn('id="wildcard-popup"', body) self.assertIn('id="wildcard-pattern-input"', body) + self.assertNotIn('id="search-btn"', body) self.assertNotIn('id="bookmarks-panel"', body) self.assertNotIn('id="tasks-panel"', body) @@ -107,6 +111,12 @@ class UiSmokeGoldenTest(unittest.TestCase): self.assertIn("document.documentElement.dataset.theme", app_js) self.assertIn('document.getElementById("theme-toggle").onclick = toggleTheme;', app_js) self.assertIn('document.getElementById("settings-btn").onclick = () => openSettings("general");', app_js) + self.assertIn('function openSearch()', app_js) + self.assertIn('async function submitSearch()', app_js) + self.assertIn('document.getElementById("search-input")', app_js) + self.assertIn("`/api/search?", app_js) + self.assertIn('event.key.toLowerCase() === "f"', app_js) + self.assertIn('(event.metaKey || event.ctrlKey)', app_js) self.assertIn('if (event.key === "F1") {', app_js) self.assertIn('if (event.key === "F2") {', app_js) self.assertIn('function openSettings(tab = "general")', app_js) diff --git a/webui/html/app.js b/webui/html/app.js index d89c9a2..658d4c8 100644 --- a/webui/html/app.js +++ b/webui/html/app.js @@ -8,6 +8,7 @@ let state = { visibleItems: [], currentRowIndex: -1, selectionAnchorIndex: null, + pendingSelectionPath: null, }, right: { currentPath: "/Volumes", @@ -17,6 +18,7 @@ let state = { visibleItems: [], currentRowIndex: -1, selectionAnchorIndex: null, + pendingSelectionPath: null, }, }, activePane: "left", @@ -46,6 +48,11 @@ let settingsState = { activeTab: "general", logsLoaded: false, }; +let searchState = { + pane: "left", + path: "/Volumes", + query: "", +}; const THEME_STORAGE_KEY = "webmanager-theme"; function preferredTheme() { @@ -199,6 +206,17 @@ function settingsElements() { }; } +function searchElements() { + return { + overlay: document.getElementById("search-modal"), + closeButton: document.getElementById("search-close-btn"), + context: document.getElementById("search-context"), + input: document.getElementById("search-input"), + error: document.getElementById("search-error"), + results: document.getElementById("search-results"), + }; +} + async function apiRequest(method, url, body) { const options = { method, headers: {} }; if (body !== undefined) { @@ -724,6 +742,16 @@ async function loadBrowsePane(pane) { model.selectedItem = model.selectedItems.length > 0 ? model.selectedItems[model.selectedItems.length - 1] : null; } + if (model.pendingSelectionPath) { + const pendingIndex = visibleItems.findIndex((item) => !item.isParent && item.path === model.pendingSelectionPath); + if (pendingIndex >= 0) { + const pendingItem = visibleItems[pendingIndex]; + model.currentRowIndex = pendingIndex; + setSingleSelectionAtIndex(pane, selectedEntryFromItem(pendingItem), pendingIndex); + } + model.pendingSelectionPath = null; + } + renderPaneItems(pane); scrollCurrentRowIntoView(pane); setStatus(`Loaded ${pane}: ${data.path}`); @@ -1382,6 +1410,96 @@ function closeVideoViewer() { video.player.load(); } +function isSearchOpen() { + return !searchElements().overlay.classList.contains("hidden"); +} + +function closeSearch() { + const elements = searchElements(); + elements.overlay.classList.add("hidden"); + elements.error.textContent = ""; +} + +function renderSearchResults(items) { + const elements = searchElements(); + elements.results.innerHTML = ""; + if (!Array.isArray(items) || items.length === 0) { + const empty = document.createElement("div"); + empty.className = "popup-meta"; + empty.textContent = "No matches found."; + elements.results.append(empty); + return; + } + + for (const item of items) { + const row = document.createElement("button"); + row.type = "button"; + row.className = "search-result"; + row.onclick = () => activateSearchResult(item); + + const name = document.createElement("div"); + name.className = "search-result-name"; + name.textContent = item.name; + + const path = document.createElement("div"); + path.className = "search-result-path"; + path.textContent = item.parent_path; + + const meta = document.createElement("div"); + meta.className = "search-result-meta"; + meta.textContent = `${item.type} · ${item.root}`; + + row.append(name, path, meta); + elements.results.append(row); + } +} + +function activateSearchResult(item) { + const pane = state.activePane; + closeSearch(); + if (item.type === "directory") { + navigateTo(pane, item.path); + return; + } + paneState(pane).pendingSelectionPath = item.path; + navigateTo(pane, item.parent_path); +} + +function openSearch() { + const pane = state.activePane; + const elements = searchElements(); + searchState.pane = pane; + searchState.path = paneState(pane).currentPath; + searchState.query = ""; + elements.context.textContent = `Searching under: ${searchState.path}`; + elements.input.value = ""; + elements.error.textContent = ""; + elements.results.innerHTML = ""; + elements.overlay.classList.remove("hidden"); + elements.input.focus(); + elements.input.select(); +} + +async function submitSearch() { + const elements = searchElements(); + const query = elements.input.value.trim(); + searchState.query = query; + elements.error.textContent = ""; + elements.results.innerHTML = ""; + try { + const data = await apiRequest("GET", `/api/search?${new URLSearchParams({ + path: searchState.path, + query, + }).toString()}`); + renderSearchResults(data.items); + if (data.truncated) { + elements.error.textContent = "Result limit reached. Showing first matches."; + } + } catch (err) { + elements.error.textContent = err.message; + } +} + function setSettingsTab(tab) { const elements = settingsElements(); settingsState.activeTab = tab === "logs" ? "logs" : "general"; @@ -1686,6 +1804,19 @@ function clearSelectionForActivePane() { } function handleKeyboardShortcuts(event) { + if (isSearchOpen()) { + if (event.key === "Escape") { + event.preventDefault(); + closeSearch(); + return; + } + if (event.key === "Enter") { + event.preventDefault(); + submitSearch(); + return; + } + return; + } if (isRenamePopupOpen()) { if (event.key === "Escape") { event.preventDefault(); @@ -1760,6 +1891,13 @@ function handleKeyboardShortcuts(event) { return; } + const isSearchShortcut = event.key.toLowerCase() === "f" && event.shiftKey && !event.altKey && (event.metaKey || event.ctrlKey); + if (isSearchShortcut) { + event.preventDefault(); + openSearch(); + return; + } + if (actionShortcutHandled(event)) { event.preventDefault(); return; @@ -1893,6 +2031,14 @@ function setupEvents() { } }; + const search = searchElements(); + search.closeButton.onclick = closeSearch; + search.overlay.onclick = (event) => { + if (event.target === search.overlay) { + closeSearch(); + } + }; + const wildcard = wildcardPopupElements(); wildcard.cancelButton.onclick = closeWildcardPopup; wildcard.applyButton.onclick = submitWildcardPopup; diff --git a/webui/html/index.html b/webui/html/index.html index 27db7d9..2398b07 100644 --- a/webui/html/index.html +++ b/webui/html/index.html @@ -99,6 +99,18 @@ + +