Hotfix create user routing (#241)

add fetch depth

.github/workflows/main.yaml

@@ -1,4 +1,4 @@
-name: main job
+name: main release
 
 on:
   push:
@@ -12,16 +12,16 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Find latest tag
+        run: |
+          echo "LATEST_TAG=$(git describe --tags `git rev-list --tags --max-count=1`)" >> $GITHUB_ENV
+          echo "latest tag is $LATEST_TAG"
       - name: Set up QEMU
         uses: docker/setup-qemu-action@v3.0.0
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v3.0.0
-        # Workaround to fix error:
-        # failed to push: failed to copy: io: read/write on closed pipe
-        # See https://github.com/docker/build-push-action/issues/761
-        with:
-          driver-opts: |
-            image=moby/buildkit:v0.10.6
       - name: Login to Docker Hub
         uses: docker/login-action@v3
         with:
@@ -36,6 +36,9 @@ jobs:
         uses: docker/build-push-action@v5
         with:
           context: .
+          build-args: |
+            VERSION=${{ env.LATEST_TAG }}
+            REVISION=${{ fromJSON(steps.meta.outputs.json).labels['org.opencontainers.image.revision'] }}
           platforms: linux/amd64,linux/arm64,linux/arm/v7
           file: ./Dockerfile
           push: true

.github/workflows/pr.yaml

@@ -1,13 +1,28 @@
-name: pr-merge
+name: pr-request
 
 on:
   pull_request:
     branches:
       - "main"
       - "v[0-9]+.[0-9]+.[0-9]+"
-      - "dev_*"
 
 jobs:
+  test_frontend:
+    name: Push release
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3.0.0
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3.0.0
+      - name: Build
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: ./Dockerfile.playwright
+          push: false
   push_pr_to_registry:
     name: Push PR
     runs-on: ubuntu-latest
@@ -18,12 +33,6 @@ jobs:
         uses: docker/setup-qemu-action@v3.0.0
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v3.0.0
-        # Workaround to fix error:
-        # failed to push: failed to copy: io: read/write on closed pipe
-        # See https://github.com/docker/build-push-action/issues/761
-        with:
-          driver-opts: |
-            image=moby/buildkit:v0.10.6
       - name: Login to Docker Hub
         uses: docker/login-action@v3
         with:
@@ -35,10 +44,13 @@ jobs:
         with:
           images: gtstef/filebrowser
       - name: Build and push
-        uses: docker/build-push-action@v5
+        uses: docker/build-push-action@v6
         with:
           context: .
           file: ./Dockerfile
           push: true
           tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
+          labels: ${{ steps.meta.outputs.labels }}
+          build-args: |
+            VERSION=${{ steps.meta.outputs.version }}
+            REVISION=${{ steps.meta.outputs.revision }}

.github/workflows/regular-tests.yaml

@@ -1,4 +1,4 @@
-name: dev
+name: dev tests
 
 on:
   push:
@@ -21,10 +21,10 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions/setup-go@v5
         with:
-            go-version: 'stable'
-      - uses: golangci/golangci-lint-action@v6
+            go-version: '1.22.5'
+      - uses: golangci/golangci-lint-action@v5
         with:
-          version: v1.59
+          version: v1.60
           working-directory: backend
   format-backend:
     runs-on: ubuntu-latest

.github/workflows/release.yaml

@@ -1,4 +1,4 @@
-name: release
+name: version release
 
 on:
   push:
@@ -34,6 +34,7 @@ jobs:
           draft: false
           generate_release_notes: true
           name: ${{ steps.extract_branch.outputs.branch }}
+
   push_release_to_registry:
     name: Push release
     runs-on: ubuntu-latest
@@ -44,14 +45,7 @@ jobs:
         uses: docker/setup-qemu-action@v3.0.0
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v3.0.0
-        # Workaround to fix error:
-        # failed to push: failed to copy: io: read/write on closed pipe
-        # See https://github.com/docker/build-push-action/issues/761
-        with:
-          driver-opts: |
-            image=moby/buildkit:v0.10.6
       - name: Login to Docker Hub
-        # Only push to Docker Hub when making a release
         uses: docker/login-action@v3
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
@@ -69,11 +63,14 @@ jobs:
           JSON=$(echo "$JSON" | sed 's/filebrowser:v/filebrowser:/')
           echo "cleaned_tag=$JSON" >> $GITHUB_OUTPUT
       - name: Build and push
-        uses: docker/build-push-action@v5
+        uses: docker/build-push-action@v6
         with:
           context: .
+          build-args: |
+            VERSION=${{ fromJSON(steps.meta.outputs.json).labels['org.opencontainers.image.version'] }}
+            REVISION=${{ fromJSON(steps.meta.outputs.json).labels['org.opencontainers.image.revision'] }}
           platforms: linux/amd64,linux/arm64,linux/arm/v7
           file: ./Dockerfile
           push: true
           tags: ${{ steps.modify-json.outputs.cleaned_tag }}
-          labels: ${{ steps.meta.outputs.labels }}
+          labels: ${{ steps.meta.outputs.labels }}

.github/workflows/release_dev.yaml

@@ -0,0 +1,50 @@
+name: dev release
+
+on:
+  push:
+    branches:
+      - "dev_v[0-9]+.[0-9]+.[0-9]+"
+
+permissions:
+  contents: write
+
+jobs:
+  push_release_to_registry:
+    name: Push dev release
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3.0.0
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3.0.0
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: gtstef/filebrowser
+      - name: Strip v from version number
+        id: modify-json
+        run: |
+          JSON="${{ steps.meta.outputs.tags }}"
+          # Use jq to remove 'v' from the version field
+          JSON=$(echo "$JSON" | sed 's/filebrowser:v/filebrowser:/')
+          echo "CLEANED_TAG=$JSON" >> $GITHUB_ENV
+      - name: Build and push
+        uses: docker/build-push-action@v6
+        with:
+          build-args: |
+            VERSION=${{ fromJSON(steps.meta.outputs.json).labels['org.opencontainers.image.version'] }}
+            REVISION=${{ fromJSON(steps.meta.outputs.json).labels['org.opencontainers.image.revision'] }}
+          context: .
+          platforms: linux/amd64
+          file: ./Dockerfile
+          push: true
+          tags: ${{ env.CLEANED_TAG }}
+          labels: ${{ steps.meta.outputs.labels }}

.github/workflows/stale.yaml

@@ -1,24 +0,0 @@
-name: 'Close stale issues and PRs'
-permissions:
-  issues: write
-  pull-requests: write
-
-on:
-  schedule:
-    - cron: '30 1 * * *'
-
-jobs:
-  stale:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/stale@v5
-        with:
-          stale-pr-message: 'This PR is stale because it has been open 30 days with no activity. Remove stale label or comment or this will be closed in 5 days.'
-          close-pr-message: 'This PR was closed because it has been stalled for 5 days with no activity.'
-          stale-issue-message: 'This issue is stale because it has been open 30 days with no activity. Remove stale label or comment or this will be closed in 5 days.'
-          close-issue-message: 'This issue was closed because it has been stalled for 30 days with no activity.'
-          days-before-stale: 30
-          days-before-close: 30
-          exempt-issue-labels: 'feature ☘,enhancement ⚙,bug 🐞'
-          exempt-pr-labels: 'need-help,wip'
-          operations-per-run: 100

.github/workflows/tag.yaml

@@ -15,6 +15,13 @@ jobs:
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+      - name: Install dependencies and build frontend
+        run: npm i && npm run build
+        working-directory: frontend
+      - name: Install UPX
+        run: sudo apt-get install -y upx
       - name: Run GoReleaser
         uses: goreleaser/goreleaser-action@v6
         with:

.gitignore

@@ -7,10 +7,13 @@ rice-box.go
 /filebrowser.exe
 /frontend/dist
 /frontend/pkg
+/frontend/test-results
 /frontend/package-lock.json
 /backend/vendor
 /backend/*.cov
 /backend/test_config.yaml
+/backend/srv
+/backend/http/dist
 
 .DS_Store
 node_modules

CHANGELOG.md

@@ -2,6 +2,79 @@
 
 All notable changes to this project will be documented in this file. For commit guidelines, please refer to [Standard Version](https://github.com/conventional-changelog/standard-version).
 
+## v0.3.0
+
+  This Release focuses on the API and making it more accessible for developers to access functions without the UI.
+
+  **New Features**:
+  - You can now long-live api tokens to interact with API from the user settings page.
+    - These tokens have the same permissions as your user.
+  - Helpful swagger page for API usage.
+  - Some API's were refactored for friendlier API usage, moving some attributes to parameters and first looking for a api token, then using the stored cookie if none is found. This allows for all api requests from swagger page to work without a token.
+  - Add file size to search preview! Should have been in last release... sorry!
+
+  **Notes**:
+  - Replaced backend http framework with go standard library.
+  - Right-click Context menu can target the item that was right-clicked. To fully address https://github.com/gtsteffaniak/filebrowser/issues/214
+  - adjusted settings menu for mobile, always shows all available cards rather than grayed out cards that need to be clicked.
+  - longer and more cryptographically secure share links based on UUID rather than base64.
+
+  **Bugfixes**:
+  - Fixed ui bug with shares with password.
+  - Fixes baseurl related bugs https://github.com/gtsteffaniak/filebrowser/pull/228 Thanks @SimLV
+  - Fixed empty directory load issue.
+  - Fixed image preview cutoff on mobile.
+  - Fixed issue introduced in v0.2.10 where new files and folders were not showing up on ui
+  - Fixed preview issue where preview would not load after viewing video files.
+  - Fixed sorting issue where files were not sorted by name by default.
+  - Fixed copy file prompt issue
+
+## v0.2.10
+
+  **New Features**:
+  - Allows user creation command line arguments https://github.com/gtsteffaniak/filebrowser/issues/196
+  - Folder sizes are always shown, leveraging the index. https://github.com/gtsteffaniak/filebrowser/issues/138
+  - Searching files based on filesize is no longer slower.
+
+  **Bugfixes**:
+  - fixes file selection usage when in single-click mode https://github.com/gtsteffaniak/filebrowser/issues/214
+  - Fixed displayed search context on root directory
+  - Fixed issue searching "smaller than" actually returned files "larger than"
+
+  **Notes**:
+  - Memory usage from index is reduced by ~40%
+  - Indexing time has increased 2x due to the extra processing time required to calculate directory sizes.
+  - File size calculations use 1024 base vs previous 1000 base (matching windows explorer)
+
+## v0.2.9
+
+  This release focused on UI navigation experience. Improving keyboard navigation and adds right click context menu.
+
+  **New Features**:
+  - listing view items are middle-clickable on selected listing or when in single-click mode.
+  - listing view items can be navigated via arrow keys.
+  - listing view can jump to items using letters and number keys to cycle through files that start with that character.
+  - You can use the enter key and backspace key to navigate backwards and forwards on selected items.
+  - ctr-space will open/close the search (leaving ctr-f to browser default find prompt)
+  - Added right-click context menu to replace the file selection prompt.
+
+  **Bugfixes**:
+  - Fixed drag to upload not working.
+  - Fixed shared video link issues.
+  - Fixed user edit bug related to other user.
+  - Fixed password reset bug.
+  - Fixed loading state getting stuck.
+
+## v0.2.8
+
+- **Feature**: New gallery view scaling options (closes [#141](https://github.com/gtsteffaniak/filebrowser/issues/141))
+- **Change**: Refactored backend files functions
+- **Change**: Improved UI response to filesystem changes
+- **Change**: Added frontend tests for deployment integrity
+- **Fix**: move/replace file prompt issue
+- **Fix**: opening files from search
+- **Fix**: Display count issue when hideDotFile is enabled.
+
 ## v0.2.7
 
  - **Change**: New sidebar style and behavior

Dockerfile

@@ -1,18 +1,27 @@
-FROM node:slim as nbuild
-WORKDIR /app
-COPY ./frontend/package*.json ./
-RUN npm i --maxsockets 1
-COPY  ./frontend/ ./
-RUN npm run build
-
-FROM golang:1.22-alpine as base
+FROM golang:1.23-alpine AS base
+ARG VERSION
+ARG REVISION
 WORKDIR /app
 COPY ./backend ./
-RUN go build -ldflags="-w -s" -o filebrowser .
+#RUN swag init --output swagger/docs
+RUN ln -s swagger /usr/local/go/src/
+RUN go build -ldflags="-w -s \
+  -X 'github.com/gtsteffaniak/filebrowser/version.Version=${VERSION}' \
+  -X 'github.com/gtsteffaniak/filebrowser/version.CommitSHA=${REVISION}'" \
+  -o filebrowser .
+
+FROM node:slim AS nbuild
+WORKDIR /app
+COPY ./frontend/package.json ./
+RUN npm i --maxsockets 1
+COPY  ./frontend/ ./
+RUN npm run build-docker
 
 FROM alpine:latest
-ARG app="/app/filebrowser"
+ENV FILEBROWSER_NO_EMBEDED="true"
 RUN apk --no-cache add ca-certificates mailcap
 COPY --from=base /app/filebrowser* ./
-COPY --from=nbuild /app/dist/ ./frontend/dist/
+# exposing default port for auto discovery.
+EXPOSE 80
+COPY --from=nbuild /app/dist/ ./http/dist/
 ENTRYPOINT [ "./filebrowser" ]

Dockerfile.playwright

@@ -0,0 +1,19 @@
+FROM golang:1.23-alpine AS base
+WORKDIR /app
+COPY ./backend ./
+RUN go build -ldflags="-w -s" -o filebrowser .
+
+FROM node:slim
+WORKDIR /app
+COPY ./frontend/package.json ./
+RUN npm i --maxsockets 1
+RUN npx playwright install --with-deps firefox
+COPY [ "backend/filebrowser.yaml", "./" ]
+COPY  ./frontend/ ./frontend
+WORKDIR /app/frontend
+RUN npm run build-docker
+WORKDIR /app
+COPY --from=base /app/filebrowser* ./
+RUN cp -R frontend/tests/ srv
+ENV FILEBROWSER_NO_EMBEDED="true"
+RUN ./filebrowser & sleep 2 && cd frontend && npx playwright test

README.md

@@ -4,49 +4,54 @@
 <p align="center">
   <img src="frontend/public/img/icons/favicon-256x256.png" width="100" title="Login With Custom URL">
 </p>
-<h3 align="center">Filebrowser - A modern web-based file manager</h3>
+<h3 align="center">FileBrowser Quantum - A modern web-based file manager</h3>
 <p align="center">
-  <img width="800" src="https://github.com/user-attachments/assets/8ba93582-aba2-4996-8ac3-25f763a2e596" title="Main Screenshot">
+  <img width="800" src="https://github.com/user-attachments/assets/e4a47229-66f8-4838-9575-dd2413596688" title="Main Screenshot">
 </p>
 
 > [!WARNING]
-> Starting with v0.2.0, *ALL* configuration is done via `filebrowser.yaml`
-> Configuration file.
-> Starting with v0.2.4 *ALL* share links need to be re-created (due to
-> security fix).
+> Starting with `v0.3.0` API routes have been slightly altered for friendly usage outside of the UI.
+> If on windows, please use docker. The windows binary is unstable and may not work.
 
-This fork makes the following significant changes to filebrowser for
-origin:
+FileBrowser Quantum is a fork of the file browser opensource project with the following changes:
 
-  1. [x] Better search
-     - Lightning fast
-     - real-time results as you type
-     - Works with more type filters
-     - interactive results page.
-  2. [x] Revamped and simplified GUI navbar and sidebar menu.
+  1. [x] Efficiently indexed files
+     - Real-time search results as you type
+     - Search Works with more type filters
+     - Enhanced interactive results page.
+     - file/folder sizes are shown in the response
+  1. [x] Revamped and simplified GUI navbar and sidebar menu.
      - Additional compact view mode as well as refreshed view mode
        styles.
-  3. [x] Revamped configuration via `filebrowser.yml` config file.
-     - More configurations possible at a per-user level
+  1. [x] Revamped and simplified configuration via `filebrowser.yml` config file.
+  1. [x] Better listing browsing
+     - Switching view modes is instant
+     - Folder sizes are shown as well
+     - Changing Sort order is instant
+     - The entire directory is loaded in 1/3 the time
+  1. Developer API support
+     - Can create long-live API Tokens.
+     - Helpful Swagger page available at `/swagger` endpoint.
 
 ## About
 
-Filebrowser provides a file managing interface within a specified directory
+FileBrowser Quantum provides a file-managing interface within a specified directory
 and can be used to upload, delete, preview, rename, and edit your files.
 It allows the creation of multiple users and each user can have its 
 directory.
 
-This repository is a fork, a collection of changes that make this program
-work better in terms of aesthetics and performance. Improved search,
-simplified ui (without removing features) and more secure and up-to-date
+This repository is a fork of the original [filebrowser](https://github.com/filebrowser/filebrowser) 
+with a collection of changes that make this program work better in terms of 
+aesthetics and performance. Improved search, simplified UI 
+(without removing features) and more secure and up-to-date
 build are just a few examples.
 
-This Implementation of filebrowser differs significantly to the original.
+FileBrowser Quantum differs significantly from the original.
 There are hundreds of thousands of lines changed and they are generally
 no longer compatible with each other. This has been intentional -- the
 focus of this fork is on a few key principles:
   - Simplicity and improved user experience
-  - Efficiency of operations and performance
+  - Improving performance and faster feedback when making changes.
   - Minimize external dependencies and standard library usage.
   - Of course -- adding much-needed features.
 
@@ -65,10 +70,9 @@ action panel. If the action is available based on context, it will show up as
 a popup menu.
 
 <p align="center">
-  <img width="800" src="https://github.com/gtsteffaniak/filebrowser/assets/42989099/899152cf-3e69-4179-aa82-752af2df3fc6" title="Main Screenshot">
-    <img width="800" src="https://github.com/user-attachments/assets/18c02d03-5c60-4e15-9c32-3cfe058a0c49" title="Main Screenshot">
-      <img width="800" src="https://github.com/user-attachments/assets/75226dc4-9802-46f0-9e3c-e4403d3275da" title="Main Screenshot">
-
+  <img width="800" src="https://github.com/user-attachments/assets/2be7a6c5-0f95-4d9f-bc05-484ee71246d8" title="Search GIF">
+  <img width="800" src="https://github.com/user-attachments/assets/f55a6f1f-b930-4399-98b5-94da6e90527a" title="Navigation GIF">
+  <img width="800" src="https://github.com/user-attachments/assets/75226dc4-9802-46f0-9e3c-e4403d3275da" title="Main Screenshot">
 </p>
 
 ## Install
@@ -81,12 +85,11 @@ Using docker:
 docker run -it -v /path/to/folder:/srv -p 80:80 gtstef/filebrowser
 ```
 
-1. docker-compose:
+1. docker compose:
 
   - with local storage
 
 ```
-version: '3.7'
 services:
   filebrowser:
     volumes:
@@ -102,7 +105,6 @@ services:
   - with network share
 
 ```
-version: '3.7'
 services:
   filebrowser:
     volumes:
@@ -118,51 +120,111 @@ volumes:
     driver_opts:
       type: cifs
       o: "username=admin,password=password,rw" # enter valid info here
-      device: "//192.168.1.100/share/"         # enter valid hinfo here
+      device: "//192.168.1.100/share/"         # enter valid info here
 
 ```
 
-Not using docker (not recommended)
-
-Note: Must download asset with frontend directory next to filebrowser binary
+Not using docker (not recommended), download your binary from releases and run with your custom config file:
 
 ```
 ./filebrowser -c <filebrowser.yml or other /path/to/config.yaml>
 ```
 
+## Command Line Usage
+
+There are very few commands available. There are 3 actions done via command line:
+
+1. Running the program, as shown on the install step. The only argument used is the config file, if you choose to override default "filebrowser.yaml"
+2. Checking the version info via `./filebrowser version`
+3. Updating the DB, which currently only supports adding users via `./filebrowser set -u username,password [-a] [-s "example/scope"]`
+
+## API Usage
+
+FileBrowser Quantum comes with a swagger page that can be accessed from the API section of settings or by going to `/swagger` to see the full list:
+
+![image](https://github.com/user-attachments/assets/12abd1f6-21d3-4437-98ed-9b0da6cf2c73)
+
+You use the token as a bearer token. For example in postman:
+
+
+Successful Request:
+
+<p align="center"><img width="500" alt="image" src="https://github.com/user-attachments/assets/4f18fa8a-8d87-4f40-9dc7-3d4407769b59"></p>
+
+Failed Request
+
+<p align="center"><img width="500" alt="image" src="https://github.com/user-attachments/assets/4da0deae-f93d-4d94-83b1-68806afb343a"></p>
+
+
 ## Configuration
 
 All configuration is now done via a single configuration file:
 `filebrowser.yaml`, here is an example of minimal [configuration
 file](./backend/filebrowser.yaml).
 
-View the [Configuration Help Page](./configuration.md) for available
+View the [Configuration Help Page](./docs/configuration.md) for available
 configuration options and other help.
 
 
-## Migration from filebrowser/filebrowser
+## Migration from the original filebrowser
 
-If you currently use filebrowser from the filebrowser/filebrowser
-repo but want to try using this. I recommend you start fresh without
-reusing the database, but there are a few things you'll need to do if you
-must migrate:
+If you currently use the original filebrowser but want to try using this. 
+I would recommend that you start fresh without reusing the database. However, 
+If you want to migrate your existing database to FileBrowser Quantum, 
+visit the [migration 
+readme](./docs/migration.md)
 
-1. Create a configuration file as mentioned above.
-2. Copy your database file from the original filebrowser to the path of
-   the new one.
-3. Update the configuration file to use the database (under server in
-   filebrowser.yml)
-4. If you are using docker, update the docker-compose file or docker run
-   command to use the config file as described in the install section
-   above.
-5. If you are not using docker, just make sure you run filebrowser -c
-   filebrowser.yml and have a valid filebrowser config.
+## Comparison Chart
 
-
-The filebrowser application should run with the same user and rules that
-you have from the original. But keep in mind the differences that are
-mentioned at the top of this readme.
+ Application Name | <img width="48" src="frontend/public/img/icons/favicon-256x256.png" > Quantum | <img width="48" src="https://github.com/filebrowser/filebrowser/blob/master/frontend/public/img/logo.svg" > Filebrowser | <img width="48" src="https://github.com/mickael-kerjean/filestash/blob/master/public/assets/logo/app_icon.png?raw=true" > Filestash | <img width="48" src="https://avatars.githubusercontent.com/u/19211038?s=200&v=4" >  Nextcloud | <img width="48" src="https://upload.wikimedia.org/wikipedia/commons/thumb/d/da/Google_Drive_logo.png/480px-Google_Drive_logo.png" > Google_Drive | <img width="48" src="https://avatars.githubusercontent.com/u/6422152?v=4" > FileRun
+--- | --- | --- | --- | --- | --- | --- |
+Filesystem support            | ✅ | ✅ | ✅ | ❌ | ❌ | ❌ |
+Linux                         | ✅ | ✅ | ✅ | ✅ | ❌ | ✅ |
+Windows                       | ✅ | ✅ | ✅ | ❌ | ❌ | ❌ |
+Mac                           | ✅ | ✅ | ✅ | ❌ | ❌ | ❌ |
+Self hostable                 | ✅ | ✅ | ✅ | ✅ | ❌ | ✅ |
+Has Stable Release?           | ❌ | ✅ | ✅ | ✅ | ✅ | ✅ |
+S3 support                    | ❌ | ❌ | ✅ | ✅ | ❌ | ✅ |
+webdav support                | ❌ | ❌ | ✅ | ✅ | ❌ | ✅ |
+ftp support                   | ❌ | ❌ | ✅ | ✅ | ❌ | ✅ |
+Dedicated docs site?          | ❌ | ✅ | ✅ | ✅ | ❌ | ✅ |
+Multiple sources at once      | ❌ | ❌ | ✅ | ✅ | ❌ | ✅ |
+Docker image size             | 22 MB  | 31 MB  | 240 MB (main image) | 250 MB | ❌ | > 2 GB |
+Min. Memory Requirements      | 128 MB | 128 MB | 128 MB (main image) | 128 MB | ❌ | 4 GB   |
+has standalone binary         | ✅ | ✅ | ❌ | ❌ | ❌ | ❌ |
+price                         | free | free | free | free tier | free tier | $99+ |
+rich media preview            | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+upload files from the web?    | ✅ | ✅ | ✅ | ✅ | ✅ | ❌ |
+Advanced Search?              | ✅ | ❌ | ❌ | configurable | ✅ | ✅ |
+Indexed Search?               | ✅ | ❌ | ❌ | configurable | ✅ | ✅ |
+Content-aware search?         | ❌ | ❌ | ❌ | configurable | ✅ | ✅ |
+Custom job support            | ❌ | ✅ | ❌ | ✅ | ❌ | ✅ |
+Multiple users                | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+Single sign-on support        | ❌ | ❌ | ❌ | ✅ | ✅ | ✅ |
+LDAP sign-on support          | ❌ | ❌ | ❌ | ✅ | ✅ | ✅ |
+2FA sign-on support           | ❌ | ❌ | ❌ | ✅ | ✅ | ✅ |
+Long-live API key support     | ✅ | ❌ | ✅ | ✅ | ✅ | ✅ |
+API documentation page        | ✅ | ❌ | ✅ | ✅ | ❌ | ✅ |
+Mobile App                    | ❌ | ❌ | ❌ | ❌ | ✅ | ❌ |
+open source?                  | ✅ | ✅ | ✅ | ✅ | ❌ | ✅ |
+tags support                  | ❌ | ❌ | ❌ | ✅ | ❌ | ✅ |
+sharable web links?           | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+Event-based notifications     | ❌ | ❌ | ❌ | ❌ | ❌ | ✅ |
+Metrics                       | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ |
+file space quotas             | ❌ | ❌ | ❌ | ❌ | ✅ | ✅ |
+text-based files editor       | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+office file support           | ❌ | ❌ | ✅ | ✅ | ✅ | ✅ |
+Themes                        | ✅ | ✅ | ❌ | ❌ | ❌ | ✅ |
+Branding support              | ❌ | ✅ | ❌ | ❌ | ❌ | ✅ |
+activity log                  | ❌ | ❌ | ❌ | ✅ | ✅ | ✅ |
+Comments support              | ❌ | ❌ | ❌ | ✅ | ✅ | ✅ |
+collaboration on same file    | ❌ | ❌ | ❌ | ✅ | ✅ | ✅ |
+trash support                 | ❌ | ❌ | ❌ | ✅ | ✅ | ✅ |
+Starred/pinned files          | ❌ | ❌ | ❌ | ❌ | ✅ | ✅ |
+Content preview icons         | ✅ | ✅ | ❌ | ❌ | ✅ | ✅ |
+Plugins support               | ❌ | ❌ | ✅ | ✅ | ❌ | ✅ |
+Chromecast support            | ❌ | ❌ | ✅ | ❌ | ❌ | ❌ |
 
 ## Roadmap
 
-see [Roadmap Page](./roadmap.md)
+see [Roadmap Page](./docs/roadmap.md)

backend/.golangci.yml

@@ -0,0 +1,232 @@
+# This code is licensed under the terms of the MIT license https://opensource.org/license/mit
+# Copyright (c) 2021 Marat Reymers
+
+## Golden config for golangci-lint v1.59.1
+#
+# This is the best config for golangci-lint based on my experience and opinion.
+# It is very strict, but not extremely strict.
+# Feel free to adapt and change it for your needs.
+
+run:
+  # Timeout for analysis, e.g. 30s, 5m.
+  # Default: 1m
+  timeout: 3m
+
+
+# This file contains only configs which differ from defaults.
+# All possible options can be found here https://github.com/golangci/golangci-lint/blob/master/.golangci.reference.yml
+linters-settings:
+  cyclop:
+    # The maximal code complexity to report.
+    # Default: 10
+    max-complexity: 30
+    # The maximal average package complexity.
+    # If it's higher than 0.0 (float) the check is enabled
+    # Default: 0.0
+    package-average: 10.0
+
+  errcheck:
+    # Report about not checking of errors in type assertions: `a := b.(MyStruct)`.
+    # Such cases aren't reported by default.
+    # Default: false
+    check-type-assertions: true
+
+  exhaustive:
+    # Program elements to check for exhaustiveness.
+    # Default: [ switch ]
+    check:
+      - switch
+      - map
+
+  exhaustruct:
+    # List of regular expressions to exclude struct packages and their names from checks.
+    # Regular expressions must match complete canonical struct package/name/structname.
+    # Default: []
+    exclude:
+      # std libs
+      - "^net/http.Client$"
+      - "^net/http.Cookie$"
+      - "^net/http.Request$"
+      - "^net/http.Response$"
+      - "^net/http.Server$"
+      - "^net/http.Transport$"
+      - "^net/url.URL$"
+      - "^os/exec.Cmd$"
+      - "^reflect.StructField$"
+      # public libs
+      - "^github.com/Shopify/sarama.Config$"
+      - "^github.com/Shopify/sarama.ProducerMessage$"
+      - "^github.com/mitchellh/mapstructure.DecoderConfig$"
+      - "^github.com/prometheus/client_golang/.+Opts$"
+      - "^github.com/spf13/cobra.Command$"
+      - "^github.com/spf13/cobra.CompletionOptions$"
+      - "^github.com/stretchr/testify/mock.Mock$"
+      - "^github.com/testcontainers/testcontainers-go.+Request$"
+      - "^github.com/testcontainers/testcontainers-go.FromDockerfile$"
+      - "^golang.org/x/tools/go/analysis.Analyzer$"
+      - "^google.golang.org/protobuf/.+Options$"
+      - "^gopkg.in/yaml.v3.Node$"
+
+  funlen:
+    # Checks the number of lines in a function.
+    # If lower than 0, disable the check.
+    # Default: 60
+    lines: 100
+    # Checks the number of statements in a function.
+    # If lower than 0, disable the check.
+    # Default: 40
+    statements: 50
+    # Ignore comments when counting lines.
+    # Default false
+    ignore-comments: true
+
+  gocognit:
+    # Minimal code complexity to report.
+    # Default: 30 (but we recommend 10-20)
+    min-complexity: 20
+
+  gocritic:
+    # Settings passed to gocritic.
+    # The settings key is the name of a supported gocritic checker.
+    # The list of supported checkers can be find in https://go-critic.github.io/overview.
+    settings:
+      captLocal:
+        # Whether to restrict checker to params only.
+        # Default: true
+        paramsOnly: false
+      underef:
+        # Whether to skip (*x).method() calls where x is a pointer receiver.
+        # Default: true
+        skipRecvDeref: false
+
+  gomodguard:
+    blocked:
+      # List of blocked modules.
+      # Default: []
+      modules:
+        - github.com/golang/protobuf:
+            recommendations:
+              - google.golang.org/protobuf
+            reason: "see https://developers.google.com/protocol-buffers/docs/reference/go/faq#modules"
+        - github.com/satori/go.uuid:
+            recommendations:
+              - github.com/google/uuid
+            reason: "satori's package is not maintained"
+        - github.com/gofrs/uuid:
+            recommendations:
+              - github.com/gofrs/uuid/v5
+            reason: "gofrs' package was not go module before v5"
+
+  govet:
+    # Enable all analyzers.
+    # Default: false
+    enable-all: true
+    # Disable analyzers by name.
+    # Run `go tool vet help` to see all analyzers.
+    # Default: []
+    disable:
+      - fieldalignment # too strict
+    # Settings per analyzer.
+    settings:
+      shadow:
+        # Whether to be strict about shadowing; can be noisy.
+        # Default: false
+        strict: false
+
+  inamedparam:
+    # Skips check for interface methods with only a single parameter.
+    # Default: false
+    skip-single-param: true
+
+  mnd:
+    # List of function patterns to exclude from analysis.
+    # Values always ignored: `time.Date`,
+    # `strconv.FormatInt`, `strconv.FormatUint`, `strconv.FormatFloat`,
+    # `strconv.ParseInt`, `strconv.ParseUint`, `strconv.ParseFloat`.
+    # Default: []
+    ignored-functions:
+      - args.Error
+      - flag.Arg
+      - flag.Duration.*
+      - flag.Float.*
+      - flag.Int.*
+      - flag.Uint.*
+      - os.Chmod
+      - os.Mkdir.*
+      - os.OpenFile
+      - os.WriteFile
+      - prometheus.ExponentialBuckets.*
+      - prometheus.LinearBuckets
+
+  nakedret:
+    # Make an issue if func has more lines of code than this setting, and it has naked returns.
+    # Default: 30
+    max-func-lines: 0
+
+  nolintlint:
+    # Exclude following linters from requiring an explanation.
+    # Default: []
+    allow-no-explanation: [ funlen, gocognit, lll ]
+    # Enable to require an explanation of nonzero length after each nolint directive.
+    # Default: false
+    require-explanation: true
+    # Enable to require nolint directives to mention the specific linter being suppressed.
+    # Default: false
+    require-specific: true
+
+  perfsprint:
+    # Optimizes into strings concatenation.
+    # Default: true
+    strconcat: false
+
+  rowserrcheck:
+    # database/sql is always checked
+    # Default: []
+    packages:
+      - github.com/jmoiron/sqlx
+
+  sloglint:
+    # Enforce not using global loggers.
+    # Values:
+    # - "": disabled
+    # - "all": report all global loggers
+    # - "default": report only the default slog logger
+    # https://github.com/go-simpler/sloglint?tab=readme-ov-file#no-global
+    # Default: ""
+    no-global: "all"
+    # Enforce using methods that accept a context.
+    # Values:
+    # - "": disabled
+    # - "all": report all contextless calls
+    # - "scope": report only if a context exists in the scope of the outermost function
+    # https://github.com/go-simpler/sloglint?tab=readme-ov-file#context-only
+    # Default: ""
+    context: "scope"
+
+  tenv:
+    # The option `all` will run against whole test files (`_test.go`) regardless of method/function signatures.
+    # Otherwise, only methods that take `*testing.T`, `*testing.B`, and `testing.TB` as arguments are checked.
+    # Default: false
+    all: true
+
+
+issues:
+  # Maximum count of issues with the same text.
+  # Set to 0 to disable.
+  # Default: 3
+  max-same-issues: 50
+
+  exclude-rules:
+    - source: "(noinspection|TODO)"
+      linters: [ godot ]
+    - source: "//noinspection"
+      linters: [ gocritic ]
+    - path: "_test\\.go"
+      linters:
+        - bodyclose
+        - dupl
+        - funlen
+        - goconst
+        - gosec
+        - noctx
+        - wrapcheck

backend/.goreleaser.yaml

@@ -1,14 +1,17 @@
+# .goreleaser.yaml
 project_name: filebrowser
+version: 2
 
 builds:
-  - ldflags:
-      - -s -w
+  # Build configuration for darwin and linux
+  - id: default
+    ldflags: &ldflags
+      - -s -w -X github.com/gtsteffaniak/filebrowser/version.Version={{ .Version }} -X github.com/gtsteffaniak/filebrowser/version.CommitSHA={{ .ShortCommit }}
     main: main.go
     binary: filebrowser
     goos:
       - darwin
       - linux
-      - windows
     goarch:
       - amd64
       - arm
@@ -16,7 +19,25 @@ builds:
     goarm:
       - 6
       - 7
+    hooks:
+      post: 
+        - upx {{ .Path }}  # Compress the binary with UPX
+
+  # Build configuration for windows without arm
+  - id: windows
+    ldflags: *ldflags
+    main: main.go
+    binary: filebrowser
+    goos:
+      - windows
+    goarch:
+      - amd64
+      - arm64
 
 archives:
   - name_template: "{{.Os}}-{{.Arch}}{{if .Arm}}v{{.Arm}}{{end}}-{{ .ProjectName }}"
     format: binary
+
+checksum:
+  disable: true
+

backend/auth/auth.go

@@ -9,7 +9,7 @@ import (
 // Auther is the authentication interface.
 type Auther interface {
 	// Auth is called to authenticate a request.
-	Auth(r *http.Request, usr users.Store) (*users.User, error)
+	Auth(r *http.Request, userStore *users.Storage) (*users.User, error)
 	// LoginPage indicates if this auther needs a login page.
 	LoginPage() bool
 }

backend/auth/hook.go

@@ -30,7 +30,7 @@ type HookAuth struct {
 }
 
 // Auth authenticates the user via a json in content body.
-func (a *HookAuth) Auth(r *http.Request, usr users.Store) (*users.User, error) {
+func (a *HookAuth) Auth(r *http.Request, usr *users.Storage) (*users.User, error) {
 	var cred hookCred
 
 	if r.Body == nil {
@@ -51,7 +51,6 @@ func (a *HookAuth) Auth(r *http.Request, usr users.Store) (*users.User, error) {
 	if err != nil {
 		return nil, err
 	}
-
 	switch action {
 	case "auth":
 		u, err := a.SaveUser()

backend/auth/json.go

@@ -23,7 +23,7 @@ type JSONAuth struct {
 }
 
 // Auth authenticates the user via a json in content body.
-func (a JSONAuth) Auth(r *http.Request, usr users.Store) (*users.User, error) {
+func (a JSONAuth) Auth(r *http.Request, userStore *users.Storage) (*users.User, error) {
 	config := &settings.Config
 	var cred jsonCred
 
@@ -47,8 +47,7 @@ func (a JSONAuth) Auth(r *http.Request, usr users.Store) (*users.User, error) {
 			return nil, os.ErrPermission
 		}
 	}
-
-	u, err := usr.Get(config.Server.Root, cred.Username)
+	u, err := userStore.Get(config.Server.Root, cred.Username)
 	if err != nil || !users.CheckPwd(cred.Password, u.Password) {
 		return nil, os.ErrPermission
 	}

backend/auth/none.go

@@ -14,7 +14,7 @@ const MethodNoAuth = "noauth"
 type NoAuth struct{}
 
 // Auth uses authenticates user 1.
-func (a NoAuth) Auth(r *http.Request, usr users.Store) (*users.User, error) {
+func (a NoAuth) Auth(r *http.Request, usr *users.Storage) (*users.User, error) {
 	return usr.Get(settings.Config.Server.Root, uint(1))
 }
 

backend/auth/proxy.go

@@ -19,7 +19,7 @@ type ProxyAuth struct {
 }
 
 // Auth authenticates the user via an HTTP header.
-func (a ProxyAuth) Auth(r *http.Request, usr users.Store) (*users.User, error) {
+func (a ProxyAuth) Auth(r *http.Request, usr *users.Storage) (*users.User, error) {
 	username := r.Header.Get(a.Header)
 	user, err := usr.Get(settings.Config.Server.Root, username)
 	if err == errors.ErrNotExist {

backend/benchmark_results.txt

@@ -5,49 +5,39 @@
 ?   	github.com/gtsteffaniak/filebrowser/auth	[no test files]
 ?   	github.com/gtsteffaniak/filebrowser/cmd	[no test files]
 PASS
-ok  	github.com/gtsteffaniak/filebrowser/diskcache	0.003s
+ok  	github.com/gtsteffaniak/filebrowser/diskcache	0.004s
 ?   	github.com/gtsteffaniak/filebrowser/errors	[no test files]
+2024/10/07 12:46:34 could not update unknown type:  unknown
 goos: linux
 goarch: amd64
 pkg: github.com/gtsteffaniak/filebrowser/files
 cpu: 11th Gen Intel(R) Core(TM) i5-11320H @ 3.20GHz
-BenchmarkFillIndex-8          	      10	   3587120 ns/op	  273640 B/op	    2013 allocs/op
-BenchmarkSearchAllIndexes-8   	      10	  31291180 ns/op	19500700 B/op	  298636 allocs/op
+BenchmarkFillIndex-8          	      10	   3847878 ns/op	  758424 B/op	    5567 allocs/op
+BenchmarkSearchAllIndexes-8   	      10	    780431 ns/op	  173444 B/op	    2014 allocs/op
 PASS
-ok  	github.com/gtsteffaniak/filebrowser/files	0.408s
+ok  	github.com/gtsteffaniak/filebrowser/files	0.073s
 PASS
 ok  	github.com/gtsteffaniak/filebrowser/fileutils	0.003s
-2024/02/07 07:16:43 Saving new user: publicUser
-2024/02/07 07:16:43 Saving new user: publicUser
-2024/02/07 07:16:43 Saving new user: publicUser
-2024/02/07 07:16:43 Saving new user: publicUser
-2024/02/07 07:16:43 Saving new user: publicUser
-2024/02/07 07:16:43 Saving new user: publicUser
-2024/02/07 07:16:43 Saving new user: publicUser
-2024/02/07 07:16:43 Saving new user: publicUser
-2024/02/07 07:16:43 h: 401  <nil>
-2024/02/07 07:16:43 h: 401  <nil>
-2024/02/07 07:16:43 h: 401  <nil>
-2024/02/07 07:16:43 h: 401  <nil>
-2024/02/07 07:16:43 Saving new user: publicUser
-2024/02/07 07:16:43 Saving new user: publicUser
-2024/02/07 07:16:43 Saving new user: publicUser
-2024/02/07 07:16:43 Saving new user: publicUser
-2024/02/07 07:16:43 h: 401  <nil>
-2024/02/07 07:16:43 h: 401  <nil>
+2024/10/07 12:46:34 h: 401  <nil>
+2024/10/07 12:46:34 h: 401  <nil>
+2024/10/07 12:46:34 h: 401  <nil>
+2024/10/07 12:46:34 h: 401  <nil>
+2024/10/07 12:46:34 h: 401  <nil>
+2024/10/07 12:46:34 h: 401  <nil>
 PASS
-ok  	github.com/gtsteffaniak/filebrowser/http	0.202s
+ok  	github.com/gtsteffaniak/filebrowser/http	0.080s
 PASS
-ok  	github.com/gtsteffaniak/filebrowser/img	0.125s
+ok  	github.com/gtsteffaniak/filebrowser/img	0.137s
 PASS
 ok  	github.com/gtsteffaniak/filebrowser/rules	0.002s
 PASS
 ok  	github.com/gtsteffaniak/filebrowser/runner	0.003s
 PASS
-ok  	github.com/gtsteffaniak/filebrowser/settings	0.005s
+ok  	github.com/gtsteffaniak/filebrowser/settings	0.004s
 ?   	github.com/gtsteffaniak/filebrowser/share	[no test files]
 ?   	github.com/gtsteffaniak/filebrowser/storage	[no test files]
 ?   	github.com/gtsteffaniak/filebrowser/storage/bolt	[no test files]
 PASS
-ok  	github.com/gtsteffaniak/filebrowser/users	0.003s
+ok  	github.com/gtsteffaniak/filebrowser/users	0.002s
+?   	github.com/gtsteffaniak/filebrowser/utils	[no test files]
 ?   	github.com/gtsteffaniak/filebrowser/version	[no test files]

backend/cmd/root.go

@@ -1,155 +1,166 @@
 package cmd
 
 import (
-	"crypto/tls"
 	"flag"
 	"fmt"
-	"io/fs"
 	"log"
-	"net"
-	"net/http"
 	"os"
-	"os/signal"
-	"strconv"
-	"syscall"
+	"strings"
 
-	"github.com/spf13/pflag"
-
-	"github.com/spf13/afero"
-	"github.com/spf13/cobra"
-
-	"github.com/gtsteffaniak/filebrowser/auth"
 	"github.com/gtsteffaniak/filebrowser/diskcache"
 	"github.com/gtsteffaniak/filebrowser/files"
 	fbhttp "github.com/gtsteffaniak/filebrowser/http"
 	"github.com/gtsteffaniak/filebrowser/img"
 	"github.com/gtsteffaniak/filebrowser/settings"
+	"github.com/gtsteffaniak/filebrowser/storage"
+	"github.com/gtsteffaniak/filebrowser/swagger/docs"
+	"github.com/swaggo/swag"
+
 	"github.com/gtsteffaniak/filebrowser/users"
+	"github.com/gtsteffaniak/filebrowser/version"
 )
 
-type dirFS struct {
-	http.Dir
+func getStore(config string) (*storage.Storage, bool) {
+	// Use the config file (global flag)
+	settings.Initialize(config)
+	store, hasDB, err := storage.InitializeDb(settings.Config.Server.Database)
+	if err != nil {
+		log.Fatal("could not load db info: ", err)
+	}
+	return store, hasDB
 }
 
-func (d dirFS) Open(name string) (fs.File, error) {
-	return d.Dir.Open(name)
-}
-
-func init() {
-	// Define a flag for the config option (-c or --config)
-	configFlag := pflag.StringP("config", "c", "filebrowser.yaml", "Path to the config file")
-	// Bind the flags to the pflag command line parser
-	pflag.CommandLine.AddGoFlagSet(flag.CommandLine)
-	pflag.Parse()
-	log.Println("Initializing with config file:", *configFlag)
-	settings.Initialize(*configFlag)
-}
-
-var rootCmd = &cobra.Command{
-	Use: "filebrowser",
-	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
-		serverConfig := settings.Config.Server
-		if !d.hadDB {
-			quickSetup(d)
-		}
-		if serverConfig.NumImageProcessors < 1 {
-			log.Fatal("Image resize workers count could not be < 1")
-		}
-		imgSvc := img.New(serverConfig.NumImageProcessors)
-		var fileCache diskcache.Interface = diskcache.NewNoOp()
-		cacheDir := "/tmp"
-		if cacheDir != "" {
-			if err := os.MkdirAll(cacheDir, 0700); err != nil { //nolint:govet,gomnd
-				log.Fatalf("can't make directory %s: %s", cacheDir, err)
-			}
-			fileCache = diskcache.New(afero.NewOsFs(), cacheDir)
-		}
-		// initialize indexing and schedule indexing ever n minutes (default 5)
-		go files.InitializeIndex(serverConfig.IndexingInterval, serverConfig.Indexing)
-		_, err := os.Stat(serverConfig.Root)
-		checkErr(fmt.Sprint("cmd os.Stat ", serverConfig.Root), err)
-		var listener net.Listener
-		address := serverConfig.Address + ":" + strconv.Itoa(serverConfig.Port)
-		switch {
-		case serverConfig.Socket != "":
-			listener, err = net.Listen("unix", serverConfig.Socket)
-			checkErr("net.Listen", err)
-			socketPerm, err := cmd.Flags().GetUint32("socket-perm") //nolint:govet
-			checkErr("cmd.Flags().GetUint32", err)
-			err = os.Chmod(serverConfig.Socket, os.FileMode(socketPerm))
-			checkErr("os.Chmod", err)
-		case serverConfig.TLSKey != "" && serverConfig.TLSCert != "":
-			cer, err := tls.LoadX509KeyPair(serverConfig.TLSCert, serverConfig.TLSKey) //nolint:govet
-			checkErr("tls.LoadX509KeyPair", err)
-			listener, err = tls.Listen("tcp", address, &tls.Config{
-				MinVersion:   tls.VersionTLS12,
-				Certificates: []tls.Certificate{cer}},
-			)
-			checkErr("tls.Listen", err)
-		default:
-			listener, err = net.Listen("tcp", address)
-			checkErr("net.Listen", err)
-		}
-		sigc := make(chan os.Signal, 1)
-		signal.Notify(sigc, os.Interrupt, syscall.SIGTERM)
-		go cleanupHandler(listener, sigc)
-		assetsFs := dirFS{Dir: http.Dir("frontend/dist")}
-		handler, err := fbhttp.NewHandler(imgSvc, fileCache, d.store, &serverConfig, assetsFs)
-		checkErr("fbhttp.NewHandler", err)
-		defer listener.Close()
-		log.Println("Listening on", listener.Addr().String())
-		//nolint: gosec
-		if err := http.Serve(listener, handler); err != nil {
-			log.Fatalf("Could not start server on port %d: %v", serverConfig.Port, err)
-		}
-	}, pythonConfig{allowNoDB: true}),
+func generalUsage() {
+	fmt.Printf(`usage: ./html-web-crawler <command> [options] --urls <urls>
+  commands:
+    collect  Collect data from URLs
+    crawl    Crawl URLs and collect data
+    install  Install chrome browser for javascript enabled scraping.
+               Note: Consider instead to install via native package manager,
+                     then set "CHROME_EXECUTABLE" in the environment
+	` + "\n")
 }
 
 func StartFilebrowser() {
-	if err := rootCmd.Execute(); err != nil {
+	// Global flags
+	var configPath string
+	var help bool
+	// Override the default usage output to use generalUsage()
+	flag.Usage = generalUsage
+	flag.StringVar(&configPath, "c", "filebrowser.yaml", "Path to the config file.")
+	flag.BoolVar(&help, "h", false, "Get help about commands")
+
+	// Parse global flags (before subcommands)
+	flag.Parse() // print generalUsage on error
+
+	// Show help if requested
+	if help {
+		generalUsage()
+		return
+	}
+
+	// Create a new FlagSet for the 'set' subcommand
+	setCmd := flag.NewFlagSet("set", flag.ExitOnError)
+	var user, scope, dbConfig string
+	var asAdmin bool
+
+	setCmd.StringVar(&user, "u", "", "Comma-separated username and password: \"set -u <username>,<password>\"")
+	setCmd.BoolVar(&asAdmin, "a", false, "Create user as admin user, used in combination with -u")
+	setCmd.StringVar(&scope, "s", "", "Specify a user scope, otherwise default user config scope is used")
+	setCmd.StringVar(&dbConfig, "c", "filebrowser.yaml", "Path to the config file.")
+
+	// Parse subcommand flags only if a subcommand is specified
+	if len(os.Args) > 1 {
+		switch os.Args[1] {
+		case "set":
+			err := setCmd.Parse(os.Args)
+			if err != nil {
+				setCmd.PrintDefaults()
+				os.Exit(1)
+			}
+			userInfo := strings.Split(user, ",")
+			if len(userInfo) < 2 {
+				fmt.Println("not enough info to create user: \"set -u username,password\"")
+				setCmd.PrintDefaults()
+				os.Exit(1)
+			}
+			username := userInfo[0]
+			password := userInfo[1]
+			getStore(dbConfig)
+			// Create the user logic
+			if asAdmin {
+				log.Printf("Creating user as admin: %s\n", username)
+			} else {
+				log.Printf("Creating user: %s\n", username)
+			}
+			newUser := users.User{
+				Username: username,
+				Password: password,
+			}
+			if scope != "" {
+				newUser.Scope = scope
+			}
+			err = storage.CreateUser(newUser, asAdmin)
+			if err != nil {
+				log.Fatal("Could not create user: ", err)
+			}
+			return
+		case "version":
+			fmt.Println("FileBrowser Quantum - A modern web-based file manager")
+			fmt.Printf("Version        : %v\n", version.Version)
+			fmt.Printf("Commit         : %v\n", version.CommitSHA)
+			fmt.Printf("Release Info   : https://github.com/gtsteffaniak/filebrowser/releases/tag/%v\n", version.Version)
+			return
+		}
+	}
+	store, dbExists := getStore(configPath)
+	indexingInterval := fmt.Sprint(settings.Config.Server.IndexingInterval, " minutes")
+	if !settings.Config.Server.Indexing {
+		indexingInterval = "disabled"
+	}
+	database := fmt.Sprintf("Using existing database  : %v", settings.Config.Server.Database)
+	if !dbExists {
+		database = fmt.Sprintf("Creating new database    : %v", settings.Config.Server.Database)
+	}
+	log.Printf("Initializing FileBrowser Quantum (%v)\n", version.Version)
+	log.Printf("Using Config file        : %v", configPath)
+	log.Println("Embeded frontend         :", os.Getenv("FILEBROWSER_NO_EMBEDED") != "true")
+	log.Println(database)
+	log.Println("Sources                  :", settings.Config.Server.Root)
+	log.Println("Indexing interval        :", indexingInterval)
+
+	serverConfig := settings.Config.Server
+	swagInfo := docs.SwaggerInfo
+	swagInfo.BasePath = serverConfig.BaseURL
+	swag.Register(docs.SwaggerInfo.InstanceName(), swagInfo)
+	// initialize indexing and schedule indexing ever n minutes (default 5)
+	go files.InitializeIndex(serverConfig.IndexingInterval, serverConfig.Indexing)
+	if err := rootCMD(store, &serverConfig); err != nil {
 		log.Fatal("Error starting filebrowser:", err)
 	}
 }
 
-func cleanupHandler(listener net.Listener, c chan os.Signal) { //nolint:interfacer
-	sig := <-c
-	log.Printf("Caught signal %s: shutting down.", sig)
-	listener.Close()
-	os.Exit(0)
-}
+func rootCMD(store *storage.Storage, serverConfig *settings.Server) error {
+	if serverConfig.NumImageProcessors < 1 {
+		log.Fatal("Image resize workers count could not be < 1")
+	}
+	imgSvc := img.New(serverConfig.NumImageProcessors)
 
-func quickSetup(d pythonData) {
-	settings.Config.Auth.Key = generateKey()
-	if settings.Config.Auth.Method == "noauth" {
-		err := d.store.Auth.Save(&auth.NoAuth{})
-		checkErr("d.store.Auth.Save", err)
+	cacheDir := "/tmp"
+	var fileCache diskcache.Interface
+
+	// Use file cache if cacheDir is specified
+	if cacheDir != "" {
+		var err error
+		fileCache, err = diskcache.NewFileCache(cacheDir)
+		if err != nil {
+			log.Fatalf("failed to create file cache: %v", err)
+		}
 	} else {
-		settings.Config.Auth.Method = "password"
-		err := d.store.Auth.Save(&auth.JSONAuth{})
-		checkErr("d.store.Auth.Save", err)
+		// No-op cache if no cacheDir is specified
+		fileCache = diskcache.NewNoOp()
 	}
-	err := d.store.Settings.Save(&settings.Config)
-	checkErr("d.store.Settings.Save", err)
-	err = d.store.Settings.SaveServer(&settings.Config.Server)
-	checkErr("d.store.Settings.SaveServer", err)
-	user := &users.User{}
-	settings.Config.UserDefaults.Apply(user)
-	user.Username = settings.Config.Auth.AdminUsername
-	user.Password = settings.Config.Auth.AdminPassword
-	user.Perm.Admin = true
-	user.Scope = "./"
-	user.DarkMode = true
-	user.ViewMode = "normal"
-	user.LockPassword = false
-	user.Perm = users.Permissions{
-		Create:   true,
-		Rename:   true,
-		Modify:   true,
-		Delete:   true,
-		Share:    true,
-		Download: true,
-		Admin:    true,
-	}
-	err = d.store.Users.Save(user)
-	checkErr("d.store.Users.Save", err)
+	fbhttp.StartHttp(imgSvc, store, fileCache)
+
+	return nil
 }

backend/cmd/rule_rm.go

@@ -6,7 +6,9 @@ import (
 	"github.com/spf13/cobra"
 
 	"github.com/gtsteffaniak/filebrowser/settings"
+	"github.com/gtsteffaniak/filebrowser/storage"
 	"github.com/gtsteffaniak/filebrowser/users"
+	"github.com/gtsteffaniak/filebrowser/utils"
 )
 
 func init() {
@@ -40,27 +42,27 @@ including 'index_end'.`,
 
 		return nil
 	},
-	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
+	Run: cobraCmd(func(cmd *cobra.Command, args []string, store *storage.Storage) {
 		i, err := strconv.Atoi(args[0])
-		checkErr("strconv.Atoi", err)
+		utils.CheckErr("strconv.Atoi", err)
 		f := i
 		if len(args) == 2 { //nolint:gomnd
 			f, err = strconv.Atoi(args[1])
-			checkErr("strconv.Atoi", err)
+			utils.CheckErr("strconv.Atoi", err)
 		}
 
 		user := func(u *users.User) {
 			u.Rules = append(u.Rules[:i], u.Rules[f+1:]...)
-			err := d.store.Users.Save(u)
-			checkErr("d.store.Users.Save", err)
+			err := store.Users.Save(u)
+			utils.CheckErr("store.Users.Save", err)
 		}
 
 		global := func(s *settings.Settings) {
 			s.Rules = append(s.Rules[:i], s.Rules[f+1:]...)
-			err := d.store.Settings.Save(s)
-			checkErr("d.store.Settings.Save", err)
+			err := store.Settings.Save(s)
+			utils.CheckErr("store.Settings.Save", err)
 		}
 
-		runRules(d.store, cmd, user, global)
-	}, pythonConfig{}),
+		runRules(store, cmd, user, global)
+	}),
 }

backend/cmd/rules.go

@@ -6,14 +6,13 @@ import (
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
 
-	"github.com/gtsteffaniak/filebrowser/rules"
 	"github.com/gtsteffaniak/filebrowser/settings"
 	"github.com/gtsteffaniak/filebrowser/storage"
 	"github.com/gtsteffaniak/filebrowser/users"
+	"github.com/gtsteffaniak/filebrowser/utils"
 )
 
 func init() {
-	rootCmd.AddCommand(rulesCmd)
 	rulesCmd.PersistentFlags().StringP("username", "u", "", "username of user to which the rules apply")
 	rulesCmd.PersistentFlags().UintP("id", "i", 0, "id of user to which the rules apply")
 }
@@ -33,7 +32,7 @@ func runRules(st *storage.Storage, cmd *cobra.Command, usersFn func(*users.User)
 	id := getUserIdentifier(cmd.Flags())
 	if id != nil {
 		user, err := st.Users.Get("", id)
-		checkErr("st.Users.Get", err)
+		utils.CheckErr("st.Users.Get", err)
 
 		if usersFn != nil {
 			usersFn(user)
@@ -44,7 +43,7 @@ func runRules(st *storage.Storage, cmd *cobra.Command, usersFn func(*users.User)
 	}
 
 	s, err := st.Settings.Get()
-	checkErr("st.Settings.Get", err)
+	utils.CheckErr("st.Settings.Get", err)
 
 	if globalFn != nil {
 		globalFn(s)
@@ -66,12 +65,7 @@ func getUserIdentifier(flags *pflag.FlagSet) interface{} {
 	return nil
 }
 
-func printRules(rulez []rules.Rule, id interface{}) {
-	if id == nil {
-		fmt.Printf("Global Rules:\n\n")
-	} else {
-		fmt.Printf("Rules for user %v:\n\n", id)
-	}
+func printRules(rulez []users.Rule, id interface{}) {
 
 	for id, rule := range rulez {
 		fmt.Printf("(%d) ", id)

backend/cmd/rules_add.go

@@ -5,9 +5,10 @@ import (
 
 	"github.com/spf13/cobra"
 
-	"github.com/gtsteffaniak/filebrowser/rules"
 	"github.com/gtsteffaniak/filebrowser/settings"
+	"github.com/gtsteffaniak/filebrowser/storage"
 	"github.com/gtsteffaniak/filebrowser/users"
+	"github.com/gtsteffaniak/filebrowser/utils"
 )
 
 func init() {
@@ -21,7 +22,7 @@ var rulesAddCmd = &cobra.Command{
 	Short: "Add a global rule or user rule",
 	Long:  `Add a global rule or user rule.`,
 	Args:  cobra.ExactArgs(1),
-	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
+	Run: cobraCmd(func(cmd *cobra.Command, args []string, store *storage.Storage) {
 		allow := mustGetBool(cmd.Flags(), "allow")
 		regex := mustGetBool(cmd.Flags(), "regex")
 		exp := args[0]
@@ -30,29 +31,29 @@ var rulesAddCmd = &cobra.Command{
 			regexp.MustCompile(exp)
 		}
 
-		rule := rules.Rule{
+		rule := users.Rule{
 			Allow: allow,
 			Regex: regex,
 		}
 
 		if regex {
-			rule.Regexp = &rules.Regexp{Raw: exp}
+			rule.Regexp = &users.Regexp{Raw: exp}
 		} else {
 			rule.Path = exp
 		}
 
 		user := func(u *users.User) {
 			u.Rules = append(u.Rules, rule)
-			err := d.store.Users.Save(u)
-			checkErr("d.store.Users.Save", err)
+			err := store.Users.Save(u)
+			utils.CheckErr("store.Users.Save", err)
 		}
 
 		global := func(s *settings.Settings) {
 			s.Rules = append(s.Rules, rule)
-			err := d.store.Settings.Save(s)
-			checkErr("d.store.Settings.Save", err)
+			err := store.Settings.Save(s)
+			utils.CheckErr("store.Settings.Save", err)
 		}
 
-		runRules(d.store, cmd, user, global)
-	}, pythonConfig{}),
+		runRules(store, cmd, user, global)
+	}),
 }

backend/cmd/rules_ls.go

@@ -1,6 +1,7 @@
 package cmd
 
 import (
+	"github.com/gtsteffaniak/filebrowser/storage"
 	"github.com/spf13/cobra"
 )
 
@@ -13,7 +14,7 @@ var rulesLsCommand = &cobra.Command{
 	Short: "List global rules or user specific rules",
 	Long:  `List global rules or user specific rules.`,
 	Args:  cobra.NoArgs,
-	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
-		runRules(d.store, cmd, nil, nil)
-	}, pythonConfig{}),
+	Run: cobraCmd(func(cmd *cobra.Command, args []string, store *storage.Storage) {
+		runRules(store, cmd, nil, nil)
+	}),
 }

backend/cmd/users.go

@@ -11,10 +11,6 @@ import (
 	"github.com/gtsteffaniak/filebrowser/users"
 )
 
-func init() {
-	rootCmd.AddCommand(usersCmd)
-}
-
 var usersCmd = &cobra.Command{
 	Use:   "users",
 	Short: "Users management utility",

backend/cmd/users_add.go

@@ -3,7 +3,9 @@ package cmd
 import (
 	"github.com/spf13/cobra"
 
+	"github.com/gtsteffaniak/filebrowser/storage"
 	"github.com/gtsteffaniak/filebrowser/users"
+	"github.com/gtsteffaniak/filebrowser/utils"
 )
 
 func init() {
@@ -15,26 +17,26 @@ var usersAddCmd = &cobra.Command{
 	Short: "Create a new user",
 	Long:  `Create a new user and add it to the database.`,
 	Args:  cobra.ExactArgs(2), //nolint:gomnd
-	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
+	Run: cobraCmd(func(cmd *cobra.Command, args []string, store *storage.Storage) {
 		user := &users.User{
 			Username:     args[0],
 			Password:     args[1],
 			LockPassword: mustGetBool(cmd.Flags(), "lockPassword"),
 		}
-		servSettings, err := d.store.Settings.GetServer()
-		checkErr("d.store.Settings.GetServer()", err)
+		servSettings, err := store.Settings.GetServer()
+		utils.CheckErr("store.Settings.GetServer()", err)
 		// since getUserDefaults() polluted s.Defaults.Scope
 		// which makes the Scope not the one saved in the db
 		// we need the right s.Defaults.Scope here
-		s2, err := d.store.Settings.Get()
-		checkErr("d.store.Settings.Get()", err)
+		s2, err := store.Settings.Get()
+		utils.CheckErr("store.Settings.Get()", err)
 
 		userHome, err := s2.MakeUserDir(user.Username, user.Scope, servSettings.Root)
-		checkErr("s2.MakeUserDir", err)
+		utils.CheckErr("s2.MakeUserDir", err)
 		user.Scope = userHome
 
-		err = d.store.Users.Save(user)
-		checkErr("d.store.Users.Save", err)
+		err = store.Users.Save(user)
+		utils.CheckErr("store.Users.Save", err)
 		printUsers([]*users.User{user})
-	}, pythonConfig{}),
+	}),
 }

backend/cmd/users_export.go

@@ -1,6 +1,8 @@
 package cmd
 
 import (
+	"github.com/gtsteffaniak/filebrowser/storage"
+	"github.com/gtsteffaniak/filebrowser/utils"
 	"github.com/spf13/cobra"
 )
 
@@ -14,11 +16,11 @@ var usersExportCmd = &cobra.Command{
 	Long: `Export all users to a json or yaml file. Please indicate the
 path to the file where you want to write the users.`,
 	Args: jsonYamlArg,
-	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
-		list, err := d.store.Users.Gets("")
-		checkErr("d.store.Users.Gets", err)
+	Run: cobraCmd(func(cmd *cobra.Command, args []string, store *storage.Storage) {
+		list, err := store.Users.Gets("")
+		utils.CheckErr("store.Users.Gets", err)
 
 		err = marshal(args[0], list)
-		checkErr("marshal", err)
-	}, pythonConfig{}),
+		utils.CheckErr("marshal", err)
+	}),
 }

backend/cmd/users_find.go

@@ -3,7 +3,9 @@ package cmd
 import (
 	"github.com/spf13/cobra"
 
+	"github.com/gtsteffaniak/filebrowser/storage"
 	"github.com/gtsteffaniak/filebrowser/users"
+	"github.com/gtsteffaniak/filebrowser/utils"
 )
 
 func init() {
@@ -26,7 +28,7 @@ var usersLsCmd = &cobra.Command{
 	Run:   findUsers,
 }
 
-var findUsers = python(func(cmd *cobra.Command, args []string, d pythonData) {
+var findUsers = cobraCmd(func(cmd *cobra.Command, args []string, store *storage.Storage) {
 	var (
 		list []*users.User
 		user *users.User
@@ -36,16 +38,16 @@ var findUsers = python(func(cmd *cobra.Command, args []string, d pythonData) {
 	if len(args) == 1 {
 		username, id := parseUsernameOrID(args[0])
 		if username != "" {
-			user, err = d.store.Users.Get("", username)
+			user, err = store.Users.Get("", username)
 		} else {
-			user, err = d.store.Users.Get("", id)
+			user, err = store.Users.Get("", id)
 		}
 
 		list = []*users.User{user}
 	} else {
-		list, err = d.store.Users.Gets("")
+		list, err = store.Users.Gets("")
 	}
 
-	checkErr("findUsers", err)
+	utils.CheckErr("findUsers", err)
 	printUsers(list)
-}, pythonConfig{})
+})

backend/cmd/users_import.go

@@ -8,7 +8,9 @@ import (
 
 	"github.com/spf13/cobra"
 
+	"github.com/gtsteffaniak/filebrowser/storage"
 	"github.com/gtsteffaniak/filebrowser/users"
+	"github.com/gtsteffaniak/filebrowser/utils"
 )
 
 func init() {
@@ -25,52 +27,47 @@ file. You can use this command to import new users to your
 installation. For that, just don't place their ID on the files
 list or set it to 0.`,
 	Args: jsonYamlArg,
-	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
+	Run: cobraCmd(func(cmd *cobra.Command, args []string, store *storage.Storage) {
 		fd, err := os.Open(args[0])
-		checkErr("os.Open", err)
+		utils.CheckErr("os.Open", err)
 		defer fd.Close()
 
 		list := []*users.User{}
 		err = unmarshal(args[0], &list)
-		checkErr("unmarshal", err)
-
-		for _, user := range list {
-			err = user.Clean("")
-			checkErr("Clean", err)
-		}
+		utils.CheckErr("unmarshal", err)
 
 		if mustGetBool(cmd.Flags(), "replace") {
-			oldUsers, err := d.store.Users.Gets("")
-			checkErr("d.store.Users.Gets", err)
+			oldUsers, err := store.Users.Gets("")
+			utils.CheckErr("store.Users.Gets", err)
 
 			err = marshal("users.backup.json", list)
-			checkErr("marshal users.backup.json", err)
+			utils.CheckErr("marshal users.backup.json", err)
 
 			for _, user := range oldUsers {
-				err = d.store.Users.Delete(user.ID)
-				checkErr("d.store.Users.Delete", err)
+				err = store.Users.Delete(user.ID)
+				utils.CheckErr("store.Users.Delete", err)
 			}
 		}
 
 		overwrite := mustGetBool(cmd.Flags(), "overwrite")
 
 		for _, user := range list {
-			onDB, err := d.store.Users.Get("", user.ID)
+			onDB, err := store.Users.Get("", user.ID)
 
 			// User exists in DB.
 			if err == nil {
 				if !overwrite {
 					newErr := errors.New("user " + strconv.Itoa(int(user.ID)) + " is already registered")
-					checkErr("", newErr)
+					utils.CheckErr("", newErr)
 				}
 
 				// If the usernames mismatch, check if there is another one in the DB
 				// with the new username. If there is, print an error and cancel the
 				// operation
 				if user.Username != onDB.Username {
-					if conflictuous, err := d.store.Users.Get("", user.Username); err == nil { //nolint:govet
+					if conflictuous, err := store.Users.Get("", user.Username); err == nil { //nolint:govet
 						newErr := usernameConflictError(user.Username, conflictuous.ID, user.ID)
-						checkErr("usernameConflictError", newErr)
+						utils.CheckErr("usernameConflictError", newErr)
 					}
 				}
 			} else {
@@ -79,10 +76,10 @@ list or set it to 0.`,
 				user.ID = 0
 			}
 
-			err = d.store.Users.Save(user)
-			checkErr("d.store.Users.Save", err)
+			err = store.Users.Save(user)
+			utils.CheckErr("store.Users.Save", err)
 		}
-	}, pythonConfig{}),
+	}),
 }
 
 func usernameConflictError(username string, originalID, newID uint) error {

backend/cmd/users_rm.go

@@ -1,8 +1,10 @@
 package cmd
 
 import (
-	"fmt"
+	"log"
 
+	"github.com/gtsteffaniak/filebrowser/storage"
+	"github.com/gtsteffaniak/filebrowser/utils"
 	"github.com/spf13/cobra"
 )
 
@@ -15,17 +17,17 @@ var usersRmCmd = &cobra.Command{
 	Short: "Delete a user by username or id",
 	Long:  `Delete a user by username or id`,
 	Args:  cobra.ExactArgs(1),
-	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
+	Run: cobraCmd(func(cmd *cobra.Command, args []string, store *storage.Storage) {
 		username, id := parseUsernameOrID(args[0])
 		var err error
 
 		if username != "" {
-			err = d.store.Users.Delete(username)
+			err = store.Users.Delete(username)
 		} else {
-			err = d.store.Users.Delete(id)
+			err = store.Users.Delete(id)
 		}
 
-		checkErr("usersRmCmd", err)
-		fmt.Println("user deleted successfully")
-	}, pythonConfig{}),
+		utils.CheckErr("usersRmCmd", err)
+		log.Println("user deleted successfully")
+	}),
 }

backend/cmd/users_update.go

@@ -3,7 +3,9 @@ package cmd
 import (
 	"github.com/spf13/cobra"
 
+	"github.com/gtsteffaniak/filebrowser/storage"
 	"github.com/gtsteffaniak/filebrowser/users"
+	"github.com/gtsteffaniak/filebrowser/utils"
 )
 
 func init() {
@@ -16,7 +18,7 @@ var usersUpdateCmd = &cobra.Command{
 	Long: `Updates an existing user. Set the flags for the
 options you want to change.`,
 	Args: cobra.ExactArgs(1),
-	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
+	Run: cobraCmd(func(cmd *cobra.Command, args []string, store *storage.Storage) {
 		username, id := parseUsernameOrID(args[0])
 
 		var (
@@ -25,14 +27,14 @@ options you want to change.`,
 		)
 
 		if id != 0 {
-			user, err = d.store.Users.Get("", id)
+			user, err = store.Users.Get("", id)
 		} else {
-			user, err = d.store.Users.Get("", username)
+			user, err = store.Users.Get("", username)
 		}
-		checkErr("d.store.Users.Get", err)
+		utils.CheckErr("store.Users.Get", err)
 
-		err = d.store.Users.Update(user)
-		checkErr("d.store.Users.Update", err)
+		err = store.Users.Update(user)
+		utils.CheckErr("store.Users.Update", err)
 		printUsers([]*users.User{user})
-	}, pythonConfig{}),
+	}),
 }

backend/cmd/utils.go

@@ -3,113 +3,42 @@ package cmd
 import (
 	"encoding/json"
 	"errors"
-	"fmt"
-	"log"
 	"os"
 	"path/filepath"
 
-	"github.com/asdine/storm/v3"
 	"github.com/goccy/go-yaml"
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
 
-	"github.com/gtsteffaniak/filebrowser/settings"
 	"github.com/gtsteffaniak/filebrowser/storage"
-	"github.com/gtsteffaniak/filebrowser/storage/bolt"
+	"github.com/gtsteffaniak/filebrowser/utils"
 )
 
-func checkErr(source string, err error) {
-	if err != nil {
-		log.Fatalf("%s: %v", source, err)
-	}
-}
-
 func mustGetString(flags *pflag.FlagSet, flag string) string {
 	s, err := flags.GetString(flag)
-	checkErr("mustGetString", err)
+	utils.CheckErr("mustGetString", err)
 	return s
 }
 
 func mustGetBool(flags *pflag.FlagSet, flag string) bool {
 	b, err := flags.GetBool(flag)
-	checkErr("mustGetBool", err)
+	utils.CheckErr("mustGetBool", err)
 	return b
 }
 
 func mustGetUint(flags *pflag.FlagSet, flag string) uint {
 	b, err := flags.GetUint(flag)
-	checkErr("mustGetUint", err)
+	utils.CheckErr("mustGetUint", err)
 	return b
 }
 
-func generateKey() []byte {
-	k, err := settings.GenerateKey()
-	checkErr("generateKey", err)
-	return k
-}
-
 type cobraFunc func(cmd *cobra.Command, args []string)
-type pythonFunc func(cmd *cobra.Command, args []string, data pythonData)
-
-type pythonConfig struct {
-	noDB      bool
-	allowNoDB bool
-}
-
-type pythonData struct {
-	hadDB bool
-	store *storage.Storage
-}
-
-func dbExists(path string) (bool, error) {
-	stat, err := os.Stat(path)
-	if err == nil {
-		return stat.Size() != 0, nil
-	}
-
-	if os.IsNotExist(err) {
-		d := filepath.Dir(path)
-		_, err = os.Stat(d)
-		if os.IsNotExist(err) {
-			if err := os.MkdirAll(d, 0700); err != nil { //nolint:govet,gomnd
-				return false, err
-			}
-			return false, nil
-		}
-	}
-
-	return false, err
-}
-
-func python(fn pythonFunc, cfg pythonConfig) cobraFunc {
-	return func(cmd *cobra.Command, args []string) {
-		data := pythonData{hadDB: true}
-		path := settings.Config.Server.Database
-		exists, err := dbExists(path)
-
-		if err != nil {
-			panic(err)
-		} else if exists && cfg.noDB {
-			log.Fatal(path + " already exists")
-		} else if !exists && !cfg.noDB && !cfg.allowNoDB {
-			log.Fatal(path + " does not exist. Please run 'filebrowser config init' first.")
-		}
-
-		data.hadDB = exists
-		db, err := storm.Open(path)
-		checkErr(fmt.Sprintf("storm.Open path %v", path), err)
-
-		defer db.Close()
-		data.store, err = bolt.NewStorage(db)
-		checkErr("bolt.NewStorage", err)
-		fn(cmd, args, data)
-	}
-}
+type pythonFunc func(cmd *cobra.Command, args []string, store *storage.Storage)
 
 func marshal(filename string, data interface{}) error {
 	fd, err := os.Create(filename)
 
-	checkErr("os.Create", err)
+	utils.CheckErr("os.Create", err)
 	defer fd.Close()
 
 	switch ext := filepath.Ext(filename); ext {
@@ -127,7 +56,7 @@ func marshal(filename string, data interface{}) error {
 
 func unmarshal(filename string, data interface{}) error {
 	fd, err := os.Open(filename)
-	checkErr("os.Open", err)
+	utils.CheckErr("os.Open", err)
 	defer fd.Close()
 
 	switch ext := filepath.Ext(filename); ext {
@@ -152,3 +81,8 @@ func jsonYamlArg(cmd *cobra.Command, args []string) error {
 		return errors.New("invalid format: " + ext)
 	}
 }
+
+func cobraCmd(fn pythonFunc) cobraFunc {
+	return func(cmd *cobra.Command, args []string) {
+	}
+}

backend/cmd/version.go

@@ -1,21 +0,0 @@
-package cmd
-
-import (
-	"fmt"
-
-	"github.com/spf13/cobra"
-
-	"github.com/gtsteffaniak/filebrowser/version"
-)
-
-func init() {
-	rootCmd.AddCommand(versionCmd)
-}
-
-var versionCmd = &cobra.Command{
-	Use:   "version",
-	Short: "Print the version number",
-	Run: func(cmd *cobra.Command, args []string) {
-		fmt.Println("File Browser v" + version.Version + "/" + version.CommitSHA)
-	},
-}

backend/diskcache/file_cache.go

@@ -10,13 +10,17 @@ import (
 	"os"
 	"path/filepath"
 	"sync"
-
-	"github.com/spf13/afero"
 )
 
-type FileCache struct {
-	fs afero.Fs
+// Cache interface for caching operations
+type Cache interface {
+	Get(key string) ([]byte, error)
+	Set(key string, value []byte) error
+}
 
+// FileCache struct for file-based caching
+type FileCache struct {
+	dir string
 	// granular locks
 	scopedLocks struct {
 		sync.Mutex
@@ -25,10 +29,12 @@ type FileCache struct {
 	}
 }
 
-func New(fs afero.Fs, root string) *FileCache {
-	return &FileCache{
-		fs: afero.NewBasePathFs(fs, root),
+// NewFileCache creates a new FileCache
+func NewFileCache(dir string) (*FileCache, error) {
+	if err := os.MkdirAll(dir, 0700); err != nil {
+		return nil, fmt.Errorf("can't make directory %s: %v", dir, err)
 	}
+	return &FileCache{dir: dir}, nil
 }
 
 func (f *FileCache) Store(ctx context.Context, key string, value []byte) error {
@@ -37,11 +43,11 @@ func (f *FileCache) Store(ctx context.Context, key string, value []byte) error {
 	defer mu.Unlock()
 
 	fileName := f.getFileName(key)
-	if err := f.fs.MkdirAll(filepath.Dir(fileName), 0700); err != nil { //nolint:gomnd
+	if err := os.MkdirAll(filepath.Dir(fileName), 0700); err != nil {
 		return err
 	}
 
-	if err := afero.WriteFile(f.fs, fileName, value, 0700); err != nil { //nolint:gomnd
+	if err := os.WriteFile(fileName, value, 0600); err != nil {
 		return err
 	}
 
@@ -68,15 +74,15 @@ func (f *FileCache) Delete(ctx context.Context, key string) error {
 	defer mu.Unlock()
 
 	fileName := f.getFileName(key)
-	if err := f.fs.Remove(fileName); err != nil && !errors.Is(err, os.ErrNotExist) {
+	if err := os.Remove(fileName); err != nil && !errors.Is(err, os.ErrNotExist) {
 		return err
 	}
 	return nil
 }
 
-func (f *FileCache) open(key string) (afero.File, bool, error) {
+func (f *FileCache) open(key string) (*os.File, bool, error) {
 	fileName := f.getFileName(key)
-	file, err := f.fs.Open(fileName)
+	file, err := os.Open(fileName)
 	if err != nil {
 		if errors.Is(err, os.ErrNotExist) {
 			return nil, false, nil
@@ -106,5 +112,5 @@ func (f *FileCache) getFileName(key string) string {
 	hasher := sha1.New() //nolint:gosec
 	_, _ = hasher.Write([]byte(key))
 	hash := hex.EncodeToString(hasher.Sum(nil))
-	return fmt.Sprintf("%s/%s/%s", hash[:1], hash[1:3], hash)
+	return filepath.Join(f.dir, fmt.Sprintf("%s/%s/%s", hash[:1], hash[1:3], hash))
 }

backend/diskcache/file_cache_test.go

@@ -2,10 +2,10 @@ package diskcache
 
 import (
 	"context"
+	"os"
 	"path/filepath"
 	"testing"
 
-	"github.com/spf13/afero"
 	"github.com/stretchr/testify/require"
 )
 
@@ -15,35 +15,39 @@ func TestFileCache(t *testing.T) {
 		key            = "key"
 		value          = "some text"
 		newValue       = "new text"
-		cacheRoot      = "/cache"
+		cacheRoot      = "cache"
 		cachedFilePath = "a/62/a62f2225bf70bfaccbc7f1ef2a397836717377de"
 	)
 
-	fs := afero.NewMemMapFs()
-	cache := New(fs, "/cache")
+	// Create temporary directory for the cache
+	cacheDir, err := os.MkdirTemp("", cacheRoot)
+	require.NoError(t, err)
+	defer os.RemoveAll(cacheDir) // Clean up
+
+	cache, err := NewFileCache(cacheDir)
+	require.NoError(t, err)
 
 	// store new key
-	err := cache.Store(ctx, key, []byte(value))
+	err = cache.Store(ctx, key, []byte(value))
 	require.NoError(t, err)
-	checkValue(t, ctx, fs, filepath.Join(cacheRoot, cachedFilePath), cache, key, value)
+	checkValue(t, ctx, cache, filepath.Join(cacheDir, cachedFilePath), key, value)
 
 	// update existing key
 	err = cache.Store(ctx, key, []byte(newValue))
 	require.NoError(t, err)
-	checkValue(t, ctx, fs, filepath.Join(cacheRoot, cachedFilePath), cache, key, newValue)
+	checkValue(t, ctx, cache, filepath.Join(cacheDir, cachedFilePath), key, newValue)
 
 	// delete key
 	err = cache.Delete(ctx, key)
 	require.NoError(t, err)
-	exists, err := afero.Exists(fs, filepath.Join(cacheRoot, cachedFilePath))
-	require.NoError(t, err)
+	exists := fileExists(filepath.Join(cacheDir, cachedFilePath))
 	require.False(t, exists)
 }
 
-func checkValue(t *testing.T, ctx context.Context, fs afero.Fs, fileFullPath string, cache *FileCache, key, wantValue string) { //nolint:golint
+func checkValue(t *testing.T, ctx context.Context, cache *FileCache, fileFullPath string, key, wantValue string) {
 	t.Helper()
 	// check actual file content
-	b, err := afero.ReadFile(fs, fileFullPath)
+	b, err := os.ReadFile(fileFullPath)
 	require.NoError(t, err)
 	require.Equal(t, wantValue, string(b))
 
@@ -53,3 +57,11 @@ func checkValue(t *testing.T, ctx context.Context, fs afero.Fs, fileFullPath str
 	require.True(t, ok)
 	require.Equal(t, wantValue, string(b))
 }
+
+func fileExists(filename string) bool {
+	info, err := os.Stat(filename)
+	if os.IsNotExist(err) {
+		return false
+	}
+	return !info.IsDir()
+}

backend/filebrowser.yaml

@@ -1,7 +1,7 @@
 server:
   port: 80
   baseURL:  "/"
-  root: "/srv"
+  root: "./srv"
 auth:
   method: password
   signup: false

backend/files/conditions.go

@@ -91,7 +91,7 @@ func ParseSearch(value string) *SearchOptions {
 			opts.LargerThan = updateSize(size)
 		}
 		if strings.HasPrefix(filter, "smallerThan=") {
-			opts.Conditions["larger"] = true
+			opts.Conditions["smaller"] = true
 			size := strings.TrimPrefix(filter, "smallerThan=")
 			opts.SmallerThan = updateSize(size)
 		}

backend/files/conditions_test.go

@@ -0,0 +1,154 @@
+package files
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+// Helper function to create error messages dynamically
+func errorMsg(extension, expectedType string, expectedMatch bool) string {
+	matchStatus := "to match"
+	if !expectedMatch {
+		matchStatus = "to not match"
+	}
+	return fmt.Sprintf("Expected %s %s type '%s'", extension, matchStatus, expectedType)
+}
+
+func TestIsMatchingType(t *testing.T) {
+	// Test cases where IsMatchingType should return true
+	trueTestCases := []struct {
+		extension    string
+		expectedType string
+	}{
+		{".pdf", "pdf"},
+		{".doc", "doc"},
+		{".docx", "doc"},
+		{".json", "text"},
+		{".sh", "text"},
+		{".zip", "archive"},
+		{".rar", "archive"},
+	}
+
+	for _, tc := range trueTestCases {
+		assert.True(t, IsMatchingType(tc.extension, tc.expectedType), errorMsg(tc.extension, tc.expectedType, true))
+	}
+
+	// Test cases where IsMatchingType should return false
+	falseTestCases := []struct {
+		extension    string
+		expectedType string
+	}{
+		{".mp4", "doc"},
+		{".mp4", "text"},
+		{".mp4", "archive"},
+	}
+
+	for _, tc := range falseTestCases {
+		assert.False(t, IsMatchingType(tc.extension, tc.expectedType), errorMsg(tc.extension, tc.expectedType, false))
+	}
+}
+
+func TestUpdateSize(t *testing.T) {
+	// Helper function for size error messages
+	sizeErrorMsg := func(input string, expected, actual int) string {
+		return fmt.Sprintf("Expected size for input '%s' to be %d, got %d", input, expected, actual)
+	}
+
+	// Test cases for updateSize
+	testCases := []struct {
+		input    string
+		expected int
+	}{
+		{"150", 150},
+		{"invalid", 100},
+		{"", 100},
+	}
+
+	for _, tc := range testCases {
+		actual := updateSize(tc.input)
+		assert.Equal(t, tc.expected, actual, sizeErrorMsg(tc.input, tc.expected, actual))
+	}
+}
+
+func TestIsDoc(t *testing.T) {
+	// Test cases where IsMatchingType should return true for document types
+	docTrueTestCases := []struct {
+		extension    string
+		expectedType string
+	}{
+		{".doc", "doc"},
+		{".pdf", "doc"},
+	}
+
+	for _, tc := range docTrueTestCases {
+		assert.True(t, IsMatchingType(tc.extension, tc.expectedType), errorMsg(tc.extension, tc.expectedType, true))
+	}
+
+	// Test case where IsMatchingType should return false for document types
+	docFalseTestCases := []struct {
+		extension    string
+		expectedType string
+	}{
+		{".mp4", "doc"},
+	}
+
+	for _, tc := range docFalseTestCases {
+		assert.False(t, IsMatchingType(tc.extension, tc.expectedType), errorMsg(tc.extension, tc.expectedType, false))
+	}
+}
+
+func TestIsText(t *testing.T) {
+	// Test cases where IsMatchingType should return true for text types
+	textTrueTestCases := []struct {
+		extension    string
+		expectedType string
+	}{
+		{".json", "text"},
+		{".sh", "text"},
+	}
+
+	for _, tc := range textTrueTestCases {
+		assert.True(t, IsMatchingType(tc.extension, tc.expectedType), errorMsg(tc.extension, tc.expectedType, true))
+	}
+
+	// Test case where IsMatchingType should return false for text types
+	textFalseTestCases := []struct {
+		extension    string
+		expectedType string
+	}{
+		{".mp4", "text"},
+	}
+
+	for _, tc := range textFalseTestCases {
+		assert.False(t, IsMatchingType(tc.extension, tc.expectedType), errorMsg(tc.extension, tc.expectedType, false))
+	}
+}
+
+func TestIsArchive(t *testing.T) {
+	// Test cases where IsMatchingType should return true for archive types
+	archiveTrueTestCases := []struct {
+		extension    string
+		expectedType string
+	}{
+		{".zip", "archive"},
+		{".rar", "archive"},
+	}
+
+	for _, tc := range archiveTrueTestCases {
+		assert.True(t, IsMatchingType(tc.extension, tc.expectedType), errorMsg(tc.extension, tc.expectedType, true))
+	}
+
+	// Test case where IsMatchingType should return false for archive types
+	archiveFalseTestCases := []struct {
+		extension    string
+		expectedType string
+	}{
+		{".mp4", "archive"},
+	}
+
+	for _, tc := range archiveFalseTestCases {
+		assert.False(t, IsMatchingType(tc.extension, tc.expectedType), errorMsg(tc.extension, tc.expectedType, false))
+	}
+}

backend/files/file.go

@@ -1,110 +1,84 @@
 package files
 
 import (
-	"crypto/md5"  //nolint:gosec
-	"crypto/sha1" //nolint:gosec
+	"crypto/md5"
+	"crypto/sha1"
 	"crypto/sha256"
 	"crypto/sha512"
 	"encoding/hex"
+	"fmt"
 	"hash"
 	"io"
 	"mime"
 	"net/http"
 	"os"
-	filepath "path/filepath"
+	"path/filepath"
 	"strings"
 	"sync"
 	"time"
 	"unicode/utf8"
 
-	"github.com/spf13/afero"
-
 	"github.com/gtsteffaniak/filebrowser/errors"
-	"github.com/gtsteffaniak/filebrowser/rules"
+	"github.com/gtsteffaniak/filebrowser/fileutils"
+	"github.com/gtsteffaniak/filebrowser/settings"
 	"github.com/gtsteffaniak/filebrowser/users"
 )
 
 var (
-	bytesInMegabyte int64      = 1000000
-	pathMutexes                = make(map[string]*sync.Mutex)
-	pathMutexesMu   sync.Mutex // Mutex to protect the pathMutexes map
+	pathMutexes   = make(map[string]*sync.Mutex)
+	pathMutexesMu sync.Mutex // Mutex to protect the pathMutexes map
 )
 
+type ReducedItem struct {
+	Name    string      `json:"name"`
+	Size    int64       `json:"size"`
+	ModTime time.Time   `json:"modified"`
+	Type    string      `json:"type"`
+	Mode    os.FileMode `json:"-"`
+	Content string      `json:"content,omitempty"`
+}
+
 // FileInfo describes a file.
+// reduced item is non-recursive reduced "Items", used to pass flat items array
 type FileInfo struct {
-	*Listing
-	Fs        afero.Fs          `json:"-"`
-	Path      string            `json:"path,omitempty"`
-	Name      string            `json:"name"`
-	Size      int64             `json:"size"`
-	Extension string            `json:"-"`
-	ModTime   time.Time         `json:"modified"`
-	CacheTime time.Time         `json:"-"`
-	Mode      os.FileMode       `json:"-"`
-	IsDir     bool              `json:"isDir,omitempty"`
-	IsSymlink bool              `json:"isSymlink,omitempty"`
-	Type      string            `json:"type"`
-	Subtitles []string          `json:"subtitles,omitempty"`
-	Content   string            `json:"content,omitempty"`
-	Checksums map[string]string `json:"checksums,omitempty"`
-	Token     string            `json:"token,omitempty"`
+	Files     []ReducedItem        `json:"-"`
+	Dirs      map[string]*FileInfo `json:"-"`
+	Path      string               `json:"path"`
+	Name      string               `json:"name"`
+	Items     []ReducedItem        `json:"items"`
+	Size      int64                `json:"size"`
+	Extension string               `json:"-"`
+	ModTime   time.Time            `json:"modified"`
+	CacheTime time.Time            `json:"-"`
+	Mode      os.FileMode          `json:"-"`
+	IsSymlink bool                 `json:"isSymlink,omitempty"`
+	Type      string               `json:"type"`
+	Subtitles []string             `json:"subtitles,omitempty"`
+	Content   string               `json:"content,omitempty"`
+	Checksums map[string]string    `json:"checksums,omitempty"`
+	Token     string               `json:"token,omitempty"`
 }
 
 // FileOptions are the options when getting a file info.
 type FileOptions struct {
-	Fs         afero.Fs
-	Path       string
+	Path       string // realpath
+	IsDir      bool
 	Modify     bool
 	Expand     bool
 	ReadHeader bool
 	Token      string
-	Checker    rules.Checker
+	Checker    users.Checker
 	Content    bool
 }
 
-// Sorting constants
-const (
-	SortingByName     = "name"
-	SortingBySize     = "size"
-	SortingByModified = "modified"
-)
-
-// Listing is a collection of files.
-type Listing struct {
-	Items    []*FileInfo   `json:"items"`
-	Path     string        `json:"path"`
-	NumDirs  int           `json:"numDirs"`
-	NumFiles int           `json:"numFiles"`
-	Sorting  users.Sorting `json:"sorting"`
-}
-
-// NewFileInfo creates a File object from a path and a given user. This File
-// object will be automatically filled depending on if it is a directory
-// or a file. If it's a video file, it will also detect any subtitles.
-func NewFileInfo(opts FileOptions) (*FileInfo, error) {
-	if !opts.Checker.Check(opts.Path) {
-		return nil, os.ErrPermission
-	}
-	file, err := stat(opts.Path, opts) // Pass opts.Path here
-	if err != nil {
-		return nil, err
-	}
-	if opts.Expand {
-		if file.IsDir {
-			if err := file.readListing(opts.Path, opts.Checker, opts.ReadHeader); err != nil { //nolint:govet
-				return nil, err
-			}
-			return file, nil
-		}
-		err = file.detectType(opts.Path, opts.Modify, opts.Content, true)
-		if err != nil {
-			return nil, err
-		}
-	}
-	return file, err
+func (f FileOptions) Components() (string, string) {
+	return filepath.Dir(f.Path), filepath.Base(f.Path)
 }
 
 func FileInfoFaster(opts FileOptions) (*FileInfo, error) {
+	index := GetIndex(rootPath)
+	opts.Path = index.makeIndexPath(opts.Path)
+
 	// Lock access for the specific path
 	pathMutex := getMutex(opts.Path)
 	pathMutex.Lock()
@@ -112,132 +86,193 @@ func FileInfoFaster(opts FileOptions) (*FileInfo, error) {
 	if !opts.Checker.Check(opts.Path) {
 		return nil, os.ErrPermission
 	}
-	index := GetIndex(rootPath)
-	trimmed := strings.TrimPrefix(opts.Path, "/")
-	if trimmed == "" {
-		trimmed = "/"
-	}
-	adjustedPath := makeIndexPath(trimmed, index.Root)
-	var info FileInfo
-	info, exists := index.GetMetadataInfo(adjustedPath)
-	if exists && !opts.Content {
-		// Check if the cache time is less than 1 second
-		if time.Since(info.CacheTime) > time.Second {
-			go RefreshFileInfo(opts)
-		}
-		// refresh cache after
-		return &info, nil
-	} else {
-		// don't bother caching content
-		if opts.Content {
-			file, err := NewFileInfo(opts)
-			return file, err
-		}
-		updated := RefreshFileInfo(opts)
-		if !updated {
-			file, err := NewFileInfo(opts)
-			return file, err
-		}
-		info, exists = index.GetMetadataInfo(adjustedPath)
-		if !exists || info.Name == "" {
-			return &FileInfo{}, errors.ErrEmptyKey
-		}
-		return &info, nil
-	}
-}
-
-func RefreshFileInfo(opts FileOptions) bool {
-	if !opts.Checker.Check(opts.Path) {
-		return false
-	}
-	index := GetIndex(rootPath)
-	trimmed := strings.TrimPrefix(opts.Path, "/")
-	if trimmed == "" {
-		trimmed = "/"
-	}
-	adjustedPath := makeIndexPath(trimmed, index.Root)
-	file, err := stat(opts.Path, opts) // Pass opts.Path here
+	_, isDir, err := GetRealPath(opts.Path)
 	if err != nil {
-		return false
+		return nil, err
 	}
-	_ = file.detectType(adjustedPath, true, opts.Content, opts.ReadHeader)
-	if file.IsDir {
-		err := file.readListing(opts.Path, opts.Checker, opts.ReadHeader)
-		if err != nil {
-			return false
+	opts.IsDir = isDir
+	// check if the file exists in the index
+	info, exists := index.GetReducedMetadata(opts.Path, opts.IsDir)
+	if exists {
+		// Let's not refresh if less than a second has passed
+		if time.Since(info.CacheTime) > time.Second {
+			RefreshFileInfo(opts) //nolint:errcheck
 		}
-		//_, exists := index.GetFileMetadata(adjustedPath)
-
-		return index.UpdateFileMetadata(adjustedPath, *file)
-	} else {
-		//_, exists := index.GetFileMetadata(adjustedPath)
-		return index.UpdateFileMetadata(adjustedPath, *file)
+		if opts.Content {
+			content := ""
+			content, err = getContent(opts.Path)
+			if err != nil {
+				return info, err
+			}
+			info.Content = content
+		}
+		return info, nil
 	}
+	err = RefreshFileInfo(opts)
+	if err != nil {
+		return nil, err
+	}
+	info, exists = index.GetReducedMetadata(opts.Path, opts.IsDir)
+	if !exists {
+		return nil, err
+	}
+	if opts.Content {
+		content, err := getContent(opts.Path)
+		if err != nil {
+			return info, err
+		}
+		info.Content = content
+	}
+	return info, nil
 }
 
-func stat(path string, opts FileOptions) (*FileInfo, error) {
-	var file *FileInfo
-	if lstaterFs, ok := opts.Fs.(afero.Lstater); ok {
-		info, _, err := lstaterFs.LstatIfPossible(path)
-		if err == nil {
-			file = &FileInfo{
-				Fs:        opts.Fs,
-				Path:      opts.Path,
-				Name:      info.Name(),
-				ModTime:   info.ModTime(),
-				Mode:      info.Mode(),
-				Size:      info.Size(),
-				Extension: filepath.Ext(info.Name()),
-				Token:     opts.Token,
-			}
-			if info.IsDir() {
-				file.IsDir = true
-			}
-			if info.Mode()&os.ModeSymlink != 0 {
-				file.IsSymlink = true
-			}
-		}
+func RefreshFileInfo(opts FileOptions) error {
+	refreshOptions := FileOptions{
+		Path:  opts.Path,
+		IsDir: opts.IsDir,
+		Token: opts.Token,
 	}
-	if file == nil || file.IsSymlink {
-		info, err := opts.Fs.Stat(opts.Path)
+	index := GetIndex(rootPath)
+
+	if !refreshOptions.IsDir {
+		refreshOptions.Path = index.makeIndexPath(filepath.Dir(refreshOptions.Path))
+		refreshOptions.IsDir = true
+	} else {
+		refreshOptions.Path = index.makeIndexPath(refreshOptions.Path)
+	}
+
+	current, exists := index.GetMetadataInfo(refreshOptions.Path, true)
+
+	file, err := stat(refreshOptions)
+	if err != nil {
+		return fmt.Errorf("file/folder does not exist to refresh data: %s", refreshOptions.Path)
+	}
+
+	//utils.PrintStructFields(*file)
+	result := index.UpdateMetadata(file)
+	if !result {
+		return fmt.Errorf("file/folder does not exist in metadata: %s", refreshOptions.Path)
+	}
+	if !exists {
+		return nil
+	}
+	if current.Size != file.Size {
+		index.recursiveUpdateDirSizes(filepath.Dir(refreshOptions.Path), file, current.Size)
+	}
+	return nil
+}
+
+func stat(opts FileOptions) (*FileInfo, error) {
+	realPath, _, err := GetRealPath(rootPath, opts.Path)
+	if err != nil {
+		return nil, err
+	}
+	info, err := os.Lstat(realPath)
+	if err != nil {
+		return nil, err
+	}
+	file := &FileInfo{
+		Path:      opts.Path,
+		Name:      filepath.Base(opts.Path),
+		ModTime:   info.ModTime(),
+		Mode:      info.Mode(),
+		Size:      info.Size(),
+		Extension: filepath.Ext(info.Name()),
+		Token:     opts.Token,
+	}
+	if info.IsDir() {
+		// Open and read directory contents
+		dir, err := os.Open(realPath)
+		if err != nil {
+			return nil, err
+		}
+		defer dir.Close()
+
+		dirInfo, err := dir.Stat()
+		if err != nil {
+			return nil, err
+		}
+		index := GetIndex(rootPath)
+		// Check cached metadata to decide if refresh is needed
+		cachedParentDir, exists := index.GetMetadataInfo(opts.Path, true)
+		if exists && dirInfo.ModTime().Before(cachedParentDir.CacheTime) {
+			return cachedParentDir, nil
+		}
+
+		// Read directory contents and process
+		files, err := dir.Readdir(-1)
 		if err != nil {
 			return nil, err
 		}
 
-		if file != nil && file.IsSymlink {
-			file.Size = info.Size()
-			file.IsDir = info.IsDir()
-			return file, nil
+		file.Files = []ReducedItem{}
+		file.Dirs = map[string]*FileInfo{}
+
+		var totalSize int64
+		for _, item := range files {
+			itemPath := filepath.Join(realPath, item.Name())
+
+			if item.IsDir() {
+				itemInfo := &FileInfo{
+					Name:    item.Name(),
+					ModTime: item.ModTime(),
+					Mode:    item.Mode(),
+				}
+
+				if exists {
+					// if directory size was already cached use that.
+					cachedDir, ok := cachedParentDir.Dirs[item.Name()]
+					if ok {
+						itemInfo.Size = cachedDir.Size
+					}
+				}
+				file.Dirs[item.Name()] = itemInfo
+				totalSize += itemInfo.Size
+			} else {
+				itemInfo := ReducedItem{
+					Name:    item.Name(),
+					Size:    item.Size(),
+					ModTime: item.ModTime(),
+					Mode:    item.Mode(),
+				}
+				if IsSymlink(item.Mode()) {
+					itemInfo.Type = "symlink"
+					info, err := os.Stat(itemPath)
+					if err == nil {
+						itemInfo.Name = info.Name()
+						itemInfo.ModTime = info.ModTime()
+						itemInfo.Size = info.Size()
+						itemInfo.Mode = info.Mode()
+					} else {
+						file.Type = "invalid_link"
+					}
+				}
+				if file.Type != "invalid_link" {
+					err := itemInfo.detectType(itemPath, true, opts.Content, opts.ReadHeader)
+					if err != nil {
+						fmt.Printf("failed to detect type for %v: %v \n", itemPath, err)
+					}
+					file.Files = append(file.Files, itemInfo)
+				}
+				totalSize += itemInfo.Size
+
+			}
 		}
 
-		file = &FileInfo{
-			Fs:        opts.Fs,
-			Path:      opts.Path,
-			Name:      info.Name(),
-			ModTime:   info.ModTime(),
-			Mode:      info.Mode(),
-			IsDir:     info.IsDir(),
-			Size:      info.Size(),
-			Extension: filepath.Ext(info.Name()),
-			Token:     opts.Token,
-		}
+		file.Size = totalSize
 	}
-
 	return file, nil
 }
 
 // Checksum checksums a given File for a given User, using a specific
 // algorithm. The checksums data is saved on File object.
 func (i *FileInfo) Checksum(algo string) error {
-	if i.IsDir {
-		return errors.ErrIsDirectory
-	}
 
 	if i.Checksums == nil {
 		i.Checksums = map[string]string{}
 	}
-
-	reader, err := i.Fs.Open(i.Path)
+	fullpath := filepath.Join(i.Path, i.Name)
+	reader, err := os.Open(fullpath)
 	if err != nil {
 		return err
 	}
@@ -266,90 +301,231 @@ func (i *FileInfo) Checksum(algo string) error {
 
 // RealPath gets the real path for the file, resolving symlinks if supported.
 func (i *FileInfo) RealPath() string {
-	if realPathFs, ok := i.Fs.(interface {
-		RealPath(name string) (fPath string, err error)
-	}); ok {
-		realPath, err := realPathFs.RealPath(i.Path)
-		if err == nil {
-			return realPath
-		}
+	realPath, err := filepath.EvalSymlinks(i.Path)
+	if err == nil {
+		return realPath
 	}
-
 	return i.Path
 }
 
-// addContent reads and sets content based on the file type.
-func (i *FileInfo) addContent(path string) error {
-	if !i.IsDir {
-		afs := &afero.Afero{Fs: i.Fs}
-		content, err := afs.ReadFile(path)
-		if err != nil {
-			return err
-		}
-		stringContent := string(content)
-		if !utf8.ValidString(stringContent) {
-			return nil
-		}
-		if stringContent == "" {
-			i.Content = "empty-file-x6OlSil"
-			return nil
-		}
-		i.Content = stringContent
+func GetRealPath(relativePath ...string) (string, bool, error) {
+	combined := []string{settings.Config.Server.Root}
+	for _, path := range relativePath {
+		combined = append(combined, strings.TrimPrefix(path, settings.Config.Server.Root))
+	}
+	joinedPath := filepath.Join(combined...)
+	// Convert relative path to absolute path
+	absolutePath, err := filepath.Abs(joinedPath)
+	if err != nil {
+		return absolutePath, false, fmt.Errorf("could not get real path: %v, %s", combined, err)
+	}
+	// Resolve symlinks and get the real path
+	return resolveSymlinks(absolutePath)
+}
+
+func DeleteFiles(absPath string, opts FileOptions) error {
+	err := os.RemoveAll(absPath)
+	if err != nil {
+		return err
+	}
+	err = RefreshFileInfo(opts)
+	if err != nil {
+		return err
 	}
 	return nil
 }
 
-// detectType detects the file type.
-func (i *FileInfo) detectType(path string, modify, saveContent, readHeader bool) error {
-	if IsNamedPipe(i.Mode) {
-		i.Type = "blob"
-		if saveContent {
-			return i.addContent(path)
-		}
-		return nil
+func MoveResource(realsrc, realdst string, isSrcDir bool) error {
+	err := fileutils.MoveFile(realsrc, realdst)
+	if err != nil {
+		return err
+	}
+	// refresh info for source and dest
+	err = RefreshFileInfo(FileOptions{
+		Path:  realsrc,
+		IsDir: isSrcDir,
+	})
+	if err != nil {
+		return errors.ErrEmptyKey
+	}
+	refreshConfig := FileOptions{Path: realdst, IsDir: true}
+	if !isSrcDir {
+		refreshConfig.Path = filepath.Dir(realdst)
+	}
+	err = RefreshFileInfo(refreshConfig)
+	if err != nil {
+		return errors.ErrEmptyKey
+	}
+	return nil
+}
+
+func CopyResource(realsrc, realdst string, isSrcDir bool) error {
+	err := fileutils.CopyFile(realsrc, realdst)
+	if err != nil {
+		return err
 	}
 
+	refreshConfig := FileOptions{Path: realdst, IsDir: true}
+	if !isSrcDir {
+		refreshConfig.Path = filepath.Dir(realdst)
+	}
+	err = RefreshFileInfo(refreshConfig)
+	if err != nil {
+		return errors.ErrEmptyKey
+	}
+	return nil
+}
+
+func WriteDirectory(opts FileOptions) error {
+	realPath, _, _ := GetRealPath(rootPath, opts.Path)
+	// Ensure the parent directories exist
+	err := os.MkdirAll(realPath, 0775)
+	if err != nil {
+		return err
+	}
+	err = RefreshFileInfo(opts)
+	if err != nil {
+		return errors.ErrEmptyKey
+	}
+	return nil
+}
+
+func WriteFile(opts FileOptions, in io.Reader) error {
+	dst := opts.Path
+	parentDir := filepath.Dir(dst)
+	// Split the directory from the destination path
+	dir := filepath.Dir(dst)
+
+	// Create the directory and all necessary parents
+	err := os.MkdirAll(dir, 0775)
+	if err != nil {
+		return err
+	}
+
+	// Open the file for writing (create if it doesn't exist, truncate if it does)
+	file, err := os.OpenFile(dst, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0775)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+
+	// Copy the contents from the reader to the file
+	_, err = io.Copy(file, in)
+	if err != nil {
+		return err
+	}
+	opts.Path = parentDir
+	err = RefreshFileInfo(opts)
+	if err != nil {
+		return errors.ErrEmptyKey
+	}
+	return nil
+}
+
+// resolveSymlinks resolves symlinks in the given path
+func resolveSymlinks(path string) (string, bool, error) {
+	for {
+		// Get the file info
+		info, err := os.Lstat(path)
+		if err != nil {
+			return path, false, fmt.Errorf("could not stat path: %v, %s", path, err)
+		}
+
+		// Check if it's a symlink
+		if info.Mode()&os.ModeSymlink != 0 {
+			// Read the symlink target
+			target, err := os.Readlink(path)
+			if err != nil {
+				return path, false, err
+			}
+
+			// Resolve the target relative to the symlink's directory
+			path = filepath.Join(filepath.Dir(path), target)
+		} else {
+			// Not a symlink, so return the resolved path and check if it's a directory
+			return path, info.IsDir(), nil
+		}
+	}
+}
+
+// addContent reads and sets content based on the file type.
+func getContent(path string) (string, error) {
+	realPath, _, err := GetRealPath(rootPath, path)
+	if err != nil {
+		return "", err
+	}
+
+	content, err := os.ReadFile(realPath)
+	if err != nil {
+		return "", err
+	}
+	stringContent := string(content)
+	if !utf8.ValidString(stringContent) {
+		return "", fmt.Errorf("file is not utf8 encoded")
+	}
+	if stringContent == "" {
+		return "empty-file-x6OlSil", nil
+	}
+	return stringContent, nil
+}
+
+// detectType detects the file type.
+func (i *ReducedItem) detectType(path string, modify, saveContent, readHeader bool) error {
+	name := i.Name
+	var contentErr error
+	var contentString string
+	if saveContent {
+		contentString, contentErr = getContent(path)
+		if contentErr == nil {
+			i.Content = contentString
+		}
+	}
+
+	if IsNamedPipe(i.Mode) {
+		i.Type = "blob"
+		return contentErr
+	}
+
+	ext := filepath.Ext(name)
 	var buffer []byte
 	if readHeader {
-		buffer = i.readFirstBytes()
-		mimetype := mime.TypeByExtension(i.Extension)
+		buffer = i.readFirstBytes(path)
+		mimetype := mime.TypeByExtension(ext)
 		if mimetype == "" {
 			http.DetectContentType(buffer)
 		}
 	}
 
-	ext := filepath.Ext(i.Name)
 	for _, fileType := range AllFiletypeOptions {
 		if IsMatchingType(ext, fileType) {
 			i.Type = fileType
 		}
-
 		switch i.Type {
 		case "text":
 			if !modify {
 				i.Type = "textImmutable"
 			}
 			if saveContent {
-				return i.addContent(path)
+				return contentErr
 			}
 		case "video":
-			parentDir := strings.TrimRight(path, i.Name)
-			i.detectSubtitles(parentDir)
+			// TODO add back somewhere else, not during metadata fetch
+			//parentDir := strings.TrimRight(path, name)
+			//i.detectSubtitles(parentDir)
 		case "doc":
 			if ext == ".pdf" {
 				i.Type = "pdf"
 				return nil
 			}
 			if saveContent {
-				return i.addContent(path)
+				return nil
 			}
 		}
 	}
-
 	if i.Type == "" {
 		i.Type = "blob"
 		if saveContent {
-			return i.addContent(path)
+			return contentErr
 		}
 	}
 
@@ -357,16 +533,16 @@ func (i *FileInfo) detectType(path string, modify, saveContent, readHeader bool)
 }
 
 // readFirstBytes reads the first bytes of the file.
-func (i *FileInfo) readFirstBytes() []byte {
-	reader, err := i.Fs.Open(i.Path)
+func (i *ReducedItem) readFirstBytes(path string) []byte {
+	file, err := os.Open(path)
 	if err != nil {
 		i.Type = "blob"
 		return nil
 	}
-	defer reader.Close()
+	defer file.Close()
 
 	buffer := make([]byte, 512) //nolint:gomnd
-	n, err := reader.Read(buffer)
+	n, err := file.Read(buffer)
 	if err != nil && err != io.EOF {
 		i.Type = "blob"
 		return nil
@@ -376,108 +552,43 @@ func (i *FileInfo) readFirstBytes() []byte {
 }
 
 // detectSubtitles detects subtitles for video files.
-func (i *FileInfo) detectSubtitles(parentDir string) {
-	if i.Type != "video" {
-		return
-	}
-	i.Subtitles = []string{}
-	ext := filepath.Ext(i.Name)
-	dir, err := os.Open(parentDir)
-	if err != nil {
-		// Directory must have been deleted, remove it from the index
-		return
-	}
-	// Read the directory contents
-	files, err := dir.Readdir(-1)
-	if err != nil {
-		return
-	}
+//func (i *FileInfo) detectSubtitles(path string) {
+//	if i.Type != "video" {
+//		return
+//	}
+//	parentDir := filepath.Dir(path)
+//	fileName := filepath.Base(path)
+//	i.Subtitles = []string{}
+//	ext := filepath.Ext(fileName)
+//	dir, err := os.Open(parentDir)
+//	if err != nil {
+//		// Directory must have been deleted, remove it from the index
+//		return
+//	}
+//	defer dir.Close() // Ensure directory handle is closed
+//
+//	files, err := dir.Readdir(-1)
+//	if err != nil {
+//		return
+//	}
+//
+//	base := strings.TrimSuffix(fileName, ext)
+//	subtitleExts := []string{".vtt", ".txt", ".srt", ".lrc"}
+//
+//	for _, f := range files {
+//		if f.IsDir() || !strings.HasPrefix(f.Name(), base) {
+//			continue
+//		}
+//
+//		for _, subtitleExt := range subtitleExts {
+//			if strings.HasSuffix(f.Name(), subtitleExt) {
+//				i.Subtitles = append(i.Subtitles, filepath.Join(parentDir, f.Name()))
+//				break
+//			}
+//		}
+//	}
+//}
 
-	base := strings.TrimSuffix(i.Name, ext)
-	subtitleExts := []string{".vtt", ".txt", ".srt", ".lrc"}
-
-	for _, f := range files {
-		if f.IsDir() || !strings.HasPrefix(f.Name(), base) {
-			continue
-		}
-
-		for _, subtitleExt := range subtitleExts {
-			if strings.HasSuffix(f.Name(), subtitleExt) {
-				i.Subtitles = append(i.Subtitles, filepath.Join(parentDir, f.Name()))
-				break
-			}
-		}
-	}
-}
-
-// readListing reads the contents of a directory and fills the listing.
-func (i *FileInfo) readListing(path string, checker rules.Checker, readHeader bool) error {
-	afs := &afero.Afero{Fs: i.Fs}
-	dir, err := afs.ReadDir(i.Path)
-	if err != nil {
-		return err
-	}
-
-	listing := &Listing{
-		Items:    []*FileInfo{},
-		Path:     i.Path,
-		NumDirs:  0,
-		NumFiles: 0,
-	}
-
-	for _, f := range dir {
-		name := f.Name()
-		fPath := filepath.Join(i.Path, name)
-
-		if !checker.Check(fPath) {
-			continue
-		}
-
-		isSymlink, isInvalidLink := false, false
-		if IsSymlink(f.Mode()) {
-			isSymlink = true
-			info, err := i.Fs.Stat(fPath)
-			if err == nil {
-				f = info
-			} else {
-				isInvalidLink = true
-			}
-		}
-
-		file := &FileInfo{
-			Name:    name,
-			Size:    f.Size(),
-			ModTime: f.ModTime(),
-			Mode:    f.Mode(),
-		}
-		if f.IsDir() {
-			file.IsDir = true
-		}
-		if isSymlink {
-			file.IsSymlink = true
-		}
-
-		if file.IsDir {
-			listing.NumDirs++
-		} else {
-			listing.NumFiles++
-
-			if isInvalidLink {
-				file.Type = "invalid_link"
-			} else {
-				err := file.detectType(path, true, false, readHeader)
-				if err != nil {
-					return err
-				}
-			}
-		}
-
-		listing.Items = append(listing.Items, file)
-	}
-
-	i.Listing = listing
-	return nil
-}
 func IsNamedPipe(mode os.FileMode) bool {
 	return mode&os.ModeNamedPipe != 0
 }
@@ -498,3 +609,14 @@ func getMutex(path string) *sync.Mutex {
 
 	return pathMutexes[path]
 }
+
+func Exists(path string) bool {
+	_, err := os.Stat(path)
+	if err == nil {
+		return true
+	}
+	if os.IsNotExist(err) {
+		return false
+	}
+	return false
+}

backend/files/file_test.go

@@ -0,0 +1,73 @@
+package files
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func Test_GetRealPath(t *testing.T) {
+	cwd, err := os.Getwd()
+	if err != nil {
+		return
+	}
+	trimPrefix := filepath.Dir(filepath.Dir(cwd)) + "/"
+	tests := []struct {
+		name  string
+		paths []string
+		want  struct {
+			path  string
+			isDir bool
+		}
+	}{
+		{
+			name: "current directory",
+			paths: []string{
+				"./",
+			},
+			want: struct {
+				path  string
+				isDir bool
+			}{
+				path:  "backend/files",
+				isDir: true,
+			},
+		},
+		{
+			name: "current directory",
+			paths: []string{
+				"./file.go",
+			},
+			want: struct {
+				path  string
+				isDir bool
+			}{
+				path:  "backend/files/file.go",
+				isDir: false,
+			},
+		},
+		{
+			name: "other test case",
+			paths: []string{
+				"/mnt/doesnt/exist",
+			},
+			want: struct {
+				path  string
+				isDir bool
+			}{
+				path:  "/mnt/doesnt/exist",
+				isDir: false,
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			realPath, isDir, _ := GetRealPath(tt.paths...)
+			adjustedRealPath := strings.TrimPrefix(realPath, trimPrefix)
+			if tt.want.path != adjustedRealPath || tt.want.isDir != isDir {
+				t.Errorf("expected %v:%v but got: %v:%v", tt.want.path, tt.want.isDir, adjustedRealPath, isDir)
+			}
+		})
+	}
+}

backend/files/indexing.go

@@ -1,9 +1,9 @@
 package files
 
 import (
-	"bytes"
 	"log"
 	"os"
+	"path/filepath"
 	"strings"
 	"sync"
 	"time"
@@ -11,22 +11,12 @@ import (
 	"github.com/gtsteffaniak/filebrowser/settings"
 )
 
-type Directory struct {
-	Metadata map[string]FileInfo
-	Files    string
-}
-type File struct {
-	Name  string
-	IsDir bool
-}
-
 type Index struct {
 	Root        string
-	Directories map[string]Directory
+	Directories map[string]*FileInfo
 	NumDirs     int
 	NumFiles    int
 	inProgress  bool
-	quickList   []File
 	LastIndexed time.Time
 	mu          sync.RWMutex
 }
@@ -48,16 +38,12 @@ func indexingScheduler(intervalMinutes uint32) {
 		rootPath = settings.Config.Server.Root
 	}
 	si := GetIndex(rootPath)
-	log.Printf("Indexing Files...")
-	log.Printf("Configured to run every %v minutes", intervalMinutes)
-	log.Printf("Indexing from root: %s", si.Root)
 	for {
 		startTime := time.Now()
 		// Set the indexing flag to indicate that indexing is in progress
 		si.resetCount()
 		// Perform the indexing operation
-		err := si.indexFiles(si.Root)
-		si.quickList = []File{}
+		err := si.indexFiles("/")
 		// Reset the indexing flag to indicate that indexing has finished
 		si.inProgress = false
 		// Update the LastIndexed time
@@ -78,90 +64,141 @@ func indexingScheduler(intervalMinutes uint32) {
 }
 
 // Define a function to recursively index files and directories
-func (si *Index) indexFiles(path string) error {
-	// Check if the current directory has been modified since the last indexing
-	path = strings.TrimSuffix(path, "/")
-	adjustedPath := makeIndexPath(path, si.Root)
-	dir, err := os.Open(path)
+func (si *Index) indexFiles(adjustedPath string) error {
+	realPath := strings.TrimRight(si.Root, "/") + adjustedPath
+
+	// Open the directory
+	dir, err := os.Open(realPath)
 	if err != nil {
-		// Directory must have been deleted, remove it from the index
-		si.RemoveDirectory(adjustedPath)
+		si.RemoveDirectory(adjustedPath) // Remove if it can't be opened
+		return err
 	}
+	defer dir.Close()
+
 	dirInfo, err := dir.Stat()
 	if err != nil {
-		dir.Close()
 		return err
 	}
 
-	// Compare the last modified time of the directory with the last indexed time
-	lastIndexed := si.LastIndexed
-	if dirInfo.ModTime().Before(lastIndexed) {
-		dir.Close()
+	// Skip directories that haven't been modified since the last index
+	if dirInfo.ModTime().Before(si.LastIndexed) {
 		return nil
 	}
 
-	// Read the directory contents
+	// Read directory contents
 	files, err := dir.Readdir(-1)
 	if err != nil {
 		return err
 	}
-	dir.Close()
-	si.UpdateQuickList(files)
-	si.InsertFiles(path)
-	// done separately for memory efficiency on recursion
-	si.InsertDirs(path)
+
+	var totalSize int64
+	var numDirs, numFiles int
+	fileInfos := []ReducedItem{}
+	dirInfos := map[string]*FileInfo{}
+	combinedPath := adjustedPath + "/"
+	if adjustedPath == "/" {
+		combinedPath = "/"
+	}
+
+	// Process each file and directory in the current directory
+	for _, file := range files {
+		itemInfo := &FileInfo{
+			ModTime: file.ModTime(),
+		}
+		if file.IsDir() {
+			itemInfo.Name = file.Name()
+			itemInfo.Path = combinedPath + file.Name()
+			// Recursively index the subdirectory
+			err := si.indexFiles(itemInfo.Path)
+			if err != nil {
+				log.Printf("Failed to index directory %s: %v", itemInfo.Path, err)
+				continue
+			}
+			// Fetch the metadata for the subdirectory after indexing
+			subDirInfo, exists := si.GetMetadataInfo(itemInfo.Path, true)
+			if exists {
+				itemInfo.Size = subDirInfo.Size
+				totalSize += subDirInfo.Size // Add subdirectory size to the total
+			}
+			dirInfos[itemInfo.Name] = itemInfo
+			numDirs++
+		} else {
+			itemInfo := &ReducedItem{
+				Name:    file.Name(),
+				ModTime: file.ModTime(),
+				Size:    file.Size(),
+				Mode:    file.Mode(),
+			}
+			_ = itemInfo.detectType(combinedPath+file.Name(), true, false, false)
+			fileInfos = append(fileInfos, *itemInfo)
+			totalSize += itemInfo.Size
+			numFiles++
+		}
+	}
+
+	// Create FileInfo for the current directory
+	dirFileInfo := &FileInfo{
+		Path:    adjustedPath,
+		Files:   fileInfos,
+		Dirs:    dirInfos,
+		Size:    totalSize,
+		ModTime: dirInfo.ModTime(),
+	}
+
+	// Update the current directory metadata in the index
+	si.UpdateMetadata(dirFileInfo)
+	si.NumDirs += numDirs
+	si.NumFiles += numFiles
+
 	return nil
 }
 
-func (si *Index) InsertFiles(path string) {
-	adjustedPath := makeIndexPath(path, si.Root)
-	subDirectory := Directory{}
-	buffer := bytes.Buffer{}
-
-	for _, f := range si.GetQuickList() {
-		if !f.IsDir {
-			buffer.WriteString(f.Name + ";")
-			si.UpdateCount("files")
-		}
+func (si *Index) makeIndexPath(subPath string) string {
+	if strings.HasPrefix(subPath, "./") {
+		subPath = strings.TrimPrefix(subPath, ".")
 	}
-	// Use GetMetadataInfo and SetFileMetadata for safer read and write operations
-	subDirectory.Files = buffer.String()
-	si.SetDirectoryInfo(adjustedPath, subDirectory)
-}
-
-func (si *Index) InsertDirs(path string) {
-	adjustedPath := makeIndexPath(path, si.Root)
-	for _, f := range si.GetQuickList() {
-		if f.IsDir {
-			if _, exists := si.Directories[adjustedPath]; exists {
-				si.UpdateCount("dirs")
-				// Add or update the directory in the map
-				if adjustedPath == "/" {
-					si.SetDirectoryInfo("/"+f.Name, Directory{})
-				} else {
-					si.SetDirectoryInfo(adjustedPath+"/"+f.Name, Directory{})
-				}
-			}
-			err := si.indexFiles(path + "/" + f.Name)
-			if err != nil {
-				if err.Error() == "invalid argument" {
-					log.Printf("Could not index \"%v\": %v \n", path, "Permission Denied")
-				} else {
-					log.Printf("Could not index \"%v\": %v \n", path, err)
-				}
-			}
-		}
-	}
-}
-
-func makeIndexPath(path string, root string) string {
-	if path == root {
+	if strings.HasPrefix(subPath, ".") || si.Root == subPath {
 		return "/"
 	}
-	adjustedPath := strings.TrimPrefix(path, root+"/")
+	// clean path
+	subPath = strings.TrimSuffix(subPath, "/")
+	// remove index prefix
+	adjustedPath := strings.TrimPrefix(subPath, si.Root)
+	// remove trailing slash
 	adjustedPath = strings.TrimSuffix(adjustedPath, "/")
-	if adjustedPath == "" {
-		adjustedPath = "/"
+	if !strings.HasPrefix(adjustedPath, "/") {
+		adjustedPath = "/" + adjustedPath
 	}
 	return adjustedPath
 }
+
+//func getParentPath(path string) string {
+//	// Trim trailing slash for consistency
+//	path = strings.TrimSuffix(path, "/")
+//	if path == "" || path == "/" {
+//		return "" // Root has no parent
+//	}
+//
+//	lastSlash := strings.LastIndex(path, "/")
+//	if lastSlash == -1 {
+//		return "/" // Parent of a top-level directory
+//	}
+//	return path[:lastSlash]
+//}
+
+func (si *Index) recursiveUpdateDirSizes(parentDir string, childInfo *FileInfo, previousSize int64) {
+	childDirName := filepath.Base(childInfo.Path)
+	if parentDir == childDirName {
+		return
+	}
+	dir, exists := si.GetMetadataInfo(parentDir, true)
+	if !exists {
+		return
+	}
+	dir.Dirs[childDirName] = childInfo
+	newSize := dir.Size - previousSize + childInfo.Size
+	dir.Size += newSize
+	si.UpdateMetadata(dir)
+	dir, _ = si.GetMetadataInfo(parentDir, true)
+	si.recursiveUpdateDirSizes(filepath.Dir(parentDir), dir, newSize)
+}

backend/files/indexing_test.go

@@ -3,6 +3,7 @@ package files
 import (
 	"encoding/json"
 	"math/rand"
+	"path/filepath"
 	"reflect"
 	"testing"
 	"time"
@@ -22,19 +23,26 @@ func BenchmarkFillIndex(b *testing.B) {
 
 func (si *Index) createMockData(numDirs, numFilesPerDir int) {
 	for i := 0; i < numDirs; i++ {
-		dirName := generateRandomPath(rand.Intn(3) + 1)
-		files := []File{}
-		// Append a new Directory to the slice
+		dirPath := generateRandomPath(rand.Intn(3) + 1)
+		files := []ReducedItem{} // Slice of FileInfo
+
+		// Simulating files and directories with FileInfo
 		for j := 0; j < numFilesPerDir; j++ {
-			newFile := File{
-				Name:  "file-" + getRandomTerm() + getRandomExtension(),
-				IsDir: false,
+			newFile := ReducedItem{
+				Name:    "file-" + getRandomTerm() + getRandomExtension(),
+				Size:    rand.Int63n(1000),                                          // Random size
+				ModTime: time.Now().Add(-time.Duration(rand.Intn(100)) * time.Hour), // Random mod time
+				Type:    "blob",
 			}
 			files = append(files, newFile)
 		}
-		si.UpdateQuickListForTests(files)
-		si.InsertFiles(dirName)
-		si.InsertDirs(dirName)
+		dirInfo := &FileInfo{
+			Name:  filepath.Base(dirPath),
+			Path:  dirPath,
+			Files: files,
+		}
+
+		si.UpdateMetadata(dirInfo)
 	}
 }
 

backend/files/search.go

@@ -1,13 +1,12 @@
 package files
 
 import (
-	"math/rand"
-	"os"
 	"path/filepath"
 	"sort"
 	"strings"
 	"sync"
-	"time"
+
+	"github.com/gtsteffaniak/filebrowser/utils"
 )
 
 var (
@@ -15,160 +14,165 @@ var (
 	maxSearchResults  = 100
 )
 
-func (si *Index) Search(search string, scope string, sourceSession string) ([]string, map[string]map[string]bool) {
+type searchResult struct {
+	Path string `json:"path"`
+	Type string `json:"type"`
+	Size int64  `json:"size"`
+}
+
+func (si *Index) Search(search string, scope string, sourceSession string) []searchResult {
 	// Remove slashes
-	scope = strings.TrimLeft(scope, "/")
-	scope = strings.TrimRight(scope, "/")
-	runningHash := generateRandomHash(4)
+	scope = si.makeIndexPath(scope)
+	runningHash := utils.GenerateRandomHash(4)
 	sessionInProgress.Store(sourceSession, runningHash) // Store the value in the sync.Map
 	searchOptions := ParseSearch(search)
-	fileListTypes := make(map[string]map[string]bool)
-	matching := []string{}
+	results := make(map[string]searchResult, 0)
 	count := 0
+	directories := si.getDirsInScope(scope)
 	for _, searchTerm := range searchOptions.Terms {
 		if searchTerm == "" {
 			continue
 		}
+		if count > maxSearchResults {
+			break
+		}
 		si.mu.Lock()
-		defer si.mu.Unlock()
-		for dirName, dir := range si.Directories {
-			isDir := true
-			files := strings.Split(dir.Files, ";")
-			value, found := sessionInProgress.Load(sourceSession)
-			if !found || value != runningHash {
-				return []string{}, map[string]map[string]bool{}
+		for _, dirName := range directories {
+			si.mu.Unlock()
+			dir, found := si.GetReducedMetadata(dirName, true)
+			si.mu.Lock()
+			if !found {
+				continue
 			}
 			if count > maxSearchResults {
 				break
 			}
-			pathName := scopedPathNameFilter(dirName, scope, isDir)
-			if pathName == "" {
-				continue // path not matched
+			reducedDir := ReducedItem{
+				Name: filepath.Base(dirName),
+				Type: "directory",
+				Size: dir.Size,
 			}
-			fileTypes := map[string]bool{}
-			matches, fileType := containsSearchTerm(dirName, searchTerm, *searchOptions, isDir, fileTypes)
+
+			matches := reducedDir.containsSearchTerm(searchTerm, searchOptions)
 			if matches {
-				fileListTypes[pathName] = fileType
-				matching = append(matching, pathName)
+				scopedPath := strings.TrimPrefix(strings.TrimPrefix(dirName, scope), "/") + "/"
+				results[scopedPath] = searchResult{Path: scopedPath, Type: "directory", Size: dir.Size}
 				count++
 			}
-			isDir = false
-			for _, file := range files {
-				if file == "" {
-					continue
+
+			// search files first
+			for _, item := range dir.Items {
+
+				fullPath := dirName + "/" + item.Name
+				if item.Type == "directory" {
+					fullPath += "/"
 				}
 				value, found := sessionInProgress.Load(sourceSession)
 				if !found || value != runningHash {
-					return []string{}, map[string]map[string]bool{}
+					si.mu.Unlock()
+					return []searchResult{}
 				}
-
 				if count > maxSearchResults {
 					break
 				}
-				fullName := pathName + file
-				fileTypes := map[string]bool{}
-
-				matches, fileType := containsSearchTerm(fullName, searchTerm, *searchOptions, isDir, fileTypes)
-				if !matches {
-					continue
+				matches := item.containsSearchTerm(searchTerm, searchOptions)
+				if matches {
+					scopedPath := strings.TrimPrefix(strings.TrimPrefix(fullPath, scope), "/")
+					results[scopedPath] = searchResult{Path: scopedPath, Type: item.Type, Size: item.Size}
+					count++
 				}
-				fileListTypes[fullName] = fileType
-				matching = append(matching, fullName)
-				count++
 			}
 		}
+		si.mu.Unlock()
+	}
+
+	// Sort keys based on the number of elements in the path after splitting by "/"
+	sortedKeys := make([]searchResult, 0, len(results))
+	for _, v := range results {
+		sortedKeys = append(sortedKeys, v)
 	}
 	// Sort the strings based on the number of elements after splitting by "/"
-	sort.Slice(matching, func(i, j int) bool {
-		parts1 := strings.Split(matching[i], "/")
-		parts2 := strings.Split(matching[j], "/")
+	sort.Slice(sortedKeys, func(i, j int) bool {
+		parts1 := strings.Split(sortedKeys[i].Path, "/")
+		parts2 := strings.Split(sortedKeys[j].Path, "/")
 		return len(parts1) < len(parts2)
 	})
-	return matching, fileListTypes
+	return sortedKeys
 }
 
-func scopedPathNameFilter(pathName string, scope string, isDir bool) string {
-	pathName = strings.TrimLeft(pathName, "/")
-	pathName = strings.TrimRight(pathName, "/")
-	if strings.HasPrefix(pathName, scope) || scope == "" {
-		pathName = strings.TrimPrefix(pathName, scope)
-		pathName = strings.TrimLeft(pathName, "/")
-		if isDir {
-			pathName = pathName + "/"
-		}
-	} else {
-		pathName = "" // return not matched
-	}
-	return pathName
-}
+// returns true if the file name contains the search term
+// returns file type if the file name contains the search term
+// returns size of file/dir if the file name contains the search term
+func (fi ReducedItem) containsSearchTerm(searchTerm string, options *SearchOptions) bool {
 
-func containsSearchTerm(pathName string, searchTerm string, options SearchOptions, isDir bool, fileTypes map[string]bool) (bool, map[string]bool) {
+	fileTypes := map[string]bool{}
+	largerThan := int64(options.LargerThan) * 1024 * 1024
+	smallerThan := int64(options.SmallerThan) * 1024 * 1024
 	conditions := options.Conditions
-	path := getLastPathComponent(pathName)
-	// Convert to lowercase once
+	lowerFileName := strings.ToLower(fi.Name)
+
+	// Convert to lowercase if not exact match
 	if !conditions["exact"] {
-		path = strings.ToLower(path)
 		searchTerm = strings.ToLower(searchTerm)
 	}
-	if strings.Contains(path, searchTerm) {
-		// Calculate fileSize only if needed
-		var fileSize int64
-		matchesAllConditions := true
-		extension := filepath.Ext(path)
-		for _, k := range AllFiletypeOptions {
-			if IsMatchingType(extension, k) {
-				fileTypes[k] = true
+
+	// Check if the file name contains the search term
+	if !strings.Contains(lowerFileName, searchTerm) {
+		return false
+	}
+
+	// Initialize file size and fileTypes map
+	var fileSize int64
+	extension := filepath.Ext(lowerFileName)
+
+	// Collect file types
+	for _, k := range AllFiletypeOptions {
+		if IsMatchingType(extension, k) {
+			fileTypes[k] = true
+		}
+	}
+	isDir := fi.Type == "directory"
+	fileTypes["dir"] = isDir
+	fileSize = fi.Size
+
+	// Evaluate all conditions
+	for t, v := range conditions {
+		if t == "exact" {
+			continue
+		}
+		switch t {
+		case "larger":
+			if largerThan > 0 {
+				if fileSize <= largerThan {
+					return false
+				}
+			}
+		case "smaller":
+			if smallerThan > 0 {
+				if fileSize >= smallerThan {
+					return false
+				}
+			}
+		default:
+			// Handle other file type conditions
+			notMatchType := v != fileTypes[t]
+			if notMatchType {
+				return false
 			}
 		}
-		fileTypes["dir"] = isDir
-		for t, v := range conditions {
-			if t == "exact" {
-				continue
-			}
-			var matchesCondition bool
-			switch t {
-			case "larger":
-				if fileSize == 0 {
-					fileSize = getFileSize(pathName)
-				}
-				matchesCondition = fileSize > int64(options.LargerThan)*bytesInMegabyte
-			case "smaller":
-				if fileSize == 0 {
-					fileSize = getFileSize(pathName)
-				}
-				matchesCondition = fileSize < int64(options.SmallerThan)*bytesInMegabyte
-			default:
-				matchesCondition = v == fileTypes[t]
-			}
-			if !matchesCondition {
-				matchesAllConditions = false
-			}
+	}
+
+	return true
+}
+
+func (si *Index) getDirsInScope(scope string) []string {
+	newList := []string{}
+	si.mu.Lock()
+	defer si.mu.Unlock()
+	for k := range si.Directories {
+		if strings.HasPrefix(k, scope) || scope == "" {
+			newList = append(newList, k)
 		}
-		return matchesAllConditions, fileTypes
 	}
-	// Clear variables and return
-	return false, map[string]bool{}
-}
-
-func getFileSize(filepath string) int64 {
-	fileInfo, err := os.Stat(rootPath + "/" + filepath)
-	if err != nil {
-		return 0
-	}
-	return fileInfo.Size()
-}
-
-func getLastPathComponent(path string) string {
-	// Use filepath.Base to extract the last component of the path
-	return filepath.Base(path)
-}
-
-func generateRandomHash(length int) string {
-	const charset = "abcdefghijklmnopqrstuvwxyz0123456789"
-	rand.New(rand.NewSource(time.Now().UnixNano()))
-	result := make([]byte, length)
-	for i := range result {
-		result[i] = charset[rand.Intn(len(charset))]
-	}
-	return string(result)
+	return newList
 }

backend/files/search_test.go

@@ -11,7 +11,7 @@ func BenchmarkSearchAllIndexes(b *testing.B) {
 	InitializeIndex(5, false)
 	si := GetIndex(rootPath)
 
-	si.createMockData(50, 3) // 1000 dirs, 3 files per dir
+	si.createMockData(50, 3) // 50 dirs, 3 files per dir
 
 	// Generate 100 random search terms
 	searchTerms := generateRandomSearchTerms(100)
@@ -26,271 +26,197 @@ func BenchmarkSearchAllIndexes(b *testing.B) {
 	}
 }
 
-// loop over test files and compare output
 func TestParseSearch(t *testing.T) {
-	value := ParseSearch("my test search")
-	want := &SearchOptions{
-		Conditions: map[string]bool{
-			"exact": false,
+	tests := []struct {
+		input string
+		want  *SearchOptions
+	}{
+		{
+			input: "my test search",
+			want: &SearchOptions{
+				Conditions: map[string]bool{"exact": false},
+				Terms:      []string{"my test search"},
+			},
 		},
-		Terms: []string{"my test search"},
-	}
-	if !reflect.DeepEqual(value, want) {
-		t.Fatalf("\n got:  %+v\n want: %+v", value, want)
-	}
-	value = ParseSearch("case:exact my|test|search")
-	want = &SearchOptions{
-		Conditions: map[string]bool{
-			"exact": true,
+		{
+			input: "case:exact my|test|search",
+			want: &SearchOptions{
+				Conditions: map[string]bool{"exact": true},
+				Terms:      []string{"my", "test", "search"},
+			},
 		},
-		Terms: []string{"my", "test", "search"},
-	}
-	if !reflect.DeepEqual(value, want) {
-		t.Fatalf("\n got:  %+v\n want: %+v", value, want)
-	}
-	value = ParseSearch("type:largerThan=100 type:smallerThan=1000 test")
-	want = &SearchOptions{
-		Conditions: map[string]bool{
-			"exact":  false,
-			"larger": true,
+		{
+			input: "type:largerThan=100 type:smallerThan=1000 test",
+			want: &SearchOptions{
+				Conditions:  map[string]bool{"exact": false, "larger": true, "smaller": true},
+				Terms:       []string{"test"},
+				LargerThan:  100,
+				SmallerThan: 1000,
+			},
 		},
-		Terms:       []string{"test"},
-		LargerThan:  100,
-		SmallerThan: 1000,
-	}
-	if !reflect.DeepEqual(value, want) {
-		t.Fatalf("\n got:  %+v\n want: %+v", value, want)
-	}
-	value = ParseSearch("type:audio thisfile")
-	want = &SearchOptions{
-		Conditions: map[string]bool{
-			"exact": false,
-			"audio": true,
+		{
+			input: "type:audio thisfile",
+			want: &SearchOptions{
+				Conditions: map[string]bool{"exact": false, "audio": true},
+				Terms:      []string{"thisfile"},
+			},
 		},
-		Terms: []string{"thisfile"},
 	}
-	if !reflect.DeepEqual(value, want) {
-		t.Fatalf("\n got:  %+v\n want: %+v", value, want)
+
+	for _, tt := range tests {
+		t.Run(tt.input, func(t *testing.T) {
+			value := ParseSearch(tt.input)
+			if !reflect.DeepEqual(value, tt.want) {
+				t.Fatalf("\n got:  %+v\n want: %+v", value, tt.want)
+			}
+		})
 	}
 }
 
 func TestSearchWhileIndexing(t *testing.T) {
 	InitializeIndex(5, false)
 	si := GetIndex(rootPath)
-	// Generate 100 random search terms
-	// Generate 100 random search terms
+
 	searchTerms := generateRandomSearchTerms(10)
 	for i := 0; i < 5; i++ {
-		// Execute the SearchAllIndexes function
-		go si.createMockData(100, 100) // 1000 dirs, 3 files per dir
+		go si.createMockData(100, 100) // Creating mock data concurrently
 		for _, term := range searchTerms {
-			go si.Search(term, "/", "test")
+			go si.Search(term, "/", "test") // Search concurrently
 		}
 	}
 }
 
 func TestSearchIndexes(t *testing.T) {
 	index := Index{
-		Directories: map[string]Directory{
-			"test": {
-				Files: "audio1.wav;",
+		Directories: map[string]*FileInfo{
+			"/test":      {Files: []ReducedItem{{Name: "audio1.wav", Type: "audio"}}},
+			"/test/path": {Files: []ReducedItem{{Name: "file.txt", Type: "text"}}},
+			"/new/test": {Files: []ReducedItem{
+				{Name: "audio.wav", Type: "audio"},
+				{Name: "video.mp4", Type: "video"},
+				{Name: "video.MP4", Type: "video"},
+			}},
+			"/new/test/path": {Files: []ReducedItem{{Name: "archive.zip", Type: "archive"}}},
+			"/firstDir": {
+				Files: []ReducedItem{
+					{Name: "archive.zip", Size: 100, Type: "archive"},
+				},
+				Dirs: map[string]*FileInfo{
+					"thisIsDir": {Name: "thisIsDir", Size: 2 * 1024 * 1024},
+				},
 			},
-			"test/path": {
-				Files: "file.txt;",
-			},
-			"new": {},
-			"new/test": {
-				Files: "audio.wav;video.mp4;video.MP4;",
-			},
-			"new/test/path": {
-				Files: "archive.zip;",
+			"/firstDir/thisIsDir": {
+				Files: []ReducedItem{
+					{Name: "hi.txt", Type: "text"},
+				},
+				Size: 2 * 1024 * 1024,
 			},
 		},
 	}
+
 	tests := []struct {
 		search         string
 		scope          string
-		expectedResult []string
-		expectedTypes  map[string]map[string]bool
+		expectedResult []searchResult
 	}{
 		{
-			search:         "audio",
-			scope:          "/new/",
-			expectedResult: []string{"test/audio.wav"},
-			expectedTypes: map[string]map[string]bool{
-				"test/audio.wav": map[string]bool{"audio": true, "dir": false},
+			search: "audio",
+			scope:  "/new/",
+			expectedResult: []searchResult{
+				{
+					Path: "test/audio.wav",
+					Type: "audio",
+					Size: 0,
+				},
 			},
 		},
 		{
-			search:         "test",
-			scope:          "/",
-			expectedResult: []string{"test/", "new/test/"},
-			expectedTypes: map[string]map[string]bool{
-				"test/":     map[string]bool{"dir": true},
-				"new/test/": map[string]bool{"dir": true},
+			search: "test",
+			scope:  "/",
+			expectedResult: []searchResult{
+				{
+					Path: "test/",
+					Type: "directory",
+					Size: 0,
+				},
+				{
+					Path: "new/test/",
+					Type: "directory",
+					Size: 0,
+				},
 			},
 		},
 		{
-			search:         "archive",
-			scope:          "/",
-			expectedResult: []string{"new/test/path/archive.zip"},
-			expectedTypes: map[string]map[string]bool{
-				"new/test/path/archive.zip": map[string]bool{"archive": true, "dir": false},
+			search: "archive",
+			scope:  "/",
+			expectedResult: []searchResult{
+				{
+					Path: "firstDir/archive.zip",
+					Type: "archive",
+					Size: 100,
+				},
+				{
+					Path: "new/test/path/archive.zip",
+					Type: "archive",
+					Size: 0,
+				},
+			},
+		},
+		{
+			search: "arch",
+			scope:  "/firstDir",
+			expectedResult: []searchResult{
+				{
+					Path: "archive.zip",
+					Type: "archive",
+					Size: 100,
+				},
+			},
+		},
+		{
+			search: "isdir",
+			scope:  "/",
+			expectedResult: []searchResult{
+				{
+					Path: "firstDir/thisIsDir/",
+					Type: "directory",
+					Size: 2097152,
+				},
+			},
+		},
+		{
+			search: "IsDir type:largerThan=1",
+			scope:  "/",
+			expectedResult: []searchResult{
+				{
+					Path: "firstDir/thisIsDir/",
+					Type: "directory",
+					Size: 2097152,
+				},
 			},
 		},
 		{
 			search: "video",
 			scope:  "/",
-			expectedResult: []string{
-				"new/test/video.mp4",
-				"new/test/video.MP4",
-			},
-			expectedTypes: map[string]map[string]bool{
-				"new/test/video.MP4": map[string]bool{"video": true, "dir": false},
-				"new/test/video.mp4": map[string]bool{"video": true, "dir": false},
+			expectedResult: []searchResult{
+				{
+					Path: "new/test/video.MP4",
+					Type: "video",
+					Size: 0,
+				},
+				{
+					Path: "new/test/video.mp4",
+					Type: "video",
+					Size: 0,
+				},
 			},
 		},
 	}
+
 	for _, tt := range tests {
 		t.Run(tt.search, func(t *testing.T) {
-			actualResult, actualTypes := index.Search(tt.search, tt.scope, "")
-			assert.Equal(t, tt.expectedResult, actualResult)
-			if !reflect.DeepEqual(tt.expectedTypes, actualTypes) {
-				t.Fatalf("\n got:  %+v\n want: %+v", actualTypes, tt.expectedTypes)
-			}
-		})
-	}
-}
-
-func Test_scopedPathNameFilter(t *testing.T) {
-	tests := []struct {
-		name string
-		args struct {
-			pathName string
-			scope    string
-			isDir    bool // Assuming isDir should be included in args
-		}
-		want string
-	}{
-		{
-			name: "scope test",
-			args: struct {
-				pathName string
-				scope    string
-				isDir    bool
-			}{
-				pathName: "/",
-				scope:    "/",
-				isDir:    false,
-			},
-			want: "", // Update this with the expected result
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := scopedPathNameFilter(tt.args.pathName, tt.args.scope, tt.args.isDir); got != tt.want {
-				t.Errorf("scopedPathNameFilter() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
-func Test_isDoc(t *testing.T) {
-	type args struct {
-		extension string
-	}
-	tests := []struct {
-		name string
-		args args
-		want bool
-	}{
-		// TODO: Add test cases.
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := isDoc(tt.args.extension); got != tt.want {
-				t.Errorf("isDoc() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
-func Test_getFileSize(t *testing.T) {
-	type args struct {
-		filepath string
-	}
-	tests := []struct {
-		name string
-		args args
-		want int64
-	}{
-		// TODO: Add test cases.
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := getFileSize(tt.args.filepath); got != tt.want {
-				t.Errorf("getFileSize() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
-func Test_isArchive(t *testing.T) {
-	type args struct {
-		extension string
-	}
-	tests := []struct {
-		name string
-		args args
-		want bool
-	}{
-		// TODO: Add test cases.
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := isArchive(tt.args.extension); got != tt.want {
-				t.Errorf("isArchive() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
-func Test_getLastPathComponent(t *testing.T) {
-	type args struct {
-		path string
-	}
-	tests := []struct {
-		name string
-		args args
-		want string
-	}{
-		// TODO: Add test cases.
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := getLastPathComponent(tt.args.path); got != tt.want {
-				t.Errorf("getLastPathComponent() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
-func Test_generateRandomHash(t *testing.T) {
-	type args struct {
-		length int
-	}
-	tests := []struct {
-		name string
-		args args
-		want string
-	}{
-		// TODO: Add test cases.
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := generateRandomHash(tt.args.length); got != tt.want {
-				t.Errorf("generateRandomHash() = %v, want %v", got, tt.want)
-			}
+			result := index.Search(tt.search, tt.scope, "")
+			assert.ElementsMatch(t, tt.expectedResult, result)
 		})
 	}
 }

backend/files/sync.go

@@ -1,93 +1,91 @@
 package files
 
 import (
-	"io/fs"
 	"log"
+	"path/filepath"
+	"sort"
 	"time"
 
 	"github.com/gtsteffaniak/filebrowser/settings"
 )
 
-// GetFileMetadata retrieves the FileInfo from the specified directory in the index.
-func (si *Index) GetFileMetadata(adjustedPath string) (FileInfo, bool) {
-	si.mu.RLock()
-	dir, exists := si.Directories[adjustedPath]
-	si.mu.RUnlock()
-	if exists {
-		// Initialize the Metadata map if it is nil
-		if dir.Metadata == nil {
-			dir.Metadata = make(map[string]FileInfo)
-			si.SetDirectoryInfo(adjustedPath, dir)
-			return FileInfo{}, false
-		} else {
-			return dir.Metadata[adjustedPath], true
-		}
-	}
-	return FileInfo{}, false
-}
-
 // UpdateFileMetadata updates the FileInfo for the specified directory in the index.
-func (si *Index) UpdateFileMetadata(adjustedPath string, info FileInfo) bool {
+func (si *Index) UpdateMetadata(info *FileInfo) bool {
 	si.mu.Lock()
 	defer si.mu.Unlock()
-	dir, exists := si.Directories[adjustedPath]
-	if !exists {
-		// Initialize the Metadata map if it is nil
-		if dir.Metadata == nil {
-			dir.Metadata = make(map[string]FileInfo)
-		}
-		si.Directories[adjustedPath] = dir
-		// Release the read lock before calling SetFileMetadata
-	}
-	return si.SetFileMetadata(adjustedPath, info)
-}
-
-// SetFileMetadata sets the FileInfo for the specified directory in the index.
-// internal use only
-func (si *Index) SetFileMetadata(adjustedPath string, info FileInfo) bool {
-
-	_, exists := si.Directories[adjustedPath]
-	if !exists {
-		return false
-	}
 	info.CacheTime = time.Now()
-	si.Directories[adjustedPath].Metadata[adjustedPath] = info
+	si.Directories[info.Path] = info
 	return true
 }
 
 // GetMetadataInfo retrieves the FileInfo from the specified directory in the index.
-func (si *Index) GetMetadataInfo(adjustedPath string) (FileInfo, bool) {
+func (si *Index) GetReducedMetadata(target string, isDir bool) (*FileInfo, bool) {
 	si.mu.RLock()
-	dir, exists := si.Directories[adjustedPath]
-	si.mu.RUnlock()
-	if exists {
-		// Initialize the Metadata map if it is nil
-		if dir.Metadata == nil {
-			dir.Metadata = make(map[string]FileInfo)
-			si.SetDirectoryInfo(adjustedPath, dir)
+	defer si.mu.RUnlock()
+	checkDir := si.makeIndexPath(target)
+	if !isDir {
+		checkDir = si.makeIndexPath(filepath.Dir(target))
+	}
+	dir, exists := si.Directories[checkDir]
+	if !exists {
+		return nil, false
+	}
+	if !isDir {
+		if checkDir == "/" {
+			checkDir = ""
 		}
-		info, metadataExists := dir.Metadata[adjustedPath]
-		return info, metadataExists
+
+		baseName := filepath.Base(target)
+		for _, item := range dir.Files {
+			if item.Name == baseName {
+				return &FileInfo{
+					Name:    item.Name,
+					Size:    item.Size,
+					ModTime: item.ModTime,
+					Type:    item.Type,
+					Path:    checkDir + "/" + item.Name,
+				}, true
+			}
+		}
+		return nil, false
 	}
-	return FileInfo{}, false
+	cleanedItems := []ReducedItem{}
+	for name, item := range dir.Dirs {
+		cleanedItems = append(cleanedItems, ReducedItem{
+			Name:    name,
+			Size:    item.Size,
+			ModTime: item.ModTime,
+			Type:    "directory",
+		})
+	}
+	cleanedItems = append(cleanedItems, dir.Files...)
+	sort.Slice(cleanedItems, func(i, j int) bool {
+		return cleanedItems[i].Name < cleanedItems[j].Name
+	})
+	dirname := filepath.Base(dir.Path)
+	if dirname == "." {
+		dirname = "/"
+	}
+	// construct file info
+	return &FileInfo{
+		Name:    dirname,
+		Type:    "directory",
+		Items:   cleanedItems,
+		ModTime: dir.ModTime,
+		Size:    dir.Size,
+	}, true
 }
 
-// SetDirectoryInfo sets the directory information in the index.
-func (si *Index) SetDirectoryInfo(adjustedPath string, dir Directory) {
-	si.mu.Lock()
-	si.Directories[adjustedPath] = dir
-	si.mu.Unlock()
-}
-
-// SetDirectoryInfo sets the directory information in the index.
-func (si *Index) GetDirectoryInfo(adjustedPath string) (Directory, bool) {
+// GetMetadataInfo retrieves the FileInfo from the specified directory in the index.
+func (si *Index) GetMetadataInfo(target string, isDir bool) (*FileInfo, bool) {
 	si.mu.RLock()
-	dir, exists := si.Directories[adjustedPath]
-	si.mu.RUnlock()
-	if exists {
-		return dir, true
+	defer si.mu.RUnlock()
+	checkDir := si.makeIndexPath(target)
+	if !isDir {
+		checkDir = si.makeIndexPath(filepath.Dir(target))
 	}
-	return Directory{}, false
+	dir, exists := si.Directories[checkDir]
+	return dir, exists
 }
 
 func (si *Index) RemoveDirectory(path string) {
@@ -127,46 +125,14 @@ func GetIndex(root string) *Index {
 	}
 	newIndex := &Index{
 		Root:        rootPath,
-		Directories: make(map[string]Directory), // Initialize the map
+		Directories: map[string]*FileInfo{},
 		NumDirs:     0,
 		NumFiles:    0,
 		inProgress:  false,
 	}
+	newIndex.Directories["/"] = &FileInfo{}
 	indexesMutex.Lock()
 	indexes = append(indexes, newIndex)
 	indexesMutex.Unlock()
 	return newIndex
 }
-
-func (si *Index) UpdateQuickList(files []fs.FileInfo) {
-	si.mu.Lock()
-	defer si.mu.Unlock()
-	si.quickList = []File{}
-	for _, file := range files {
-		newFile := File{
-			Name:  file.Name(),
-			IsDir: file.IsDir(),
-		}
-		si.quickList = append(si.quickList, newFile)
-	}
-}
-
-func (si *Index) UpdateQuickListForTests(files []File) {
-	si.mu.Lock()
-	defer si.mu.Unlock()
-	si.quickList = []File{}
-	for _, file := range files {
-		newFile := File{
-			Name:  file.Name,
-			IsDir: file.IsDir,
-		}
-		si.quickList = append(si.quickList, newFile)
-	}
-}
-
-func (si *Index) GetQuickList() []File {
-	si.mu.Lock()
-	defer si.mu.Unlock()
-	newQuickList := si.quickList
-	return newQuickList
-}

backend/files/sync_test.go

@@ -0,0 +1,260 @@
+package files
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+var testIndex Index
+
+// Test for GetFileMetadata// Test for GetFileMetadata
+func TestGetFileMetadataSize(t *testing.T) {
+	t.Parallel()
+	tests := []struct {
+		name         string
+		adjustedPath string
+		expectedName string
+		expectedSize int64
+	}{
+		{
+			name:         "testpath exists",
+			adjustedPath: "/testpath",
+			expectedName: "testfile.txt",
+			expectedSize: 100,
+		},
+		{
+			name:         "testpath exists",
+			adjustedPath: "/testpath",
+			expectedName: "directory",
+			expectedSize: 100,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			fileInfo, _ := testIndex.GetReducedMetadata(tt.adjustedPath, true)
+			// Iterate over fileInfo.Items to look for expectedName
+			for _, item := range fileInfo.Items {
+				// Assert the existence and the name
+				if item.Name == tt.expectedName {
+					assert.Equal(t, tt.expectedSize, item.Size)
+					break
+				}
+			}
+		})
+	}
+}
+
+// Test for GetFileMetadata// Test for GetFileMetadata
+func TestGetFileMetadata(t *testing.T) {
+	t.Parallel()
+	tests := []struct {
+		name           string
+		adjustedPath   string
+		expectedName   string
+		expectedExists bool
+		isDir          bool
+	}{
+		{
+			name:           "testpath exists",
+			adjustedPath:   "/testpath/testfile.txt",
+			expectedName:   "testfile.txt",
+			expectedExists: true,
+		},
+		{
+			name:           "testpath not exists",
+			adjustedPath:   "/testpath/nonexistent.txt",
+			expectedName:   "nonexistent.txt",
+			expectedExists: false,
+		},
+		{
+			name:           "File exists in /anotherpath",
+			adjustedPath:   "/anotherpath/afile.txt",
+			expectedName:   "afile.txt",
+			expectedExists: true,
+		},
+		{
+			name:           "File does not exist in /anotherpath",
+			adjustedPath:   "/anotherpath/nonexistentfile.txt",
+			expectedName:   "nonexistentfile.txt",
+			expectedExists: false,
+		},
+		{
+			name:           "Directory does not exist",
+			adjustedPath:   "/nonexistentpath",
+			expectedName:   "",
+			expectedExists: false,
+			isDir:          true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			fileInfo, _ := testIndex.GetReducedMetadata(tt.adjustedPath, tt.isDir)
+			if fileInfo == nil {
+				found := false
+				assert.Equal(t, tt.expectedExists, found)
+				return
+			}
+			found := false
+			if tt.isDir {
+				// Iterate over fileInfo.Items to look for expectedName
+				for _, item := range fileInfo.Items {
+					// Assert the existence and the name
+					if item.Name == tt.expectedName {
+						found = true
+						break
+					}
+				}
+			} else {
+				if fileInfo.Name == tt.expectedName {
+					found = true
+				}
+			}
+
+			assert.Equal(t, tt.expectedExists, found)
+		})
+	}
+}
+
+// Test for UpdateFileMetadata
+func TestUpdateFileMetadata(t *testing.T) {
+	info := &FileInfo{
+		Path: "/testpath",
+		Name: "testpath",
+		Type: "directory",
+		Files: []ReducedItem{
+			{Name: "testfile.txt"},
+			{Name: "anotherfile.txt"},
+		},
+	}
+
+	index := &Index{
+		Directories: map[string]*FileInfo{
+			"/testpath": info,
+		},
+	}
+
+	success := index.UpdateMetadata(info)
+	if !success {
+		t.Fatalf("expected UpdateFileMetadata to succeed")
+	}
+
+	fileInfo, exists := index.GetReducedMetadata("/testpath/testfile.txt", false)
+	if !exists || fileInfo.Name != "testfile.txt" {
+		t.Fatalf("expected testfile.txt to be updated in the directory metadata:%v %v", exists, info.Name)
+	}
+}
+
+// Test for GetDirMetadata
+func TestGetDirMetadata(t *testing.T) {
+	t.Parallel()
+	_, exists := testIndex.GetReducedMetadata("/testpath", true)
+	if !exists {
+		t.Fatalf("expected GetDirMetadata to return initialized metadata map")
+	}
+
+	_, exists = testIndex.GetReducedMetadata("/nonexistent", true)
+	if exists {
+		t.Fatalf("expected GetDirMetadata to return false for nonexistent directory")
+	}
+}
+
+// Test for SetDirectoryInfo
+func TestSetDirectoryInfo(t *testing.T) {
+	index := &Index{
+		Directories: map[string]*FileInfo{
+			"/testpath": {
+				Path: "/testpath",
+				Name: "testpath",
+				Type: "directory",
+				Items: []ReducedItem{
+					{Name: "testfile.txt"},
+					{Name: "anotherfile.txt"},
+				},
+			},
+		},
+	}
+	dir := &FileInfo{
+		Path: "/newPath",
+		Name: "newPath",
+		Type: "directory",
+		Items: []ReducedItem{
+			{Name: "testfile.txt"},
+		},
+	}
+	index.UpdateMetadata(dir)
+	storedDir, exists := index.Directories["/newPath"]
+	if !exists || storedDir.Items[0].Name != "testfile.txt" {
+		t.Fatalf("expected SetDirectoryInfo to store directory info correctly")
+	}
+}
+
+// Test for RemoveDirectory
+func TestRemoveDirectory(t *testing.T) {
+	index := &Index{
+		Directories: map[string]*FileInfo{
+			"/testpath": {},
+		},
+	}
+	index.RemoveDirectory("/testpath")
+	_, exists := index.Directories["/testpath"]
+	if exists {
+		t.Fatalf("expected directory to be removed")
+	}
+}
+
+// Test for UpdateCount
+func TestUpdateCount(t *testing.T) {
+	index := &Index{}
+	index.UpdateCount("files")
+	if index.NumFiles != 1 {
+		t.Fatalf("expected NumFiles to be 1 after UpdateCount('files')")
+	}
+	if index.NumFiles != 1 {
+		t.Fatalf("expected NumFiles to be 1 after UpdateCount('files')")
+	}
+	index.UpdateCount("dirs")
+	if index.NumDirs != 1 {
+		t.Fatalf("expected NumDirs to be 1 after UpdateCount('dirs')")
+	}
+	index.UpdateCount("unknown")
+	// Just ensure it does not panic or update any counters
+	if index.NumFiles != 1 || index.NumDirs != 1 {
+		t.Fatalf("expected counts to remain unchanged for unknown type")
+	}
+	index.resetCount()
+	if index.NumFiles != 0 || index.NumDirs != 0 || !index.inProgress {
+		t.Fatalf("expected resetCount to reset counts and set inProgress to true")
+	}
+}
+
+func init() {
+	testIndex = Index{
+		Root:       "/",
+		NumFiles:   10,
+		NumDirs:    5,
+		inProgress: false,
+		Directories: map[string]*FileInfo{
+			"/testpath": {
+				Path: "/testpath",
+				Name: "testpath",
+				Type: "directory",
+				Files: []ReducedItem{
+					{Name: "testfile.txt", Size: 100},
+					{Name: "anotherfile.txt", Size: 100},
+				},
+			},
+			"/anotherpath": {
+				Path: "/anotherpath",
+				Name: "anotherpath",
+				Type: "directory",
+				Files: []ReducedItem{
+					{Name: "afile.txt", Size: 100},
+				},
+				Dirs: map[string]*FileInfo{
+					"directory": {Name: "directory", Type: "directory", Size: 100},
+				},
+			},
+		},
+	}
+}

backend/fileutils/copy.go

@@ -2,23 +2,23 @@ package fileutils
 
 import (
 	"os"
-	"path"
-
-	"github.com/spf13/afero"
+	"path/filepath"
 )
 
 // Copy copies a file or folder from one place to another.
-func Copy(fs afero.Fs, src, dst string) error {
-	if src = path.Clean("/" + src); src == "" {
+func CopyHelper(src, dst string) error {
+	src = filepath.Clean(src)
+	if src == "" {
 		return os.ErrNotExist
 	}
 
-	if dst = path.Clean("/" + dst); dst == "" {
+	dst = filepath.Clean(dst)
+	if dst == "" {
 		return os.ErrNotExist
 	}
 
 	if src == "/" || dst == "/" {
-		// Prohibit copying from or to the virtual root directory.
+		// Prohibit copying from or to the root directory.
 		return os.ErrInvalid
 	}
 
@@ -26,14 +26,14 @@ func Copy(fs afero.Fs, src, dst string) error {
 		return os.ErrInvalid
 	}
 
-	info, err := fs.Stat(src)
+	info, err := os.Stat(src)
 	if err != nil {
 		return err
 	}
 
 	if info.IsDir() {
-		return CopyDir(fs, src, dst)
+		return CopyDir(src, dst)
 	}
 
-	return CopyFile(fs, src, dst)
+	return CopyFile(src, dst)
 }

backend/fileutils/dir.go

@@ -2,27 +2,32 @@ package fileutils
 
 import (
 	"errors"
-
-	"github.com/spf13/afero"
+	"os"
+	"path/filepath"
 )
 
 // CopyDir copies a directory from source to dest and all
 // of its sub-directories. It doesn't stop if it finds an error
 // during the copy. Returns an error if any.
-func CopyDir(fs afero.Fs, source, dest string) error {
+func CopyDir(source, dest string) error {
 	// Get properties of source.
-	srcinfo, err := fs.Stat(source)
+	srcinfo, err := os.Stat(source)
 	if err != nil {
 		return err
 	}
 
 	// Create the destination directory.
-	err = fs.MkdirAll(dest, srcinfo.Mode())
+	err = os.MkdirAll(dest, srcinfo.Mode())
 	if err != nil {
 		return err
 	}
 
-	dir, _ := fs.Open(source)
+	dir, err := os.Open(source)
+	if err != nil {
+		return err
+	}
+	defer dir.Close()
+
 	obs, err := dir.Readdir(-1)
 	if err != nil {
 		return err
@@ -31,18 +36,18 @@ func CopyDir(fs afero.Fs, source, dest string) error {
 	var errs []error
 
 	for _, obj := range obs {
-		fsource := source + "/" + obj.Name()
-		fdest := dest + "/" + obj.Name()
+		fsource := filepath.Join(source, obj.Name())
+		fdest := filepath.Join(dest, obj.Name())
 
 		if obj.IsDir() {
 			// Create sub-directories, recursively.
-			err = CopyDir(fs, fsource, fdest)
+			err = CopyDir(fsource, fdest)
 			if err != nil {
 				errs = append(errs, err)
 			}
 		} else {
 			// Perform the file copy.
-			err = CopyFile(fs, fsource, fdest)
+			err = CopyFile(fsource, fdest)
 			if err != nil {
 				errs = append(errs, err)
 			}

backend/fileutils/file.go

@@ -5,24 +5,22 @@ import (
 	"os"
 	"path"
 	"path/filepath"
-
-	"github.com/spf13/afero"
 )
 
-// MoveFile moves file from src to dst.
-// By default the rename filesystem system call is used. If src and dst point to different volumes
-// the file copy is used as a fallback
-func MoveFile(fs afero.Fs, src, dst string) error {
-	if fs.Rename(src, dst) == nil {
+// MoveFile moves a file from src to dst.
+// By default, the rename system call is used. If src and dst point to different volumes,
+// the file copy is used as a fallback.
+func MoveFile(src, dst string) error {
+	if os.Rename(src, dst) == nil {
 		return nil
 	}
 	// fallback
-	err := CopyFile(fs, src, dst)
+	err := CopyFile(src, dst)
 	if err != nil {
-		_ = fs.Remove(dst)
+		_ = os.Remove(dst)
 		return err
 	}
-	if err := fs.Remove(src); err != nil {
+	if err := os.Remove(src); err != nil {
 		return err
 	}
 	return nil
@@ -30,23 +28,22 @@ func MoveFile(fs afero.Fs, src, dst string) error {
 
 // CopyFile copies a file from source to dest and returns
 // an error if any.
-func CopyFile(fs afero.Fs, source, dest string) error {
+func CopyFile(source, dest string) error {
 	// Open the source file.
-	src, err := fs.Open(source)
+	src, err := os.Open(source)
 	if err != nil {
 		return err
 	}
 	defer src.Close()
 
-	// Makes the directory needed to create the dst
-	// file.
-	err = fs.MkdirAll(filepath.Dir(dest), 0666) //nolint:gomnd
+	// Makes the directory needed to create the dst file.
+	err = os.MkdirAll(filepath.Dir(dest), 0775) //nolint:gomnd
 	if err != nil {
 		return err
 	}
 
 	// Create the destination file.
-	dst, err := fs.OpenFile(dest, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0775) //nolint:gomnd
+	dst, err := os.OpenFile(dest, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0666) //nolint:gomnd
 	if err != nil {
 		return err
 	}
@@ -58,12 +55,12 @@ func CopyFile(fs afero.Fs, source, dest string) error {
 		return err
 	}
 
-	// Copy the mode
-	info, err := fs.Stat(source)
+	// Copy the mode.
+	info, err := os.Stat(source)
 	if err != nil {
 		return err
 	}
-	err = fs.Chmod(dest, info.Mode())
+	err = os.Chmod(dest, info.Mode())
 	if err != nil {
 		return err
 	}
@@ -71,7 +68,7 @@ func CopyFile(fs afero.Fs, source, dest string) error {
 	return nil
 }
 
-// CommonPrefix returns common directory path of provided files
+// CommonPrefix returns the common directory path of provided files.
 func CommonPrefix(sep byte, paths ...string) string {
 	// Handle special cases.
 	switch len(paths) {
@@ -81,30 +78,19 @@ func CommonPrefix(sep byte, paths ...string) string {
 		return path.Clean(paths[0])
 	}
 
-	// Note, we treat string as []byte, not []rune as is often
-	// done in Go. (And sep as byte, not rune). This is because
-	// most/all supported OS' treat paths as string of non-zero
-	// bytes. A filename may be displayed as a sequence of Unicode
-	// runes (typically encoded as UTF-8) but paths are
-	// not required to be valid UTF-8 or in any normalized form
-	// (e.g. "é" (U+00C9) and "é" (U+0065,U+0301) are different
-	// file names.
+	// Treat string as []byte, not []rune as is often done in Go.
 	c := []byte(path.Clean(paths[0]))
 
-	// We add a trailing sep to handle the case where the
-	// common prefix directory is included in the path list
-	// (e.g. /home/user1, /home/user1/foo, /home/user1/bar).
-	// path.Clean will have cleaned off trailing / separators with
-	// the exception of the root directory, "/" (in which case we
-	// make it "//", but this will get fixed up to "/" bellow).
+	// Add a trailing sep to handle the case where the common prefix directory
+	// is included in the path list.
 	c = append(c, sep)
 
-	// Ignore the first path since it's already in c
+	// Ignore the first path since it's already in c.
 	for _, v := range paths[1:] {
-		// Clean up each path before testing it
+		// Clean up each path before testing it.
 		v = path.Clean(v) + string(sep)
 
-		// Find the first non-common byte and truncate c
+		// Find the first non-common byte and truncate c.
 		if len(v) < len(c) {
 			c = c[:len(v)]
 		}
@@ -116,7 +102,7 @@ func CommonPrefix(sep byte, paths ...string) string {
 		}
 	}
 
-	// Remove trailing non-separator characters and the final separator
+	// Remove trailing non-separator characters and the final separator.
 	for i := len(c) - 1; i >= 0; i-- {
 		if c[i] == sep {
 			c = c[:i]

backend/frontend/dist

@@ -1 +0,0 @@
-../../frontend/dist

backend/frontend/package-lock.json

@@ -1,6 +0,0 @@
-{
-  "name": "frontend",
-  "lockfileVersion": 3,
-  "requires": true,
-  "packages": {}
-}

backend/go.mod

@@ -1,56 +1,61 @@
 module github.com/gtsteffaniak/filebrowser
 
-go 1.22.0
+go 1.22.5
 
 require (
 	github.com/asdine/storm/v3 v3.2.1
 	github.com/disintegration/imaging v1.6.2
 	github.com/dsoprea/go-exif/v3 v3.0.1
 	github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568
-	github.com/goccy/go-yaml v1.11.3
-	github.com/golang-jwt/jwt/v4 v4.5.0
+	github.com/goccy/go-yaml v1.14.3
+	github.com/golang-jwt/jwt/v4 v4.5.1
 	github.com/google/go-cmp v0.6.0
-	github.com/gorilla/mux v1.8.1
 	github.com/marusama/semaphore/v2 v2.5.0
 	github.com/mholt/archiver/v3 v3.5.1
 	github.com/shirou/gopsutil/v3 v3.24.5
 	github.com/spf13/afero v1.11.0
-	github.com/spf13/cobra v1.8.0
+	github.com/spf13/cobra v1.8.1
 	github.com/spf13/pflag v1.0.5
 	github.com/stretchr/testify v1.9.0
-	github.com/tomasen/realip v0.0.0-20180522021738-f0c99a92ddce
-	golang.org/x/crypto v0.24.0
-	golang.org/x/image v0.17.0
-	golang.org/x/text v0.16.0
+	github.com/swaggo/http-swagger v1.3.4
+	github.com/swaggo/swag v1.16.4
+	golang.org/x/crypto v0.29.0
+	golang.org/x/image v0.22.0
+	golang.org/x/text v0.20.0
 )
 
 require (
-	github.com/andybalholm/brotli v1.1.0 // indirect
+	github.com/KyleBanks/depth v1.2.1 // indirect
+	github.com/andybalholm/brotli v1.1.1 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/dsnet/compress v0.0.2-0.20210315054119-f66993602bf5 // indirect
 	github.com/dsoprea/go-logging v0.0.0-20200710184922-b02d349568dd // indirect
 	github.com/dsoprea/go-utility/v2 v2.0.0-20221003172846-a3e1774ef349 // indirect
-	github.com/fatih/color v1.17.0 // indirect
 	github.com/go-errors/errors v1.5.1 // indirect
 	github.com/go-ole/go-ole v1.3.0 // indirect
+	github.com/go-openapi/jsonpointer v0.21.0 // indirect
+	github.com/go-openapi/jsonreference v0.21.0 // indirect
+	github.com/go-openapi/spec v0.21.0 // indirect
+	github.com/go-openapi/swag v0.23.0 // indirect
 	github.com/golang/geo v0.0.0-20230421003525-6adc56603217 // indirect
 	github.com/golang/snappy v0.0.4 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
-	github.com/klauspost/compress v1.17.9 // indirect
+	github.com/josharian/intern v1.0.0 // indirect
+	github.com/klauspost/compress v1.17.11 // indirect
 	github.com/klauspost/pgzip v1.2.6 // indirect
-	github.com/mattn/go-colorable v0.1.13 // indirect
-	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/mailru/easyjson v0.7.7 // indirect
 	github.com/nwaples/rardecode v1.1.3 // indirect
 	github.com/pierrec/lz4/v4 v4.1.21 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirect
+	github.com/swaggo/files v1.0.1 // indirect
 	github.com/ulikunitz/xz v0.5.12 // indirect
 	github.com/xi2/xz v0.0.0-20171230120015-48954b6210f8 // indirect
 	github.com/yusufpapurcu/wmi v1.2.4 // indirect
-	go.etcd.io/bbolt v1.3.10 // indirect
-	golang.org/x/net v0.26.0 // indirect
-	golang.org/x/sys v0.21.0 // indirect
-	golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 // indirect
+	go.etcd.io/bbolt v1.3.11 // indirect
+	golang.org/x/net v0.31.0 // indirect
+	golang.org/x/sys v0.27.0 // indirect
+	golang.org/x/tools v0.27.0 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

backend/go.sum

@@ -1,13 +1,15 @@
 github.com/DataDog/zstd v1.4.1 h1:3oxKN3wbHibqx897utPC2LTQU4J+IHWWJO+glkAkpFM=
 github.com/DataDog/zstd v1.4.1/go.mod h1:1jcaCB/ufaK+sKp1NBhlGmpz41jOoPQ35bpF36t7BBo=
+github.com/KyleBanks/depth v1.2.1 h1:5h8fQADFrWtarTdtDudMmGsC7GPbOAu6RVB3ffsVFHc=
+github.com/KyleBanks/depth v1.2.1/go.mod h1:jzSb9d0L43HxTQfT+oSA1EEp2q+ne2uh6XgeJcm8brE=
 github.com/Sereal/Sereal v0.0.0-20190618215532-0b8ac451a863 h1:BRrxwOZBolJN4gIwvZMJY1tzqBvQgpaZiQRuIDD40jM=
 github.com/Sereal/Sereal v0.0.0-20190618215532-0b8ac451a863/go.mod h1:D0JMgToj/WdxCgd30Kc1UcA9E+WdZoJqeVOuYW7iTBM=
 github.com/andybalholm/brotli v1.0.1/go.mod h1:loMXtMfwqflxFJPmdbJO0a3KNoPuLBgiu3qAvBg8x/Y=
-github.com/andybalholm/brotli v1.1.0 h1:eLKJA0d02Lf0mVpIDgYnqXcUn0GqVmEFny3VuID1U3M=
-github.com/andybalholm/brotli v1.1.0/go.mod h1:sms7XGricyQI9K10gOSf56VKKWS4oLer58Q+mhRPtnY=
+github.com/andybalholm/brotli v1.1.1 h1:PR2pgnyFznKEugtsUo0xLdDop5SKXd5Qf5ysW+7XdTA=
+github.com/andybalholm/brotli v1.1.1/go.mod h1:05ib4cKhjx3OQYUY22hTVd34Bc8upXjOLL2rKwwZBoA=
 github.com/asdine/storm/v3 v3.2.1 h1:I5AqhkPK6nBZ/qJXySdI7ot5BlXSZ7qvDY1zAn5ZJac=
 github.com/asdine/storm/v3 v3.2.1/go.mod h1:LEpXwGt4pIqrE/XcTvCnZHT5MgZCV6Ub9q7yQzOFWr0=
-github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/disintegration/imaging v1.6.2 h1:w1LecBlG2Lnp8B3jk5zSuNqd7b4DXhcjwek1ei82L+c=
@@ -32,8 +34,6 @@ github.com/dsoprea/go-utility/v2 v2.0.0-20221003142440-7a1927d49d9d/go.mod h1:LV
 github.com/dsoprea/go-utility/v2 v2.0.0-20221003160719-7bc88537c05e/go.mod h1:VZ7cB0pTjm1ADBWhJUOHESu4ZYy9JN+ZPqjfiW09EPU=
 github.com/dsoprea/go-utility/v2 v2.0.0-20221003172846-a3e1774ef349 h1:DilThiXje0z+3UQ5YjYiSRRzVdtamFpvBQXKwMglWqw=
 github.com/dsoprea/go-utility/v2 v2.0.0-20221003172846-a3e1774ef349/go.mod h1:4GC5sXji84i/p+irqghpPFZBF8tRN/Q7+700G0/DLe8=
-github.com/fatih/color v1.17.0 h1:GlRw1BRJxkpqUCBKzKOw098ed57fEsKeNjpTe3cSjK4=
-github.com/fatih/color v1.17.0/go.mod h1:YZ7TlrGPkiz6ku9fK3TLD/pl3CpsiFyu8N92HLgmosI=
 github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568 h1:BHsljHzVlRcyQhjrss6TZTdY2VfCqZPbv5k3iBFa2ZQ=
 github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568/go.mod h1:xEzjJPgXI435gkrCt3MPfRiAkVrwSbHsst4LCFVfpJc=
 github.com/go-errors/errors v1.0.1/go.mod h1:f4zRHt4oKfwPJE5k8C9vpYG+aDHdBFUsgrm6/TyX73Q=
@@ -45,16 +45,18 @@ github.com/go-errors/errors v1.5.1/go.mod h1:sIVyrIiJhuEF+Pj9Ebtd6P/rEYROXFi3Bop
 github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
 github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE=
 github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78=
-github.com/go-playground/locales v0.13.0 h1:HyWk6mgj5qFqCT5fjGBuRArbVDfE4hi8+e8ceBS/t7Q=
-github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8=
-github.com/go-playground/universal-translator v0.17.0 h1:icxd5fm+REJzpZx7ZfpaD876Lmtgy7VtROAbHHXk8no=
-github.com/go-playground/universal-translator v0.17.0/go.mod h1:UkSxE5sNxxRwHyU+Scu5vgOQjsIJAF8j9muTVoKLVtA=
-github.com/go-playground/validator/v10 v10.4.1 h1:pH2c5ADXtd66mxoE0Zm9SUhxE20r7aM3F26W0hOn+GE=
-github.com/go-playground/validator/v10 v10.4.1/go.mod h1:nlOn6nFhuKACm19sB/8EGNn9GlaMV7XkbRSipzJ0Ii4=
-github.com/goccy/go-yaml v1.11.3 h1:B3W9IdWbvrUu2OYQGwvU1nZtvMQJPBKgBUuweJjLj6I=
-github.com/goccy/go-yaml v1.11.3/go.mod h1:wKnAMd44+9JAAnGQpWVEgBzGt3YuTaQ4uXoHvE4m7WU=
-github.com/golang-jwt/jwt/v4 v4.5.0 h1:7cYmW1XlMY7h7ii7UhUyChSgS5wUJEnm9uZVTGqOWzg=
-github.com/golang-jwt/jwt/v4 v4.5.0/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0=
+github.com/go-openapi/jsonpointer v0.21.0 h1:YgdVicSA9vH5RiHs9TZW5oyafXZFc6+2Vc1rr/O9oNQ=
+github.com/go-openapi/jsonpointer v0.21.0/go.mod h1:IUyH9l/+uyhIYQ/PXVA41Rexl+kOkAPDdXEYns6fzUY=
+github.com/go-openapi/jsonreference v0.21.0 h1:Rs+Y7hSXT83Jacb7kFyjn4ijOuVGSvOdF2+tg1TRrwQ=
+github.com/go-openapi/jsonreference v0.21.0/go.mod h1:LmZmgsrTkVg9LG4EaHeY8cBDslNPMo06cago5JNLkm4=
+github.com/go-openapi/spec v0.21.0 h1:LTVzPc3p/RzRnkQqLRndbAzjY0d0BCL72A6j3CdL9ZY=
+github.com/go-openapi/spec v0.21.0/go.mod h1:78u6VdPw81XU44qEWGhtr982gJ5BWg2c0I5XwVMotYk=
+github.com/go-openapi/swag v0.23.0 h1:vsEVJDUo2hPJ2tu0/Xc+4noaxyEffXNIs3cOULZ+GrE=
+github.com/go-openapi/swag v0.23.0/go.mod h1:esZ8ITTYEsH1V2trKHjAN8Ai7xHb8RV+YSZ577vPjgQ=
+github.com/goccy/go-yaml v1.14.3 h1:8tVD+aqqPLWisSEhM+6wWoiURWXCx6BwaTKS6ZeITgM=
+github.com/goccy/go-yaml v1.14.3/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=
+github.com/golang-jwt/jwt/v4 v4.5.1 h1:JdqV9zKUdtaa9gdPlywC3aeoEsR681PlKC+4F5gQgeo=
+github.com/golang-jwt/jwt/v4 v4.5.1/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0=
 github.com/golang/geo v0.0.0-20190916061304-5b978397cfec/go.mod h1:QZ0nwyI2jOfgRAoBvP+ab5aRr7c9x7lhGEJrKvBwjWI=
 github.com/golang/geo v0.0.0-20200319012246-673a6f80352d/go.mod h1:QZ0nwyI2jOfgRAoBvP+ab5aRr7c9x7lhGEJrKvBwjWI=
 github.com/golang/geo v0.0.0-20210211234256-740aa86cb551/go.mod h1:QZ0nwyI2jOfgRAoBvP+ab5aRr7c9x7lhGEJrKvBwjWI=
@@ -71,34 +73,31 @@ github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEW
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
-github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY=
-github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
 github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
 github.com/jessevdk/go-flags v1.5.0/go.mod h1:Fw0T6WPc1dYxT4mKEZRfG5kJhaTDP9pj1c2EWnYs/m4=
+github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY=
+github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
 github.com/klauspost/compress v1.4.1/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A=
 github.com/klauspost/compress v1.11.4/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
-github.com/klauspost/compress v1.17.9 h1:6KIumPrER1LHsvBVuDa0r5xaG0Es51mhhB9BQB2qeMA=
-github.com/klauspost/compress v1.17.9/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw=
+github.com/klauspost/compress v1.17.11 h1:In6xLpyWOi1+C7tXUUWv2ot1QvBjxevKAaI6IXrJmUc=
+github.com/klauspost/compress v1.17.11/go.mod h1:pMDklpSncoRMuLFrf1W9Ss9KT+0rH90U12bZKk7uwG0=
 github.com/klauspost/cpuid v1.2.0/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek=
 github.com/klauspost/pgzip v1.2.5/go.mod h1:Ch1tH69qFZu15pkjo5kYi6mth2Zzwzt50oCQKQE9RUs=
 github.com/klauspost/pgzip v1.2.6 h1:8RXeL5crjEUFnR2/Sn6GJNWtSQ3Dk8pq4CL3jvdDyjU=
 github.com/klauspost/pgzip v1.2.6/go.mod h1:Ch1tH69qFZu15pkjo5kYi6mth2Zzwzt50oCQKQE9RUs=
-github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/leodido/go-urn v1.2.0 h1:hpXL4XnriNwQ/ABnpepYM/1vCLWNDfUNts8dX3xTG6Y=
-github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0=
+github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
 github.com/marusama/semaphore/v2 v2.5.0 h1:o/1QJD9DBYOWRnDhPwDVAXQn6mQYD0gZaS1Tpx6DJGM=
 github.com/marusama/semaphore/v2 v2.5.0/go.mod h1:z9nMiNUekt/LTpTUQdpp+4sJeYqUGpwMHfW0Z8V8fnQ=
-github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
-github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
-github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
-github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
-github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mholt/archiver/v3 v3.5.1 h1:rDjOBX9JSF5BvoJGvjqK479aL70qh9DIpZCl+k7Clwo=
 github.com/mholt/archiver/v3 v3.5.1/go.mod h1:e3dqJ7H78uzsRSEACH1joayhuSyhnonssnDhppzS1L4=
 github.com/nwaples/rardecode v1.1.0/go.mod h1:5DzqNKiOdpKKBH87u8VlvAnPZMXcGRhxWkRpHbbfGS0=
@@ -111,20 +110,26 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 h1:o4JXh1EVt9k/+g42oCprj/FisM4qX9L3sZB3upGN2ZU=
 github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE=
+github.com/rogpeppe/go-internal v1.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDNXVBh4M=
+github.com/rogpeppe/go-internal v1.11.0/go.mod h1:ddIwULY96R17DhadqLgMfk9H9tvdUzkipdSkR5nkCZA=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/shirou/gopsutil/v3 v3.24.5 h1:i0t8kL+kQTvpAYToeuiVk3TgDeKOFioZO3Ztz/iZ9pI=
 github.com/shirou/gopsutil/v3 v3.24.5/go.mod h1:bsoOS1aStSs9ErQ1WWfxllSeS1K5D+U30r2NfcubMVk=
 github.com/spf13/afero v1.11.0 h1:WJQKhtpdm3v2IzqG8VMqrr6Rf3UYpEF239Jy9wNepM8=
 github.com/spf13/afero v1.11.0/go.mod h1:GH9Y3pIexgf1MTIWtNGyogA5MwRIDXGUr+hbWNoBjkY=
-github.com/spf13/cobra v1.8.0 h1:7aJaZx1B85qltLMc546zn58BxxfZdR/W22ej9CFoEf0=
-github.com/spf13/cobra v1.8.0/go.mod h1:WXLWApfZ71AjXPya3WOlMsY9yMs7YeiHhFVlvLyhcho=
+github.com/spf13/cobra v1.8.1 h1:e5/vxKd/rZsfSJMUX1agtjeTDf+qv1/JdBF8gg5k9ZM=
+github.com/spf13/cobra v1.8.1/go.mod h1:wHxEcudfqmLYa8iTfL+OuZPbBZkmvliBWKIezN3kD9Y=
 github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-github.com/tomasen/realip v0.0.0-20180522021738-f0c99a92ddce h1:fb190+cK2Xz/dvi9Hv8eCYJYvIGUTN2/KLq1pT6CjEc=
-github.com/tomasen/realip v0.0.0-20180522021738-f0c99a92ddce/go.mod h1:o8v6yHRoik09Xen7gje4m9ERNah1d1PPsVq1VEx9vE4=
+github.com/swaggo/files v1.0.1 h1:J1bVJ4XHZNq0I46UU90611i9/YzdrF7x92oX1ig5IdE=
+github.com/swaggo/files v1.0.1/go.mod h1:0qXmMNH6sXNf+73t65aKeB+ApmgxdnkQzVTAj2uaMUg=
+github.com/swaggo/http-swagger v1.3.4 h1:q7t/XLx0n15H1Q9/tk3Y9L4n210XzJF5WtnDX64a5ww=
+github.com/swaggo/http-swagger v1.3.4/go.mod h1:9dAh0unqMBAlbp1uE2Uc2mQTxNMU/ha4UbucIg1MFkQ=
+github.com/swaggo/swag v1.16.4 h1:clWJtd9LStiG3VeijiCfOVODP6VpHtKdQy9ELFG3s1A=
+github.com/swaggo/swag v1.16.4/go.mod h1:VBsHJRsDvfYvqoiMKnsdwhNV9LEMHgEDZcyVYX0sxPg=
 github.com/ulikunitz/xz v0.5.8/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
 github.com/ulikunitz/xz v0.5.9/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
 github.com/ulikunitz/xz v0.5.12 h1:37Nm15o69RwBkXM0J6A5OlE67RZTfzUxTj8fB3dfcsc=
@@ -133,60 +138,83 @@ github.com/vmihailenco/msgpack v4.0.4+incompatible h1:dSLoQfGFAo3F6OoNhwUmLwVgaU
 github.com/vmihailenco/msgpack v4.0.4+incompatible/go.mod h1:fy3FlTQTDXWkZ7Bh6AcGMlsjHatGryHQYUTf1ShIgkk=
 github.com/xi2/xz v0.0.0-20171230120015-48954b6210f8 h1:nIPpBwaJSVYIxUFsDv3M8ofmx9yWTog9BfvIu0q41lo=
 github.com/xi2/xz v0.0.0-20171230120015-48954b6210f8/go.mod h1:HUYIGzjTL3rfEspMxjDjgmT5uz5wzYJKVo23qUhYTos=
+github.com/xyproto/randomstring v1.0.5 h1:YtlWPoRdgMu3NZtP45drfy1GKoojuR7hmRcnhZqKjWU=
+github.com/xyproto/randomstring v1.0.5/go.mod h1:rgmS5DeNXLivK7YprL0pY+lTuhNQW3iGxZ18UQApw/E=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0=
 github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
 go.etcd.io/bbolt v1.3.4/go.mod h1:G5EMThwa9y8QZGBClrRx5EY+Yw9kAhnjy3bSjsnlVTQ=
-go.etcd.io/bbolt v1.3.10 h1:+BqfJTcCzTItrop8mq/lbzL8wSGtj94UO/3U31shqG0=
-go.etcd.io/bbolt v1.3.10/go.mod h1:bK3UQLPJZly7IlNmV7uVHJDxfe5aK9Ll93e/74Y9oEQ=
+go.etcd.io/bbolt v1.3.11 h1:yGEzV1wPz2yVCLsD8ZAiGHhHVlczyC9d1rP43/VCRJ0=
+go.etcd.io/bbolt v1.3.11/go.mod h1:dksAq7YMXoljX0xu6VF5DMZGbhYYoLUalEiSySYAS4I=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.24.0 h1:mnl8DM0o513X8fdIkmyFE/5hTYxbwYOjDS/+rK6qpRI=
-golang.org/x/crypto v0.24.0/go.mod h1:Z1PMYSOR5nyMcyAVAIQSKCDwalqy85Aqn1x3Ws4L5DM=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/crypto v0.29.0 h1:L5SG1JTTXupVV3n6sUqMTeWbjAyfPwoda2DLX8J8FrQ=
+golang.org/x/crypto v0.29.0/go.mod h1:+F4F4N5hv6v38hfeYwTdx20oUvLLc+QfrE9Ax9HtgRg=
 golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
-golang.org/x/image v0.17.0 h1:nTRVVdajgB8zCMZVsViyzhnMKPwYeroEERRC64JuLco=
-golang.org/x/image v0.17.0/go.mod h1:4yyo5vMFQjVjUcVk4jEQcU9MGy/rulF5WvUILseCM2E=
+golang.org/x/image v0.22.0 h1:UtK5yLUzilVrkjMAZAZ34DXGpASN8i8pj8g+O+yd10g=
+golang.org/x/image v0.22.0/go.mod h1:9hPFhljd4zZ1GNSIZJ49sqbp45GKK9t6w+iXvGqZUz4=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/mod v0.22.0 h1:D4nJWe9zXqHOmWqj4VMOJhvzj7bEZg4wEYa759z1pH4=
+golang.org/x/mod v0.22.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY=
 golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20191105084925-a882066a44e0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200320220750-118fecf932d8/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
 golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
 golang.org/x/net v0.0.0-20221002022538-bcab6841153b/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk=
-golang.org/x/net v0.26.0 h1:soB7SVo0PWrY4vPW/+ay0jKDNScG2X9wFeYlXIvJsOQ=
-golang.org/x/net v0.26.0/go.mod h1:5YKkiSynbBIh3p6iOc/vibscux0x38BZDkn8sCUPxHE=
-golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
-golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
+golang.org/x/net v0.31.0 h1:68CPQngjLL0r2AlUKiSxtQFKvzRVbnzLwMUn5SzcLHo=
+golang.org/x/net v0.31.0/go.mod h1:P4fl1q7dY2hnZFxEk4pPSkDHF+QqjitcnDjUQyMM+pM=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.9.0 h1:fEo0HyrW1GIgZdpbhCRO0PkJajUS5H9IFUztCgEo2jQ=
+golang.org/x/sync v0.9.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201204225414-ed752295db88/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220928140112-f11e5e49a4ec/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.21.0 h1:rF+pYz3DAGSQAxAu1CbC7catZg4ebC4UIeIhKxBZvws=
-golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.27.0 h1:wBqf8DvsY9Y/2P8gAfPDEYNuS30J4lPHJxXSb/nJZ+s=
+golang.org/x/sys v0.27.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
-golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
-golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
+golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.20.0 h1:gK/Kv2otX8gz+wn7Rmb3vT96ZwuoxnQlY+HlJVj7Qug=
+golang.org/x/text v0.20.0/go.mod h1:D4IsuqiFMhST5bX19pQ9ikHC2GsaKyk/oF+pn3ducp4=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/tools v0.27.0 h1:qEKojBykQkQ4EynWy4S8Weg69NumxKdn40Fce3uc/8o=
+golang.org/x/tools v0.27.0/go.mod h1:sUi0ZgbwW9ZPAq26Ekut+weQPR5eIM6GQLQ1Yjm1H0Q=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 h1:+cNy6SZtPcJQH3LJVLOSmiC7MMxXNOb3PU/VUEz+EhU=
-golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028/go.mod h1:NDW/Ps6MPRej6fsCIbMTohpP40sJ/P/vI1MoTEGwX90=
 google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
 google.golang.org/appengine v1.6.7 h1:FZR1q0exgwxzPzp/aF+VccGrSfxfPpkBqjIIEq3ru6c=
 google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
 google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8=
 google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
 gopkg.in/yaml.v2 v2.2.7/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=

backend/http/api.go

@@ -0,0 +1,121 @@
+package http
+
+import (
+	"fmt"
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/gtsteffaniak/filebrowser/users"
+)
+
+func createApiKeyHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
+	name := r.URL.Query().Get("name")
+	durationStr := r.URL.Query().Get("days")
+	permissionsStr := r.URL.Query().Get("permissions")
+
+	if name == "" {
+		return http.StatusInternalServerError, fmt.Errorf("api name must be valid")
+	}
+	if durationStr == "" {
+		return http.StatusInternalServerError, fmt.Errorf("api duration must be valid")
+	}
+	if permissionsStr == "" {
+		return http.StatusInternalServerError, fmt.Errorf("api permissions must be valid")
+	}
+	// Parse permissions from the query parameter
+	permissions := users.Permissions{
+		Api:      strings.Contains(permissionsStr, "api") && d.user.Perm.Api,
+		Admin:    strings.Contains(permissionsStr, "admin") && d.user.Perm.Admin,
+		Execute:  strings.Contains(permissionsStr, "execute") && d.user.Perm.Execute,
+		Create:   strings.Contains(permissionsStr, "create") && d.user.Perm.Create,
+		Rename:   strings.Contains(permissionsStr, "rename") && d.user.Perm.Rename,
+		Modify:   strings.Contains(permissionsStr, "modify") && d.user.Perm.Modify,
+		Delete:   strings.Contains(permissionsStr, "delete") && d.user.Perm.Delete,
+		Share:    strings.Contains(permissionsStr, "share") && d.user.Perm.Share,
+		Download: strings.Contains(permissionsStr, "download") && d.user.Perm.Download,
+	}
+
+	// Convert the duration string to an int64
+	durationInt, err := strconv.ParseInt(durationStr, 10, 64) // Base 10 and bit size of 64
+	if err != nil {
+		return http.StatusBadRequest, fmt.Errorf("invalid duration value: %w", err)
+	}
+
+	// Here we assume the duration is in seconds; convert to time.Duration
+	duration := time.Duration(durationInt) * time.Hour * 24
+
+	// get request body like:
+	token, err := makeSignedTokenAPI(d.user, name, duration, permissions)
+	if err != nil {
+		if strings.Contains(err.Error(), "key already exists with same name") {
+			return http.StatusConflict, err
+		}
+		return http.StatusInternalServerError, err
+	}
+	response := HttpResponse{
+		Message: "here is your token!",
+		Token:   token.Key,
+	}
+	return renderJSON(w, r, response)
+}
+
+func deleteApiKeyHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
+	name := r.URL.Query().Get("name")
+
+	keyInfo, ok := d.user.ApiKeys[name]
+	if !ok {
+		return http.StatusNotFound, fmt.Errorf("api key not found")
+	}
+	// Perform the user update
+	err := store.Users.DeleteApiKey(d.user.ID, name)
+	if err != nil {
+		return http.StatusNotFound, err
+	}
+
+	revokeAPIKey(keyInfo.Key) // add to blacklist
+	response := HttpResponse{
+		Message: "successfully deleted api key from user",
+	}
+	return renderJSON(w, r, response)
+}
+
+type AuthTokenMin struct {
+	Key         string            `json:"key"`
+	Name        string            `json:"name"`
+	Created     int64             `json:"created"`
+	Expires     int64             `json:"expires"`
+	Permissions users.Permissions `json:"Permissions"`
+}
+
+func listApiKeysHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
+	key := r.URL.Query().Get("key")
+
+	if key != "" {
+		keyInfo, ok := d.user.ApiKeys[key]
+		if !ok {
+			return http.StatusNotFound, fmt.Errorf("api key not found")
+		}
+		modifiedKey := AuthTokenMin{
+			Key:         keyInfo.Key,
+			Name:        key,
+			Created:     keyInfo.Created,
+			Expires:     keyInfo.Expires,
+			Permissions: keyInfo.Permissions,
+		}
+		return renderJSON(w, r, modifiedKey)
+	}
+
+	modifiedList := map[string]AuthTokenMin{}
+	for key, value := range d.user.ApiKeys {
+		modifiedList[key] = AuthTokenMin{
+			Key:         value.Key,
+			Created:     value.Created,
+			Expires:     value.Expires,
+			Permissions: value.Permissions,
+		}
+	}
+
+	return renderJSON(w, r, modifiedList)
+}

backend/http/auth.go

@@ -7,6 +7,7 @@ import (
 	"net/http"
 	"os"
 	"strings"
+	"sync"
 	"time"
 
 	"github.com/golang-jwt/jwt/v4"
@@ -15,91 +16,77 @@ import (
 	"github.com/gtsteffaniak/filebrowser/errors"
 	"github.com/gtsteffaniak/filebrowser/settings"
 	"github.com/gtsteffaniak/filebrowser/users"
+	"github.com/gtsteffaniak/filebrowser/utils"
 )
 
-type authToken struct {
-	User users.User `json:"user"`
-	jwt.RegisteredClaims
-}
+var (
+	revokedApiKeyList map[string]bool
+	revokeMu          sync.Mutex
+)
 
-type extractor []string
+// first checks for cookie
+// then checks for header Authorization as Bearer token
+// then checks for query parameter
+func extractToken(r *http.Request) (string, error) {
+	hasToken := false
+	tokenObj, err := r.Cookie("auth")
+	if err == nil {
+		hasToken = true
+		token := tokenObj.Value
+		// Checks if the token isn't empty and if it contains two dots.
+		// The former prevents incompatibility with URLs that previously
+		// used basic auth.
+		if token != "" && strings.Count(token, ".") == 2 {
+			return token, nil
+		}
+	}
 
-func (e extractor) ExtractToken(r *http.Request) (string, error) {
-	token, _ := request.HeaderExtractor{"X-Auth"}.ExtractToken(r)
-
-	// Checks if the token isn't empty and if it contains two dots.
-	// The former prevents incompatibility with URLs that previously
-	// used basic auth.
-	if token != "" && strings.Count(token, ".") == 2 {
-		return token, nil
+	// Check for Authorization header
+	authHeader := r.Header.Get("Authorization")
+	if authHeader != "" {
+		hasToken = true
+		// Split the header to get "Bearer {token}"
+		parts := strings.Split(authHeader, " ")
+		if len(parts) == 2 && parts[0] == "Bearer" {
+			token := parts[1]
+			return token, nil
+		}
 	}
 
 	auth := r.URL.Query().Get("auth")
-	if auth != "" && strings.Count(auth, ".") == 2 {
-		return auth, nil
+	if auth != "" {
+		hasToken = true
+		if strings.Count(auth, ".") == 2 {
+			return auth, nil
+		}
 	}
 
-	if r.Method == http.MethodGet {
-		cookie, _ := r.Cookie("auth")
-		if cookie != nil && strings.Count(cookie.Value, ".") == 2 {
-			return cookie.Value, nil
-		}
+	if hasToken {
+		return "", fmt.Errorf("invalid token provided")
 	}
 
 	return "", request.ErrNoTokenInRequest
 }
 
-func withUser(fn handleFunc) handleFunc {
-	return func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
-		keyFunc := func(token *jwt.Token) (interface{}, error) {
-			return d.settings.Auth.Key, nil
-		}
-
-		var tk authToken
-		token, err := request.ParseFromRequest(r, &extractor{}, keyFunc, request.WithClaims(&tk))
-
-		if err != nil || !token.Valid {
-			return http.StatusUnauthorized, nil
-		}
-
-		expired := !tk.VerifyExpiresAt(time.Now().Add(time.Hour), true)
-		updated := tk.IssuedAt != nil && tk.IssuedAt.Unix() < d.store.Users.LastUpdate(tk.User.ID)
-
-		if expired || updated {
-			w.Header().Add("X-Renew-Token", "true")
-		}
-
-		d.user, err = d.store.Users.Get(d.server.Root, tk.User.ID)
-		if err != nil {
-			return http.StatusInternalServerError, err
-		}
-		return fn(w, r, d)
-	}
-}
-
-func withAdmin(fn handleFunc) handleFunc {
-	return withUser(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
-		if !d.user.Perm.Admin {
-			return http.StatusForbidden, nil
-		}
-
-		return fn(w, r, d)
-	})
-}
-
-var loginHandler = func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
-	auther, err := d.store.Auth.Get(d.settings.Auth.Method)
+func loginHandler(w http.ResponseWriter, r *http.Request) {
+	// Get the authentication method from the settings
+	auther, err := store.Auth.Get(config.Auth.Method)
 	if err != nil {
-		return http.StatusInternalServerError, err
+		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+		return
 	}
-
-	user, err := auther.Auth(r, d.store.Users)
+	// Authenticate the user based on the request
+	user, err := auther.Auth(r, store.Users)
 	if err == os.ErrPermission {
-		return http.StatusForbidden, nil
+		http.Error(w, http.StatusText(http.StatusForbidden), http.StatusForbidden)
+		return
 	} else if err != nil {
-		return http.StatusInternalServerError, err
-	} else {
-		return printToken(w, r, d, user)
+		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+		return
+	}
+	status, err := printToken(w, r, user) // Pass the data object
+	if err != nil {
+		http.Error(w, http.StatusText(status), status)
 	}
 }
 
@@ -108,76 +95,115 @@ type signupBody struct {
 	Password string `json:"password"`
 }
 
-var signupHandler = func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
+func signupHandler(w http.ResponseWriter, r *http.Request) {
 	if !settings.Config.Auth.Signup {
-		return http.StatusMethodNotAllowed, nil
+		http.Error(w, http.StatusText(http.StatusMethodNotAllowed), http.StatusMethodNotAllowed)
+		return
 	}
 
 	if r.Body == nil {
-		return http.StatusBadRequest, nil
+		http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
+		return
 	}
 
 	info := &signupBody{}
 	err := json.NewDecoder(r.Body).Decode(info)
 	if err != nil {
-		return http.StatusBadRequest, err
+		http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
+		return
 	}
 
 	if info.Password == "" || info.Username == "" {
-		return http.StatusBadRequest, nil
+		http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
+		return
 	}
 
-	user := &users.User{
-		Username: info.Username,
-		Password: info.Password,
-	}
-	settings.Config.UserDefaults.Apply(user)
-	userHome, err := d.settings.MakeUserDir(user.Username, user.Scope, d.server.Root)
+	user := settings.ApplyUserDefaults(users.User{})
+	user.Username = info.Username
+	user.Password = info.Password
+
+	userHome, err := config.MakeUserDir(user.Username, user.Scope, config.Server.Root)
 	if err != nil {
 		log.Printf("create user: failed to mkdir user home dir: [%s]", userHome)
-		return http.StatusInternalServerError, err
+		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+		return
 	}
 	user.Scope = userHome
 	log.Printf("new user: %s, home dir: [%s].", user.Username, userHome)
-	settings.Config.UserDefaults.Apply(user)
-	err = d.store.Users.Save(user)
+	err = store.Users.Save(&user)
 	if err == errors.ErrExist {
-		return http.StatusConflict, err
+		http.Error(w, http.StatusText(http.StatusConflict), http.StatusConflict)
+		return
 	} else if err != nil {
-		return http.StatusInternalServerError, err
+		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+		return
 	}
-
-	return http.StatusOK, nil
 }
 
-var renewHandler = withUser(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
-	return printToken(w, r, d, d.user)
-})
+func renewHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
+	// check if x-auth header is present and token is
+	return printToken(w, r, d.user)
+}
 
-func printToken(w http.ResponseWriter, _ *http.Request, d *data, user *users.User) (int, error) {
-	duration, err := time.ParseDuration(settings.Config.Auth.TokenExpirationTime)
-	if err != nil {
-		fmt.Println("Error parsing duration:", err)
-		duration = time.Hour * 2
-	}
-	claims := &authToken{
-		User: *user,
-		RegisteredClaims: jwt.RegisteredClaims{
-			IssuedAt:  jwt.NewNumericDate(time.Now()),
-			ExpiresAt: jwt.NewNumericDate(time.Now().Add(duration)),
-			Issuer:    "File Browser",
-		},
-	}
-
-	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
-	signed, err := token.SignedString(d.settings.Auth.Key)
+func printToken(w http.ResponseWriter, _ *http.Request, user *users.User) (int, error) {
+	signed, err := makeSignedTokenAPI(user, "WEB_TOKEN_"+utils.GenerateRandomHash(4), time.Hour*2, user.Perm)
 	if err != nil {
+		if strings.Contains(err.Error(), "key already exists with same name") {
+			return http.StatusConflict, err
+		}
 		return http.StatusInternalServerError, err
 	}
-
 	w.Header().Set("Content-Type", "text/plain")
-	if _, err := w.Write([]byte(signed)); err != nil {
+	if _, err := w.Write([]byte(signed.Key)); err != nil {
 		return http.StatusInternalServerError, err
 	}
 	return 0, nil
 }
+
+func isRevokedApiKey(key string) bool {
+	_, exists := revokedApiKeyList[key]
+	return exists
+}
+
+func revokeAPIKey(key string) {
+	revokeMu.Lock()
+	delete(revokedApiKeyList, key)
+	revokeMu.Unlock()
+}
+
+func makeSignedTokenAPI(user *users.User, name string, duration time.Duration, perms users.Permissions) (users.AuthToken, error) {
+	_, ok := user.ApiKeys[name]
+	if ok {
+		return users.AuthToken{}, fmt.Errorf("key already exists with same name %v ", name)
+	}
+	now := time.Now()
+	expires := now.Add(duration)
+	claim := users.AuthToken{
+		Permissions: perms,
+		Created:     now.Unix(),
+		Expires:     expires.Unix(),
+		Name:        name,
+		BelongsTo:   user.ID,
+		RegisteredClaims: jwt.RegisteredClaims{
+			IssuedAt:  jwt.NewNumericDate(now),
+			ExpiresAt: jwt.NewNumericDate(expires),
+			Issuer:    "FileBrowser Quantum",
+		},
+	}
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claim)
+	tokenString, err := token.SignedString(config.Auth.Key)
+	if err != nil {
+		return claim, err
+	}
+	claim.Key = tokenString
+	if strings.HasPrefix(name, "WEB_TOKEN") {
+		// don't add to api tokens, its a short lived web token
+		return claim, err
+	}
+	// Perform the user update
+	err = store.Users.AddApiKey(user.ID, name, claim)
+	if err != nil {
+		return claim, err
+	}
+	return claim, err
+}

backend/http/data.go

@@ -1,75 +0,0 @@
-package http
-
-import (
-	"log"
-	"net/http"
-	"strconv"
-
-	"github.com/tomasen/realip"
-
-	"github.com/gtsteffaniak/filebrowser/runner"
-	"github.com/gtsteffaniak/filebrowser/settings"
-	"github.com/gtsteffaniak/filebrowser/storage"
-	"github.com/gtsteffaniak/filebrowser/users"
-)
-
-type handleFunc func(w http.ResponseWriter, r *http.Request, d *data) (int, error)
-
-type data struct {
-	*runner.Runner
-	settings *settings.Settings
-	server   *settings.Server
-	store    *storage.Storage
-	user     *users.User
-	raw      interface{}
-}
-
-// Check implements rules.Checker.
-func (d *data) Check(path string) bool {
-
-	allow := true
-	for _, rule := range d.settings.Rules {
-		if rule.Matches(path) {
-			allow = rule.Allow
-		}
-	}
-	for _, rule := range d.user.Rules {
-		if rule.Matches(path) {
-			allow = rule.Allow
-		}
-	}
-
-	return allow
-}
-
-func handle(fn handleFunc, prefix string, store *storage.Storage, server *settings.Server) http.Handler {
-	handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
-
-		settings, err := store.Settings.Get()
-		if err != nil {
-			log.Fatalf("ERROR: couldn't get settings: %v\n", err)
-			return
-		}
-
-		status, err := fn(w, r, &data{
-			Runner:   &runner.Runner{Enabled: server.EnableExec, Settings: settings},
-			store:    store,
-			settings: settings,
-			server:   server,
-		})
-
-		if status >= 400 || err != nil {
-			clientIP := realip.FromRequest(r)
-			log.Printf("%s: %v %s %v", r.URL.Path, status, clientIP, err)
-		}
-
-		if status != 0 {
-			txt := http.StatusText(status)
-			http.Error(w, strconv.Itoa(status)+" "+txt, status)
-			return
-		}
-	})
-
-	return stripPrefix(prefix, handler)
-}

backend/http/embed/.gitignore

@@ -0,0 +1 @@
+*

backend/http/http.go

@@ -1,76 +0,0 @@
-package http
-
-import (
-	"io/fs"
-	"net/http"
-
-	"github.com/gorilla/mux"
-
-	"github.com/gtsteffaniak/filebrowser/settings"
-	"github.com/gtsteffaniak/filebrowser/storage"
-)
-
-type modifyRequest struct {
-	What  string   `json:"what"`  // Answer to: what data type?
-	Which []string `json:"which"` // Answer to: which fields?
-}
-
-func NewHandler(
-	imgSvc ImgService,
-	fileCache FileCache,
-	store *storage.Storage,
-	server *settings.Server,
-	assetsFs fs.FS,
-) (http.Handler, error) {
-	server.Clean()
-
-	r := mux.NewRouter()
-	r.Use(func(next http.Handler) http.Handler {
-		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			w.Header().Set("Content-Security-Policy", `default-src 'self'; style-src 'unsafe-inline';`)
-			next.ServeHTTP(w, r)
-		})
-	})
-	index, static := getStaticHandlers(store, server, assetsFs)
-	// NOTE: This fixes the issue where it would redirect if people did not put a
-	// trailing slash in the end. I hate this decision since this allows some awful
-	// URLs https://www.gorillatoolkit.org/pkg/mux#Router.SkipClean
-	r = r.SkipClean(true)
-	monkey := func(fn handleFunc, prefix string) http.Handler {
-		return handle(fn, prefix, store, server)
-	}
-	r.HandleFunc("/health", healthHandler)
-	r.PathPrefix("/static").Handler(static)
-	r.NotFoundHandler = index
-	api := r.PathPrefix("/api").Subrouter()
-	api.Handle("/login", monkey(loginHandler, ""))
-	api.Handle("/signup", monkey(signupHandler, ""))
-	api.Handle("/renew", monkey(renewHandler, ""))
-	users := api.PathPrefix("/users").Subrouter()
-	users.Handle("", monkey(usersGetHandler, "")).Methods("GET")
-	users.Handle("", monkey(userPostHandler, "")).Methods("POST")
-	users.Handle("/{id:[0-9]+}", monkey(userPutHandler, "")).Methods("PUT")
-	users.Handle("/{id:[0-9]+}", monkey(userGetHandler, "")).Methods("GET")
-	users.Handle("/{id:[0-9]+}", monkey(userDeleteHandler, "")).Methods("DELETE")
-	api.PathPrefix("/resources").Handler(monkey(resourceGetHandler, "/api/resources")).Methods("GET")
-	api.PathPrefix("/resources").Handler(monkey(resourceDeleteHandler(fileCache), "/api/resources")).Methods("DELETE")
-	api.PathPrefix("/resources").Handler(monkey(resourcePostHandler(fileCache), "/api/resources")).Methods("POST")
-	api.PathPrefix("/resources").Handler(monkey(resourcePutHandler, "/api/resources")).Methods("PUT")
-	api.PathPrefix("/resources").Handler(monkey(resourcePatchHandler(fileCache), "/api/resources")).Methods("PATCH")
-	api.PathPrefix("/usage").Handler(monkey(diskUsage, "/api/usage")).Methods("GET")
-	api.Path("/shares").Handler(monkey(shareListHandler, "/api/shares")).Methods("GET")
-	api.PathPrefix("/share").Handler(monkey(shareGetsHandler, "/api/share")).Methods("GET")
-	api.PathPrefix("/share").Handler(monkey(sharePostHandler, "/api/share")).Methods("POST")
-	api.PathPrefix("/share").Handler(monkey(shareDeleteHandler, "/api/share")).Methods("DELETE")
-	api.Handle("/settings", monkey(settingsGetHandler, "")).Methods("GET")
-	api.Handle("/settings", monkey(settingsPutHandler, "")).Methods("PUT")
-	api.PathPrefix("/raw").Handler(monkey(rawHandler, "/api/raw")).Methods("GET")
-	api.PathPrefix("/preview/{size}/{path:.*}").
-		Handler(monkey(previewHandler(imgSvc, fileCache, server.EnableThumbnails, server.ResizePreview), "/api/preview")).Methods("GET")
-	api.PathPrefix("/search").Handler(monkey(searchHandler, "/api/search")).Methods("GET")
-	public := api.PathPrefix("/public").Subrouter()
-	public.Handle("/publicUser", monkey(publicUserGetHandler, "")).Methods("GET")
-	public.PathPrefix("/dl").Handler(monkey(publicDlHandler, "/api/public/dl/")).Methods("GET")
-	public.PathPrefix("/share").Handler(monkey(publicShareHandler, "/api/public/share/")).Methods("GET")
-	return stripPrefix(server.BaseURL, r), nil
-}

backend/http/middleware.go

@@ -0,0 +1,291 @@
+package http
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/http"
+	"path/filepath"
+	"time"
+
+	"github.com/golang-jwt/jwt/v4"
+	"github.com/gtsteffaniak/filebrowser/files"
+	"github.com/gtsteffaniak/filebrowser/runner"
+	"github.com/gtsteffaniak/filebrowser/users"
+)
+
+type requestContext struct {
+	user *users.User
+	*runner.Runner
+	raw interface{}
+}
+
+type HttpResponse struct {
+	Status  int    `json:"status,omitempty"`
+	Message string `json:"message,omitempty"`
+	Token   string `json:"token,omitempty"`
+}
+
+// Updated handleFunc to match the new signature
+type handleFunc func(w http.ResponseWriter, r *http.Request, data *requestContext) (int, error)
+
+// Middleware to handle file requests by hash and pass it to the handler
+func withHashFileHelper(fn handleFunc) handleFunc {
+	return func(w http.ResponseWriter, r *http.Request, data *requestContext) (int, error) {
+		path := r.URL.Query().Get("path")
+		hash := r.URL.Query().Get("hash")
+		data.user = &users.PublicUser
+
+		// Get the file link by hash
+		link, err := store.Share.GetByHash(hash)
+		if err != nil {
+			return http.StatusNotFound, err
+		}
+		// Authenticate the share request if needed
+		var status int
+		if link.Hash != "" {
+			status, err = authenticateShareRequest(r, link)
+			if err != nil || status != http.StatusOK {
+				return status, err
+			}
+		}
+		// Retrieve the user (using the public user by default)
+		user := &users.PublicUser
+
+		// Get file information with options
+		file, err := files.FileInfoFaster(files.FileOptions{
+			Path:       filepath.Join(user.Scope, link.Path+"/"+path),
+			Modify:     user.Perm.Modify,
+			Expand:     true,
+			ReadHeader: config.Server.TypeDetectionByHeader,
+			Checker:    user, // Call your checker function here
+			Token:      link.Token,
+		})
+		if err != nil {
+			return errToStatus(err), err
+		}
+
+		// Set the file info in the `data` object
+		data.raw = file
+
+		// Call the next handler with the data
+		return fn(w, r, data)
+	}
+}
+
+// Middleware to ensure the user is an admin
+func withAdminHelper(fn handleFunc) handleFunc {
+	return withUserHelper(func(w http.ResponseWriter, r *http.Request, data *requestContext) (int, error) {
+		// Ensure the user has admin permissions
+		if !data.user.Perm.Admin {
+			return http.StatusForbidden, nil
+		}
+
+		// Proceed to the actual handler if the user is admin
+		return fn(w, r, data)
+	})
+}
+
+// Middleware to retrieve and authenticate user
+func withUserHelper(fn handleFunc) handleFunc {
+	return func(w http.ResponseWriter, r *http.Request, data *requestContext) (int, error) {
+		keyFunc := func(token *jwt.Token) (interface{}, error) {
+			return config.Auth.Key, nil
+		}
+		tokenString, err := extractToken(r)
+		if err != nil {
+			return http.StatusUnauthorized, err
+		}
+
+		var tk users.AuthToken
+		token, err := jwt.ParseWithClaims(tokenString, &tk, keyFunc)
+		if err != nil {
+			return http.StatusUnauthorized, fmt.Errorf("error processing token, %v", err)
+		}
+		if !token.Valid {
+			return http.StatusUnauthorized, fmt.Errorf("invalid token")
+		}
+		if isRevokedApiKey(tk.Key) || tk.Expires < time.Now().Unix() {
+			return http.StatusUnauthorized, fmt.Errorf("token expired or revoked")
+		}
+		// Check if the token is about to expire and send a header to renew it
+		if tk.Expires < time.Now().Add(time.Hour).Unix() {
+			w.Header().Add("X-Renew-Token", "true")
+		}
+		// Retrieve the user from the store and store it in the context
+		data.user, err = store.Users.Get(config.Server.Root, tk.BelongsTo)
+		if err != nil {
+			return http.StatusInternalServerError, err
+		}
+		// Call the handler function, passing in the context
+		return fn(w, r, data)
+	}
+}
+
+// Middleware to ensure the user is either the requested user or an admin
+func withSelfOrAdminHelper(fn handleFunc) handleFunc {
+	return withUserHelper(func(w http.ResponseWriter, r *http.Request, data *requestContext) (int, error) {
+		// Check if the current user is the same as the requested user or if they are an admin
+		if !data.user.Perm.Admin {
+			return http.StatusForbidden, nil
+		}
+		// Call the actual handler function with the updated context
+		return fn(w, r, data)
+	})
+}
+
+func wrapHandler(fn handleFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		data := &requestContext{
+			Runner: &runner.Runner{Enabled: config.Server.EnableExec, Settings: config},
+		}
+
+		// Call the actual handler function and get status code and error
+		status, err := fn(w, r, data)
+
+		// Handle the error case if there is one
+		if err != nil {
+			// Create an error response in JSON format
+			response := &HttpResponse{
+				Status:  status, // Use the status code from the middleware
+				Message: err.Error(),
+			}
+
+			// Set the content type to JSON and status code
+			w.Header().Set("Content-Type", "application/json; charset=utf-8")
+			w.WriteHeader(status)
+
+			// Marshal the error response to JSON
+			errorBytes, marshalErr := json.Marshal(response)
+			if marshalErr != nil {
+				log.Printf("Error marshalling error response: %v", marshalErr)
+				http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+				return
+			}
+
+			// Write the JSON error response
+			if _, writeErr := w.Write(errorBytes); writeErr != nil {
+				log.Printf("Error writing error response: %v", writeErr)
+			}
+			return
+		}
+
+		// No error, proceed to write status if non-zero
+		if status != 0 {
+			w.WriteHeader(status)
+		}
+	}
+}
+
+func withPermShareHelper(fn handleFunc) handleFunc {
+	return withUserHelper(func(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
+		if !d.user.Perm.Share {
+			return http.StatusForbidden, nil
+		}
+		return fn(w, r, d)
+	})
+}
+
+func withPermShare(fn handleFunc) http.HandlerFunc {
+	return wrapHandler(withPermShareHelper(fn))
+}
+
+// Example of wrapping specific middleware functions for use with http.HandleFunc
+func withHashFile(fn handleFunc) http.HandlerFunc {
+	return wrapHandler(withHashFileHelper(fn))
+}
+
+func withAdmin(fn handleFunc) http.HandlerFunc {
+	return wrapHandler(withAdminHelper(fn))
+}
+
+func withUser(fn handleFunc) http.HandlerFunc {
+	return wrapHandler(withUserHelper(fn))
+}
+
+func withSelfOrAdmin(fn handleFunc) http.HandlerFunc {
+	return wrapHandler(withSelfOrAdminHelper(fn))
+}
+
+func muxWithMiddleware(mux *http.ServeMux) *http.ServeMux {
+	wrappedMux := http.NewServeMux()
+	wrappedMux.Handle("/", LoggingMiddleware(mux))
+	return wrappedMux
+}
+
+// ResponseWriterWrapper wraps the standard http.ResponseWriter to capture the status code
+type ResponseWriterWrapper struct {
+	http.ResponseWriter
+	StatusCode  int
+	wroteHeader bool
+}
+
+// WriteHeader captures the status code and ensures it's only written once
+func (w *ResponseWriterWrapper) WriteHeader(statusCode int) {
+	if !w.wroteHeader { // Prevent WriteHeader from being called multiple times
+		if statusCode == 0 {
+			statusCode = http.StatusInternalServerError
+		}
+		w.StatusCode = statusCode
+		w.ResponseWriter.WriteHeader(statusCode)
+		w.wroteHeader = true
+	}
+}
+
+// Write is the method to write the response body and ensure WriteHeader is called
+func (w *ResponseWriterWrapper) Write(b []byte) (int, error) {
+	if !w.wroteHeader { // Default to 200 if WriteHeader wasn't called explicitly
+		w.WriteHeader(http.StatusOK)
+	}
+	return w.ResponseWriter.Write(b)
+}
+
+// LoggingMiddleware logs each request and its status code
+func LoggingMiddleware(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		start := time.Now()
+
+		// Wrap the ResponseWriter to capture the status code
+		wrappedWriter := &ResponseWriterWrapper{ResponseWriter: w, StatusCode: http.StatusOK}
+
+		// Call the next handler
+		next.ServeHTTP(wrappedWriter, r)
+
+		// Determine the color based on the status code
+		color := "\033[32m" // Default green color
+		if wrappedWriter.StatusCode >= 300 && wrappedWriter.StatusCode < 500 {
+			color = "\033[33m" // Yellow for client errors (4xx)
+		} else if wrappedWriter.StatusCode >= 500 {
+			color = "\033[31m" // Red for server errors (5xx)
+		}
+		// Capture the full URL path including the query parameters
+		fullURL := r.URL.Path
+		if r.URL.RawQuery != "" {
+			fullURL += "?" + r.URL.RawQuery
+		}
+
+		// Log the request and its status code
+		log.Printf("%s%-7s | %3d | %-15s | %-12s | \"%s\"%s",
+			color,
+			r.Method,
+			wrappedWriter.StatusCode, // Now capturing the correct status
+			r.RemoteAddr,
+			time.Since(start).String(),
+			fullURL,
+			"\033[0m", // Reset color
+		)
+	})
+}
+
+func renderJSON(w http.ResponseWriter, _ *http.Request, data interface{}) (int, error) {
+	marsh, err := json.Marshal(data)
+	if err != nil {
+		return http.StatusInternalServerError, err
+	}
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+	if _, err := w.Write(marsh); err != nil {
+		return http.StatusInternalServerError, err
+	}
+
+	return 0, nil
+}

backend/http/middleware_test.go

@@ -0,0 +1,252 @@
+package http
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/asdine/storm/v3"
+	"github.com/gtsteffaniak/filebrowser/diskcache"
+	"github.com/gtsteffaniak/filebrowser/img"
+	"github.com/gtsteffaniak/filebrowser/settings"
+	"github.com/gtsteffaniak/filebrowser/share"
+	"github.com/gtsteffaniak/filebrowser/storage"
+	"github.com/gtsteffaniak/filebrowser/storage/bolt"
+	"github.com/gtsteffaniak/filebrowser/users"
+	"github.com/gtsteffaniak/filebrowser/utils"
+)
+
+func setupTestEnv(t *testing.T) {
+	dbPath := filepath.Join(t.TempDir(), "db")
+	db, err := storm.Open(dbPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	authStore, userStore, shareStore, settingsStore, err := bolt.NewStorage(db)
+	if err != nil {
+		t.Fatal(err)
+	}
+	store = &storage.Storage{
+		Auth:     authStore,
+		Users:    userStore,
+		Share:    shareStore,
+		Settings: settingsStore,
+	}
+	fileCache = diskcache.NewNoOp() // mocked
+	imgSvc = img.New(1)             // mocked
+	config = &settings.Config       // mocked
+}
+
+func TestWithAdminHelper(t *testing.T) {
+	setupTestEnv(t)
+	// Mock a user who has admin permissions
+	adminUser := &users.User{
+		ID:       1,
+		Username: "admin",
+		Perm:     users.Permissions{Admin: true}, // Ensure the user is an admin
+	}
+	nonAdminUser := &users.User{
+		ID:       2,
+		Username: "non-admin",
+		Perm:     users.Permissions{Admin: false}, // Non-admin user
+	}
+	// Save the users to the mock database
+	if err := store.Users.Save(adminUser); err != nil {
+		t.Fatal("failed to save admin user:", err)
+	}
+	if err := store.Users.Save(nonAdminUser); err != nil {
+		t.Fatal("failed to save non-admin user:", err)
+	}
+	// Test cases for different scenarios
+	testCases := []struct {
+		name               string
+		expectedStatusCode int
+		user               *users.User
+	}{
+		{
+			name:               "Admin access allowed",
+			expectedStatusCode: http.StatusOK, // Admin should be able to access
+			user:               adminUser,
+		},
+		{
+			name:               "Non-admin access forbidden",
+			expectedStatusCode: http.StatusForbidden, // Non-admin should be forbidden
+			user:               nonAdminUser,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			// Mock the context with the current user
+			data := &requestContext{
+				user: tc.user,
+			}
+			token, err := makeSignedTokenAPI(tc.user, "WEB_TOKEN_"+utils.GenerateRandomHash(4), time.Hour*2, tc.user.Perm)
+			if err != nil {
+				t.Fatalf("Error making token for request: %v", err)
+			}
+
+			// Wrap the usersGetHandler with the middleware
+			handler := withAdminHelper(mockHandler)
+
+			// Create a response recorder to capture the handler's output
+			recorder := httptest.NewRecorder()
+			// Create the request and apply the token as a cookie
+			req, err := http.NewRequest(http.MethodGet, "/users", http.NoBody)
+			if err != nil {
+				t.Fatalf("Error creating request: %v", err)
+			}
+			req.AddCookie(&http.Cookie{
+				Name:  "auth",
+				Value: token.Key,
+			})
+
+			// Call the handler with the test request and mock context
+			status, err := handler(recorder, req, data)
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+
+			// Verify the status code
+			if status != tc.expectedStatusCode {
+				t.Errorf("\"%v\" expected status code %d, got %d", tc.name, tc.expectedStatusCode, status)
+			}
+		})
+	}
+}
+
+func TestPublicShareHandlerAuthentication(t *testing.T) {
+	setupTestEnv(t)
+
+	const passwordBcrypt = "$2y$10$TFAmdCbyd/mEZDe5fUeZJu.MaJQXRTwdqb/IQV.eTn6dWrF58gCSe" // bcrypt hashed password
+
+	testCases := []struct {
+		name               string
+		share              *share.Link
+		token              string
+		password           string
+		extraHeaders       map[string]string
+		expectedStatusCode int
+	}{
+		{
+			name: "Public share, no auth required",
+			share: &share.Link{
+				Hash: "public_hash",
+			},
+			expectedStatusCode: 0, // zero means 200 on helpers
+		},
+		{
+			name: "Private share, no auth provided",
+			share: &share.Link{
+				Hash:         "private_hash",
+				UserID:       1,
+				PasswordHash: passwordBcrypt,
+				Token:        "123",
+			},
+			expectedStatusCode: http.StatusUnauthorized,
+		},
+		{
+			name: "Private share, valid token",
+			share: &share.Link{
+				Hash:         "token_hash",
+				UserID:       1,
+				PasswordHash: passwordBcrypt,
+				Token:        "123",
+			},
+			token:              "123",
+			expectedStatusCode: 0, // zero means 200 on helpers
+		},
+		{
+			name: "Private share, invalid password",
+			share: &share.Link{
+				Hash:         "pw_hash",
+				UserID:       1,
+				PasswordHash: passwordBcrypt,
+				Token:        "123",
+			},
+			extraHeaders: map[string]string{
+				"X-SHARE-PASSWORD": "wrong-password",
+			},
+			expectedStatusCode: http.StatusUnauthorized,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			// Save the share in the mock store
+			if err := store.Share.Save(tc.share); err != nil {
+				t.Fatal("failed to save share:", err)
+			}
+
+			// Create a response recorder to capture handler output
+			recorder := httptest.NewRecorder()
+
+			// Wrap the handler with authentication middleware
+			handler := withHashFileHelper(publicShareHandler)
+			if err := store.Settings.Save(&settings.Settings{
+				Auth: settings.Auth{
+					Key: []byte("key"),
+				},
+			}); err != nil {
+				t.Fatalf("failed to save settings: %v", err)
+			}
+
+			// Prepare the request with query parameters and optional headers
+			req := newTestRequest(t, tc.share.Hash, tc.token, tc.password, tc.extraHeaders)
+
+			// Serve the request
+			status, err := handler(recorder, req, &requestContext{})
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+
+			// Check if the response matches the expected status code
+			if status != tc.expectedStatusCode {
+				t.Errorf("expected status code %d, got %d", tc.expectedStatusCode, status)
+			}
+		})
+	}
+}
+
+// Helper function to create a new HTTP request with optional parameters
+func newTestRequest(t *testing.T, hash, token, password string, headers map[string]string) *http.Request {
+	req := newHTTPRequest(t, hash, func(r *http.Request) {
+		// Set query parameters based on provided values
+		q := r.URL.Query()
+		q.Set("path", "/")
+		q.Set("hash", hash)
+		if token != "" {
+			q.Set("token", token)
+		}
+		if password != "" {
+			q.Set("password", password)
+		}
+		r.URL.RawQuery = q.Encode()
+
+		// Set any extra headers if provided
+		for key, value := range headers {
+			r.Header.Set(key, value)
+		}
+	})
+	return req
+}
+
+func mockHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
+	return http.StatusOK, nil // mock response
+}
+
+// Modify newHTTPRequest to accept the hash and use it in the URL path.
+func newHTTPRequest(t *testing.T, hash string, requestModifiers ...func(*http.Request)) *http.Request {
+	t.Helper()
+	url := "/public/share/" + hash + "/" // Dynamically include the hash in the URL path
+	r, err := http.NewRequest(http.MethodGet, url, http.NoBody)
+	if err != nil {
+		t.Fatalf("failed to create request: %v", err)
+	}
+	for _, modify := range requestModifiers {
+		modify(r)
+	}
+	return r
+}

backend/http/preview.go

@@ -1,4 +1,3 @@
-//go:generate go-enum --sql --marshal --names --file $GOFILE
 package http
 
 import (
@@ -7,21 +6,13 @@ import (
 	"fmt"
 	"io"
 	"net/http"
-
-	"github.com/gorilla/mux"
+	"os"
+	"path/filepath"
 
 	"github.com/gtsteffaniak/filebrowser/files"
 	"github.com/gtsteffaniak/filebrowser/img"
 )
 
-/*
-ENUM(
-thumb
-big
-)
-*/
-type PreviewSize int
-
 type ImgService interface {
 	FormatFromExtension(ext string) (img.Format, error)
 	Resize(ctx context.Context, in io.Reader, width, height int, out io.Writer, options ...img.Option) error
@@ -33,84 +24,93 @@ type FileCache interface {
 	Delete(ctx context.Context, key string) error
 }
 
-func previewHandler(imgSvc ImgService, fileCache FileCache, enableThumbnails, resizePreview bool) handleFunc {
-	return withUser(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
+// previewHandler handles the preview request for images.
+// @Summary Get image preview
+// @Description Returns a preview image based on the requested path and size.
+// @Tags Resources
+// @Accept json
+// @Produce json
+// @Param path query string true "File path of the image to preview"
+// @Param size query string false "Preview size ('small' or 'large'). Default is based on server config."
+// @Success 200 {file} file "Preview image content"
+// @Failure 202 {object} map[string]string "Download permissions required"
+// @Failure 400 {object} map[string]string "Invalid request path"
+// @Failure 404 {object} map[string]string "File not found"
+// @Failure 415 {object} map[string]string "Unsupported file type for preview"
+// @Failure 500 {object} map[string]string "Internal server error"
+// @Router /api/preview [get]
+func previewHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
+	path := r.URL.Query().Get("path")
+	previewSize := r.URL.Query().Get("size")
+	if previewSize != "small" {
+		previewSize = "large"
+	}
+
+	if path == "" {
+		return http.StatusBadRequest, fmt.Errorf("invalid request path")
+	}
+	file, err := files.FileInfoFaster(files.FileOptions{
+		Path:       filepath.Join(d.user.Scope, path),
+		Modify:     d.user.Perm.Modify,
+		Expand:     true,
+		ReadHeader: config.Server.TypeDetectionByHeader,
+		Checker:    d.user,
+	})
+	if err != nil {
+		return errToStatus(err), err
+	}
+	realPath, _, err := files.GetRealPath(file.Path)
+	if err != nil {
+		return http.StatusInternalServerError, err
+	}
+	file.Path = realPath
+	if file.Type == "directory" {
+		return http.StatusBadRequest, fmt.Errorf("can't create preview for directory")
+	}
+	setContentDisposition(w, r, file)
+	if file.Type != "image" {
+		return http.StatusNotImplemented, fmt.Errorf("can't create preview for %s type", file.Type)
+	}
+
+	if (previewSize == "large" && !config.Server.ResizePreview) ||
+		(previewSize == "small" && !config.Server.EnableThumbnails) {
 		if !d.user.Perm.Download {
 			return http.StatusAccepted, nil
 		}
-		vars := mux.Vars(r)
-
-		previewSize, err := ParsePreviewSize(vars["size"])
-		if err != nil {
-			return http.StatusBadRequest, err
-		}
-
-		file, err := files.FileInfoFaster(files.FileOptions{
-			Fs:         d.user.Fs,
-			Path:       "/" + vars["path"],
-			Modify:     d.user.Perm.Modify,
-			Expand:     true,
-			ReadHeader: d.server.TypeDetectionByHeader,
-			Checker:    d,
-		})
-
-		if err != nil {
-			return errToStatus(err), err
-		}
-		setContentDisposition(w, r, file)
-
-		switch file.Type {
-		case "image":
-			return handleImagePreview(w, r, imgSvc, fileCache, file, previewSize, enableThumbnails, resizePreview)
-		default:
-			return http.StatusNotImplemented, fmt.Errorf("can't create preview for %s type", file.Type)
-		}
-	})
-}
-
-func handleImagePreview(
-	w http.ResponseWriter,
-	r *http.Request,
-	imgSvc ImgService,
-	fileCache FileCache,
-	file *files.FileInfo,
-	previewSize PreviewSize,
-	enableThumbnails, resizePreview bool,
-) (int, error) {
-	if (previewSize == PreviewSizeBig && !resizePreview) ||
-		(previewSize == PreviewSizeThumb && !enableThumbnails) {
 		return rawFileHandler(w, r, file)
 	}
-	format, err := imgSvc.FormatFromExtension(file.Extension)
+
+	format, err := imgSvc.FormatFromExtension(filepath.Ext(file.Name))
 	// Unsupported extensions directly return the raw data
 	if err == img.ErrUnsupportedFormat || format == img.FormatGif {
+		if !d.user.Perm.Download {
+			return http.StatusAccepted, nil
+		}
 		return rawFileHandler(w, r, file)
 	}
 	if err != nil {
 		return errToStatus(err), err
 	}
-
 	cacheKey := previewCacheKey(file, previewSize)
 	resizedImage, ok, err := fileCache.Load(r.Context(), cacheKey)
 	if err != nil {
 		return errToStatus(err), err
 	}
+
 	if !ok {
 		resizedImage, err = createPreview(imgSvc, fileCache, file, previewSize)
 		if err != nil {
 			return errToStatus(err), err
 		}
 	}
-
 	w.Header().Set("Cache-Control", "private")
-	http.ServeContent(w, r, file.Name, file.ModTime, bytes.NewReader(resizedImage))
+	http.ServeContent(w, r, file.Path, file.ModTime, bytes.NewReader(resizedImage))
 
 	return 0, nil
 }
 
-func createPreview(imgSvc ImgService, fileCache FileCache,
-	file *files.FileInfo, previewSize PreviewSize) ([]byte, error) {
-	fd, err := file.Fs.Open(file.Path)
+func createPreview(imgSvc ImgService, fileCache FileCache, file *files.FileInfo, previewSize string) ([]byte, error) {
+	fd, err := os.Open(file.Path)
 	if err != nil {
 		return nil, err
 	}
@@ -123,11 +123,11 @@ func createPreview(imgSvc ImgService, fileCache FileCache,
 	)
 
 	switch {
-	case previewSize == PreviewSizeBig:
+	case previewSize == "large":
 		width = 1080
 		height = 1080
 		options = append(options, img.WithMode(img.ResizeModeFit), img.WithQuality(img.QualityMedium))
-	case previewSize == PreviewSizeThumb:
+	case previewSize == "small":
 		width = 256
 		height = 256
 		options = append(options, img.WithMode(img.ResizeModeFill), img.WithQuality(img.QualityLow), img.WithFormat(img.FormatJpeg))
@@ -150,6 +150,7 @@ func createPreview(imgSvc ImgService, fileCache FileCache,
 	return buf.Bytes(), nil
 }
 
-func previewCacheKey(f *files.FileInfo, previewSize PreviewSize) string {
+// Generates a cache key for the preview image
+func previewCacheKey(f *files.FileInfo, previewSize string) string {
 	return fmt.Sprintf("%x%x%x", f.RealPath(), f.ModTime.Unix(), previewSize)
 }

backend/http/preview_enum.go

@@ -1,100 +0,0 @@
-// Code generated by go-enum
-// DO NOT EDIT!
-
-package http
-
-import (
-	"database/sql/driver"
-	"fmt"
-	"strings"
-)
-
-const (
-	// PreviewSizeThumb is a PreviewSize of type Thumb
-	PreviewSizeThumb PreviewSize = iota
-	// PreviewSizeBig is a PreviewSize of type Big
-	PreviewSizeBig
-)
-
-const _PreviewSizeName = "thumbbig"
-
-var _PreviewSizeNames = []string{
-	_PreviewSizeName[0:5],
-	_PreviewSizeName[5:8],
-}
-
-// PreviewSizeNames returns a list of possible string values of PreviewSize.
-func PreviewSizeNames() []string {
-	tmp := make([]string, len(_PreviewSizeNames))
-	copy(tmp, _PreviewSizeNames)
-	return tmp
-}
-
-var _PreviewSizeMap = map[PreviewSize]string{
-	0: _PreviewSizeName[0:5],
-	1: _PreviewSizeName[5:8],
-}
-
-// String implements the Stringer interface.
-func (x PreviewSize) String() string {
-	if str, ok := _PreviewSizeMap[x]; ok {
-		return str
-	}
-	return fmt.Sprintf("PreviewSize(%d)", x)
-}
-
-var _PreviewSizeValue = map[string]PreviewSize{
-	_PreviewSizeName[0:5]: 0,
-	_PreviewSizeName[5:8]: 1,
-}
-
-// ParsePreviewSize attempts to convert a string to a PreviewSize
-func ParsePreviewSize(name string) (PreviewSize, error) {
-	if x, ok := _PreviewSizeValue[name]; ok {
-		return x, nil
-	}
-	return PreviewSize(0), fmt.Errorf("%s is not a valid PreviewSize, try [%s]", name, strings.Join(_PreviewSizeNames, ", "))
-}
-
-// MarshalText implements the text marshaller method
-func (x PreviewSize) MarshalText() ([]byte, error) {
-	return []byte(x.String()), nil
-}
-
-// UnmarshalText implements the text unmarshaller method
-func (x *PreviewSize) UnmarshalText(text []byte) error {
-	name := string(text)
-	tmp, err := ParsePreviewSize(name)
-	if err != nil {
-		return err
-	}
-	*x = tmp
-	return nil
-}
-
-// Scan implements the Scanner interface.
-func (x *PreviewSize) Scan(value interface{}) error {
-	var name string
-
-	switch v := value.(type) {
-	case string:
-		name = v
-	case []byte:
-		name = string(v)
-	case nil:
-		*x = PreviewSize(0)
-		return nil
-	}
-
-	tmp, err := ParsePreviewSize(name)
-	if err != nil {
-		return err
-	}
-	*x = tmp
-	return nil
-}
-
-// Value implements the driver Valuer interface.
-func (x PreviewSize) Value() (driver.Value, error) {
-	return x.String(), nil
-}

backend/http/public.go

@@ -1,112 +1,71 @@
 package http
 
 import (
+	"encoding/json"
 	"errors"
+	"fmt"
 	"net/http"
 	"net/url"
-	"path"
-	"path/filepath"
 	"strings"
 
-	"github.com/spf13/afero"
 	"golang.org/x/crypto/bcrypt"
 
 	"github.com/gtsteffaniak/filebrowser/files"
 	"github.com/gtsteffaniak/filebrowser/settings"
 	"github.com/gtsteffaniak/filebrowser/share"
 	"github.com/gtsteffaniak/filebrowser/users"
+
+	_ "github.com/gtsteffaniak/filebrowser/swagger/docs"
 )
 
-var withHashFile = func(fn handleFunc) handleFunc {
-	return func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
-		id, path := ifPathWithName(r)
-		link, err := d.store.Share.GetByHash(id)
-		if err != nil {
-			return errToStatus(err), err
-		}
-		if link.Hash != "" {
-			status, err := authenticateShareRequest(r, link)
-			if status != 0 || err != nil {
-				return status, err
-			}
-		}
-		d.user = &users.PublicUser
-		if path == "/" {
-			path = link.Path
-		} else if strings.HasPrefix("/"+path, link.Path) {
-			path = "/" + path
-		} else {
-			path = link.Path + "/" + path
-		}
-		sharePath := settings.Config.Server.Root + path
-		lastComponent := filepath.Base(sharePath)
-		basePath := filepath.Dir(sharePath)
-		fsPath := afero.NewBasePathFs(afero.NewOsFs(), basePath)
-		file, err := files.FileInfoFaster(files.FileOptions{
-			Fs:         fsPath,
-			Path:       lastComponent,
-			Modify:     d.user.Perm.Modify,
-			Expand:     true,
-			ReadHeader: d.server.TypeDetectionByHeader,
-			Checker:    d,
-			Token:      link.Token,
-		})
-		if err != nil {
-			return errToStatus(err), err
-		}
-		d.raw = file
-		return fn(w, r, d)
+func publicShareHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
+	file, ok := d.raw.(*files.FileInfo)
+	if !ok {
+		return http.StatusInternalServerError, fmt.Errorf("failed to assert type *files.FileInfo")
 	}
-}
-
-func ifPathWithName(r *http.Request) (id, filePath string) {
-	pathElements := strings.Split(r.URL.Path, "/")
-	id = pathElements[0]
-	allButFirst := path.Join(pathElements[1:]...)
-	if len(pathElements) == 1 {
-		allButFirst = "/"
-	}
-	return id, allButFirst
-}
-
-var publicShareHandler = withHashFile(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
-	file := d.raw.(*files.FileInfo)
 	file.Path = strings.TrimPrefix(file.Path, settings.Config.Server.Root)
-	if file.IsDir {
-		return renderJSON(w, r, file)
-	}
-
 	return renderJSON(w, r, file)
-})
+}
 
-var publicUserGetHandler = func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
+func publicUserGetHandler(w http.ResponseWriter, r *http.Request) {
 	// Call the actual handler logic here (e.g., renderJSON, etc.)
 	// You may need to replace `fn` with the actual handler logic.
-	return renderJSON(w, r, users.PublicUser)
-}
-
-var publicDlHandler = withHashFile(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
-	file := d.raw.(*files.FileInfo)
-	if !file.IsDir {
-		return rawFileHandler(w, r, file)
+	status, err := renderJSON(w, r, users.PublicUser)
+	if err != nil {
+		http.Error(w, http.StatusText(status), status)
 	}
 
-	return rawDirHandler(w, r, d, file)
-})
+}
+
+func publicDlHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
+	file, _ := d.raw.(*files.FileInfo)
+	if file == nil {
+		return http.StatusInternalServerError, fmt.Errorf("failed to assert type files.FileInfo")
+	}
+	if d.user == nil {
+		return http.StatusUnauthorized, fmt.Errorf("failed to get user")
+	}
+
+	if file.Type == "directory" {
+		return rawDirHandler(w, r, d, file)
+	}
+
+	return rawFileHandler(w, r, file)
+}
 
 func authenticateShareRequest(r *http.Request, l *share.Link) (int, error) {
 	if l.PasswordHash == "" {
-		return 0, nil
+		return 200, nil
 	}
 
 	if r.URL.Query().Get("token") == l.Token {
-		return 0, nil
+		return 200, nil
 	}
 
 	password := r.Header.Get("X-SHARE-PASSWORD")
 	password, err := url.QueryUnescape(password)
 	if err != nil {
-		return 0, err
+		return http.StatusUnauthorized, err
 	}
 	if password == "" {
 		return http.StatusUnauthorized, nil
@@ -115,12 +74,25 @@ func authenticateShareRequest(r *http.Request, l *share.Link) (int, error) {
 		if errors.Is(err, bcrypt.ErrMismatchedHashAndPassword) {
 			return http.StatusUnauthorized, nil
 		}
-		return 0, err
+		return 401, err
 	}
-	return 0, nil
+	return 200, nil
 }
 
-func healthHandler(w http.ResponseWriter, _ *http.Request) {
-	w.WriteHeader(http.StatusOK)
-	_, _ = w.Write([]byte(`{"status":"OK"}`))
+// health godoc
+// @Summary Health Check
+// @Schemes
+// @Description Returns the health status of the API.
+// @Tags Health
+// @Accept json
+// @Produce json
+// @Success 200 {object} HttpResponse "successful health check response"
+// @Router /health [get]
+func healthHandler(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "application/json")
+	response := HttpResponse{Message: "ok"}    // Create response with status "ok"
+	err := json.NewEncoder(w).Encode(response) // Encode the response into JSON
+	if err != nil {
+		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+	}
 }

backend/http/public_test.go

@@ -1,136 +0,0 @@
-package http
-
-import (
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"path/filepath"
-	"testing"
-
-	"github.com/asdine/storm/v3"
-	"github.com/spf13/afero"
-
-	"github.com/gtsteffaniak/filebrowser/settings"
-	"github.com/gtsteffaniak/filebrowser/share"
-	"github.com/gtsteffaniak/filebrowser/storage/bolt"
-	"github.com/gtsteffaniak/filebrowser/users"
-)
-
-func TestPublicShareHandlerAuthentication(t *testing.T) {
-	t.Parallel()
-
-	const passwordBcrypt = "$2y$10$TFAmdCbyd/mEZDe5fUeZJu.MaJQXRTwdqb/IQV.eTn6dWrF58gCSe" //nolint:gosec
-	testCases := map[string]struct {
-		share              *share.Link
-		req                *http.Request
-		expectedStatusCode int
-	}{
-		"Public share, no auth required": {
-			share:              &share.Link{Hash: "h"},
-			req:                newHTTPRequest(t),
-			expectedStatusCode: 200,
-		},
-		"Private share, no auth provided, 401": {
-			share:              &share.Link{Hash: "h", UserID: 1, PasswordHash: passwordBcrypt, Token: "123"},
-			req:                newHTTPRequest(t),
-			expectedStatusCode: 401,
-		},
-		"Private share, authentication via token": {
-			share:              &share.Link{Hash: "h", UserID: 1, PasswordHash: passwordBcrypt, Token: "123"},
-			req:                newHTTPRequest(t, func(r *http.Request) { r.URL.RawQuery = "token=123" }),
-			expectedStatusCode: 200,
-		},
-		"Private share, authentication via invalid token, 401": {
-			share:              &share.Link{Hash: "h", UserID: 1, PasswordHash: passwordBcrypt, Token: "123"},
-			req:                newHTTPRequest(t, func(r *http.Request) { r.URL.RawQuery = "token=1234" }),
-			expectedStatusCode: 401,
-		},
-		"Private share, authentication via password": {
-			share:              &share.Link{Hash: "h", UserID: 1, PasswordHash: passwordBcrypt, Token: "123"},
-			req:                newHTTPRequest(t, func(r *http.Request) { r.Header.Set("X-SHARE-PASSWORD", "password") }),
-			expectedStatusCode: 200,
-		},
-		"Private share, authentication via invalid password, 401": {
-			share:              &share.Link{Hash: "h", UserID: 1, PasswordHash: passwordBcrypt, Token: "123"},
-			req:                newHTTPRequest(t, func(r *http.Request) { r.Header.Set("X-SHARE-PASSWORD", "wrong-password") }),
-			expectedStatusCode: 401,
-		},
-	}
-
-	for name, tc := range testCases {
-		for handlerName, handler := range map[string]handleFunc{"public share handler": publicShareHandler, "public dl handler": publicDlHandler} {
-			name, tc, handlerName, handler := name, tc, handlerName, handler
-			t.Run(fmt.Sprintf("%s: %s", handlerName, name), func(t *testing.T) {
-				t.Parallel()
-
-				dbPath := filepath.Join(t.TempDir(), "db")
-				db, err := storm.Open(dbPath)
-				if err != nil {
-					t.Fatalf("failed to open db: %v", err)
-				}
-
-				t.Cleanup(func() {
-					if err := db.Close(); err != nil { //nolint:govet
-						t.Errorf("failed to close db: %v", err)
-					}
-				})
-
-				storage, err := bolt.NewStorage(db)
-				if err != nil {
-					t.Fatalf("failed to get storage: %v", err)
-				}
-				if err := storage.Share.Save(tc.share); err != nil {
-					t.Fatalf("failed to save share: %v", err)
-				}
-				if err := storage.Settings.Save(&settings.Settings{
-					Auth: settings.Auth{
-						Key: []byte("key"),
-					},
-				}); err != nil {
-					t.Fatalf("failed to save settings: %v", err)
-				}
-
-				storage.Users = &customFSUser{
-					Store: storage.Users,
-					fs:    &afero.MemMapFs{},
-				}
-
-				recorder := httptest.NewRecorder()
-				handler := handle(handler, "", storage, &settings.Server{})
-				handler.ServeHTTP(recorder, tc.req)
-				result := recorder.Result()
-				defer result.Body.Close()
-				if result.StatusCode != tc.expectedStatusCode {
-					t.Errorf("expected status code %d, got status code %d", tc.expectedStatusCode, result.StatusCode)
-				}
-			})
-		}
-	}
-}
-
-func newHTTPRequest(t *testing.T, requestModifiers ...func(*http.Request)) *http.Request {
-	t.Helper()
-	r, err := http.NewRequest(http.MethodGet, "h", http.NoBody)
-	if err != nil {
-		t.Fatalf("failed to construct request: %v", err)
-	}
-	for _, modify := range requestModifiers {
-		modify(r)
-	}
-	return r
-}
-
-type customFSUser struct {
-	users.Store
-	fs afero.Fs
-}
-
-func (cu *customFSUser) Get(baseScope string, id interface{}) (*users.User, error) {
-	user, err := cu.Store.Get(baseScope, id)
-	if err != nil {
-		return nil, err
-	}
-	user.Fs = cu.fs
-
-	return user, nil
-}

backend/http/raw.go

@@ -5,6 +5,7 @@ import (
 	"log"
 	"net/http"
 	"net/url"
+	"os"
 	gopath "path"
 	"path/filepath"
 	"strings"
@@ -76,18 +77,34 @@ func setContentDisposition(w http.ResponseWriter, r *http.Request, file *files.F
 	}
 }
 
-var rawHandler = withUser(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
+// rawHandler serves the raw content of a file, multiple files, or directory in various formats.
+// @Summary Get raw content of a file, multiple files, or directory
+// @Description Returns the raw content of a file, multiple files, or a directory. Supports downloading files as archives in various formats.
+// @Tags Resources
+// @Accept json
+// @Produce json
+// @Param path query string true "Path to the file or directory"
+// @Param files query string false "Comma-separated list of specific files within the directory (optional)"
+// @Param inline query bool false "If true, sets 'Content-Disposition' to 'inline'. Otherwise, defaults to 'attachment'."
+// @Param algo query string false "Compression algorithm for archiving multiple files or directories. Options: 'zip', 'tar', 'targz', 'tarbz2', 'tarxz', 'tarlz4', 'tarsz'. Default is 'zip'."
+// @Success 200 {file} file "Raw file or directory content, or archive for multiple files"
+// @Failure 202 {object} map[string]string "Download permissions required"
+// @Failure 400 {object} map[string]string "Invalid request path"
+// @Failure 404 {object} map[string]string "File or directory not found"
+// @Failure 415 {object} map[string]string "Unsupported file type for preview"
+// @Failure 500 {object} map[string]string "Internal server error"
+// @Router /api/raw [get]
+func rawHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
 	if !d.user.Perm.Download {
 		return http.StatusAccepted, nil
 	}
-
+	path := r.URL.Query().Get("path")
 	file, err := files.FileInfoFaster(files.FileOptions{
-		Fs:         d.user.Fs,
-		Path:       r.URL.Path,
+		Path:       filepath.Join(d.user.Scope, path),
 		Modify:     d.user.Perm.Modify,
 		Expand:     false,
-		ReadHeader: d.server.TypeDetectionByHeader,
-		Checker:    d,
+		ReadHeader: config.Server.TypeDetectionByHeader,
+		Checker:    d.user,
 	})
 	if err != nil {
 		return errToStatus(err), err
@@ -96,19 +113,18 @@ var rawHandler = withUser(func(w http.ResponseWriter, r *http.Request, d *data)
 		setContentDisposition(w, r, file)
 		return 0, nil
 	}
-
-	if !file.IsDir {
-		return rawFileHandler(w, r, file)
+	if file.Type == "directory" {
+		return rawDirHandler(w, r, d, file)
 	}
 
-	return rawDirHandler(w, r, d, file)
-})
+	return rawFileHandler(w, r, file)
+}
 
-func addFile(ar archiver.Writer, d *data, path, commonPath string) error {
-	if !d.Check(path) {
+func addFile(ar archiver.Writer, d *requestContext, path, commonPath string) error {
+	if !d.user.Check(path) {
 		return nil
 	}
-	info, err := d.user.Fs.Stat(path)
+	info, err := os.Stat(path)
 	if err != nil {
 		return err
 	}
@@ -117,7 +133,7 @@ func addFile(ar archiver.Writer, d *data, path, commonPath string) error {
 		return nil
 	}
 
-	file, err := d.user.Fs.Open(path)
+	file, err := os.Open(path)
 	if err != nil {
 		return err
 	}
@@ -156,12 +172,11 @@ func addFile(ar archiver.Writer, d *data, path, commonPath string) error {
 	return nil
 }
 
-func rawDirHandler(w http.ResponseWriter, r *http.Request, d *data, file *files.FileInfo) (int, error) {
+func rawDirHandler(w http.ResponseWriter, r *http.Request, d *requestContext, file *files.FileInfo) (int, error) {
 	filenames, err := parseQueryFiles(r, file, d.user)
 	if err != nil {
 		return http.StatusInternalServerError, err
 	}
-
 	extension, ar, err := parseQueryAlgorithm(r)
 	if err != nil {
 		return http.StatusInternalServerError, err
@@ -198,7 +213,8 @@ func rawDirHandler(w http.ResponseWriter, r *http.Request, d *data, file *files.
 }
 
 func rawFileHandler(w http.ResponseWriter, r *http.Request, file *files.FileInfo) (int, error) {
-	fd, err := file.Fs.Open(file.Path)
+	realPath, _, _ := files.GetRealPath(file.Path)
+	fd, err := os.Open(realPath)
 	if err != nil {
 		return http.StatusInternalServerError, err
 	}

backend/http/resource.go

@@ -3,7 +3,6 @@ package http
 import (
 	"context"
 	"fmt"
-	"io"
 	"net/http"
 	"net/url"
 	"os"
@@ -12,28 +11,40 @@ import (
 	"strings"
 
 	"github.com/shirou/gopsutil/v3/disk"
-	"github.com/spf13/afero"
 
 	"github.com/gtsteffaniak/filebrowser/errors"
 	"github.com/gtsteffaniak/filebrowser/files"
-	"github.com/gtsteffaniak/filebrowser/fileutils"
 )
 
-var resourceGetHandler = withUser(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
+// resourceGetHandler retrieves information about a resource.
+// @Summary Get resource information
+// @Description Returns metadata and optionally file contents for a specified resource path.
+// @Tags Resources
+// @Accept json
+// @Produce json
+// @Param path query string true "Path to the resource"
+// @Param source query string false "Name for the desired source, default is used if not provided"
+// @Param content query string false "Include file content if true"
+// @Param checksum query string false "Optional checksum validation"
+// @Success 200 {object} files.FileInfo "Resource metadata"
+// @Failure 404 {object} map[string]string "Resource not found"
+// @Failure 500 {object} map[string]string "Internal server error"
+// @Router /api/resources [get]
+func resourceGetHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
+	// TODO source := r.URL.Query().Get("source")
+	path := r.URL.Query().Get("path")
 	file, err := files.FileInfoFaster(files.FileOptions{
-		Fs:         d.user.Fs,
-		Path:       r.URL.Path,
+		Path:       filepath.Join(d.user.Scope, path),
 		Modify:     d.user.Perm.Modify,
 		Expand:     true,
-		ReadHeader: d.server.TypeDetectionByHeader,
-		Checker:    d,
+		ReadHeader: config.Server.TypeDetectionByHeader,
+		Checker:    d.user,
 		Content:    r.URL.Query().Get("content") == "true",
 	})
 	if err != nil {
 		return errToStatus(err), err
 	}
-	if file.IsDir {
-		file.Listing.Sorting = d.user.Sorting
+	if file.Type == "directory" {
 		return renderJSON(w, r, file)
 	}
 	if checksum := r.URL.Query().Get("checksum"); checksum != "" {
@@ -44,274 +55,259 @@ var resourceGetHandler = withUser(func(w http.ResponseWriter, r *http.Request, d
 			return http.StatusInternalServerError, err
 		}
 	}
-
 	return renderJSON(w, r, file)
-})
 
-func resourceDeleteHandler(fileCache FileCache) handleFunc {
-	return withUser(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
-		if r.URL.Path == "/" || !d.user.Perm.Delete {
-			return http.StatusForbidden, nil
-		}
+}
 
-		file, err := files.FileInfoFaster(files.FileOptions{
-			Fs:         d.user.Fs,
-			Path:       r.URL.Path,
-			Modify:     d.user.Perm.Modify,
-			Expand:     false,
-			ReadHeader: d.server.TypeDetectionByHeader,
-			Checker:    d,
-		})
+// resourceDeleteHandler deletes a resource at a specified path.
+// @Summary Delete a resource
+// @Description Deletes a resource located at the specified path.
+// @Tags Resources
+// @Accept json
+// @Produce json
+// @Param path query string true "Path to the resource"
+// @Param source query string false "Name for the desired source, default is used if not provided"
+// @Success 200 "Resource deleted successfully"
+// @Failure 403 {object} map[string]string "Forbidden"
+// @Failure 404 {object} map[string]string "Resource not found"
+// @Failure 500 {object} map[string]string "Internal server error"
+// @Router /api/resources [delete]
+func resourceDeleteHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
+	// TODO source := r.URL.Query().Get("source")
+	path := r.URL.Query().Get("path")
+	if path == "/" || !d.user.Perm.Delete {
+		return http.StatusForbidden, nil
+	}
+	realPath, isDir, err := files.GetRealPath(d.user.Scope, path)
+	if err != nil {
+		return http.StatusNotFound, err
+	}
+	fileOpts := files.FileOptions{
+		Path:       filepath.Join(d.user.Scope, path),
+		IsDir:      isDir,
+		Modify:     d.user.Perm.Modify,
+		Expand:     false,
+		ReadHeader: config.Server.TypeDetectionByHeader,
+		Checker:    d.user,
+	}
+	file, err := files.FileInfoFaster(fileOpts)
+	if err != nil {
+		return errToStatus(err), err
+	}
+
+	// delete thumbnails
+	err = delThumbs(r.Context(), fileCache, file)
+	if err != nil {
+		return errToStatus(err), err
+	}
+
+	err = files.DeleteFiles(realPath, fileOpts)
+	if err != nil {
+		return errToStatus(err), err
+	}
+	return http.StatusOK, nil
+
+}
+
+// resourcePostHandler creates or uploads a new resource.
+// @Summary Create or upload a resource
+// @Description Creates a new resource or uploads a file at the specified path. Supports file uploads and directory creation.
+// @Tags Resources
+// @Accept json
+// @Produce json
+// @Param path query string true "Path to the resource"
+// @Param source query string false "Name for the desired source, default is used if not provided"
+// @Param override query bool false "Override existing file if true"
+// @Success 200 "Resource created successfully"
+// @Failure 403 {object} map[string]string "Forbidden"
+// @Failure 404 {object} map[string]string "Resource not found"
+// @Failure 409 {object} map[string]string "Conflict - Resource already exists"
+// @Failure 500 {object} map[string]string "Internal server error"
+// @Router /api/resources [post]
+func resourcePostHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
+	// TODO source := r.URL.Query().Get("source")
+	path := r.URL.Query().Get("path")
+	if !d.user.Perm.Create || !d.user.Check(path) {
+		return http.StatusForbidden, nil
+	}
+	fileOpts := files.FileOptions{
+		Path:       filepath.Join(d.user.Scope, path),
+		Modify:     d.user.Perm.Modify,
+		Expand:     false,
+		ReadHeader: config.Server.TypeDetectionByHeader,
+		Checker:    d.user,
+	}
+	// Directories creation on POST.
+	if strings.HasSuffix(path, "/") {
+		err := files.WriteDirectory(fileOpts)
 		if err != nil {
 			return errToStatus(err), err
 		}
+		return http.StatusOK, nil
+	}
+	file, err := files.FileInfoFaster(fileOpts)
+	if err == nil {
+		if r.URL.Query().Get("override") != "true" {
+			return http.StatusConflict, nil
+		}
+
+		// Permission for overwriting the file
+		if !d.user.Perm.Modify {
+			return http.StatusForbidden, nil
+		}
 
-		// delete thumbnails
 		err = delThumbs(r.Context(), fileCache, file)
 		if err != nil {
 			return errToStatus(err), err
 		}
-
-		err = d.RunHook(func() error {
-			return d.user.Fs.RemoveAll(r.URL.Path)
-		}, "delete", r.URL.Path, "", d.user)
-
-		if err != nil {
-			return errToStatus(err), err
-		}
-
-		return http.StatusOK, nil
-	})
+	}
+	err = files.WriteFile(fileOpts, r.Body)
+	return errToStatus(err), err
 }
 
-func resourcePostHandler(fileCache FileCache) handleFunc {
-	return withUser(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
-		if !d.user.Perm.Create || !d.Check(r.URL.Path) {
-			return http.StatusForbidden, nil
-		}
-
-		// Directories creation on POST.
-		if strings.HasSuffix(r.URL.Path, "/") {
-			err := d.user.Fs.MkdirAll(r.URL.Path, 0775) //nolint:gomnd
-			return errToStatus(err), err
-		}
-
-		file, err := files.FileInfoFaster(files.FileOptions{
-			Fs:         d.user.Fs,
-			Path:       r.URL.Path,
-			Modify:     d.user.Perm.Modify,
-			Expand:     false,
-			ReadHeader: d.server.TypeDetectionByHeader,
-			Checker:    d,
-		})
-		if err == nil {
-			if r.URL.Query().Get("override") != "true" {
-				return http.StatusConflict, nil
-			}
-
-			// Permission for overwriting the file
-			if !d.user.Perm.Modify {
-				return http.StatusForbidden, nil
-			}
-
-			err = delThumbs(r.Context(), fileCache, file)
-			if err != nil {
-				return errToStatus(err), err
-			}
-		}
-
-		err = d.RunHook(func() error {
-			info, writeErr := writeFile(d.user.Fs, r.URL.Path, r.Body)
-			if writeErr != nil {
-				return writeErr
-			}
-
-			etag := fmt.Sprintf(`"%x%x"`, info.ModTime().UnixNano(), info.Size())
-			w.Header().Set("ETag", etag)
-			return nil
-		}, "upload", r.URL.Path, "", d.user)
-
-		if err != nil {
-			_ = d.user.Fs.RemoveAll(r.URL.Path)
-		}
-
-		return errToStatus(err), err
-	})
-}
-
-var resourcePutHandler = withUser(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
-	if !d.user.Perm.Modify || !d.Check(r.URL.Path) {
+// resourcePutHandler updates an existing file resource.
+// @Summary Update a file resource
+// @Description Updates an existing file at the specified path.
+// @Tags Resources
+// @Accept json
+// @Produce json
+// @Param path query string true "Path to the resource"
+// @Param source query string false "Name for the desired source, default is used if not provided"
+// @Success 200 "Resource updated successfully"
+// @Failure 403 {object} map[string]string "Forbidden"
+// @Failure 404 {object} map[string]string "Resource not found"
+// @Failure 405 {object} map[string]string "Method not allowed"
+// @Failure 500 {object} map[string]string "Internal server error"
+// @Router /api/resources [put]
+func resourcePutHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
+	// TODO source := r.URL.Query().Get("source")
+	path := r.URL.Query().Get("path")
+	if !d.user.Perm.Modify || !d.user.Check(path) {
 		return http.StatusForbidden, nil
 	}
 
 	// Only allow PUT for files.
-	if strings.HasSuffix(r.URL.Path, "/") {
+	if strings.HasSuffix(path, "/") {
 		return http.StatusMethodNotAllowed, nil
 	}
 
-	exists, err := afero.Exists(d.user.Fs, r.URL.Path)
+	realPath, isDir, err := files.GetRealPath(d.user.Scope, path)
 	if err != nil {
-		return http.StatusInternalServerError, err
+		return http.StatusNotFound, err
 	}
-	if !exists {
-		return http.StatusNotFound, nil
+	fileOpts := files.FileOptions{
+		Path:       realPath,
+		IsDir:      isDir,
+		Modify:     d.user.Perm.Modify,
+		Expand:     false,
+		ReadHeader: config.Server.TypeDetectionByHeader,
+		Checker:    d.user,
 	}
-
-	err = d.RunHook(func() error {
-		info, writeErr := writeFile(d.user.Fs, r.URL.Path, r.Body)
-		if writeErr != nil {
-			return writeErr
-		}
-
-		etag := fmt.Sprintf(`"%x%x"`, info.ModTime().UnixNano(), info.Size())
-		w.Header().Set("ETag", etag)
-		return nil
-	}, "save", r.URL.Path, "", d.user)
+	err = files.WriteFile(fileOpts, r.Body)
 	return errToStatus(err), err
-})
-
-func resourcePatchHandler(fileCache FileCache) handleFunc {
-	return withUser(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
-		src := r.URL.Path
-		dst := r.URL.Query().Get("destination")
-		action := r.URL.Query().Get("action")
-		dst, err := url.QueryUnescape(dst)
-		if !d.Check(src) || !d.Check(dst) {
-			return http.StatusForbidden, nil
-		}
-		if err != nil {
-			return errToStatus(err), err
-		}
-		if dst == "/" || src == "/" {
-			return http.StatusForbidden, nil
-		}
-
-		err = checkParent(src, dst)
-		if err != nil {
-			return http.StatusBadRequest, err
-		}
-
-		override := r.URL.Query().Get("override") == "true"
-		rename := r.URL.Query().Get("rename") == "true"
-		if !override && !rename {
-			if _, err = d.user.Fs.Stat(dst); err == nil {
-				return http.StatusConflict, nil
-			}
-		}
-		if rename {
-			dst = addVersionSuffix(dst, d.user.Fs)
-		}
-
-		// Permission for overwriting the file
-		if override && !d.user.Perm.Modify {
-			return http.StatusForbidden, nil
-		}
-
-		err = d.RunHook(func() error {
-			return patchAction(r.Context(), action, src, dst, d, fileCache)
-		}, action, src, dst, d.user)
-
-		return errToStatus(err), err
-	})
 }
 
-func checkParent(src, dst string) error {
-	rel, err := filepath.Rel(src, dst)
+// resourcePatchHandler performs a patch operation (e.g., move, rename) on a resource.
+// @Summary Patch resource (move/rename)
+// @Description Moves or renames a resource to a new destination.
+// @Tags Resources
+// @Accept json
+// @Produce json
+// @Param from query string true "Path from resource"
+// @Param destination query string true "Destination path for the resource"
+// @Param action query string true "Action to perform (copy, rename)"
+// @Param overwrite query bool false "Overwrite if destination exists"
+// @Param rename query bool false "Rename if destination exists"
+// @Success 200 "Resource moved/renamed successfully"
+// @Failure 403 {object} map[string]string "Forbidden"
+// @Failure 404 {object} map[string]string "Resource not found"
+// @Failure 409 {object} map[string]string "Conflict - Destination exists"
+// @Failure 500 {object} map[string]string "Internal server error"
+// @Router /api/resources [patch]
+func resourcePatchHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
+	// TODO source := r.URL.Query().Get("source")
+	src := r.URL.Query().Get("from")
+	dst := r.URL.Query().Get("destination")
+	action := r.URL.Query().Get("action")
+	dst, err := url.QueryUnescape(dst)
+	if !d.user.Check(src) || !d.user.Check(dst) {
+		return http.StatusForbidden, nil
+	}
 	if err != nil {
-		return err
+		return errToStatus(err), err
+	}
+	if dst == "/" || src == "/" {
+		return http.StatusForbidden, nil
 	}
 
-	rel = filepath.ToSlash(rel)
-	if !strings.HasPrefix(rel, "../") && rel != ".." && rel != "." {
-		return errors.ErrSourceIsParent
+	// check target dir exists
+	parentDir, _, err := files.GetRealPath(d.user.Scope, filepath.Dir(dst))
+	if err != nil {
+		return http.StatusNotFound, err
 	}
+	realDest := parentDir + "/" + filepath.Base(dst)
+	realSrc, isSrcDir, err := files.GetRealPath(d.user.Scope, src)
+	if err != nil {
+		return http.StatusNotFound, err
+	}
+	overwrite := r.URL.Query().Get("overwrite") == "true"
+	rename := r.URL.Query().Get("rename") == "true"
+	if rename {
+		realDest = addVersionSuffix(realDest)
+	}
+	// Permission for overwriting the file
+	if overwrite && !d.user.Perm.Modify {
+		return http.StatusForbidden, nil
+	}
+	err = d.RunHook(func() error {
+		return patchAction(r.Context(), action, realSrc, realDest, d, fileCache, isSrcDir)
+	}, action, realSrc, realDest, d.user)
 
-	return nil
+	return errToStatus(err), err
 }
 
-func addVersionSuffix(source string, fs afero.Fs) string {
+func addVersionSuffix(source string) string {
 	counter := 1
 	dir, name := path.Split(source)
 	ext := filepath.Ext(name)
 	base := strings.TrimSuffix(name, ext)
-
 	for {
-		if _, err := fs.Stat(source); err != nil {
+		if _, err := os.Stat(source); err != nil {
 			break
 		}
 		renamed := fmt.Sprintf("%s(%d)%s", base, counter, ext)
 		source = path.Join(dir, renamed)
 		counter++
 	}
-
 	return source
 }
 
-func writeFile(fs afero.Fs, dst string, in io.Reader) (os.FileInfo, error) {
-	dir, _ := path.Split(dst)
-	err := fs.MkdirAll(dir, 0775) //nolint:gomnd
-	if err != nil {
-		return nil, err
-	}
-
-	file, err := fs.OpenFile(dst, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0775) //nolint:gomnd
-	if err != nil {
-		return nil, err
-	}
-	defer file.Close()
-
-	_, err = io.Copy(file, in)
-	if err != nil {
-		return nil, err
-	}
-
-	// Gets the info about the file.
-	info, err := file.Stat()
-	if err != nil {
-		return nil, err
-	}
-
-	//files.RefreshFileInfo(files.FileOptions{
-	//	Fs: info,
-	//})
-
-	return info, nil
-}
-
 func delThumbs(ctx context.Context, fileCache FileCache, file *files.FileInfo) error {
-	for _, previewSizeName := range PreviewSizeNames() {
-		size, _ := ParsePreviewSize(previewSizeName)
-		if err := fileCache.Delete(ctx, previewCacheKey(file, size)); err != nil {
-			return err
-		}
+	if err := fileCache.Delete(ctx, previewCacheKey(file, "small")); err != nil {
+		return err
 	}
-
 	return nil
 }
 
-func patchAction(ctx context.Context, action, src, dst string, d *data, fileCache FileCache) error {
+func patchAction(ctx context.Context, action, src, dst string, d *requestContext, fileCache FileCache, isSrcDir bool) error {
 	switch action {
 	// TODO: use enum
 	case "copy":
 		if !d.user.Perm.Create {
 			return errors.ErrPermissionDenied
 		}
-
-		return fileutils.Copy(d.user.Fs, src, dst)
-	case "rename":
+		return files.CopyResource(src, dst, isSrcDir)
+	case "rename", "move":
 		if !d.user.Perm.Rename {
 			return errors.ErrPermissionDenied
 		}
-		src = path.Clean("/" + src)
-		dst = path.Clean("/" + dst)
-
 		file, err := files.FileInfoFaster(files.FileOptions{
-			Fs:         d.user.Fs,
 			Path:       src,
+			IsDir:      isSrcDir,
 			Modify:     d.user.Perm.Modify,
 			Expand:     false,
 			ReadHeader: false,
-			Checker:    d,
+			Checker:    d.user,
 		})
 		if err != nil {
 			return err
@@ -322,8 +318,7 @@ func patchAction(ctx context.Context, action, src, dst string, d *data, fileCach
 		if err != nil {
 			return err
 		}
-
-		return fileutils.MoveFile(d.user.Fs, src, dst)
+		return files.MoveResource(src, dst, isSrcDir)
 	default:
 		return fmt.Errorf("unsupported action %s: %w", action, errors.ErrInvalidRequestParams)
 	}
@@ -334,26 +329,33 @@ type DiskUsageResponse struct {
 	Used  uint64 `json:"used"`
 }
 
-var diskUsage = withUser(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
+// diskUsage returns the disk usage information for a given directory.
+// @Summary Get disk usage
+// @Description Returns the total and used disk space for a specified directory.
+// @Tags Resources
+// @Accept json
+// @Produce json
+// @Param source query string false "Name for the desired source, default is used if not provided"
+// @Success 200 {object} DiskUsageResponse "Disk usage details"
+// @Failure 404 {object} map[string]string "Directory not found"
+// @Failure 500 {object} map[string]string "Internal server error"
+// @Router /api/usage [get]
+func diskUsage(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
+	source := r.URL.Query().Get("source")
+	if source == "" {
+		source = "/"
+	}
 	file, err := files.FileInfoFaster(files.FileOptions{
-		Fs:         d.user.Fs,
-		Path:       r.URL.Path,
-		Modify:     d.user.Perm.Modify,
-		Expand:     false,
-		ReadHeader: false,
-		Checker:    d,
+		Path:    source,
+		Checker: d.user,
 	})
 	if err != nil {
 		return errToStatus(err), err
 	}
 	fPath := file.RealPath()
-	if !file.IsDir {
-		return renderJSON(w, r, &DiskUsageResponse{
-			Total: 0,
-			Used:  0,
-		})
+	if file.Type != "directory" {
+		return http.StatusBadRequest, fmt.Errorf("path is not a directory")
 	}
-
 	usage, err := disk.UsageWithContext(r.Context(), fPath)
 	if err != nil {
 		return errToStatus(err), err
@@ -362,4 +364,12 @@ var diskUsage = withUser(func(w http.ResponseWriter, r *http.Request, d *data) (
 		Total: usage.Total,
 		Used:  usage.Used,
 	})
-})
+}
+
+func inspectIndex(w http.ResponseWriter, r *http.Request) {
+	path := r.URL.Query().Get("path")
+	isDir := r.URL.Query().Get("isDir") == "true"
+	index := files.GetIndex(config.Server.Root)
+	info, _ := index.GetReducedMetadata(path, isDir)
+	renderJSON(w, r, info) // nolint:errcheck
+}

backend/http/router.go

@@ -0,0 +1,186 @@
+package http
+
+import (
+	"crypto/tls"
+	"embed"
+	"fmt"
+	"io/fs"
+	"log"
+	"net/http"
+	"os"
+	"text/template"
+
+	"github.com/gtsteffaniak/filebrowser/settings"
+	"github.com/gtsteffaniak/filebrowser/storage"
+	"github.com/gtsteffaniak/filebrowser/version"
+
+	httpSwagger "github.com/swaggo/http-swagger" // http-swagger middleware
+)
+
+// Embed the files in the frontend/dist directory
+//
+//go:embed embed/*
+var assets embed.FS
+
+// Boolean flag to determine whether to use the embedded FS or not
+var embeddedFS = os.Getenv("FILEBROWSER_NO_EMBEDED") != "true"
+
+// Custom dirFS to handle both embedded and non-embedded file systems
+type dirFS struct {
+	http.Dir
+}
+
+// Implement the Open method for dirFS, which wraps http.Dir
+func (d dirFS) Open(name string) (fs.File, error) {
+	return d.Dir.Open(name)
+}
+
+var (
+	store     *storage.Storage
+	config    *settings.Settings
+	fileCache FileCache
+	imgSvc    ImgService
+	assetFs   fs.FS
+)
+
+func StartHttp(Service ImgService, storage *storage.Storage, cache FileCache) {
+
+	store = storage
+	fileCache = cache
+	imgSvc = Service
+	config = &settings.Config
+
+	var err error
+
+	if embeddedFS {
+		// Embedded mode: Serve files from the embedded assets
+		assetFs, err = fs.Sub(assets, "embed")
+		if err != nil {
+			log.Fatal("Could not embed frontend. Does dist exist?")
+		}
+	} else {
+		assetFs = dirFS{Dir: http.Dir("http/dist")}
+	}
+
+	templateRenderer = &TemplateRenderer{
+		templates: template.Must(template.ParseFS(assetFs, "public/index.html")),
+	}
+
+	router := http.NewServeMux()
+	// API group routing
+	api := http.NewServeMux()
+
+	// User routes
+	api.HandleFunc("GET /users", withUser(userGetHandler))
+	api.HandleFunc("POST /users", withSelfOrAdmin(usersPostHandler))
+	api.HandleFunc("PUT /users", withUser(userPutHandler))
+	api.HandleFunc("DELETE /users", withSelfOrAdmin(userDeleteHandler))
+
+	// Auth routes
+	api.HandleFunc("POST /auth/login", loginHandler)
+	api.HandleFunc("GET /auth/signup", signupHandler)
+	api.HandleFunc("POST /auth/renew", withUser(renewHandler))
+	api.HandleFunc("PUT /auth/token", withUser(createApiKeyHandler))
+	api.HandleFunc("GET /auth/token", withUser(createApiKeyHandler))
+	api.HandleFunc("DELETE /auth/token", withUser(deleteApiKeyHandler))
+	api.HandleFunc("GET /auth/tokens", withUser(listApiKeysHandler))
+
+	// Resources routes
+	api.HandleFunc("GET /resources", withUser(resourceGetHandler))
+	api.HandleFunc("DELETE /resources", withUser(resourceDeleteHandler))
+	api.HandleFunc("POST /resources", withUser(resourcePostHandler))
+	api.HandleFunc("PUT /resources", withUser(resourcePutHandler))
+	api.HandleFunc("PATCH /resources", withUser(resourcePatchHandler))
+	api.HandleFunc("GET /usage", withUser(diskUsage))
+	api.HandleFunc("GET /raw", withUser(rawHandler))
+	api.HandleFunc("GET /preview", withUser(previewHandler))
+	if version.Version == "testing" || version.Version == "untracked" {
+		api.HandleFunc("GET /inspectIndex", inspectIndex)
+	}
+
+	// Share routes
+	api.HandleFunc("GET /shares", withPermShare(shareListHandler))
+	api.HandleFunc("GET /share", withPermShare(shareGetsHandler))
+	api.HandleFunc("POST /share", withPermShare(sharePostHandler))
+	api.HandleFunc("DELETE /share", withPermShare(shareDeleteHandler))
+
+	// Public routes
+	api.HandleFunc("GET /public/publicUser", publicUserGetHandler)
+	api.HandleFunc("GET /public/dl", withHashFile(publicDlHandler))
+	api.HandleFunc("GET /public/share", withHashFile(publicShareHandler))
+
+	// Settings routes
+	api.HandleFunc("GET /settings", withAdmin(settingsGetHandler))
+	api.HandleFunc("PUT /settings", withAdmin(settingsPutHandler))
+
+	api.HandleFunc("GET /search", withUser(searchHandler))
+	apiPath := config.Server.BaseURL + "api"
+	router.Handle(apiPath+"/", http.StripPrefix(apiPath, api))
+
+	// Static and index file handlers
+	router.HandleFunc(fmt.Sprintf("GET %vstatic/", config.Server.BaseURL), staticFilesHandler)
+	router.HandleFunc(config.Server.BaseURL, indexHandler)
+
+	// health
+	router.HandleFunc(fmt.Sprintf("GET %vhealth/", config.Server.BaseURL), healthHandler)
+
+	// Swagger
+	router.Handle(fmt.Sprintf("%vswagger/", config.Server.BaseURL),
+		httpSwagger.Handler(
+			httpSwagger.URL(config.Server.BaseURL+"swagger/doc.json"), //The url pointing to API definition
+			httpSwagger.DeepLinking(true),
+			httpSwagger.DocExpansion("none"),
+			httpSwagger.DomID("swagger-ui"),
+		),
+	)
+
+	var scheme string
+	port := ""
+
+	// Determine whether to use HTTPS (TLS) or HTTP
+	if config.Server.TLSCert != "" && config.Server.TLSKey != "" {
+		// Load the TLS certificate and key
+		cer, err := tls.LoadX509KeyPair(config.Server.TLSCert, config.Server.TLSKey)
+		if err != nil {
+			log.Fatalf("could not load certificate: %v", err)
+		}
+
+		// Create a custom TLS listener
+		tlsConfig := &tls.Config{
+			MinVersion:   tls.VersionTLS12,
+			Certificates: []tls.Certificate{cer},
+		}
+
+		// Set HTTPS scheme and default port for TLS
+		scheme = "https"
+
+		// Listen on TCP and wrap with TLS
+		listener, err := tls.Listen("tcp", fmt.Sprintf(":%v", config.Server.Port), tlsConfig)
+		if err != nil {
+			log.Fatalf("could not start TLS server: %v", err)
+		}
+		if config.Server.Port != 443 {
+			port = fmt.Sprintf(":%d", config.Server.Port)
+		}
+		// Build the full URL with host and port
+		fullURL := fmt.Sprintf("%s://localhost%s%s", scheme, port, config.Server.BaseURL)
+		log.Printf("Running at               : %s", fullURL)
+		err = http.Serve(listener, muxWithMiddleware(router))
+		if err != nil {
+			log.Fatalf("could not start server: %v", err)
+		}
+	} else {
+		// Set HTTP scheme and the default port for HTTP
+		scheme = "http"
+		if config.Server.Port != 443 {
+			port = fmt.Sprintf(":%d", config.Server.Port)
+		}
+		// Build the full URL with host and port
+		fullURL := fmt.Sprintf("%s://localhost%s%s", scheme, port, config.Server.BaseURL)
+		log.Printf("Running at               : %s", fullURL)
+		err := http.ListenAndServe(fmt.Sprintf(":%v", config.Server.Port), muxWithMiddleware(router))
+		if err != nil {
+			log.Fatalf("could not start server: %v", err)
+		}
+	}
+}

backend/http/search.go

@@ -8,29 +8,63 @@ import (
 	"github.com/gtsteffaniak/filebrowser/settings"
 )
 
-var searchHandler = withUser(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
-	response := []map[string]interface{}{}
+// searchHandler handles search requests for files based on the provided query.
+//
+// This endpoint processes a search query, retrieves relevant file paths, and
+// returns a JSON response with the search results. The search is performed
+// against the file index, which is built from the root directory specified in
+// the server's configuration. The results are filtered based on the user's scope.
+//
+// The handler expects the following headers in the request:
+// - SessionId: A unique identifier for the user's session.
+// - UserScope: The scope of the user, which influences the search context.
+//
+// The request URL should include a query parameter named `query` that specifies
+// the search terms to use. The response will include an array of searchResponse objects
+// containing the path, type, and dir status.
+//
+// Example request:
+//
+//	GET api/search?query=myfile
+//
+// Example response:
+// [
+//
+//	{
+//	    "path": "/path/to/myfile.txt",
+//	    "type": "text"
+//	},
+//	{
+//	    "path": "/path/to/mydir/",
+//	    "type": "directory"
+//	}
+//
+// ]
+//
+// @Summary Search Files
+// @Description Searches for files matching the provided query. Returns file paths and metadata based on the user's session and scope.
+// @Tags Search
+// @Accept json
+// @Produce json
+// @Param query query string true "Search query"
+// @Param scope query string false "path within user scope to search, for example '/first/second' to search within the second directory only"
+// @Param SessionId header string false "User session ID, add unique value to prevent collisions"
+// @Success 200 {array} files.searchResult "List of search results"
+// @Failure 400 {object} map[string]string "Bad Request"
+// @Router /api/search [get]
+func searchHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
 	query := r.URL.Query().Get("query")
+	searchScope := strings.TrimPrefix(r.URL.Query().Get("scope"), ".")
+	searchScope = strings.TrimPrefix(searchScope, "/")
 	// Retrieve the User-Agent and X-Auth headers from the request
 	sessionId := r.Header.Get("SessionId")
-	userScope := r.Header.Get("UserScope")
 	index := files.GetIndex(settings.Config.Server.Root)
-	combinedScope := strings.TrimPrefix(userScope+r.URL.Path, ".")
-	results, fileTypes := index.Search(query, combinedScope, sessionId)
-	for _, path := range results {
-		responseObj := map[string]interface{}{
-			"path": path,
-			"dir":  true,
-		}
-		if _, ok := fileTypes[path]; ok {
-			responseObj["dir"] = false
-			for filterType, value := range fileTypes[path] {
-				if value {
-					responseObj[filterType] = value
-				}
-			}
-		}
-		response = append(response, responseObj)
-	}
+	userScope := strings.TrimPrefix(d.user.Scope, ".")
+	combinedScope := strings.TrimPrefix(userScope+"/"+searchScope, "/")
+
+	// Perform the search using the provided query and user scope
+	response := index.Search(query, combinedScope, sessionId)
+	// Set the Content-Type header to application/json
+	w.Header().Set("Content-Type", "application/json")
 	return renderJSON(w, r, response)
-})
+}

backend/http/settings.go

@@ -4,8 +4,8 @@ import (
 	"encoding/json"
 	"net/http"
 
-	"github.com/gtsteffaniak/filebrowser/rules"
 	"github.com/gtsteffaniak/filebrowser/settings"
+	"github.com/gtsteffaniak/filebrowser/users"
 )
 
 type settingsData struct {
@@ -13,41 +13,56 @@ type settingsData struct {
 	CreateUserDir    bool                  `json:"createUserDir"`
 	UserHomeBasePath string                `json:"userHomeBasePath"`
 	Defaults         settings.UserDefaults `json:"defaults"`
-	Rules            []rules.Rule          `json:"rules"`
+	Rules            []users.Rule          `json:"rules"`
 	Frontend         settings.Frontend     `json:"frontend"`
-	Shell            []string              `json:"shell"`
 	Commands         map[string][]string   `json:"commands"`
 }
 
-var settingsGetHandler = withAdmin(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
+// settingsGetHandler retrieves the current system settings.
+// @Summary Get system settings
+// @Description Returns the current configuration settings for signup, user directories, rules, frontend, and commands.
+// @Tags Settings
+// @Accept json
+// @Produce json
+// @Success 200 {object} settingsData "System settings data"
+// @Router /api/settings [get]
+func settingsGetHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
 	data := &settingsData{
-		Signup:           settings.Config.Auth.Signup,
-		CreateUserDir:    settings.Config.Server.CreateUserDir,
-		UserHomeBasePath: settings.Config.Server.UserHomeBasePath,
-		Defaults:         d.settings.UserDefaults,
-		Rules:            d.settings.Rules,
-		Frontend:         d.settings.Frontend,
-		Shell:            d.settings.Shell,
-		Commands:         d.settings.Commands,
+		Signup:           config.Auth.Signup,
+		CreateUserDir:    config.Server.CreateUserDir,
+		UserHomeBasePath: config.Server.UserHomeBasePath,
+		Defaults:         config.UserDefaults,
+		Rules:            config.Rules,
+		Frontend:         config.Frontend,
 	}
 
 	return renderJSON(w, r, data)
-})
+}
 
-var settingsPutHandler = withAdmin(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
+// settingsPutHandler updates the system settings.
+// @Summary Update system settings
+// @Description Updates the system configuration settings for signup, user directories, rules, frontend, and commands.
+// @Tags Settings
+// @Accept json
+// @Produce json
+// @Param body body settingsData true "Settings data to update"
+// @Success 200 "Settings updated successfully"
+// @Failure 400 {object} map[string]string "Bad request - failed to decode body"
+// @Failure 500 {object} map[string]string "Internal server error"
+// @Router /api/settings [put]
+func settingsPutHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
 	req := &settingsData{}
 	err := json.NewDecoder(r.Body).Decode(req)
 	if err != nil {
 		return http.StatusBadRequest, err
 	}
 
-	d.settings.Server.CreateUserDir = req.CreateUserDir
-	d.settings.Server.UserHomeBasePath = req.UserHomeBasePath
-	d.settings.UserDefaults = req.Defaults
-	d.settings.Rules = req.Rules
-	d.settings.Frontend = req.Frontend
-	d.settings.Shell = req.Shell
-	d.settings.Commands = req.Commands
-	err = d.store.Settings.Save(d.settings)
+	config.Server.CreateUserDir = req.CreateUserDir
+	config.Server.UserHomeBasePath = req.UserHomeBasePath
+	config.UserDefaults = req.Defaults
+	config.Rules = req.Rules
+	config.Frontend = req.Frontend
+	config.Auth.Signup = req.Signup
+	err = store.Settings.Save(config)
 	return errToStatus(err), err
-})
+}

backend/http/share.go

@@ -8,7 +8,6 @@ import (
 	"net/http"
 	"sort"
 	"strconv"
-	"strings"
 	"time"
 
 	"golang.org/x/crypto/bcrypt"
@@ -17,24 +16,24 @@ import (
 	"github.com/gtsteffaniak/filebrowser/share"
 )
 
-func withPermShare(fn handleFunc) handleFunc {
-	return withUser(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
-		if !d.user.Perm.Share {
-			return http.StatusForbidden, nil
-		}
-		return fn(w, r, d)
-	})
-}
-
-var shareListHandler = withPermShare(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
+// shareListHandler returns a list of all share links.
+// @Summary List share links
+// @Description Returns a list of share links for the current user, or all links if the user is an admin.
+// @Tags Shares
+// @Accept json
+// @Produce json
+// @Success 200 {array} share.Link "List of share links"
+// @Failure 500 {object} map[string]string "Internal server error"
+// @Router /api/shares [get]
+func shareListHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
 	var (
 		s   []*share.Link
 		err error
 	)
 	if d.user.Perm.Admin {
-		s, err = d.store.Share.All()
+		s, err = store.Share.All()
 	} else {
-		s, err = d.store.Share.FindByUserID(d.user.ID)
+		s, err = store.Share.FindByUserID(d.user.ID)
 	}
 	if err == errors.ErrNotExist {
 		return renderJSON(w, r, []*share.Link{})
@@ -51,39 +50,68 @@ var shareListHandler = withPermShare(func(w http.ResponseWriter, r *http.Request
 		return s[i].Expire < s[j].Expire
 	})
 	return renderJSON(w, r, s)
-})
+}
 
-var shareGetsHandler = withPermShare(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
-	s, err := d.store.Share.Gets(r.URL.Path, d.user.ID)
+// shareGetsHandler retrieves share links for a specific resource path.
+// @Summary Get share links by path
+// @Description Retrieves all share links associated with a specific resource path for the current user.
+// @Tags Shares
+// @Accept json
+// @Produce json
+// @Param path query string true "Resource path for which to retrieve share links"
+// @Success 200 {array} share.Link "List of share links for the specified path"
+// @Failure 500 {object} map[string]string "Internal server error"
+// @Router /api/share [get]
+func shareGetsHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
+	path := r.URL.Query().Get("path")
+	s, err := store.Share.Gets(path, d.user.ID)
 	if err == errors.ErrNotExist {
 		return renderJSON(w, r, []*share.Link{})
 	}
-
 	if err != nil {
 		return http.StatusInternalServerError, err
 	}
-
 	return renderJSON(w, r, s)
-})
+}
 
-var shareDeleteHandler = withPermShare(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
-	hash := strings.TrimSuffix(r.URL.Path, "/")
-	hash = strings.TrimPrefix(hash, "/")
+// shareDeleteHandler deletes a specific share link by its hash.
+// @Summary Delete a share link
+// @Description Deletes a share link specified by its hash.
+// @Tags Shares
+// @Accept json
+// @Produce json
+// @Param hash path string true "Hash of the share link to delete"
+// @Success 200 "Share link deleted successfully"
+// @Failure 400 {object} map[string]string "Bad request - missing or invalid hash"
+// @Failure 500 {object} map[string]string "Internal server error"
+// @Router /api/shares/{hash} [delete]
+func shareDeleteHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
+	hash := r.URL.Query().Get("hash")
 
 	if hash == "" {
 		return http.StatusBadRequest, nil
 	}
 
-	err := d.store.Share.Delete(hash)
+	err := store.Share.Delete(hash)
 	if err != nil {
 		return errToStatus(err), err
 	}
 
 	return errToStatus(err), err
-})
-
-var sharePostHandler = withPermShare(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
+}
 
+// sharePostHandler creates a new share link.
+// @Summary Create a share link
+// @Description Creates a new share link with an optional expiration time and password protection.
+// @Tags Shares
+// @Accept json
+// @Produce json
+// @Param body body share.CreateBody true "Share link creation parameters"
+// @Success 200 {object} share.Link "Created share link"
+// @Failure 400 {object} map[string]string "Bad request - failed to decode body"
+// @Failure 500 {object} map[string]string "Internal server error"
+// @Router /api/shares [post]
+func sharePostHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
 	var s *share.Link
 	var body share.CreateBody
 	if r.Body != nil {
@@ -93,14 +121,11 @@ var sharePostHandler = withPermShare(func(w http.ResponseWriter, r *http.Request
 		defer r.Body.Close()
 	}
 
-	bytes := make([]byte, 6) //nolint:gomnd
-	_, err := rand.Read(bytes)
+	secure_hash, err := generateShortUUID()
 	if err != nil {
 		return http.StatusInternalServerError, err
 	}
 
-	str := base64.URLEncoding.EncodeToString(bytes)
-
 	var expire int64 = 0
 
 	if body.Expires != "" {
@@ -139,24 +164,24 @@ var sharePostHandler = withPermShare(func(w http.ResponseWriter, r *http.Request
 		token = base64.URLEncoding.EncodeToString(tokenBuffer)
 		stringHash = string(hash)
 	}
+	path := r.URL.Query().Get("path")
 	s = &share.Link{
-		Path:         strings.TrimSuffix(r.URL.Path, "/"),
-		Hash:         str,
+		Path:         path,
+		Hash:         secure_hash,
 		Expire:       expire,
 		UserID:       d.user.ID,
 		PasswordHash: stringHash,
 		Token:        token,
 	}
 
-	if err := d.store.Share.Save(s); err != nil {
+	if err := store.Share.Save(s); err != nil {
 		return http.StatusInternalServerError, err
 	}
 
 	return renderJSON(w, r, s)
-})
+}
 
 func getSharePasswordHash(body share.CreateBody) (data []byte, statuscode int, err error) {
-
 	if body.Password == "" {
 		return nil, 0, nil
 	}
@@ -168,3 +193,18 @@ func getSharePasswordHash(body share.CreateBody) (data []byte, statuscode int, e
 
 	return hash, 0, nil
 }
+
+func generateShortUUID() (string, error) {
+	// Generate 16 random bytes (128 bits of entropy)
+	bytes := make([]byte, 16)
+	_, err := rand.Read(bytes)
+	if err != nil {
+		return "", err
+	}
+
+	// Encode the bytes to a URL-safe base64 string
+	uuid := base64.RawURLEncoding.EncodeToString(bytes)
+
+	// Trim the length to 22 characters for a shorter ID
+	return uuid[:22], nil
+}

backend/http/static.go

@@ -14,40 +14,58 @@ import (
 
 	"github.com/gtsteffaniak/filebrowser/auth"
 	"github.com/gtsteffaniak/filebrowser/settings"
-	"github.com/gtsteffaniak/filebrowser/storage"
 	"github.com/gtsteffaniak/filebrowser/version"
 )
 
-func handleWithStaticData(w http.ResponseWriter, _ *http.Request, d *data, fSys fs.FS, file, contentType string) (int, error) {
+var templateRenderer *TemplateRenderer
+
+type TemplateRenderer struct {
+	templates *template.Template
+}
+
+// Render renders a template document with headers and data
+func (t *TemplateRenderer) Render(w http.ResponseWriter, name string, data interface{}) error {
+	// Set headers
+	w.Header().Set("Cache-Control", "no-cache, private, max-age=0")
+	w.Header().Set("Pragma", "no-cache")
+	w.Header().Set("X-Accel-Expires", "0")
+	w.Header().Set("Transfer-Encoding", "identity")
+	// Execute the template with the provided data
+	return t.templates.ExecuteTemplate(w, name, data)
+}
+
+func handleWithStaticData(w http.ResponseWriter, r *http.Request, file, contentType string) {
 	w.Header().Set("Content-Type", contentType)
 
-	auther, err := d.store.Auth.Get(d.settings.Auth.Method)
+	auther, err := store.Auth.Get(config.Auth.Method)
 	if err != nil {
-		return http.StatusInternalServerError, err
+		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+		return
 	}
 
 	data := map[string]interface{}{
-		"Name":                  d.settings.Frontend.Name,
-		"DisableExternal":       d.settings.Frontend.DisableExternal,
-		"DisableUsedPercentage": d.settings.Frontend.DisableUsedPercentage,
+		"Name":                  config.Frontend.Name,
+		"DisableExternal":       config.Frontend.DisableExternal,
+		"DisableUsedPercentage": config.Frontend.DisableUsedPercentage,
 		"darkMode":              settings.Config.UserDefaults.DarkMode,
-		"Color":                 d.settings.Frontend.Color,
-		"BaseURL":               d.server.BaseURL,
+		"Color":                 config.Frontend.Color,
+		"BaseURL":               config.Server.BaseURL,
 		"Version":               version.Version,
-		"StaticURL":             path.Join(d.server.BaseURL, "/static"),
+		"CommitSHA":             version.CommitSHA,
+		"StaticURL":             path.Join(config.Server.BaseURL, "static"),
 		"Signup":                settings.Config.Auth.Signup,
-		"NoAuth":                d.settings.Auth.Method == "noauth",
-		"AuthMethod":            d.settings.Auth.Method,
+		"NoAuth":                config.Auth.Method == "noauth",
+		"AuthMethod":            config.Auth.Method,
 		"LoginPage":             auther.LoginPage(),
 		"CSS":                   false,
 		"ReCaptcha":             false,
-		"EnableThumbs":          d.server.EnableThumbnails,
-		"ResizePreview":         d.server.ResizePreview,
-		"EnableExec":            d.server.EnableExec,
+		"EnableThumbs":          config.Server.EnableThumbnails,
+		"ResizePreview":         config.Server.ResizePreview,
+		"EnableExec":            config.Server.EnableExec,
 	}
 
-	if d.settings.Frontend.Files != "" {
-		fPath := filepath.Join(d.settings.Frontend.Files, "custom.css")
+	if config.Frontend.Files != "" {
+		fPath := filepath.Join(config.Frontend.Files, "custom.css")
 		_, err := os.Stat(fPath) //nolint:govet
 
 		if err != nil && !os.IsNotExist(err) {
@@ -59,12 +77,19 @@ func handleWithStaticData(w http.ResponseWriter, _ *http.Request, d *data, fSys
 		}
 	}
 
-	if d.settings.Auth.Method == "password" {
-		raw, err := d.store.Auth.Get(d.settings.Auth.Method) //nolint:govet
+	if config.Auth.Method == "password" {
+		raw, err := store.Auth.Get(config.Auth.Method) //nolint:govet
 		if err != nil {
-			return http.StatusInternalServerError, err
+			http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+			return
 		}
-		auther := raw.(*auth.JSONAuth)
+
+		auther, ok := raw.(*auth.JSONAuth)
+		if !ok {
+			http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+			return
+		}
+
 		if auther.ReCaptcha != nil {
 			data["ReCaptcha"] = auther.ReCaptcha.Key != "" && auther.ReCaptcha.Secret != ""
 			data["ReCaptchaHost"] = auther.ReCaptcha.Host
@@ -74,77 +99,47 @@ func handleWithStaticData(w http.ResponseWriter, _ *http.Request, d *data, fSys
 
 	b, err := json.Marshal(data)
 	if err != nil {
-		return http.StatusInternalServerError, err
+		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+		return
 	}
 
-	data["Json"] = strings.ReplaceAll(string(b), `'`, `\'`)
+	data["globalVars"] = strings.ReplaceAll(string(b), `'`, `\'`)
 
-	fileContents, err := fs.ReadFile(fSys, file)
-	if err != nil {
-		if err == os.ErrNotExist {
-			return http.StatusNotFound, err
-		}
-		return http.StatusInternalServerError, err
+	// Render the template with global variables
+	if err := templateRenderer.Render(w, file, data); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
 	}
-	index := template.Must(template.New("index").Delims("[{[", "]}]").Parse(string(fileContents)))
-	err = index.Execute(w, data)
-	if err != nil {
-		return http.StatusInternalServerError, err
-	}
-
-	return 0, nil
 }
 
-func getStaticHandlers(store *storage.Storage, server *settings.Server, assetsFs fs.FS) (index, static http.Handler) {
-	index = handle(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
-		if r.Method != http.MethodGet {
-			return http.StatusNotFound, nil
-		}
-
-		w.Header().Set("x-xss-protection", "1; mode=block")
-		return handleWithStaticData(w, r, d, assetsFs, "public/index.html", "text/html; charset=utf-8")
-	}, "", store, server)
-
-	static = handle(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
-		if r.Method != http.MethodGet {
-			return http.StatusNotFound, nil
-		}
-
-		const maxAge = 86400 // 1 day
-		w.Header().Set("Cache-Control", fmt.Sprintf("public, max-age=%v", maxAge))
-
-		if d.settings.Frontend.Files != "" {
-			if strings.HasPrefix(r.URL.Path, "img/") {
-				fPath := filepath.Join(d.settings.Frontend.Files, r.URL.Path)
-				if _, err := os.Stat(fPath); err == nil {
-					http.ServeFile(w, r, fPath)
-					return 0, nil
-				}
-			} else if r.URL.Path == "custom.css" && d.settings.Frontend.Files != "" {
-				http.ServeFile(w, r, filepath.Join(d.settings.Frontend.Files, "custom.css"))
-				return 0, nil
-			}
-		}
-
-		if !strings.HasSuffix(r.URL.Path, ".js") {
-			http.FileServer(http.FS(assetsFs)).ServeHTTP(w, r)
-			return 0, nil
-		}
-
-		fileContents, err := fs.ReadFile(assetsFs, r.URL.Path+".gz")
-		if err != nil {
-			return http.StatusNotFound, err
-		}
-
-		w.Header().Set("Content-Encoding", "gzip")
+func staticFilesHandler(w http.ResponseWriter, r *http.Request) {
+	const maxAge = 86400 // 1 day
+	w.Header().Set("Cache-Control", fmt.Sprintf("public, max-age=%v", maxAge))
+	w.Header().Set("Content-Security-Policy", `default-src 'self'; style-src 'unsafe-inline';`)
+	// Remove "/static/" from the request path
+	adjustedPath := strings.TrimPrefix(r.URL.Path, fmt.Sprintf("%vstatic/", config.Server.BaseURL))
+	adjustedCompressed := adjustedPath + ".gz"
+	if strings.HasSuffix(adjustedPath, ".js") {
 		w.Header().Set("Content-Type", "application/javascript; charset=utf-8") // Set the correct MIME type for JavaScript files
-
-		if _, err := w.Write(fileContents); err != nil {
-			return http.StatusInternalServerError, err
+	}
+	// Check if the gzipped version of the file exists
+	fileContents, err := fs.ReadFile(assetFs, adjustedCompressed)
+	if err == nil {
+		w.Header().Set("Content-Encoding", "gzip") // Let the browser know the file is compressed
+		status, err := w.Write(fileContents)       // Write the gzipped file content to the response
+		if err != nil {
+			http.Error(w, http.StatusText(status), status)
 		}
-
-		return 0, nil
-	}, "/static/", store, server)
-
-	return index, static
+	} else {
+		// Otherwise, serve the regular file
+		http.StripPrefix(fmt.Sprintf("%vstatic/", config.Server.BaseURL), http.FileServer(http.FS(assetFs))).ServeHTTP(w, r)
+	}
+}
+
+func indexHandler(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		http.Error(w, http.StatusText(http.StatusNotFound), http.StatusNotFound)
+		return
+	}
+	handleWithStaticData(w, r, "index.html", "text/html")
+
 }

backend/http/users.go

@@ -2,17 +2,19 @@ package http
 
 import (
 	"encoding/json"
-	"log"
+	"fmt"
+	"io"
 	"net/http"
 	"reflect"
 	"sort"
 	"strconv"
 
-	"github.com/gorilla/mux"
 	"golang.org/x/text/cases"
 	"golang.org/x/text/language"
 
 	"github.com/gtsteffaniak/filebrowser/errors"
+	"github.com/gtsteffaniak/filebrowser/files"
+	"github.com/gtsteffaniak/filebrowser/storage"
 	"github.com/gtsteffaniak/filebrowser/users"
 )
 
@@ -25,102 +27,153 @@ type Sorting struct {
 	By  string `json:"by"`
 	Asc bool   `json:"asc"`
 }
-type modifyUserRequest struct {
-	modifyRequest
-	Data *users.User `json:"data"`
+type UserRequest struct {
+	What  string      `json:"what"`
+	Which []string    `json:"which"`
+	Data  *users.User `json:"data"`
 }
 
-func getUserID(r *http.Request) (uint, error) {
-	vars := mux.Vars(r)
-	i, err := strconv.ParseUint(vars["id"], 10, 0)
-	if err != nil {
-		return 0, err
-	}
-	return uint(i), err
-}
+// userGetHandler retrieves a user by ID.
+// @Summary Retrieve a user by ID
+// @Description Returns a user's details based on their ID.
+// @Tags Users
+// @Accept json
+// @Produce json
+// @Param id path int true "User ID" or "self"
+// @Success 200 {object} users.User "User details"
+// @Failure 403 {object} map[string]string "Forbidden"
+// @Failure 404 {object} map[string]string "Not Found"
+// @Failure 500 {object} map[string]string "Internal Server Error"
+// @Router /api/users/{id} [get]
+func userGetHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
+	givenUserIdString := r.URL.Query().Get("id")
 
-func getUser(_ http.ResponseWriter, r *http.Request) (*modifyUserRequest, error) {
-	if r.Body == nil {
-		return nil, errors.ErrEmptyRequest
-	}
+	// since api self is used to validate a logged in user
+	w.Header().Add("X-Renew-Token", "false")
 
-	req := &modifyUserRequest{}
-	err := json.NewDecoder(r.Body).Decode(req)
-	if err != nil {
-		return nil, err
-	}
-
-	if req.What != "user" {
-		return nil, errors.ErrInvalidDataType
-	}
-
-	return req, nil
-}
-
-func withSelfOrAdmin(fn handleFunc) handleFunc {
-	return withUser(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
-		id, err := getUserID(r)
+	var givenUserId uint
+	if givenUserIdString == "self" {
+		givenUserId = d.user.ID
+	} else if givenUserIdString == "" {
+		if !d.user.Perm.Admin {
+			return http.StatusForbidden, nil
+		}
+		users, err := store.Users.Gets(config.Server.Root)
 		if err != nil {
 			return http.StatusInternalServerError, err
 		}
-		if d.user.ID != id && !d.user.Perm.Admin {
-			return http.StatusForbidden, nil
+
+		for _, u := range users {
+			u.Password = ""
+		}
+		for _, u := range users {
+			u.ApiKeys = nil
 		}
 
-		d.raw = id
-		return fn(w, r, d)
-	})
-}
+		sort.Slice(users, func(i, j int) bool {
+			return users[i].ID < users[j].ID
+		})
 
-var usersGetHandler = withAdmin(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
-	users, err := d.store.Users.Gets(d.server.Root)
-	if err != nil {
-		return http.StatusInternalServerError, err
+		return renderJSON(w, r, users)
+	} else {
+		num, _ := strconv.ParseUint(givenUserIdString, 10, 32)
+		givenUserId = uint(num)
 	}
 
-	for _, u := range users {
-		u.Password = ""
+	if givenUserId != d.user.ID && !d.user.Perm.Admin {
+		return http.StatusForbidden, nil
 	}
 
-	sort.Slice(users, func(i, j int) bool {
-		return users[i].ID < users[j].ID
-	})
-
-	return renderJSON(w, r, users)
-})
-
-var userGetHandler = withSelfOrAdmin(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
-	u, err := d.store.Users.Get(d.server.Root, d.raw.(uint))
+	// Fetch the user details
+	u, err := store.Users.Get(config.Server.Root, givenUserId)
 	if err == errors.ErrNotExist {
 		return http.StatusNotFound, err
 	}
-
 	if err != nil {
 		return http.StatusInternalServerError, err
 	}
 
+	// Remove the password from the response if the user is not an admin
 	u.Password = ""
+	u.ApiKeys = nil
 	if !d.user.Perm.Admin {
 		u.Scope = ""
 	}
-	return renderJSON(w, r, u)
-})
 
-var userDeleteHandler = withSelfOrAdmin(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
-	err := d.store.Users.Delete(d.raw.(uint))
+	return renderJSON(w, r, u)
+}
+
+// userDeleteHandler deletes a user by ID.
+// @Summary Delete a user by ID
+// @Description Deletes a user identified by their ID.
+// @Tags Users
+// @Accept json
+// @Produce json
+// @Param id path int true "User ID"
+// @Success 200 "User deleted successfully"
+// @Failure 403 {object} map[string]string "Forbidden"
+// @Failure 500 {object} map[string]string "Internal Server Error"
+// @Router /api/users/{id} [delete]
+func userDeleteHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
+	givenUserIdString := r.URL.Query().Get("id")
+	num, _ := strconv.ParseUint(givenUserIdString, 10, 32)
+	givenUserId := uint(num)
+
+	if givenUserId == d.user.ID {
+		return http.StatusForbidden, fmt.Errorf("cannot delete your own user")
+	}
+
+	if !d.user.Perm.Admin {
+		return http.StatusForbidden, fmt.Errorf("cannot delete users without admin permissions")
+	}
+
+	if givenUserId == 1 {
+		return http.StatusForbidden, fmt.Errorf("cannot delete the default admin user")
+	}
+
+	// Delete the user
+	err := store.Users.Delete(givenUserId)
 	if err != nil {
 		return errToStatus(err), err
 	}
-
 	return http.StatusOK, nil
-})
+}
 
-var userPostHandler = withAdmin(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
-	req, err := getUser(w, r)
+// usersPostHandler creates a new user.
+// @Summary Create a new user
+// @Description Adds a new user to the system.
+// @Tags Users
+// @Accept json
+// @Produce json
+// @Param data body users.User true "User data to create a new user"
+// @Success 201 {object} users.User "Created user"
+// @Failure 400 {object} map[string]string "Bad Request"
+// @Failure 500 {object} map[string]string "Internal Server Error"
+// @Router /api/users [post]
+func usersPostHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
+	if !d.user.Perm.Admin {
+		return http.StatusForbidden, nil
+	}
+
+	// Validate the user's scope
+	_, _, err := files.GetRealPath(config.Server.Root, d.user.Scope)
 	if err != nil {
 		return http.StatusBadRequest, err
 	}
 
+	// Read the JSON body
+	body, err := io.ReadAll(r.Body)
+	if err != nil {
+		return http.StatusInternalServerError, err
+	}
+	defer r.Body.Close()
+
+	// Parse the JSON into the UserRequest struct
+	var req UserRequest
+	if err = json.Unmarshal(body, &req); err != nil {
+		return http.StatusBadRequest, err
+	}
+
 	if len(req.Which) != 0 {
 		return http.StatusBadRequest, nil
 	}
@@ -129,33 +182,57 @@ var userPostHandler = withAdmin(func(w http.ResponseWriter, r *http.Request, d *
 		return http.StatusBadRequest, errors.ErrEmptyPassword
 	}
 
-	userHome, err := d.settings.MakeUserDir(req.Data.Username, req.Data.Scope, d.server.Root)
-	if err != nil {
-		log.Printf("create user: failed to mkdir user home dir: [%s]", userHome)
-		return http.StatusInternalServerError, err
-	}
-	req.Data.Scope = userHome
-	log.Printf("user: %s, home dir: [%s].", req.Data.Username, userHome)
-
-	err = d.store.Users.Save(req.Data)
+	err = storage.CreateUser(*req.Data, req.Data.Perm.Admin)
 	if err != nil {
 		return http.StatusInternalServerError, err
 	}
 
 	w.Header().Set("Location", "/settings/users/"+strconv.FormatUint(uint64(req.Data.ID), 10))
 	return http.StatusCreated, nil
-})
+}
 
-var userPutHandler = withSelfOrAdmin(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
-	req, err := getUser(w, r)
+// userPutHandler updates an existing user's details.
+// @Summary Update a user's details
+// @Description Updates the details of a user identified by ID.
+// @Tags Users
+// @Accept json
+// @Produce json
+// @Param id path int true "User ID"
+// @Param data body users.User true "User data to update"
+// @Success 200 {object} users.User "Updated user details"
+// @Failure 400 {object} map[string]string "Bad Request"
+// @Failure 403 {object} map[string]string "Forbidden"
+// @Failure 500 {object} map[string]string "Internal Server Error"
+// @Router /api/users/{id} [put]
+func userPutHandler(w http.ResponseWriter, r *http.Request, d *requestContext) (int, error) {
+	givenUserIdString := r.URL.Query().Get("id")
+	num, _ := strconv.ParseUint(givenUserIdString, 10, 32)
+	givenUserId := uint(num)
+
+	if givenUserId != d.user.ID && !d.user.Perm.Admin {
+		return http.StatusForbidden, nil
+	}
+
+	// Validate the user's scope
+	_, _, err := files.GetRealPath(config.Server.Root, d.user.Scope)
 	if err != nil {
 		return http.StatusBadRequest, err
 	}
 
-	if req.Data.ID != d.raw.(uint) {
-		return http.StatusBadRequest, nil
+	// Read the JSON body
+	body, err := io.ReadAll(r.Body)
+	if err != nil {
+		return http.StatusInternalServerError, err
+	}
+	defer r.Body.Close()
+
+	// Parse the JSON into the UserRequest struct
+	var req UserRequest
+	if err = json.Unmarshal(body, &req); err != nil {
+		return http.StatusBadRequest, err
 	}
 
+	// If `Which` is not specified, default to updating all fields
 	if len(req.Which) == 0 || req.Which[0] == "all" {
 		req.Which = []string{}
 		v := reflect.ValueOf(req.Data)
@@ -163,18 +240,25 @@ var userPutHandler = withSelfOrAdmin(func(w http.ResponseWriter, r *http.Request
 			v = v.Elem()
 		}
 		t := v.Type()
+
+		// Dynamically populate fields to update
 		for i := 0; i < t.NumField(); i++ {
 			field := t.Field(i)
-			if field.Name != "Password" && field.Name != "Fs" {
+			if field.Name == "Password" && req.Data.Password != "" {
+				req.Which = append(req.Which, field.Name)
+			} else if field.Name != "Password" && field.Name != "Fs" {
 				req.Which = append(req.Which, field.Name)
 			}
 		}
 	}
 
-	for k, v := range req.Which {
-		v = cases.Title(language.English, cases.NoLower).String(v)
-		req.Which[k] = v
-		if v == "Password" {
+	// Process the fields to update
+	for _, field := range req.Which {
+		// Title case field names
+		field = cases.Title(language.English, cases.NoLower).String(field)
+
+		// Handle password update
+		if field == "Password" {
 			if !d.user.Perm.Admin && d.user.LockPassword {
 				return http.StatusForbidden, nil
 			}
@@ -184,16 +268,20 @@ var userPutHandler = withSelfOrAdmin(func(w http.ResponseWriter, r *http.Request
 			}
 		}
 
-		for _, f := range NonModifiableFieldsForNonAdmin {
-			if !d.user.Perm.Admin && v == f {
+		// Prevent non-admins from modifying certain fields
+		for _, restrictedField := range NonModifiableFieldsForNonAdmin {
+			if !d.user.Perm.Admin && field == restrictedField {
 				return http.StatusForbidden, nil
 			}
 		}
 	}
-	err = d.store.Users.Update(req.Data, req.Which...)
+	// Perform the user update
+	err = store.Users.Update(req.Data, req.Which...)
 	if err != nil {
 		return http.StatusInternalServerError, err
 	}
 
-	return http.StatusOK, nil
-})
+	// Return the updated user (with the password hidden) as JSON response
+	req.Data.Password = ""
+	return renderJSON(w, r, req.Data)
+}

backend/http/utils.go

@@ -1,30 +1,13 @@
 package http
 
 import (
-	"encoding/json"
 	"errors"
 	"net/http"
-	"net/url"
 	"os"
-	"strings"
 
 	libErrors "github.com/gtsteffaniak/filebrowser/errors"
 )
 
-func renderJSON(w http.ResponseWriter, _ *http.Request, data interface{}) (int, error) {
-	marsh, err := json.Marshal(data)
-	if err != nil {
-		return http.StatusInternalServerError, err
-	}
-
-	w.Header().Set("Content-Type", "application/json; charset=utf-8")
-	if _, err := w.Write(marsh); err != nil {
-		return http.StatusInternalServerError, err
-	}
-
-	return 0, nil
-}
-
 func errToStatus(err error) int {
 	switch {
 	case err == nil:
@@ -45,23 +28,3 @@ func errToStatus(err error) int {
 		return http.StatusInternalServerError
 	}
 }
-
-// This is an addaptation if http.StripPrefix in which we don't
-// return 404 if the page doesn't have the needed prefix.
-func stripPrefix(prefix string, h http.Handler) http.Handler {
-	if prefix == "" || prefix == "/" {
-		return h
-	}
-
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		p := strings.TrimPrefix(r.URL.Path, prefix)
-		rp := strings.TrimPrefix(r.URL.RawPath, prefix)
-		r2 := new(http.Request)
-		*r2 = *r
-		r2.URL = new(url.URL)
-		*r2.URL = *r.URL
-		r2.URL.Path = p
-		r2.URL.RawPath = rp
-		h.ServeHTTP(w, r2)
-	})
-}

backend/rules/rules_test.go

@@ -1,23 +0,0 @@
-package rules
-
-import "testing"
-
-func TestMatchHidden(t *testing.T) {
-	cases := map[string]bool{
-		"/":                   false,
-		"/src":                false,
-		"/src/":               false,
-		"/.circleci":          true,
-		"/a/b/c/.docker.json": true,
-		".docker.json":        true,
-		"Dockerfile":          false,
-		"/Dockerfile":         false,
-	}
-
-	for path, want := range cases {
-		got := MatchHidden(path)
-		if got != want {
-			t.Errorf("MatchHidden(%s)=%v; want %v", path, got, want)
-		}
-	}
-}

backend/run_tests.sh

@@ -9,7 +9,7 @@ checkExit() {
 if command -v go &> /dev/null
 then
     printf "\n == Running tests == \n"
-    go test -race -v ./...
+    go test -race -parallel -v ./...
     checkExit
 else
     echo "ERROR: unable to perform tests"

backend/runner/runner.go

@@ -7,6 +7,7 @@ import (
 	"os/exec"
 	"strings"
 
+	"github.com/gtsteffaniak/filebrowser/files"
 	"github.com/gtsteffaniak/filebrowser/settings"
 	"github.com/gtsteffaniak/filebrowser/users"
 )
@@ -19,8 +20,8 @@ type Runner struct {
 
 // RunHook runs the hooks for the before and after event.
 func (r *Runner) RunHook(fn func() error, evt, path, dst string, user *users.User) error {
-	path = user.FullPath(path)
-	dst = user.FullPath(dst)
+	path, _, _ = files.GetRealPath(user.Scope, path)
+	dst, _, _ = files.GetRealPath(user.Scope, dst)
 
 	if r.Enabled {
 		if val, ok := r.Commands["before_"+evt]; ok {

backend/settings/config.go

@@ -3,6 +3,7 @@ package settings
 import (
 	"log"
 	"os"
+	"path/filepath"
 	"strings"
 
 	"github.com/goccy/go-yaml"
@@ -19,22 +20,36 @@ func Initialize(configFile string) {
 		log.Fatalf("Error unmarshaling YAML data: %v", err)
 	}
 	Config.UserDefaults.Perm = Config.UserDefaults.Permissions
-	Config.Server.Root = strings.TrimSuffix(Config.Server.Root, "/")
+	// Convert relative path to absolute path
+	realRoot, err := filepath.Abs(Config.Server.Root)
+	if err != nil {
+		log.Fatalf("Error getting root path: %v", err)
+	}
+	_, err = os.Stat(realRoot)
+	if err != nil {
+		log.Fatalf("ERROR: Configured Root Path does not exist! %v", err)
+	}
+	Config.Server.Root = realRoot
+	baseurl := strings.Trim(Config.Server.BaseURL, "/")
+	if baseurl == "" {
+		Config.Server.BaseURL = "/"
+	} else {
+		Config.Server.BaseURL = "/" + baseurl + "/"
+	}
 }
 
 func loadConfigFile(configFile string) []byte {
 	// Open and read the YAML file
 	yamlFile, err := os.Open(configFile)
 	if err != nil {
-		log.Printf("ERROR: opening config file\n %v\n WARNING: Using default config only\n If this was a mistake, please make sure the file exists and is accessible by the filebrowser binary.\n\n", err)
-		Config = setDefaults()
-		return []byte{}
+		log.Println(err)
+		os.Exit(1)
 	}
 	defer yamlFile.Close()
 
 	stat, err := yamlFile.Stat()
 	if err != nil {
-		log.Fatalf("Error getting file information: %s", err.Error())
+		log.Fatalf("error getting file information: %s", err.Error())
 	}
 
 	yamlData := make([]byte, stat.Size())
@@ -77,6 +92,7 @@ func setDefaults() Settings {
 			HideDotfiles:    true,
 			DarkMode:        false,
 			DisableSettings: false,
+			ViewMode:        "normal",
 			Locale:          "en",
 			Permissions: users.Permissions{
 				Create:   false,
@@ -86,23 +102,8 @@ func setDefaults() Settings {
 				Share:    false,
 				Download: false,
 				Admin:    false,
+				Api:      false,
 			},
 		},
 	}
 }
-
-// Apply applies the default options to a user.
-func (d *UserDefaults) Apply(u *users.User) {
-	u.StickySidebar = d.StickySidebar
-	u.DisableSettings = d.DisableSettings
-	u.DarkMode = d.DarkMode
-	u.Scope = d.Scope
-	u.Locale = d.Locale
-	u.ViewMode = d.ViewMode
-	u.SingleClick = d.SingleClick
-	u.Perm = d.Perm
-	u.Sorting = d.Sorting
-	u.Commands = d.Commands
-	u.HideDotfiles = d.HideDotfiles
-	u.DateFormat = d.DateFormat
-}

backend/settings/dir.go

@@ -6,16 +6,14 @@ import (
 	"log"
 	"os"
 	"path"
+	"path/filepath"
 	"regexp"
 	"strings"
-
-	"github.com/spf13/afero"
 )
 
 var (
 	invalidFilenameChars = regexp.MustCompile(`[^0-9A-Za-z@_\-.]`)
-
-	dashes = regexp.MustCompile(`[\-]+`)
+	dashes               = regexp.MustCompile(`[\-]+`)
 )
 
 // MakeUserDir makes the user directory according to settings.
@@ -32,8 +30,8 @@ func (s *Settings) MakeUserDir(username, userScope, serverRoot string) (string,
 
 	userScope = path.Join("/", userScope)
 
-	fs := afero.NewBasePathFs(afero.NewOsFs(), serverRoot)
-	if err := fs.MkdirAll(userScope, os.ModePerm); err != nil {
+	fullPath := filepath.Join(serverRoot, userScope)
+	if err := os.MkdirAll(fullPath, os.ModePerm); err != nil {
 		return "", fmt.Errorf("failed to create user home dir: [%s]: %w", userScope, err)
 	}
 	return userScope, nil

backend/settings/dir_test.go

@@ -3,7 +3,7 @@ package settings
 import (
 	"testing"
 
-	"github.com/gtsteffaniak/filebrowser/rules"
+	"github.com/gtsteffaniak/filebrowser/users"
 )
 
 func TestSettings_MakeUserDir(t *testing.T) {
@@ -15,7 +15,7 @@ func TestSettings_MakeUserDir(t *testing.T) {
 		Shell            []string
 		AdminUsername    string
 		AdminPassword    string
-		Rules            []rules.Rule
+		Rules            []users.Rule
 		Server           Server
 		Auth             Auth
 		Frontend         Frontend

backend/settings/settings.go

@@ -2,9 +2,8 @@ package settings
 
 import (
 	"crypto/rand"
-	"strings"
 
-	"github.com/gtsteffaniak/filebrowser/rules"
+	"github.com/gtsteffaniak/filebrowser/users"
 )
 
 const DefaultUsersHomeBasePath = "/users"
@@ -12,18 +11,6 @@ const DefaultUsersHomeBasePath = "/users"
 // AuthMethod describes an authentication method.
 type AuthMethod string
 
-// Settings contain the main settings of the application.
-// GetRules implements rules.Provider.
-func (s *Settings) GetRules() []rules.Rule {
-	return s.Rules
-}
-
-// Server specific settings
-// Clean cleans any variables that might need cleaning.
-func (s *Server) Clean() {
-	s.BaseURL = strings.TrimSuffix(s.BaseURL, "/")
-}
-
 // GenerateKey generates a key of 512 bits.
 func GenerateKey() ([]byte, error) {
 	b := make([]byte, 64) //nolint:gomnd
@@ -39,3 +26,33 @@ func GenerateKey() ([]byte, error) {
 func GetSettingsConfig(nameType string, Value string) string {
 	return nameType + Value
 }
+
+func AdminPerms() users.Permissions {
+	return users.Permissions{
+		Create:   true,
+		Rename:   true,
+		Modify:   true,
+		Delete:   true,
+		Share:    true,
+		Download: true,
+		Admin:    true,
+		Api:      true,
+	}
+}
+
+// Apply applies the default options to a user.
+func ApplyUserDefaults(u users.User) users.User {
+	u.StickySidebar = Config.UserDefaults.StickySidebar
+	u.DisableSettings = Config.UserDefaults.DisableSettings
+	u.DarkMode = Config.UserDefaults.DarkMode
+	u.Scope = Config.UserDefaults.Scope
+	u.Locale = Config.UserDefaults.Locale
+	u.ViewMode = Config.UserDefaults.ViewMode
+	u.SingleClick = Config.UserDefaults.SingleClick
+	u.Perm = Config.UserDefaults.Perm
+	u.Sorting = Config.UserDefaults.Sorting
+	u.Commands = Config.UserDefaults.Commands
+	u.HideDotfiles = Config.UserDefaults.HideDotfiles
+	u.DateFormat = Config.UserDefaults.DateFormat
+	return u
+}

backend/settings/storage.go

@@ -2,7 +2,7 @@ package settings
 
 import (
 	"github.com/gtsteffaniak/filebrowser/errors"
-	"github.com/gtsteffaniak/filebrowser/rules"
+	"github.com/gtsteffaniak/filebrowser/users"
 )
 
 // StorageBackend is a settings storage backend.
@@ -62,11 +62,7 @@ func (s *Storage) Save(set *Settings) error {
 	}
 
 	if set.Rules == nil {
-		set.Rules = []rules.Rule{}
-	}
-
-	if set.Shell == nil {
-		set.Shell = []string{}
+		set.Rules = []users.Rule{}
 	}
 
 	if set.Commands == nil {
@@ -98,6 +94,5 @@ func (s *Storage) GetServer() (*Server, error) {
 
 // SaveServer wraps StorageBackend.SaveServer and adds some verification.
 func (s *Storage) SaveServer(ser *Server) error {
-	ser.Clean()
 	return s.back.SaveServer(ser)
 }

backend/settings/structs.go

@@ -1,14 +1,13 @@
 package settings
 
 import (
-	"github.com/gtsteffaniak/filebrowser/rules"
 	"github.com/gtsteffaniak/filebrowser/users"
 )
 
 type Settings struct {
 	Commands     map[string][]string `json:"commands"`
 	Shell        []string            `json:"shell"`
-	Rules        []rules.Rule        `json:"rules"`
+	Rules        []users.Rule        `json:"rules"`
 	Server       Server              `json:"server"`
 	Auth         Auth                `json:"auth"`
 	Frontend     Frontend            `json:"frontend"`
@@ -75,8 +74,9 @@ type UserDefaults struct {
 	Scope           string       `json:"scope"`
 	Locale          string       `json:"locale"`
 	ViewMode        string       `json:"viewMode"`
+	GallerySize     int          `json:"gallerySize"`
 	SingleClick     bool         `json:"singleClick"`
-	Rules           []rules.Rule `json:"rules"`
+	Rules           []users.Rule `json:"rules"`
 	Sorting         struct {
 		By  string `json:"by"`
 		Asc bool   `json:"asc"`

backend/storage/bolt/auth.go

@@ -28,5 +28,5 @@ func (s authBackend) Get(t string) (auth.Auther, error) {
 }
 
 func (s authBackend) Save(a auth.Auther) error {
-	return save(s.db, "auther", a)
+	return Save(s.db, "auther", a)
 }

backend/storage/bolt/bolt.go

@@ -6,26 +6,14 @@ import (
 	"github.com/gtsteffaniak/filebrowser/auth"
 	"github.com/gtsteffaniak/filebrowser/settings"
 	"github.com/gtsteffaniak/filebrowser/share"
-	"github.com/gtsteffaniak/filebrowser/storage"
 	"github.com/gtsteffaniak/filebrowser/users"
 )
 
 // NewStorage creates a storage.Storage based on Bolt DB.
-func NewStorage(db *storm.DB) (*storage.Storage, error) {
+func NewStorage(db *storm.DB) (*auth.Storage, *users.Storage, *share.Storage, *settings.Storage, error) {
 	userStore := users.NewStorage(usersBackend{db: db})
 	shareStore := share.NewStorage(shareBackend{db: db})
 	settingsStore := settings.NewStorage(settingsBackend{db: db})
 	authStore := auth.NewStorage(authBackend{db: db}, userStore)
-
-	err := save(db, "version", 2) //nolint:gomnd
-	if err != nil {
-		return nil, err
-	}
-
-	return &storage.Storage{
-		Auth:     authStore,
-		Users:    userStore,
-		Share:    shareStore,
-		Settings: settingsStore,
-	}, nil
+	return authStore, userStore, shareStore, settingsStore, nil
 }

backend/storage/bolt/config.go

@@ -15,7 +15,7 @@ func (s settingsBackend) Get() (*settings.Settings, error) {
 }
 
 func (s settingsBackend) Save(set *settings.Settings) error {
-	return save(s.db, "settings", set)
+	return Save(s.db, "settings", set)
 }
 
 func (s settingsBackend) GetServer() (*settings.Server, error) {
@@ -27,5 +27,5 @@ func (s settingsBackend) GetServer() (*settings.Server, error) {
 }
 
 func (s settingsBackend) SaveServer(server *settings.Server) error {
-	return save(s.db, "server", server)
+	return Save(s.db, "server", server)
 }

backend/storage/bolt/users.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/gtsteffaniak/filebrowser/errors"
 	"github.com/gtsteffaniak/filebrowser/users"
+	"github.com/gtsteffaniak/filebrowser/utils"
 )
 
 type usersBackend struct {
@@ -55,14 +56,24 @@ func (st usersBackend) Update(user *users.User, fields ...string) error {
 	if len(fields) == 0 {
 		return st.Save(user)
 	}
+
+	val := reflect.ValueOf(user).Elem()
+
 	for _, field := range fields {
-		userField := reflect.ValueOf(user).Elem().FieldByName(field)
+		// Capitalize the first letter (you can adjust this based on your field naming convention)
+		correctedField := utils.CapitalizeFirst(field)
+
+		userField := val.FieldByName(correctedField)
 		if !userField.IsValid() {
 			return fmt.Errorf("invalid field: %s", field)
 		}
+		if !userField.CanSet() {
+			return fmt.Errorf("cannot update unexported field: %s", field)
+		}
+
 		val := userField.Interface()
-		if err := st.db.UpdateField(user, field, val); err != nil {
-			return fmt.Errorf("Error updating user field: %s, error: %v", field, err.Error())
+		if err := st.db.UpdateField(user, correctedField, val); err != nil {
+			return fmt.Errorf("Error updating user field: %s, error: %v", correctedField, err.Error())
 		}
 	}
 	return nil

backend/storage/bolt/utils.go

@@ -15,6 +15,6 @@ func get(db *storm.DB, name string, to interface{}) error {
 	return err
 }
 
-func save(db *storm.DB, name string, from interface{}) error {
+func Save(db *storm.DB, name string, from interface{}) error {
 	return db.Set("config", name, from)
 }

backend/storage/storage.go

@@ -1,17 +1,136 @@
 package storage
 
 import (
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+
+	"github.com/asdine/storm/v3"
 	"github.com/gtsteffaniak/filebrowser/auth"
+	"github.com/gtsteffaniak/filebrowser/errors"
+	"github.com/gtsteffaniak/filebrowser/files"
 	"github.com/gtsteffaniak/filebrowser/settings"
 	"github.com/gtsteffaniak/filebrowser/share"
+	"github.com/gtsteffaniak/filebrowser/storage/bolt"
 	"github.com/gtsteffaniak/filebrowser/users"
+	"github.com/gtsteffaniak/filebrowser/utils"
 )
 
 // Storage is a storage powered by a Backend which makes the necessary
 // verifications when fetching and saving data to ensure consistency.
 type Storage struct {
-	Users    users.Store
+	Users    *users.Storage
 	Share    *share.Storage
 	Auth     *auth.Storage
 	Settings *settings.Storage
 }
+
+var store *Storage
+
+func InitializeDb(path string) (*Storage, bool, error) {
+	exists, err := dbExists(path)
+	if err != nil {
+		panic(err)
+	}
+	db, err := storm.Open(path)
+
+	utils.CheckErr(fmt.Sprintf("storm.Open path %v", path), err)
+	authStore, userStore, shareStore, settingsStore, err := bolt.NewStorage(db)
+	if err != nil {
+		return nil, exists, err
+	}
+
+	err = bolt.Save(db, "version", 2) //nolint:gomnd
+	if err != nil {
+		return nil, exists, err
+	}
+	store = &Storage{
+		Auth:     authStore,
+		Users:    userStore,
+		Share:    shareStore,
+		Settings: settingsStore,
+	}
+	if !exists {
+		quickSetup(store)
+	}
+
+	return store, exists, err
+}
+
+func dbExists(path string) (bool, error) {
+	stat, err := os.Stat(path)
+	if err == nil {
+		return stat.Size() != 0, nil
+	}
+
+	if os.IsNotExist(err) {
+		d := filepath.Dir(path)
+		_, err = os.Stat(d)
+		if os.IsNotExist(err) {
+			if err := os.MkdirAll(d, 0700); err != nil { //nolint:govet,gomnd
+				return false, err
+			}
+			return false, nil
+		}
+	}
+
+	return false, err
+}
+
+func quickSetup(store *Storage) {
+	settings.Config.Auth.Key = utils.GenerateKey()
+	if settings.Config.Auth.Method == "noauth" {
+		err := store.Auth.Save(&auth.NoAuth{})
+		utils.CheckErr("store.Auth.Save", err)
+	} else {
+		settings.Config.Auth.Method = "password"
+		err := store.Auth.Save(&auth.JSONAuth{})
+		utils.CheckErr("store.Auth.Save", err)
+	}
+	err := store.Settings.Save(&settings.Config)
+	utils.CheckErr("store.Settings.Save", err)
+	err = store.Settings.SaveServer(&settings.Config.Server)
+	utils.CheckErr("store.Settings.SaveServer", err)
+	user := settings.ApplyUserDefaults(users.User{})
+	user.Username = settings.Config.Auth.AdminUsername
+	user.Password = settings.Config.Auth.AdminPassword
+	user.Perm.Admin = true
+	user.Scope = "./"
+	user.DarkMode = true
+	user.ViewMode = "normal"
+	user.LockPassword = false
+	user.Perm = settings.AdminPerms()
+	err = store.Users.Save(&user)
+	utils.CheckErr("store.Users.Save", err)
+}
+
+// create new user
+func CreateUser(userInfo users.User, asAdmin bool) error {
+	// must have username or password to create
+	if userInfo.Username == "" || userInfo.Password == "" {
+		return errors.ErrInvalidRequestParams
+	}
+	newUser := settings.ApplyUserDefaults(userInfo)
+	if asAdmin {
+		newUser.Perm = settings.AdminPerms()
+	}
+	// create new home directory
+	userHome, err := settings.Config.MakeUserDir(newUser.Username, newUser.Scope, settings.Config.Server.Root)
+	if err != nil {
+		log.Printf("create user: failed to mkdir user home dir: [%s]", userHome)
+		return err
+	}
+	newUser.Scope = userHome
+	log.Printf("user: %s, home dir: [%s].", newUser.Username, userHome)
+	_, _, err = files.GetRealPath(settings.Config.Server.Root, newUser.Scope)
+	if err != nil {
+		log.Println("user path is not valid", newUser.Scope)
+		return nil
+	}
+	err = store.Users.Save(&newUser)
+	if err != nil {
+		return err
+	}
+	return nil
+}

backend/users/rules.go

@@ -1,4 +1,4 @@
-package rules
+package users
 
 import (
 	"path/filepath"
@@ -11,6 +11,18 @@ type Checker interface {
 	Check(path string) bool
 }
 
+// Check implements rules.Checker.
+func (user *User) Check(path string) bool {
+	allow := true
+	for _, rule := range user.Rules {
+		if rule.Matches(path) {
+			allow = rule.Allow
+		}
+	}
+
+	return allow
+}
+
 // Rule is a allow/disallow rule.
 type Rule struct {
 	Regex  bool    `json:"regex"`

backend/users/storage.go

@@ -1,12 +1,10 @@
 package users
 
 import (
-	"log"
 	"sync"
 	"time"
 
 	"github.com/gtsteffaniak/filebrowser/errors"
-	"github.com/gtsteffaniak/filebrowser/rules"
 )
 
 // StorageBackend is the interface to implement for a users storage.
@@ -27,7 +25,9 @@ type Store interface {
 	Save(user *User) error
 	Delete(id interface{}) error
 	LastUpdate(id uint) int64
-	AddRule(username string, rule rules.Rule) error
+	AddApiKey(username uint, name string, key AuthToken) error
+	DeleteApiKey(username uint, name string) error
+	AddRule(username string, rule Rule) error
 	DeleteRule(username string, ruleID string) error
 }
 
@@ -54,9 +54,6 @@ func (s *Storage) Get(baseScope string, id interface{}) (user *User, err error)
 	if err != nil {
 		return
 	}
-	if err := user.Clean(baseScope); err != nil {
-		return nil, err
-	}
 	return user, err
 }
 
@@ -66,23 +63,12 @@ func (s *Storage) Gets(baseScope string) ([]*User, error) {
 	if err != nil {
 		return nil, err
 	}
-	for _, user := range users {
-		if err := user.Clean(baseScope); err != nil { //nolint:govet
-			return nil, err
-		}
-	}
-
 	return users, err
 }
 
 // Update updates a user in the database.
 func (s *Storage) Update(user *User, fields ...string) error {
-	err := user.Clean("")
-	if err != nil {
-		return err
-	}
-
-	err = s.back.Update(user, fields...)
+	err := s.back.Update(user, fields...)
 	if err != nil {
 		return err
 	}
@@ -94,7 +80,7 @@ func (s *Storage) Update(user *User, fields ...string) error {
 }
 
 // AddRule adds a rule to the user's rules list and updates the user in the database.
-func (s *Storage) AddRule(userID string, rule rules.Rule) error {
+func (s *Storage) AddRule(userID string, rule Rule) error {
 	user, err := s.Get("", userID)
 	if err != nil {
 		return err
@@ -110,6 +96,42 @@ func (s *Storage) AddRule(userID string, rule rules.Rule) error {
 	return nil
 }
 
+func (s *Storage) AddApiKey(userID uint, name string, key AuthToken) error {
+	user, err := s.Get("", userID)
+	if err != nil {
+		return err
+	}
+	// Initialize the ApiKeys map if it is nil
+	if user.ApiKeys == nil {
+		user.ApiKeys = make(map[string]AuthToken)
+	}
+	user.ApiKeys[name] = key
+	err = s.Update(user, "ApiKeys")
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (s *Storage) DeleteApiKey(userID uint, name string) error {
+	user, err := s.Get("", userID)
+	if err != nil {
+		return err
+	}
+	// Initialize the ApiKeys map if it is nil
+	if user.ApiKeys == nil {
+		user.ApiKeys = make(map[string]AuthToken)
+	}
+	delete(user.ApiKeys, name)
+	err = s.Update(user, "ApiKeys")
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
 // DeleteRule deletes a rule specified by ID from the user's rules list and updates the user in the database.
 func (s *Storage) DeleteRule(userID string, ruleID string) error {
 	user, err := s.Get("", userID)
@@ -118,7 +140,7 @@ func (s *Storage) DeleteRule(userID string, ruleID string) error {
 	}
 
 	// Find and remove the rule with the specified ID
-	var updatedRules []rules.Rule
+	var updatedRules []Rule
 	for _, r := range user.Rules {
 		if r.Id != ruleID {
 			updatedRules = append(updatedRules, r)
@@ -137,11 +159,6 @@ func (s *Storage) DeleteRule(userID string, ruleID string) error {
 
 // Save saves the user in a storage.
 func (s *Storage) Save(user *User) error {
-	log.Println("Saving new user:", user.Username)
-	if err := user.Clean(""); err != nil {
-		return err
-	}
-
 	return s.back.Save(user)
 }
 

backend/users/users.go

@@ -1,15 +1,23 @@
 package users
 
 import (
-	"path/filepath"
 	"regexp"
 
-	"github.com/spf13/afero"
-
-	"github.com/gtsteffaniak/filebrowser/rules"
+	"github.com/golang-jwt/jwt/v4"
 )
 
+type AuthToken struct {
+	Key                  string      `json:"key"`
+	Name                 string      `json:"name"`
+	Created              int64       `json:"createdAt"`
+	Expires              int64       `json:"expiresAt"`
+	BelongsTo            uint        `json:"belongsTo"`
+	Permissions          Permissions `json:"Permissions"`
+	jwt.RegisteredClaims `json:"-"`
+}
+
 type Permissions struct {
+	Api      bool `json:"api"`
 	Admin    bool `json:"admin"`
 	Execute  bool `json:"execute"`
 	Create   bool `json:"create"`
@@ -28,24 +36,25 @@ type Sorting struct {
 
 // User describes a user.
 type User struct {
-	StickySidebar   bool         `json:"stickySidebar"`
-	DarkMode        bool         `json:"darkMode"`
-	DisableSettings bool         `json:"disableSettings"`
-	ID              uint         `storm:"id,increment" json:"id"`
-	Username        string       `storm:"unique" json:"username"`
-	Password        string       `json:"password"`
-	Scope           string       `json:"scope"`
-	Locale          string       `json:"locale"`
-	LockPassword    bool         `json:"lockPassword"`
-	ViewMode        string       `json:"viewMode"`
-	SingleClick     bool         `json:"singleClick"`
-	Perm            Permissions  `json:"perm"`
-	Commands        []string     `json:"commands"`
-	Sorting         Sorting      `json:"sorting"`
-	Fs              afero.Fs     `json:"-" yaml:"-"`
-	Rules           []rules.Rule `json:"rules"`
-	HideDotfiles    bool         `json:"hideDotfiles"`
-	DateFormat      bool         `json:"dateFormat"`
+	StickySidebar   bool                 `json:"stickySidebar"`
+	DarkMode        bool                 `json:"darkMode"`
+	DisableSettings bool                 `json:"disableSettings"`
+	ID              uint                 `storm:"id,increment" json:"id"`
+	Username        string               `storm:"unique" json:"username"`
+	Password        string               `json:"password,omitempty"`
+	Scope           string               `json:"scope"`
+	Locale          string               `json:"locale"`
+	LockPassword    bool                 `json:"lockPassword"`
+	ViewMode        string               `json:"viewMode"`
+	SingleClick     bool                 `json:"singleClick"`
+	Sorting         Sorting              `json:"sorting"`
+	Perm            Permissions          `json:"perm"`
+	Commands        []string             `json:"commands"`
+	Rules           []Rule               `json:"rules"`
+	ApiKeys         map[string]AuthToken `json:"apiKeys,omitempty"`
+	HideDotfiles    bool                 `json:"hideDotfiles"`
+	DateFormat      bool                 `json:"dateFormat"`
+	GallerySize     int                  `json:"gallerySize"`
 }
 
 var PublicUser = User{
@@ -54,43 +63,23 @@ var PublicUser = User{
 	Scope:        "./",
 	ViewMode:     "normal",
 	LockPassword: true,
-	Fs:           afero.NewMemMapFs(),
 	Perm: Permissions{
 		Create:   false,
 		Rename:   false,
 		Modify:   false,
 		Delete:   false,
-		Share:    true,
+		Share:    false,
 		Download: true,
 		Admin:    false,
+		Api:      false,
 	},
 }
 
 // GetRules implements rules.Provider.
-func (u *User) GetRules() []rules.Rule {
+func (u *User) GetRules() []Rule {
 	return u.Rules
 }
 
-// Clean cleans up a user and verifies if all its fields
-// are alright to be saved.
-//
-//nolint:gocyclo
-func (u *User) Clean(baseScope string) error {
-
-	if u.Fs == nil {
-		scope := u.Scope
-		scope = filepath.Join(baseScope, filepath.Join("/", scope)) //nolint:gocritic
-		u.Fs = afero.NewBasePathFs(afero.NewOsFs(), scope)
-	}
-
-	return nil
-}
-
-// FullPath gets the full path for a user's relative path.
-func (u *User) FullPath(path string) string {
-	return afero.FullBaseFsPath(u.Fs.(*afero.BasePathFs), path)
-}
-
 // CanExecute checks if an user can execute a specific command.
 func (u *User) CanExecute(command string) bool {
 	if !u.Perm.Execute {

backend/utils/main.go

@@ -0,0 +1,71 @@
+package utils
+
+import (
+	"crypto/rand"
+	"fmt"
+	"log"
+	math "math/rand"
+	"reflect"
+	"strings"
+	"time"
+)
+
+func CheckErr(source string, err error) {
+	if err != nil {
+		log.Fatalf("%s: %v", source, err)
+	}
+}
+
+func GenerateKey() []byte {
+	b := make([]byte, 64)
+	_, err := rand.Read(b)
+	if err != nil {
+		return nil
+	}
+	return b
+}
+
+// CapitalizeFirst returns the input string with the first letter capitalized.
+func CapitalizeFirst(s string) string {
+	if len(s) == 0 {
+		return s // Return the empty string as is
+	}
+	return strings.ToUpper(string(s[0])) + s[1:]
+}
+
+func GenerateRandomHash(length int) string {
+	const charset = "abcdefghijklmnopqrstuvwxyz0123456789"
+	math.New(math.NewSource(time.Now().UnixNano()))
+	result := make([]byte, length)
+	for i := range result {
+		result[i] = charset[math.Intn(len(charset))]
+	}
+	return string(result)
+}
+
+func PrintStructFields(v interface{}) {
+	val := reflect.ValueOf(v)
+	typ := reflect.TypeOf(v)
+
+	// Ensure the input is a struct
+	if val.Kind() != reflect.Struct {
+		fmt.Println("Provided value is not a struct")
+		return
+	}
+
+	// Iterate over the fields of the struct
+	for i := 0; i < val.NumField(); i++ {
+		field := val.Field(i)
+		fieldType := typ.Field(i)
+
+		// Convert field value to string, if possible
+		fieldValue := fmt.Sprintf("%v", field.Interface())
+
+		// Limit to 50 characters
+		if len(fieldValue) > 100 {
+			fieldValue = fieldValue[:100] + "..."
+		}
+
+		fmt.Printf("Field: %s, %s\n", fieldType.Name, fieldValue)
+	}
+}

backend/version/version.go

@@ -1,8 +1,7 @@
 package version
 
 var (
-	// Version is the current File Browser version.
-	Version = "(0.2.7)"
-	// CommitSHA is the commmit sha.
-	CommitSHA = "(unknown)"
+	// Dynamically updated during build via build args
+	Version   = "untracked"
+	CommitSHA = "untracked"
 )

docs/configuration.md

@@ -35,9 +35,7 @@ auth:
   tokenExpirationTime: 2h
   header: ""
   method: json
-  command: ""
   signup: false
-  shell: ""
 frontend:
   name: ""
   disableExternal: false
@@ -63,7 +61,6 @@ userDefaults:
     delete: true
     share: true
     download: true
-  commands: []
   hideDotfiles: false
   dateFormat: false
 ```
@@ -165,10 +162,6 @@ userDefaults:
   - `oath` - oath authentication
   - `noauth` - no authentication/login required.
 
-- `command`: Deprecated: This is the authentication command.
-
-- `shell`: This is the shell configuration.
-
 - `Signup`: This boolean value indicates whether user signup is enabled on the login page. NOTE: Be mindful of `userDefaults` settings if enabled. Default: `false`
 
 - `AdminUsername`: This is the username of the admin user. Default: `admin`
@@ -227,7 +220,7 @@ userDefaults:
 
   - `download`: This boolean value determines whether download permissions are granted.
 
-- `commands`: Deprecated: This is a list of commands.
+  - `api`: Ability to create and manage API keys.
 
 - `hideDotfiles`: This boolean value determines whether dotfiles are hidden. (`true` or `false`)